NXC: BT Multiplexer für Sensoren + Motoren (bis 4 NXTs)

Modelle zum Nachbauen oder wo gibt es etwas interessantes oder Projekte?

Moderator: Moderatoren

Benutzeravatar
HaWe
Administrator
Administrator
Beiträge: 4767
Registriert: 11. Jan 2006 21:01
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze

NXC: BT Multiplexer für Sensoren + Motoren (bis 4 NXTs)

Beitragvon HaWe » 20. Aug 2011 13:02

hier ein Konzept, um per BT bis zu 4 NXTs zu vernetzen und vom Master aus sowohl die Sensoren als auch die Motoren an den Slaves zu lesen bzw. zu steuern.
Im Master-Programm wird mit dem Befehl

Code: Alles auswählen

StartBTMuxNetwork(1);   // (1), (2), (3): number of slaves to be connected

festgelegt, wieviele Slaves der Master zu steuern hat.

Code für den Master:

Code: Alles auswählen

// MASTER
//  v.038


#define BT_CONN_1 1 // Slave 1
#define OUTBOX_1  1 // out
#define INBOX_11  2 // sensors (continuously)
#define INBOX_12  3 // motors, values

#define BT_CONN_2 2 // Slave 2
#define OUTBOX_2  4 // out
#define INBOX_21  5 // sensors (continuously)
#define INBOX_22  6 // motors, values

#define BT_CONN_3 3 // Slave 3
#define OUTBOX_3  7 // out
#define INBOX_31  8 // sensors (continuously)
#define INBOX_32  9 // motors, values

long SensorRemoteArray[3][10][4];  // [3 slaves][10 "sensors"][4 values each]
char _NOS_;                        // Number of Slaves



//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

