Mindstormsforum Dateiupload | Links | Lexikon | NXT Shop | RobotC.de | Wettbewerbe |    Seitenreport - Die SEO und Website Analyse

bild
bild
Unbeantwortete Themen | Aktive Themen Aktuelle Zeit: 1. Nov 2014 13:58


Auf das Thema antworten  [ 1 Beitrag ] 
NXC: BT Multiplexer für Sensoren + Motoren (bis 4 NXTs) 
Autor Nachricht
Administrator
Administrator
Benutzeravatar

Registriert: 11. Jan 2006 21:01
Beiträge: 4353
Wohnort: ein kleiner Planet in der Nähe von Beteigeuze
Beitrag NXC: BT Multiplexer für Sensoren + Motoren (bis 4 NXTs)
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:
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:
// 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:
// 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


20. Aug 2011 13:02
Profil
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Auf das Thema antworten   [ 1 Beitrag ] 

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 9 Gäste


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
Gehe zu:  
Impressum Powered by phpBB © 2000, 2002, 2005, 2007 phpBB Group.
Designed by ST Software for PTF.
Deutsche Übersetzung durch phpBB.de