inline long GetMuxSensorValue(char slaveID, char port, char dim)
{
     long MyValue;

     MyValue= SensorRemoteArray[slaveID][port][dim];

     TextOut( 0, 56, "Sl v0 v1 v2 v3");

     if (port<=3)   {
        TextOut((dim+1)*20, 48-8*port,"   ");
        NumOut ( 0,         48-8*port, slaveID);
        NumOut ((dim+1)*18, 48-8*port, SensorRemoteArray[slaveID][port][dim]);
     }

     if (port>=7)   {
       TextOut((dim+1)*20, 48-8*(port-3),"       ");
       NumOut ((dim+1)*18, 48-8*(port-3), SensorRemoteArray[slaveID][port][dim]);
     }


     return MyValue;
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

inline void ParseBTResponseMsg(char sID, string msg)  // slaveID=0...2
{
    string pstr, rstr, vstr, buf, sp, sz, sn;
    int i, p, z, n, len, t, v;

    len=StrLen(msg);   //

    for (i=0; i<=9; i++)
    {

       sp=SubStr(msg,0,1);
          p=StrToNum(sp); // port

       sz=SubStr(msg,1,1);
          z=StrToNum(sz); // dim

       sn=SubStr(msg,2,1);
          n=StrToNum(sn); // dec


       //x=z*n;

       pstr=SubStr(msg, 3, z*n);   // z*n= length of value string
       rstr=pstr;

       for (t=0; t<z; t++)
       {
          vstr=SubStr(rstr, 0, n);
          v=StrToNum(vstr);
          SensorRemoteArray[sID][i][t]=v;

          buf=vstr;
          rstr=SubStr(rstr, n, n);
       }

       rstr=SubStr(msg, (z*n)+3, len);
       msg=rstr;
       len=StrLen(msg);
    }
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

task ReceiveSlaveData()    // NOS = Number of Slaves
{
   string msg;

   while(true)

   {
     if (_NOS_>=1) {
       until(ReceiveRemoteString(INBOX_11, true, msg) == NO_ERR);
       ParseBTResponseMsg(0, msg) ;
     }

     if (_NOS_>=2) {
       until(ReceiveRemoteString(INBOX_21, true, msg) == NO_ERR);
       ParseBTResponseMsg(1, msg) ;
     }

     if (_NOS_==3) {
       until(ReceiveRemoteString(INBOX_31, true, msg) == NO_ERR);
       ParseBTResponseMsg(2, msg) ;
      }

     Wait(1);

   }
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

inline void BTrRotateMotorEx(byte ID, byte outp, char powr, int angl, char tpct, char sync, char stpp)
{

  string  cmd="R";
  string  sID, soutp, spowr, sangl, stpct, ssync, sstpp;
  char    len, OUTBOX, INBOX;


  sID = NumToStr(ID);

  soutp= NumToStr(outp);
  len=StrLen(soutp);
  while (len<4)
  {
     soutp=StrCat(" ",soutp);
     len=StrLen(soutp);
  }

  spowr= NumToStr(powr);
  len=StrLen(spowr);
  while (len<4)
  {
     spowr=StrCat(" ",spowr);
     len=StrLen(spowr);
  }

  sangl= NumToStr(angl);
  len=StrLen(sangl);
  while (len<6)
  {
     sangl=StrCat(" ",sangl);
     len=StrLen(sangl);
  }

  stpct= NumToStr(tpct);
  len=StrLen(stpct);
  while (len<4)
  {
     stpct=StrCat(" ",stpct);
     len=StrLen(stpct);
  }

  ssync= NumToStr(sync);

  sstpp= NumToStr(stpp);

  cmd=StrCat(cmd,soutp,spowr,sangl,stpct,ssync,sstpp);

  INBOX = 3*ID;
  OUTBOX= INBOX -2;

  int ack=0;
  while (ack==0)
  {
    SendRemoteString(OUTBOX, 1, cmd);
    ReceiveRemoteNumber(INBOX, true, ack);
  }

}


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

inline void BTSetMotorEx(byte ID, byte outp, char powr, int angl, char tpct, char sync, char stpp)
{  //= starts RotateMotorEx in a personal task

  string  cmd="X";
  string  sID, soutp, spowr, sangl, stpct, ssync, sstpp;
  char    len, OUTBOX, INBOX;


  sID = NumToStr(ID);

  soutp= NumToStr(outp);
  len=StrLen(soutp);
  while (len<4)
  {
     soutp=StrCat(" ",soutp);
     len=StrLen(soutp);
  }

  spowr= NumToStr(powr);
  len=StrLen(spowr);
  while (len<4)
  {
     spowr=StrCat(" ",spowr);
     len=StrLen(spowr);
  }

  sangl= NumToStr(angl);
  len=StrLen(sangl);
  while (len<6)
  {
     sangl=StrCat(" ",sangl);
     len=StrLen(sangl);
  }

  stpct= NumToStr(tpct);
  len=StrLen(stpct);
  while (len<4)
  {
     stpct=StrCat(" ",stpct);
     len=StrLen(stpct);
  }

  ssync= NumToStr(sync);

  sstpp= NumToStr(stpp);

  cmd=StrCat(cmd,soutp,spowr,sangl,stpct,ssync,sstpp);

  INBOX = 3*ID;
  OUTBOX= INBOX -2;

  int ack=0;
  while (ack==0)
  {
    SendRemoteString(OUTBOX, 1, cmd);
    ReceiveRemoteNumber(INBOX, true, ack);
  }

}


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

inline void BTOnFwd(byte ID, byte outp, char powr)
{

  string  buf, cmd="F";
  string  sID, soutp, spowr;
  char len, INBOX, OUTBOX;


  sID = NumToStr(ID);

  soutp= NumToStr(outp);
  len=StrLen(soutp);
  while (len<4)
  {
     soutp=StrCat(" ",soutp);
     len=StrLen(soutp);
  }

  spowr= NumToStr(powr);
  len=StrLen(spowr);
  while (len<4)
  {
     spowr=StrCat(" ",spowr);
     len=StrLen(spowr);
  }

  cmd=StrCat(cmd,soutp,spowr);

  INBOX = 3*ID;
  OUTBOX= INBOX -2;


  int ack=0;
  while (ack==0)
  {
    SendRemoteString(OUTBOX, 1, cmd);
    ReceiveRemoteNumber(INBOX, true, ack);
  }

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

inline void BTStop(byte ID, byte outp)
{

  string  buf, cmd="S";
  string  sID, soutp;
  char len, INBOX, OUTBOX;


  sID = NumToStr(ID);

  soutp= NumToStr(outp);
  len=StrLen(soutp);
  while (len<4)
  {
     soutp=StrCat(" ",soutp);
     len=StrLen(soutp);
  }


  cmd=StrCat(cmd,soutp);

  INBOX = 3*ID;
  OUTBOX= INBOX -2;


  int ack=0;
  while (ack==0)
  {
    SendRemoteString(OUTBOX, 1, cmd);
    ReceiveRemoteNumber(INBOX, true, ack);
  }

}


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

inline void BTCoast(byte ID, byte outp)
{

  string  buf, cmd="C";
  string  sID, soutp;
  char len, INBOX, OUTBOX;


  sID = NumToStr(ID);

  soutp= NumToStr(outp);
  len=StrLen(soutp);
  while (len<4)
  {
     soutp=StrCat(" ",soutp);
     len=StrLen(soutp);
  }


  cmd=StrCat(cmd,soutp);

  INBOX = 3*ID;
  OUTBOX= INBOX -2;


  int ack=0;
  while (ack==0)
  {
    SendRemoteString(OUTBOX, 1, cmd);
    ReceiveRemoteNumber(INBOX, true, ack);
  }

}


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void BTConnect(int conn)    // <> header file
{
  TextOut( 0, LCD_LINE1, "connect: slave ", false);
  NumOut (92, LCD_LINE1, conn, false);

  do {
    CommExecuteFunctionType args2;
    args2.Cmd = INTF_CONNECT;
    args2.Param1 = conn-1; // device index
    args2.Param2 = conn;   // connection index
    SysCommExecuteFunction(args2);  // make the connection
  }
  while (BluetoothStatus(conn)==STAT_COMM_PENDING) ;


  TextOut(0,LCD_LINE1, "connected:slave ", false);
  NumOut (92, LCD_LINE1, conn, false);
}


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void   StartBTMuxNetwork(int Number_of_Slaves)  // NOS=Number Of Slaves
{
   _NOS_= Number_of_Slaves;  //_NOS_ global var used by task ReceiveSlaveData()

   if (_NOS_ >=1) BTConnect(BT_CONN_1);
   if (_NOS_ >=2) BTConnect(BT_CONN_2);
   if (_NOS_ ==3) BTConnect(BT_CONN_3);

   start ReceiveSlaveData;
}


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void Init()
{
   ResetSleepTimer();
   SetSleepTimeout(0);
}


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

task main()
{
  char s, p, d;
  long MyValue;

  Init();
  StartBTMuxNetwork(1);   // (1), (2), (3): number of slaves to be connected

  // this is for your own code using the above BT network functions
 
  // for motor control:
  // BTOnFwd...
  // BTRotateMotorEx
  // BTSetMotorEx...
  // BTCoast...
  // BTStop...
 
 
  // for sensor polling:
  // GetMuxSensorValue...


  while (true) {  }

}


für bis zu 3 Slaves (für Slaves 2 + 3 den Code anpassen):

Code: Alles auswählen

// SLAVE 1
//  v.102

//#define debug

#define BT_CONN   0
#define INBOX     1 // requests (motor ctrl, variables)
#define OUTBOX_1  2 // sensors (continuously)
#define OUTBOX_2  3 //
#define MyName "Slave 1"


int  SensorValueDim[10];       // number of value dimensions of 7 sensors
int  SensorValueDecimals[10];  // decimals: 1: (0...9), 4: (-999...9999)
long SensorArray[4];       // 1...4 returned long values of each sensor


char MPortArray[3];     //RotateMotorEx(OUT_A, 75, 360, 0, false, true);
char MPowrArray[3];
int  MAnglArray[3];
char MTpctArray[3];
bool MSyncArray[3];
bool MStopArray[3];


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


void InitSensors()
{
/////////////////////////////////////////////////////////////
//                              Sensors  S1...S4

   SetSensorTouch(0);
   SensorValueDim[0]=1;         // value dimensions of the 1st of 7 sensors
   SensorValueDecimals[0]=1;    // Touch Sensor: 1 decimal ("0" or "1")

   SetSensorType(1, SENSOR_TYPE_TOUCH);
   SetSensorMode(1, SENSOR_MODE_RAW);
   SensorValueDim[1]=1;         // value dimensions of the 2nd of 7 sensors
   SensorValueDecimals[1]=4;    // raw values: 4 decimals (max. "1023")

   SetSensorLowspeed(2);
   SensorValueDim[2]=1;        // value dimensions of the 3rd of 7 sensors
   SensorValueDecimals[2]=2;   // HTColorS. color number: 2 decimals (max. "17")

   SetSensorLowspeed(3);
   SensorValueDim[3]=1;        // value dimensions of the 4th of 7 sensors
   SensorValueDecimals[3]=3;   // Ultrasonic Sensor: 3 decimals (max. "255")


//                              e.g. "fictive" Sensors / Mux-Sensors
   SensorValueDim[4]=1;
   SensorValueDecimals[4]=1;

   SensorValueDim[5]=1;
   SensorValueDecimals[5]=1;

   SensorValueDim[6]=1;
   SensorValueDecimals[6]=1;


//                              e.g. Motor Counter M1...M3
   SensorValueDim[7]=1;
   SensorValueDecimals[7]=6;

   SensorValueDim[8]=1;
   SensorValueDecimals[8]=6;

   SensorValueDim[9]=1;
   SensorValueDecimals[9]=6;

/////////////////////////////////////////////////////////////

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


void GetSensorValues(int i)
{
   switch (i) {

          case 0: SensorArray[0]=Sensor(i);
                  break;

          case 1: SensorArray[0]=SensorRaw(i);
                  break;

          case 2: SensorArray[0]=SensorHTColorNum(i);
                  break;

          case 3: SensorArray[0]=SensorUS(i);
                  break;

          case 4: SensorArray[0]=0;      break;

          case 5: SensorArray[0]=0;      break;

          case 6: SensorArray[0]=0;      break;

          case 7: SensorArray[0]=MotorRotationCount(0);  break;

          case 8: SensorArray[0]=MotorRotationCount(1);  break;

          case 9: SensorArray[0]=MotorRotationCount(2);  break;

   }
}


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

inline void MotorOff(const byte &port)
{
   SetOutput(port, Power, 0, OutputMode, OUT_MODE_COAST, RegMode, OUT_REGMODE_IDLE,
             RunState, OUT_RUNSTATE_IDLE, UpdateFlags, UF_UPDATE_MODE + UF_UPDATE_SPEED);
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
inline void SetMotorFieldArray(byte outp, char powr, int angl, char tpct, char sync, char stpp)
{                       //                     0         1          2          3          4

     MPowrArray[outp]=powr;
     MAnglArray[outp]=angl;
     MTpctArray[outp]=tpct;
     MSyncArray[outp]=sync;
     MStopArray[outp]=stpp;
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
task ResetMotor()
{
   MotorOff(OUT_A);
   Wait(1);
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


task SetMotorEx_A()
{
    // RotateMotorEx(port, power, tacholimit, TurnPct, SynchRatio, StoppMode);
    bool stpp;
    {
     stpp= MStopArray[OUT_A];
     RotateMotorEx (OUT_A, MPowrArray[OUT_A], MAnglArray[OUT_A], MTpctArray[OUT_A], MSyncArray[OUT_A],stpp);
     Wait(1);
     ResetTachoCount(OUT_A); Wait(1);
     SetMotorFieldArray(OUT_A,0,0,0,0,stpp);
   }
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

task SetMotorEx_B()
{
    bool stpp;
   {

     stpp= MStopArray[OUT_B];
     RotateMotorEx (OUT_B, MPowrArray[OUT_B], MAnglArray[OUT_B], MTpctArray[OUT_B], MSyncArray[OUT_B], stpp);
     Wait(1);
     ResetTachoCount(OUT_B); Wait(1);
     SetMotorFieldArray(OUT_B,0,0,0,0,stpp);
   }
}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

task SetMotorEx_C()
{
    bool stpp;
   {
     stpp= MStopArray[OUT_C];
     RotateMotorEx (OUT_C, MPowrArray[OUT_C], MAnglArray[OUT_C], MTpctArray[OUT_C], MSyncArray[OUT_C], stpp);
     Wait(1);
     ResetTachoCount(OUT_C); Wait(1);
     SetMotorFieldArray(OUT_C,0,0,0,0,stpp);
   }
}
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


inline void ExecCmd(string cmd)
{
  char l, port=0, power=0, turnpct=0, synch=0, stopp=0;
  int  angle=0;
  string sport,  spower,  sangle,  sturnpct,  ssynch,  sstopp;


  TextOut(0, 56, cmd); //Wait(500);

  l=cmd[0];

  if (l=='R')     // RotateMotorEx
  {
     sport=SubStr(cmd, 1, 4);
     port=StrToNum(sport);            TextOut(0,48, sport);

     spower=SubStr(cmd, 5, 4);
     power=StrToNum(spower);          TextOut(0,40, spower);

     sangle=SubStr(cmd, 9, 6);
     angle=StrToNum(sangle);          TextOut(0,32, sangle);

     sturnpct=SubStr(cmd, 15, 4);
     turnpct=StrToNum(sturnpct);      TextOut(0,24, sturnpct);

     ssynch= SubStr(cmd,19, 1);
     synch=StrToNum(ssynch);          TextOut(0,16, ssynch);

     sstopp= SubStr(cmd,20, 1);
     stopp=StrToNum(sstopp);          TextOut(0, 8, sstopp);

     MotorOff(port); Wait(1);
     RotateMotorEx (port, power, angle, turnpct, synch, stopp );
     Wait(1);
  }

  if (l=='X')   // SetMotorEx= starts RotoateMotorEx in a personal task
  {
     sport=SubStr(cmd, 1, 4);
     port=StrToNum(sport);            TextOut(0,48, sport);

     spower=SubStr(cmd, 5, 4);
     power=StrToNum(spower);          TextOut(0,40, spower);

     sangle=SubStr(cmd, 9, 6);
     angle=StrToNum(sangle);          TextOut(0,32, sangle);

     sturnpct=SubStr(cmd, 15, 4);
     turnpct=StrToNum(sturnpct);      TextOut(0,24, sturnpct);

     ssynch= SubStr(cmd,19, 1);
     synch=StrToNum(ssynch);          TextOut(0,16, ssynch);

     sstopp= SubStr(cmd,20, 1);
     stopp=StrToNum(sstopp);          TextOut(0, 8, sstopp);
     

     if (port==OUT_A) {
        MotorOff(OUT_A);  Wait(1);
        ResetTachoCount(OUT_A); Wait(1);
        stop SetMotorEx_A; Wait(1);
        SetMotorFieldArray(OUT_A, power, angle, turnpct, synch, stopp);
        start SetMotorEx_A;
     }
     
     else
     
     if (port==OUT_B) {
        MotorOff(OUT_B);  Wait(1);
        ResetTachoCount(OUT_B); Wait(1);
        stop SetMotorEx_B; Wait(1);
        SetMotorFieldArray(OUT_B, power, angle, turnpct, synch, stopp);
        start SetMotorEx_B;
     }
     
     else
     
     if (port==OUT_C) {
        MotorOff(OUT_C);  Wait(1);
        ResetTachoCount(OUT_C); Wait(1);
        stop SetMotorEx_C; Wait(1);
        SetMotorFieldArray(OUT_C, power, angle, turnpct, synch, stopp);
        start SetMotorEx_C;
     }

     Wait(1);
  }


  if (l=='F')
  {
     sport=SubStr(cmd, 1, 4);
     port=StrToNum(sport);        TextOut(0,48, sport);
     spower=SubStr(cmd, 5, 4);
     power=StrToNum(spower);      TextOut(0,40, spower);

     MotorOff(port); Wait(1);
     OnFwd( port, power);
     Wait(1);
  }

}

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

void Init()
{
   ResetSleepTimer();
   SetSleepTimeout(0);

/*                                      // führt zu sofortigem Abbruch!
   SetMotorFieldArray(OUT_A,0,0,0,0,0);
   SetMotorFieldArray(OUT_B,0,0,0,0,0);
   SetMotorFieldArray(OUT_C,0,0,0,0,0);
*/

}


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


void BTCheck(int conn)
{
  while (!BluetoothStatus(conn)==NO_ERR)
  {
    TextOut(5, LCD_LINE2, "looking for BT", false);
    Wait(100);

  }
  TextOut(5, LCD_LINE2, "                   ", false);
}


//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

task main()
{

  string sp, sz, sn, svv;
  string fmtstr, buf, buf0, buf1, buf2, buf3, out, outp, in;

  int port, dim, dec, len, t;


  /////////////////////////////////////////////////////////////////

  Init();
  InitSensors();

  BTCheck(0);      // Slave Channel

  /////////////////////////////////////////////////////////////////

  while(true)
  {
     out="";


     for(port=0;port<=9;port++)   // Sensorports: 0...3
     {

        GetSensorValues(port) ;

        dim=SensorValueDim[port];
        dec=SensorValueDecimals[port];

        outp="";
        buf0=""; buf1=""; buf2=""; buf3="";

        sp=NumToStr(port);    // sensor port
        sz=NumToStr(dim);     // sensor dimension
        sn=NumToStr(dec);     // value decimals

        fmtstr=StrCat("%",NumToStr(dec),"d");
       
        buf0=FormatNum(fmtstr,SensorArray[0]);
        svv=buf0;
        //- - - - - - - - - - - - - -  - - - -
        if (dim>=2){
          buf1=FormatNum(fmtstr,SensorArray[1]);
          svv=StrCat(svv,buf1);
        }
        //- - - - - - - - - - - - - -  - - - -
        if (dim>=3){
          buf2=FormatNum(fmtstr,SensorArray[2]);
          svv=StrCat(svv,buf2);
        }
        //- - - - - - - - - - - - - -  - - - -
        if (dim==4){
          buf3=FormatNum(fmtstr,SensorArray[3]);
          svv=StrCat(svv,buf3);
        }
        //- - - - - - - - - - - - - -  - - - -

        outp= StrCat(sp,sz,sn,svv);
        out = StrCat(out, outp);
#ifdef debug
        if (port<=3)     // auf Display: Sensoren 0...3
        {
          NumOut (0,  48-8*port, port,  false);
          TextOut(10, 48-8*port ,outp,  false);
        }

        if (port>6)      // auf Display:  mCounter 0...2
        {
          NumOut (0,  48-8*(port-3), port, false);
          TextOut(10, 48-8*(port-3), outp, false);
        }
#endif
     } //  for port=...

     if (StrLen(out)>58) strncpy(out,out,58);     // 58 = max msg length
     SendResponseString(OUTBOX_1, out);
     
     in= "     ' '       ";
#ifdef debug
     TextOut(0, 56, in);
#endif
     if (ReceiveRemoteString(INBOX, true, buf) != STAT_MSG_EMPTY_MAILBOX)
     {
       SendResponseNumber(OUTBOX_2, 0xff);
       ExecCmd(buf);
     }

     Wait(0);

  } // while(true)

} // 


Bug Reports werden begrüßt!
Gruß,
HaWe
±·≠≈²³αβγδε∂ζλμνπξφωΔΦ≡ΠΣΨΩ∫√∀∃∈∉∧∨¬⊂⊄∩∪∅∞
NXT NXC SCHACHROBOTER: https://www.youtube.com/watch?v=Cv-yzuebC7E

Zurück zu „Projekte, Showcase, Bauanleitungen“

Wer ist online?

Mitglieder in diesem Forum: Google Adsense [Bot] und 8 Gäste

Lego Mindstorms EV3, NXT und RCX Forum : Haftungsauschluss