首页 › Arduino › 偶的遥控小车－可以运行，但是有瑕疵

萧芸凤 发表于 2012-12-10 19:30:01

偶的遥控小车－可以运行，但是有瑕疵

本帖最后由 萧芸凤 于 2012-12-10 19:44 编辑

忙了一个月的小车暂时告一段落了，基本实现了预想的功能，剩下的就是一些完善的细节了。
整个小车有两个模式，一个是遥控控制，使用摇杆输入速度和方向。按键是控制灯光的，实现左转弯，右转弯，刹车，倒车的灯光和蜂鸣器响应。这个灯光和速度也有自动和手动模式，自动的时候除了前大灯是需要手动控制外其他的在执行相应的动作时可以实现，手动那就是完全的按键操作了。
另一个模式就是自动避障，这个最简单了，也是里面出错较少的一个，全程不需要遥控操作。
目前的主要问题还是在遥控数据的发送和接收，使用了帧结构还是会出现数据接收错误。现在把程序发出来大家探讨。
说明一下，由于使用的是2560,串口比较多，所以程序中涉及到Serial的是调试用的，发送的是Serial1.
另一个项目使用诺基亚屏幕实现菜单功能还在完善当中，这周应该会有结果了，先预告一下。当然了，只是菜单功能，菜单里面的实际动作无法实现，没有相应的模块。
先上小车的图。



然后是比较冗长繁琐的代码。
摇控器部分
#include <Wire.h>
///////////////////////////////方向控制引脚（电位计输入） ////////////
#define DIRECT_INPUTA6
///////////////////////////////速度控制引脚（电位计输入)////////////
#define SPEED_INPUT   A7
///////////////////////////////状态指示灯控制（输入引脚） ////////////
#define LED_AUTO      33
#define SPEED_AUTO    40
#define FRONT_LED   38
#define LEFT_LED      34
#define RIGHT_LED   39
#define SKID_LED      35
#define BACK_LED      37
#define BUZZER      36
//////////////////////////////// 自动控制按键输入/////////////////////
#define ON_OFF_CTRL   30
#define MANUAL_CTRL   31
#define SMART_CTRL    32
#define DATA_GET      29
//////////////////////////////// 方向（舵机）最大角度控制 //////////////
#define DIRECT_LEFT_MAX       89
#define DIRECT_LEFT_MIN       45
#define DIRECT_RIGHT_MAX      135
#define DIRECT_RIGHT_MIN      91
#define DIRECT_MIDDLE         90
#define SPEED_FORWARD_MAX   249
#define SPEED_FORWARD_MIN   101
#define SPEED_BACK_MAX      99
#define SPEED_BACK_MIN      50
#define SPEED_STOP            0
///////////////////////////////////// 传感器（摇杆模块）参数 ///////////
#define SENSOR_LEFT         399
#define SENSOR_RIGHT          623
#define SENSOR_FORWARD      449
#define SERSOR_BACK         550
/////////////////////////////////// 数组大小，延时时间等//////////////
#define WIRELESS_DALAY_TIME          10
#define WIRELESS_DALAY_TIME_SEND   10
#define WIRELESS_DALAY_TIME_RECEIVE20
////////////////////////////////////帧头帧尾定义 /////////////////////
#define FRAME_HEAD_H      0xFA
#define FRAME_HEAD_L      0xFB
#define FRAME_END         0xFC
/////////////////////// 车辆引脚初始化 //////////////////////////////////
void remoteInti()
{
pinMode ( DIRECT_INPUT , INPUT );
pinMode ( SPEED_INPUT, INPUT );

pinMode ( FRONT_LED    , INPUT );
pinMode ( LEFT_LED   , INPUT );
pinMode ( RIGHT_LED    , INPUT );
pinMode ( SKID_LED   , INPUT );
pinMode ( BACK_LED   , INPUT );
pinMode ( BUZZER       , INPUT );
pinMode ( LED_AUTO   , INPUT );
pinMode ( SPEED_AUTO   , INPUT );

pinMode ( SMART_CTRL   , INPUT );
pinMode ( MANUAL_CTRL, INPUT );
pinMode ( ON_OFF_CTRL, INPUT );
pinMode ( DATA_GET   , INPUT );

}
///////////////////////// 手动方向控制（数据转换） //////////////////////
byte manualDirectCtrl()
{
int direct;
direct= analogRead(DIRECT_INPUT);
if ( direct >= 0 && direct <= SENSOR_LEFT )                                                 // 将电位计模拟量转换为角度
    {
      direct= map(direct,0,SENSOR_LEFT,DIRECT_LEFT_MIN,DIRECT_LEFT_MAX);                  //左转向
    }   
if (direct > SENSOR_LEFT && direct < SENSOR_RIGHT)
    {
      direct= map(direct,SENSOR_LEFT + 1,SENSOR_RIGHT - 1,DIRECT_MIDDLE,DIRECT_MIDDLE);   //正向行驶
    }
if (direct >= SENSOR_RIGHT && direct <= 1023)
    {
      direct= map(direct,SENSOR_RIGHT,1023,DIRECT_RIGHT_MIN,DIRECT_RIGHT_MAX);            //右转向
    }
    //Serial.print("direct = :   ");// 调试用
    //Serial.println(direct);

return (byte) direct;
}
//////////////////////////////////// 速度控制 /////////////////////////////
byte manualSpeedCtrl()
{
int speed;
speed   = analogRead(SPEED_INPUT);
if (speed >= 0 && speed <= SENSOR_FORWARD)                                                 // 前进
{
    speed   = map(speed,0,SENSOR_FORWARD,SPEED_FORWARD_MAX,SPEED_FORWARD_MIN);
}
if (speed > SENSOR_FORWARD && speed < SERSOR_BACK)                                       // 停止
{
    speed = map(speed,SENSOR_FORWARD + 1 ,SERSOR_BACK,SPEED_STOP,SPEED_STOP);
}
if (speed >= SERSOR_BACK && speed <= 1023)                                                 // 后退
{
    speed   = map(speed,SERSOR_BACK - 1,1023,SPEED_BACK_MIN,SPEED_BACK_MAX);               
}
//Serial.print("speed = :   ");   // 调试用
//Serial.println( speed );
return (byte) speed;
}
//////////////////////////////LED 控制////////////////////////////////
byte ledCtrl()
{
byte led ;
bitWrite( led , 0 , digitalRead( LED_AUTO   ));
bitWrite( led , 1 , digitalRead( SPEED_AUTO ));
bitWrite( led , 2 , digitalRead( FRONT_LED));
bitWrite( led , 3 , digitalRead( LEFT_LED   ));
bitWrite( led , 4 , digitalRead( RIGHT_LED));
bitWrite( led , 5 , digitalRead( SKID_LED   ));
bitWrite( led , 6 , digitalRead( BACK_LED   ));
bitWrite( led , 7 , digitalRead( BUZZER   ));
return led ;
}
//////////////////////长整形转化为字节数组 /////////////////////////////
void longtoByte(long *arraylong,byte *arraybyte,int N)
{
for (int i = 0; i < N; i++)
{
    for (int j = 0 ; j < 4 ; j++)
    {
      arraybyte = arraylong >> (j * 8 );
      //Serial.print(arraybyte,HEX);         // 调试用
      //Serial.print("|");
    }
}
      //Serial.println();
}
////////////////////////字节数组转换为长整形 ///////////////////////////
void bytetoLong(byte *arraybyte,long *arraylong,int N)
{
long temp_0,temp_1;

for ( int i = 0 ; i < N ; i++)
{   
    temp_1 = 0;
    for ( int j = 3 ; j >= 0 ; j--)
    {
      temp_0 = arraybyte[ ( i * 4 ) + j ];
      temp_1 = temp_1 | ( temp_0 << (j * 8));
      //Serial.print(temp_0,HEX);                  // 调试用
      //Serial.print("||");
    }
      arraylong = temp_1 ;
      Serial.print(arraylong,HEX);
      //Serial.print("|||");                     // 调试用
      //Serial.println();
}
      //Serial.println();
}
///////////////////////整型转换为字节数组 ///////////////////////////////
void inttoByte(int *arrayint,byte *arraybyte,int N)
{
for (int i = 0; i < N; i++)
{
    for (int j = 0 ; j < 2 ; j++)
    {
      arraybyte = arrayint >> (j * 8 );
      //Serial.print(arraybyte,HEX);       // 调试用
      //Serial.print("|");
    }
}
      //Serial.println();
}
/////////////////////////   字节数组转换为整型    /////////////////////////
void bytetoInt(byte *arraybyte,int *arrayint,int N)
{
long temp_0,temp_1;
for ( int i = 0 ; i < N ; i++)
{   
    temp_1 = 0;
    for ( int j = 1 ; j >= 0 ; j--)
    {
      temp_0 = arraybyte[ ( i * 2 ) + j ];
      temp_1 = temp_1 | ( temp_0 << (j * 8));
      //Serial.print(temp_0,HEX);             // 调试用
      //Serial.print("||");
    }
      arrayint = temp_1 ;
      //Serial.print(arrayint,HEX);      // 调试用
      //Serial.print("|||");
      //Serial.println();
}
      //Serial.println();
}
///////////////////////////////数据帧发送 /////////////////////////////
boolean dataFrameSend( byte *datasend , byte datalen )
{
byte rc , count ;
count = 0 ;
rc = 0 ;
for ( int i = 0 ; i < datalen ; i++ )
    rc ^= datasend;                // 计算数据校验结果，数据按位异或处理
//Serial.print(" rc =");          // 调试用
//Serial.println(rc);
Serial1.write(FRAME_HEAD_H);
delay(WIRELESS_DALAY_TIME_SEND);
count ++;
Serial1.write(FRAME_HEAD_L);
delay(WIRELESS_DALAY_TIME_SEND);    // 发送帧头（两位，0xFA,0xFB)
count ++;
Serial1.write(datalen);
delay(WIRELESS_DALAY_TIME_SEND);    // 发送数据长度
count ++;
for ( int i = 0 ; i < datalen ; i++)
{
    Serial1.write(datasend);
    delay(WIRELESS_DALAY_TIME_SEND);// 数据发送
    count ++;
}                  
Serial1.write(rc);
delay(WIRELESS_DALAY_TIME_SEND);    // 发送校验结果
count ++;
Serial1.write(FRAME_END);   
count ++;
delay(WIRELESS_DALAY_TIME_SEND);    // 发送结束位
if ( count == ( datalen + 5))       // 结果返回
    return 1;
else
    return 0;
//////////////////////////一个数据帧包含以下信息//////////////////////////
//帧头（高位）    帧头（低位）    数据长度    数据      校验      帧头    //
//0xFA            0xFB             datalen    datasendrc(XOR)   0xFC    //
//////////////////////////////////////////////////////////////////////////////
}
/////////////////////////////数据帧接收 /////////////////////////////////
boolean dataFrameReceive(byte *datareceive,byte datalen)
{
//byte frameheadL,frameheadH,datalenr,rc,frameend;// 调试用
byte temp,r,count;
boolean frame;
frame = false;
while ( Serial1.available() )         //串口缓存有数据，同时停止标志位假时进行数据读取
{
    count = 0;
    r = 0;
    temp = Serial1.read();
    delay(WIRELESS_DALAY_TIME_RECEIVE);
    count ++;
    if (temp == FRAME_HEAD_H)         //帧头（高位）读取判断
    {
      //frameheadH = temp;
      temp = Serial1.read();
      delay(WIRELESS_DALAY_TIME_RECEIVE);
      count ++;
      if (temp == FRAME_HEAD_L)         //帧头（低位）读取判断
      {
      //frameheadL = temp;
      temp = Serial1.read();
      delay(WIRELESS_DALAY_TIME_RECEIVE);
      count ++;               
      if ( temp == datalen)         //数据长度读取判断
      {
          //datalenr = temp;
          for ( int i = 0 ; i < datalen ; i++ )
          {
            datareceive= Serial1.read();
            delay(WIRELESS_DALAY_TIME_RECEIVE);
            count ++;         
          }                           //数据接收
          temp = Serial1.read();
          delay(WIRELESS_DALAY_TIME_RECEIVE);
          count ++;
          for (int i = 0 ; i < datalen ; i++ )
            r ^= datareceive;      //计算接收数据校验结果
          //Serial.print(" r =");   // 调试用
          //Serial.println(r);
          if ( r == temp)
          {
            //rc = temp;
            temp = Serial1.read();
            delay(WIRELESS_DALAY_TIME_RECEIVE);
            count ++;
            if (temp = FRAME_END)   // 接收结束位
            {
            //frameend = temp;
            frame = true;         // 帧接收成功标识
            return 1;
            //Serial.print(" count ="); // 调试用
            //Serial.println(count);
            Serial.println(" zheng que jie shou!");               // 调试用
            }
            else
            Serial.println(" mu you jie shou dao jie shu wei !");   // 调试用
          }
          else
            Serial.println("jiao yan jie guo bu zheng que !");      // 调试用
      }
      else
          Serial.println(" shu ju chang du jie shou cuo wu!");      // 调试用
      }
      else
      Serial.println(" zhen tou di wei cuo wu !");                  // 调试用
    }
    else
      Serial.println(" zhen tou gao wei cuo wo!");                  // 调试用
}
    Serial.println(" mei you shu ju huo shu ju jie shou ting zhi !"); // 调试用
    return 0;
}
///////////////////////////////////////////////////////////////////
void setup()
{
remoteInti();
Serial.begin(9600);
Serial1.begin(9600);
}
void loop()
{
boolean power = true;
boolean sw    = true;

byte datasend;               // 数据发送数组


while (digitalRead(ON_OFF_CTRL))// 电源按键控制
{
   
    datasend = 'P';
    datasend = 'L';
    datasend = 0xFF;
    datasend = 0xFF;
    datasend = 0xFF;
    datasend = 0xFF;
    datasend = 0xFF;
    datasend = 0xFF;
    if (sw)
    {
      dataFrameSend(datasend,8);
      sw = false;
      for (int i = 0 ; i < 8 ; i++ )          // 调试用
      {
      Serial.print(datasend);
      Serial.print("|   ");
      }
      Serial.println();
    }
    while (digitalRead(MANUAL_CTRL))          // 手动模式
    {
      byte ledcur , speedcur , directcur ;
      byte ledpre , speedpre , directpre ;
      ledcur      = ledCtrl();
      directcur   = manualDirectCtrl();
      speedcur    = manualSpeedCtrl();

      if (ledcur != ledpre || directcur != directpre || speedcur != speedpre )
      {
      datasend = 'M';
      datasend = 'D';
      datasend = 0xFE;
      datasend = 0xFE;
      datasend = ledcur;
      datasend = directcur;
      datasend = speedcur;
      datasend = 0xFF;
      dataFrameSend(datasend,8);            // 有数据发生改变时才会发送数据
      ledpre    = ledcur;
      directpre = directcur;
      speedpre= speedcur;
      for (int i = 0 ; i < 8 ; i++ )      // 调试用
      {
          Serial.print(datasend);
          Serial.print("|   ");
      }
          Serial.println();
      }
      
    }
    while (digitalRead(SMART_CTRL))         // 智能模式
    {
      byte ledcur;
      byte ledpre;
      ledcur      = ledCtrl();
      if (ledcur != ledpre)
      {
      datasend = 'S';
      datasend = 'D';
      datasend = 0xFE;
      datasend = 0xFE;
      datasend = ledcur;
      datasend = 0xFF;
      datasend = 0xFF;
      datasend = 0xFF;
      dataFrameSend(datasend,8);
      ledpre    = ledcur;
      for (int i = 0 ; i < 8 ; i++ )      // 调试用
      {
          Serial.print(datasend);
          Serial.print("|   ");
      }
          Serial.println();
      }
      
    }
    while (digitalRead(DATA_GET))          // 数据获取
    {   
      byte datareceive;
      byte cmd;
      byte masscur ;
      byte masspre ;
      masscur   = 'A';                     // 需要改变 的变量，可以使按键等
      
      //infcur = 'T';

      if (masscur != masspre)               // 发送数据请求
      {
      datasend = 'G';
      datasend = 'D';
      datasend = 0xFE;
      datasend = 0xFE;
      datasend = masscur;
      datasend = 0xFE;
      datasend = 0xFE;
      datasend = 0xFE;
      dataFrameSend(datasend,8);
      masspre = masscur;
      for (int i = 0 ; i < 8 ; i++ )    // 调试用
      {
          Serial.print(datasend);
          Serial.print("|   ");
      }
          Serial.println();
      }

      if (dataFrameReceive(datareceive,5))// 接收回传数据
      {
      for (int i = 0 ; i < 5 ; i++ )      // 调试用
      {
          Serial.print(datareceive);
          Serial.print("|   ");
      }
          Serial.println();

      cmd = datareceive;
      switch(cmd)
      {
          case 'A' :
                  while(!Serial1.available())   // 酒精量测试数据
                  {
                      int alcohol;
                      byte alcoholbyte;
                      alcoholbyte = datareceive;
                      alcoholbyte = datareceive;
                      bytetoInt(alcoholbyte,&alcohol,1);
                      Serial.print( " alcohol : " );    // 调试用
                      Serial.println(alcohol);
                  }
                  break;

          case 'B' :
                  while(!Serial1.available())   // 可燃气体测试数据
                  {
                      int combustible;
                      byte combustiblebyte;
                      combustiblebyte = datareceive;
                      combustiblebyte = datareceive;
                      bytetoInt(combustiblebyte,&combustible,1);
                      Serial.print( " combustible : " );    // 调试用
                      Serial.println(combustible);
                  }
                  break;

          case 'T' :
                  while(!Serial1.available())   // 温度测试数据
                  {
                      int temperature;
                      byte temperaturebyte;
                      temperaturebyte = datareceive;
                      temperaturebyte = datareceive;
                      bytetoInt(temperaturebyte,&temperature,1);
                      Serial.print( " temperature : " );    // 调试用
                      Serial.println(temperature);
                  }
                  break;
          default :
                  break;
      }
      }
    }
}
}

小车部分

#include <Wire.h>
#include <Servo.h>
/////////////////////////////// 方向控制引脚（舵机输出）////////////////////
#define DIRECT_OUTPUT   13
//////////////////////////////速度控制引脚（输出接至电机驱动板 )////////
#define SPEED_CTRL      46
#define MOTOR_DIRECT    47
///////////////////////////// 状态指示灯控制（输出引脚）////////////////////
//#define LED_AUTO      24
//#define SPEED_AUTO    25
#define FRONT_LED   26
#define LEFT_LED      22
#define RIGHT_LED   23
#define SKID_LED      24
#define BACK_LED      25
#define BUZZER      29
#define SPEAKER       12
#define POWER_LED   48
/////////////////////////// 气体传感器输入引脚///////////////////////////
#define ALCOHOL_AINPUTA13
#define COMBUST_AINPUTA14
#define ALCOHOL_DINPUT43
#define COMBUST_DINPUT44
//////////////////////////// 麦克风输出引脚 ///////////////////////////////
#define MIC_DINPUT      42
#define MIC_AINPUT      A12
///////////////////////////光敏传感器输入引脚 ///////////////////////////
#define LIGHT_SONSER    A15
/////////////////////////// 超声波测距输入引脚 ///////////////////////////
#define TRIQ8          // 触发输入
#define ECHO9          // 回响输出
/////////////////////////// 距离传感器输入引脚 ///////////////////////////
#define DISTANCE_LEFT   11
#define DISTANCE_RIGHT10
/////////////////////////// 七段码 LED数码管引脚 /////////////////////////
#define LED_A   30
#define LED_B   31
#define LED_C   32
#define LED_D   33
#define LED_E   34
#define LED_F   35
#define LED_G   36
#define LED_P   37
////////////////////////// 数码管选择///////////////////////////////////
#define LED_1   41
#define LED_2   42
#define LED_3   43
#define LED_4   44
/////////////////////////控制字（） ////////////////////////////////////
#define LED_AUTO_BIT      0
#define SPEED_AUTO_BIT    1            
///////////////////////距离速度范围控制//////////////////////////////
#define DIRECT_LEFT_MAX   89
#define DIRECT_LEFT_MIN   45
#define DIRECT_RIGHT_MAX135
#define DIRECT_RIGHT_MIN91
#define DIRECT_MIDDLE   90
#define SPEED_FORWARD_MAX 250
#define SPEED_FORWARD_MIN 101
#define SPEED_BACK_MAX    99
#define SPEED_BACK_MIN    50
#define SPEED_NORMAL      100
//////////////////////延时时间////////////////////////////////////////
#define DIRECT_TIME                  50
#define SPEED_TIME                   100
#define DELAY_TIME_1               2
#define LED_DISPLAY_TIME             60
#define WIRELESS_DALAY_TIME          50
#define WIRELESS_DALAY_TIME_SEND   10
#define WIRELESS_DALAY_TIME_RECEIVE30
///////////////////// 帧头帧尾定义 //////////////////////////////////////
#define FRAME_HEAD_H0xFA
#define FRAME_HEAD_L0xFB
#define FRAME_END   0xFC
////////////////////方向控制 //////////////////////////////////////////
#define FORWARD         HIGH
#define BACK            LOW
#define LEFT            HIGH
#define RIGHT             LOW
/////////////////// 转向距离控制 ///////////////////////////////////////
#define DISTANCE_TURN   300
#define DISTANCE_MAX      1000
//////////////////气体传感器初始化 ///////////////////////////////////
void gasInti()
{
pinMode(ALCOHOL_AINPUT,INPUT);
pinMode(ALCOHOL_DINPUT,INPUT);
pinMode(COMBUST_AINPUT,INPUT);
pinMode(COMBUST_DINPUT,INPUT);
}
/////////////////酒精数据读取 ////////////////////////////////////////
int alcoholRead()
{
int alcohol;
alcohol = analogRead(ALCOHOL_AINPUT);
delay(DELAY_TIME_1);
return alcohol;
}
////////////////可燃气体数据读取 /////////////////////////////////////
int combustibleRead()
{
int combustible;
combustible = analogRead(COMBUST_AINPUT);
delay(DELAY_TIME_1);
return combustible;
}

Servo mycar;   // 舵机声明
/////////////////超声波距离传感器初始化 //////////////////////////////
void distanceInti()
{
pinMode(TRIQ,OUTPUT);
pinMode(ECHO,INPUT );
}
////////////////超声波距离读取 ///////////////////////////////////////
int distance()
{
float distance;
int distanceToint;
digitalWrite(TRIQ, LOW);      // 发射低电压2μs
delayMicroseconds(2);
digitalWrite(TRIQ, HIGH);       // 发射高电压并维持10μs
delayMicroseconds(10);
digitalWrite(TRIQ, LOW);      // 恢复低压发射
distance = pulseIn(ECHO, HIGH); // 读取返回时间差
distance = distance / 5.8 / 10;   
distanceToint =(int) distance * 10 ;
return distanceToint;
}
////////////////// 小车引脚初始化 ///////////////////////////////////////
void carInti()
{

pinMode( SPEED_CTRL   , OUTPUT );
pinMode( MOTOR_DIRECT , OUTPUT );

pinMode( FRONT_LED    , OUTPUT );
pinMode( LEFT_LED   , OUTPUT );
pinMode( RIGHT_LED    , OUTPUT );
pinMode( SKID_LED   , OUTPUT );
pinMode( BACK_LED   , OUTPUT );
pinMode( BUZZER       , OUTPUT );
pinMode( POWER_LED    , OUTPUT );
pinMode( DISTANCE_LEFT, INPUT);
pinMode(DISTANCE_RIGHT, INPUT);

}
//////////////////////////////////// LED闪烁函数////////////////////////
void ledSpark(byte led,byte speed)
{
digitalWrite(led,HIGH);
delay(speed);
digitalWrite(led,LOW);
delay(speed);
}
//////////////////////////////////// LED 控制函数 ////////////////////////
void ledCtrl(byte ledct)
{
//digitalWrite( LED_AUTO, bitRead(ledct,0) );
//digitalWrite( SPEED_AUTO, bitRead(ledct,1) );
digitalWrite( FRONT_LED , bitRead(ledct,2) );
if( bitRead(ledct,3) )
ledSpark( LEFT_LED, 60 );
if( bitRead(ledct,4) )
ledSpark( RIGHT_LED , 60 );
digitalWrite( SKID_LED, bitRead(ledct,5) );
if(bitRead(ledct,6))
ledSpark( BACK_LED, 60 );
digitalWrite( BUZZER    , bitRead(ledct,7) );

}

///////////////////////// 方向控制 ///////////////////////////////////////
void directCtrl(byte directIn,byte ledct)
{
if (directIn >= DIRECT_LEFT_MIN&& directIn <= DIRECT_LEFT_MAX)   //左转向
{
    if (bitRead(ledct,LED_AUTO_BIT))
    {
      digitalWrite( FRONT_LED , bitRead(ledct,2) );
      ledSpark( LEFT_LED, 60 );
      digitalWrite( RIGHT_LED ,LOW);
      digitalWrite( SKID_LED,bitRead(ledct,5));
      ledSpark( BUZZER    ,60 );
    }
    else
    {
      ledCtrl(ledct);
    }
}   
if (directIn == DIRECT_MIDDLE )                                 // 前行／后退
{
    if (bitRead(ledct,LED_AUTO_BIT))
    {
      
      digitalWrite( FRONT_LED , bitRead(ledct,2));      
      digitalWrite( LEFT_LED,LOW );      
      digitalWrite( RIGHT_LED ,LOW );
      if( bitRead(ledct,5) )
      ledSpark( SKID_LED, 60 );
      digitalWrite( BUZZER   ,bitRead(ledct,7) );
    }
    else
    {
      ledCtrl(ledct);
    }
}
if (directIn >= DIRECT_RIGHT_MIN && directIn <= DIRECT_RIGHT_MAX ) // 右转向
{
    if (bitRead(ledct,LED_AUTO_BIT))
    {
      digitalWrite( FRONT_LED, bitRead(ledct,2) );
      digitalWrite( LEFT_LED,LOW );
      ledSpark( RIGHT_LED ,60 );
      digitalWrite( SKID_LED, bitRead(ledct,5));
      ledSpark( BUZZER    ,60 );
      Serial.println("ri");
    }
    else
    {
      ledCtrl(ledct);
    }
}
//Serial.print("direct = :   ");// 调试用
//Serial.println(directIn);
//carDirection.write(directIn);
//delay(100);
mycar.write(directIn);
delay(DIRECT_TIME);
}
//////////////////////////////////// 速度控制 ///////////////////////////////
void speedCtrl(byte speedIn,byte ledct)
{
if (speedIn >= SPEED_BACK_MIN && speedIn <= SPEED_BACK_MAX)         //后退
{
    if (bitRead(ledct,LED_AUTO_BIT))
    {
      digitalWrite(FRONT_LED,bitRead(ledct,2));
      digitalWrite(SKID_LED,bitRead(ledct,5));
      ledSpark( BACK_LED ,60 );
      ledSpark( BUZZER   ,60 );   
    }
    else
    {
      ledCtrl(ledct);
    }
    digitalWrite(MOTOR_DIRECT,BACK);   
    if(bitRead(ledct,SPEED_AUTO_BIT))
    {
      analogWrite(SPEED_CTRL,SPEED_NORMAL);
      delay(SPEED_TIME);
    }
    else
    {
      analogWrite(SPEED_CTRL,speedIn);
      delay(SPEED_TIME);
      //Serial.print("speed = :   ");   // 调试用
      //Serial.println(speed);
    }
}
if (speedIn == 100 )                                              //停止
{
    if (bitRead(ledct,LED_AUTO_BIT))
    {
      ledCtrl(ledct);
    }
    else
    {
      ledCtrl(ledct);
    }
    digitalWrite(MOTOR_DIRECT,LOW);   
    digitalWrite(SPEED_CTRL,LOW);
}
if (speedIn > SPEED_FORWARD_MIN && speedIn <= SPEED_FORWARD_MAX)    //前进
{
    if (bitRead(ledct,LED_AUTO_BIT))
    {
      digitalWrite(FRONT_LED,bitRead(ledct,2));
      digitalWrite(SKID_LED,bitRead(ledct,5));
      digitalWrite( BACK_LED,LOW );
      digitalWrite(BUZZER,bitRead(ledct,7));

    }
    else
    {
      ledCtrl(ledct);
    }
    digitalWrite(MOTOR_DIRECT,FORWARD);      //加速   
    if(bitRead(ledct,SPEED_AUTO_BIT))
    {
      analogWrite(SPEED_CTRL,SPEED_NORMAL);
      delay(SPEED_TIME);
    }
    else
    {
      analogWrite(SPEED_CTRL,speedIn);
      delay(SPEED_TIME);
      //Serial.print("speed = :   ");   // 调试用
      //Serial.println(speed);
    }   
}

}
//////////////////////////////////////

//////////////////////////////////// 小车控制 /////////////////////////////
void manualCtrl(byte speedIn,byte directIn,byte ledct)
{
if (speedIn >= SPEED_BACK_MIN && speedIn <= SPEED_BACK_MAX)      //后退
{
    if (directIn >= DIRECT_LEFT_MIN&& directIn <= DIRECT_LEFT_MAX) //左转向
    {
      if (bitRead(ledct,LED_AUTO_BIT) )
      {
      digitalWrite( FRONT_LED , bitRead(ledct,2) );
      ledSpark( LEFT_LED, 60 );
      digitalWrite( RIGHT_LED , LOW);
      digitalWrite( SKID_LED,bitRead(ledct,5));
      ledSpark( BACK_LED, 60 );
      ledSpark( BUZZER    , 60 );
      }
      else
      {
      ledCtrl(ledct);
      }
   
    }   
    if (directIn == DIRECT_MIDDLE )                                  //直退
    {
      if (bitRead(ledct,LED_AUTO_BIT))
      {
      digitalWrite( FRONT_LED , bitRead(ledct,2) );
      digitalWrite( LEFT_LED, LOW );
      digitalWrite( RIGHT_LED , LOW );
      digitalWrite( SKID_LED,bitRead(ledct,5));
      ledSpark( BACK_LED, 60 );
      ledSpark( BUZZER    , 60 );
      }
      else
      {
      ledCtrl(ledct);
      }
   
    }
    if (directIn >= DIRECT_RIGHT_MIN && directIn <= DIRECT_RIGHT_MAX ) //右转向
    {
      if (bitRead(ledct,LED_AUTO_BIT))
      {
      digitalWrite( FRONT_LED , bitRead(ledct,2) );
      digitalWrite( LEFT_LED, LOW );
      ledSpark( RIGHT_LED   , 60);
      digitalWrite( SKID_LED,bitRead(ledct,5));
      ledSpark( BACK_LED, 60 );
      ledSpark( BUZZER    , 60 );
      }
      else
      {
      ledCtrl(ledct);
      }
   
    }

    mycar.write(directIn);
    delay(DIRECT_TIME);

    digitalWrite(MOTOR_DIRECT,BACK);
    if(bitRead(ledct,SPEED_AUTO_BIT))
    {
      analogWrite(SPEED_CTRL,SPEED_NORMAL);
      delay(SPEED_TIME);
    }
    else
    {
      analogWrite(SPEED_CTRL,speedIn);
      delay(SPEED_TIME);   
    }

}
if (speedIn == 100 )                                                    //停止
{
    ledCtrl(ledct);   
    digitalWrite(MOTOR_DIRECT,LOW);   
    digitalWrite(SPEED_CTRL,LOW);   
}

if (speedIn > SPEED_FORWARD_MIN && speedIn <= SPEED_FORWARD_MAX)      //前进
{
    if (directIn >= DIRECT_LEFT_MIN&& directIn <= DIRECT_LEFT_MAX)      //左转向
    {
      if (bitRead(ledct,LED_AUTO_BIT))
      {
      digitalWrite( FRONT_LED , bitRead(ledct,2) );
      ledSpark( LEFT_LED, 60 );
      digitalWrite( RIGHT_LED , LOW);
      digitalWrite( SKID_LED,bitRead(ledct,5));
      digitalWrite( BACK_LED, LOW );
      ledSpark( BUZZER    , 60 );
      }
      else
      {
      ledCtrl(ledct);
      }
   
    }   
    if (directIn == DIRECT_MIDDLE )                                       //直行
    {
      if (bitRead(ledct,LED_AUTO_BIT))
      {
      digitalWrite( FRONT_LED , bitRead(ledct,2) );
      digitalWrite( LEFT_LED, LOW );
      digitalWrite( RIGHT_LED , LOW);
      digitalWrite( SKID_LED,bitRead(ledct,5));
      digitalWrite( BACK_LED, LOW );
      if ( bitRead(ledct,7 ))
      ledSpark( BUZZER    , 60 );
      }
      else
      {
      ledCtrl(ledct);
      }
   
    }
    if (directIn >= DIRECT_RIGHT_MIN && directIn <= DIRECT_RIGHT_MAX )    //右转向
    {
      if (bitRead(ledct,LED_AUTO_BIT))
      {
      digitalWrite( FRONT_LED , bitRead(ledct,2) );
      digitalWrite( LEFT_LED, LOW );
      ledSpark( RIGHT_LED , 60);
      digitalWrite( SKID_LED,bitRead(ledct,5));
      digitalWrite( BACK_LED, LOW );
      ledSpark( BUZZER    , 60 );
      }
      else
      {
      ledCtrl(ledct);
      }
   
    }

    mycar.write(directIn);
    delay(DIRECT_TIME);
    digitalWrite(MOTOR_DIRECT,FORWARD);

    if(bitRead(ledct,SPEED_AUTO_BIT))
    {
      analogWrite(SPEED_CTRL,SPEED_NORMAL);
      delay(SPEED_TIME);
    }
    else
    {
      analogWrite(SPEED_CTRL,speedIn);
      delay(SPEED_TIME);   
    }
   
}


}
///////////////////////////智能控制模式 //////////////////////////////
void smartCtrl(byte ledct)
{

if ( distance() < DISTANCE_TURN && !DISTANCE_LEFT && DISTANCE_RIGHT ) // 右转
{
   
    digitalWrite( FRONT_LED, bitRead(ledct,2) );
    digitalWrite( LEFT_LED,LOW );
    ledSpark( RIGHT_LED ,60 );
    digitalWrite( SKID_LED, bitRead(ledct,5));
    digitalWrite( BACK_LED, bitRead(ledct,6));
    ledSpark( BUZZER    ,60 );
    mycar.write(DIRECT_RIGHT_MAX);
    delay(DIRECT_TIME);
    digitalWrite(MOTOR_DIRECT,FORWARD);
    analogWrite(SPEED_CTRL,SPEED_NORMAL);
    delay(SPEED_TIME);
}
if ( distance() < DISTANCE_TURN && DISTANCE_LEFT && !DISTANCE_RIGHT ) // 左转
{
    digitalWrite( FRONT_LED , bitRead(ledct,2) );
    ledSpark( LEFT_LED, 60 );
    digitalWrite( RIGHT_LED ,LOW);
    digitalWrite( SKID_LED,bitRead(ledct,5));
    digitalWrite( BACK_LED,bitRead(ledct,6));
    ledSpark( BUZZER    ,60 );
    mycar.write(DIRECT_LEFT_MAX);
    delay(DIRECT_TIME);
    digitalWrite(MOTOR_DIRECT,FORWARD);
    analogWrite(SPEED_CTRL,SPEED_NORMAL);
    delay(SPEED_TIME);
}
if ( distance()< DISTANCE_TURN && !DISTANCE_LEFT && !DISTANCE_RIGHT ) // 后退
{
    digitalWrite(FRONT_LED,bitRead(ledct,2));
    if( bitRead(ledct,3) )
    ledSpark(LEFT_LED ,60);
    if( bitRead(ledct,4) )
    ledSpark(RIGHT_LED,bitRead(ledct,4));
    digitalWrite(SKID_LED,bitRead(ledct,5));
    ledSpark( BACK_LED ,60 );
    ledSpark( BUZZER   ,60 );   
    mycar.write(DIRECT_MIDDLE);
    delay(DIRECT_TIME);
    digitalWrite(MOTOR_DIRECT,BACK);
    analogWrite(SPEED_CTRL,SPEED_NORMAL);
    delay(SPEED_TIME);
}
if ( distance() > DISTANCE_TURN )                                    // 前行
{
    digitalWrite(FRONT_LED,bitRead(ledct,2));
    digitalWrite(LEFT_LED,LOW);
    digitalWrite(RIGHT_LED,LOW);
    digitalWrite(SKID_LED,bitRead(ledct,5));
    digitalWrite( BACK_LED,LOW );
    digitalWrite(BUZZER,bitRead(ledct,7));
    mycar.write(DIRECT_MIDDLE);
    delay(DIRECT_TIME);
    digitalWrite(MOTOR_DIRECT,FORWARD);
    analogWrite(SPEED_CTRL,SPEED_NORMAL);
    delay(SPEED_TIME);
}

}
////////////////////////////////数码管控制 /////////////////////////////
void ledsevDisplay(byte led)
{
digitalWrite( LED_A , bitRead( led , 7 ));
digitalWrite( LED_B , bitRead( led , 6 ));
digitalWrite( LED_C , bitRead( led , 5 ));
digitalWrite( LED_D , bitRead( led , 4 ));
digitalWrite( LED_E , bitRead( led , 3 ));
digitalWrite( LED_F , bitRead( led , 2 ));
digitalWrite( LED_G , bitRead( led , 1 ));
digitalWrite( LED_P , bitRead( led , 0 ));
}
///////////////////////////////数码管位选择 ///////////////////////////
void ledNum(byte num)
{
digitalWrite( LED_1 , bitRead( num , 0 ));//0x01
digitalWrite( LED_2 , bitRead( num , 1 ));//0x02
digitalWrite( LED_3 , bitRead( num , 2 ));//0x04
digitalWrite( LED_4 , bitRead( num , 3 ));//0x08

}
////////////////////////////// 前行动画 ////////////////////////////////
void forword()
{

ledNum(0x08);
ledsevDisplay(0x6F);
delay(LED_DISPLAY_TIME);

ledNum(0x04);
ledsevDisplay(0x6F);
delay(LED_DISPLAY_TIME);

ledNum(0x02);
ledsevDisplay(0x6F);
delay(LED_DISPLAY_TIME);

ledNum(0x01);
ledsevDisplay(0x6F);
delay(LED_DISPLAY_TIME);
}
/////////////////////////////前行左转动画 ////////////////////////////
void leftF()
{
ledNum(0x08);
ledsevDisplay(0x7F);
delay(LED_DISPLAY_TIME);

ledNum(0x04);
ledsevDisplay(0x7F);
delay(LED_DISPLAY_TIME);

ledNum(0x02);
ledsevDisplay(0x7F);
delay(LED_DISPLAY_TIME);

ledNum(0x01);
ledsevDisplay(0x7F);
delay(LED_DISPLAY_TIME);

ledNum(0x01);
ledsevDisplay(0xFB);
delay(LED_DISPLAY_TIME);

ledNum(0x01);
ledsevDisplay(0xF7);
delay(LED_DISPLAY_TIME);

}
///////////////////////////// 前行右转动画 //////////////////////////////
void rightF()
{
ledNum(0x08);
ledsevDisplay(0xEF);
delay(LED_DISPLAY_TIME);

ledNum(0x04);
ledsevDisplay(0xEF);
delay(LED_DISPLAY_TIME);

ledNum(0x02);
ledsevDisplay(0xEF);
delay(LED_DISPLAY_TIME);

ledNum(0x01);
ledsevDisplay(0xEF);
delay(LED_DISPLAY_TIME);

ledNum(0x01);
ledsevDisplay(0xF7);
delay(LED_DISPLAY_TIME);

ledNum(0x01);
ledsevDisplay(0xFB);
delay(LED_DISPLAY_TIME);

}
////////////////////////////// 后退动画 ////////////////////////////////
void back()
{

ledNum(0x01);
ledsevDisplay(0x6F);
delay(LED_DISPLAY_TIME);

ledNum(0x02);
ledsevDisplay(0x6F);
delay(LED_DISPLAY_TIME);

ledNum(0x04);
ledsevDisplay(0x6F);
delay(LED_DISPLAY_TIME);

ledNum(0x08);
ledsevDisplay(0x6F);
delay(LED_DISPLAY_TIME);
}
////////////////////////////// 后退左转动画 ////////////////////////////
void leftB()
{
ledNum(0x01);
ledsevDisplay(0x7F);
delay(LED_DISPLAY_TIME);

ledNum(0x02);
ledsevDisplay(0x7F);
delay(LED_DISPLAY_TIME);

ledNum(0x04);
ledsevDisplay(0x7F);
delay(LED_DISPLAY_TIME);

ledNum(0x08);
ledsevDisplay(0x7F);
delay(LED_DISPLAY_TIME);

ledNum(0x08);
ledsevDisplay(0xFB);
delay(LED_DISPLAY_TIME);

ledNum(0x08);
ledsevDisplay(0xF7);
delay(LED_DISPLAY_TIME);

}
////////////////////////////// 后退右转动画 ///////////////////////////
void rightB()
{
ledNum(0x01);
ledsevDisplay(0xEF);
delay(LED_DISPLAY_TIME);

ledNum(0x02);
ledsevDisplay(0xEF);
delay(LED_DISPLAY_TIME);

ledNum(0x03);
ledsevDisplay(0xEF);
delay(LED_DISPLAY_TIME);

ledNum(0x08);
ledsevDisplay(0xEF);
delay(LED_DISPLAY_TIME);

ledNum(0x08);
ledsevDisplay(0xF7);
delay(LED_DISPLAY_TIME);

ledNum(0x08);
ledsevDisplay(0xFB);
delay(LED_DISPLAY_TIME);

}

//////////////////////////////////// 状态显示 ///////////////////////////////
void carRunStatus(byte speedIn,byte directIn)
{
if (speedIn >= SPEED_BACK_MIN && speedIn <= SPEED_BACK_MAX)             //后退
{
    if (directIn >= DIRECT_LEFT_MIN&& directIn <= DIRECT_LEFT_MAX)      //左转向
    {
      leftB();   
    }   
    if (directIn == DIRECT_MIDDLE )                                       //直退
    {
      back();   
    }
    if (directIn >= DIRECT_RIGHT_MIN && directIn <= DIRECT_RIGHT_MAX )   //右转向
    {
      rightB();   
    }
   
}
if (speedIn == 100 )                                                    //停止
{
   
}

if (speedIn > SPEED_FORWARD_MIN && speedIn <= SPEED_FORWARD_MAX)      //前进
{
    if (directIn >= DIRECT_LEFT_MIN&& directIn <= DIRECT_LEFT_MAX)      //左转向
    {
      leftF();
    }   
    if (directIn == DIRECT_MIDDLE )                                       //直行
    {
      forword();
    }
    if (directIn >= DIRECT_RIGHT_MIN && directIn <= DIRECT_RIGHT_MAX )    //右转向
    {
      rightF();
    }
}
}

//////////////////////长整形转化为字节数组 /////////////////////////////
void longtoByte(long *arraylong,byte *arraybyte,int N)
{
for (int i = 0; i < N; i++)
{
    for (int j = 0 ; j < 4 ; j++)
    {
      arraybyte = arraylong >> (j * 8 );
      //Serial.print(arraybyte,HEX);         // 调试用
      //Serial.print("|");
    }
}
      //Serial.println();
}
////////////////////////字节数组转换为长整形 ///////////////////////////
void bytetoLong(byte *arraybyte,long *arraylong,int N)
{
long temp_0,temp_1;

for ( int i = 0 ; i < N ; i++)
{   
    temp_1 = 0;
    for ( int j = 3 ; j >= 0 ; j--)
    {
      temp_0 = arraybyte[ ( i * 4 ) + j ];
      temp_1 = temp_1 | ( temp_0 << (j * 8));
      //Serial.print(temp_0,HEX);                  // 调试用
      //Serial.print("||");
    }
      arraylong = temp_1 ;
      Serial.print(arraylong,HEX);
      //Serial.print("|||");                     // 调试用
      //Serial.println();
}
      //Serial.println();
}
///////////////////////整型转换为字节数组 ///////////////////////////////
void inttoByte(int *arrayint,byte *arraybyte,int N)
{
for (int i = 0; i < N; i++)
{
    for (int j = 0 ; j < 2 ; j++)
    {
      arraybyte = arrayint >> (j * 8 );
      //Serial.print(arraybyte,HEX);       // 调试用
      //Serial.print("|");
    }
}
      //Serial.println();
}
/////////////////////////   字节数组转换为整型    /////////////////////////
void bytetoInt(byte *arraybyte,int *arrayint,int N)
{
long temp_0,temp_1;
for ( int i = 0 ; i < N ; i++)
{   
    temp_1 = 0;
    for ( int j = 1 ; j >= 0 ; j--)
    {
      temp_0 = arraybyte[ ( i * 2 ) + j ];
      temp_1 = temp_1 | ( temp_0 << (j * 8));
      //Serial.print(temp_0,HEX);             // 调试用
      //Serial.print("||");
    }
      arrayint = temp_1 ;
      //Serial.print(arrayint,HEX);      // 调试用
      //Serial.print("|||");
      //Serial.println();
}
      //Serial.println();
}
///////////////////////////////数据帧发送 /////////////////////////////
boolean dataFrameSend( byte *datasend , byte datalen )
{
byte rc , count ;
count = 0 ;
rc = 0 ;
for ( int i = 0 ; i < datalen ; i++ )
    rc ^= datasend;                // 计算数据校验结果，数据按位异或处理
//Serial.print(" rc =");          // 调试用
//Serial.println(rc);
Serial1.write(FRAME_HEAD_H);
delay(WIRELESS_DALAY_TIME_SEND);
count ++;
Serial1.write(FRAME_HEAD_L);
delay(WIRELESS_DALAY_TIME_SEND);    // 发送帧头（两位，0xFA,0xFB)
count ++;
Serial1.write(datalen);
delay(WIRELESS_DALAY_TIME_SEND);    // 发送数据长度
count ++;
for ( int i = 0 ; i < datalen ; i++)
{
    Serial1.write(datasend);
    delay(WIRELESS_DALAY_TIME_SEND);// 数据发送
    count ++;
}                  
Serial1.write(rc);
delay(WIRELESS_DALAY_TIME_SEND);    // 发送校验结果
count ++;
Serial1.write(FRAME_END);   
count ++;
delay(WIRELESS_DALAY_TIME_SEND);    // 发送结束位
if ( count == ( datalen + 5))       // 结果返回
    return 1;
else
    return 0;
//////////////////////////一个数据帧包含以下信息//////////////////////////
//帧头（高位）    帧头（低位）    数据长度    数据      校验      帧头    //
//0xFA            0xFB             datalen    datasendrc(XOR)   0xFC    //
//////////////////////////////////////////////////////////////////////////////
}
/////////////////////////////数据帧接收 /////////////////////////////////
boolean dataFrameReceive(byte *datareceive,byte datalen)
{
//byte frameheadL,frameheadH,datalenr,rc,frameend;// 调试用
byte temp,r,count;
boolean frame;
frame = false;
while ( Serial1.available() )         //串口缓存有数据，同时停止标志位假时进行数据读取
{
    count = 0;
    r = 0;
    temp = Serial1.read();
    delay(WIRELESS_DALAY_TIME_RECEIVE);
    count ++;
    if (temp == FRAME_HEAD_H)         //帧头（高位）读取判断
    {
      //frameheadH = temp;
      temp = Serial1.read();
      delay(WIRELESS_DALAY_TIME_RECEIVE);
      count ++;
      if (temp == FRAME_HEAD_L)         //帧头（低位）读取判断
      {
      //frameheadL = temp;
      temp = Serial1.read();
      delay(WIRELESS_DALAY_TIME_RECEIVE);
      count ++;               
      if ( temp == datalen)         //数据长度读取判断
      {
          //datalenr = temp;
          for ( int i = 0 ; i < datalen ; i++ )
          {
            datareceive= Serial1.read();
            delay(WIRELESS_DALAY_TIME_RECEIVE);
            count ++;         
          }                           //数据接收
          temp = Serial1.read();
          delay(WIRELESS_DALAY_TIME_RECEIVE);
          count ++;
          for (int i = 0 ; i < datalen ; i++ )
            r ^= datareceive;      //计算接收数据校验结果
          //Serial.print(" r =");   // 调试用
          //Serial.println(r);
          if ( r == temp)
          {
            //rc = temp;
            temp = Serial1.read();
            delay(WIRELESS_DALAY_TIME_RECEIVE);
            count ++;
            if (temp = FRAME_END)   // 接收结束位
            {
            //frameend = temp;
            frame = true;         // 帧接收成功标识
            return 1;
            //Serial.print(" count ="); // 调试用
            //Serial.println(count);
            Serial.println(" zheng que jie shou!,suan ni zheng qu .");               // 调试用
            }
            else
            Serial.println(" wo kao ,mu you jie shou dao jie shu wei !");   // 调试用
          }
          else
            Serial.println(" wo ri ,jiao yan jie guo bu zheng que !");      // 调试用
      }
      else
          Serial.println("fuck you, shu ju chang du jie shou cuo wu!");      // 调试用
      }
      else
      Serial.println(" shit zhen tou di wei cuo wu !");                  // 调试用
    }
    else
      Serial.println(" ri a ri a , zhen tou gao wei cuo wo!");                  // 调试用
}
    Serial.println(" SB de, mei you shu ju huo shu ju jie shou ting zhi !"); // 调试用
    return 0;
}
///////////////////////////////////////////////////////////////////
void setup()
{   
carInti();
distanceInti();
mycar.attach(DIRECT_OUTPUT);
Serial.begin(9600);
Serial1.begin(9600);
Serial2.begin(9600);
}
void loop()
{
/////////////////////////////数据接收//////////////////////////
    byte datareceive;
    byte cmd;
    byte speedIn,directIn,led,inf;
    ledSpark(POWER_LED,1000);
    if ( dataFrameReceive(datareceive,8))
    {
      for (int i = 0 ; i < 8 ; i++ )                // 调试用
      {
          Serial.print(datareceive);
          Serial.print("|   ");
      }
          Serial.println();
   
      cmd = datareceive;
      switch(cmd)
      {
      case 'P':
                while(!Serial1.available())         //电源未打开
                {
                  byte inf;
                  inf = datareceive;
                  digitalWrite(MOTOR_DIRECT,LOW);
                  digitalWrite(SPEED_CTRL,LOW);   //停止
                  ledSpark(POWER_LED,1000);
                }
                  break;
      case 'M':
                while(!Serial1.available())         // 手动模式
                {               
                  byte inf;
                  inf      = datareceive;
                  led      = datareceive;
                  directIn = datareceive;
                  speedIn= datareceive;
                  directCtrl(directIn,led);
                  speedCtrl(speedIn,led);

                  //manualCtrl(speedIn,directIn,led);
               
                  carRunStatus(speedIn,directIn);
                }
                  break;            
      case 'S':
                while(!Serial1.available())         // 智能模式
                {
                  byte inf;
                  inf   = datareceive;
                  led   = datareceive;
                  smartCtrl(led);
                }
                  break;
      case 'G':
                while(!Serial1.available())         // 数据获取模式
                {
                  int gascur,gaspre;
                  byte gasbyte,datasend;
                  byte mass;
                  inf   = datareceive;
                  mass= datareceive;
                  if ( mass == 'A')
                  {
                  gascur = alcoholRead();         // 酒精数据采集与发送
                  if (gascur != gaspre )
                  {
                      inttoByte(&gascur,gasbyte,1);
                      datasend = 'A';
                      datasend = gasbyte;
                      datasend = gasbyte;
                      datasend = 0xFF;
                      datasend = 0xFF;
                      dataFrameSend(gasbyte,4);
                      gaspre = gascur;
                      for (int i = 0 ; i < 5 ; i++ )// 调试用
                      {
                        Serial.print(datasend);
                        Serial.print("|   ");
                      }
                        Serial.println();
                  }
                  }
                  if ( mass == 'B')
                  {
                  gascur = combustibleRead();   // 可燃气体采集与发送
                  if (gascur != gaspre )
                  {
                      inttoByte(&gascur,gasbyte,1);
                      datasend = 'B';
                      datasend = gasbyte;
                      datasend = gasbyte;
                      datasend = 0xFF;
                      datasend = 0xFF;
                      dataFrameSend(gasbyte,4);
                      gaspre = gascur;
                      for (int i = 0 ; i < 5 ; i++ )
                      {
                        Serial.print(datasend);// 调试用
                        Serial.print("|   ");
                      }
                        Serial.println();
                  }
                  }
                  if ( mass == 'T')            // 温度数据采集与发送
                  {
                  gascur = alcoholRead();
                  if (gascur != gaspre )
                  {
                      inttoByte(&gascur,gasbyte,1);
                      datasend = 'T';
                      datasend = gasbyte;
                      datasend = gasbyte;
                      datasend = 0xFF;
                      datasend = 0xFF;
                      dataFrameSend(gasbyte,4);
                      gaspre = gascur;
                      for (int i = 0 ; i < 5 ; i++ )// 调试用
                      {
                        Serial.print(datasend);
                        Serial.print("|   ");
                      }
                        Serial.println();
                  }

                  }
                }

                  break;
      default   :
                  Serial.println("mo shi xuan ze cuo wu "); // 调试用
                  break;
      }
      
    }
Serial.println("shu ju mei you ");                        // 调试用

}

很长啊，希望大家有耐心看下去。这周要发的菜单更是冗长，到现在已经有了3000多行的代码了。

tgyfish 发表于 2012-12-10 19:38:40

这代码~凤~我晕！

萧芸凤 发表于 2012-12-10 19:47:52

tgyfish 发表于 2012-12-10 19:38 static/image/common/back.gif
这代码~凤~我晕！

木有办法啊，水平在哪里限制着，不会用高级的方法。
现在的手头的这个菜单，上学的时候用C语言实现过，当时用了链表，现在arduino上面的指针和结构体还是不知道怎么用，然后用了最笨的函数实现方法，按一次按键刷一次屏，调用一个函数。我现在都快疯了，找函数就要拉好久。

txmg 发表于 2012-12-10 21:26:46

代码是很长！！！:lol:lol

smfox10 发表于 2012-12-10 23:30:51

lz威武，有米之人啊...这车的一身装备;Parduino的硬伤啊，看上去好乱呢，就是不知道为什么要把arduino设计那么特别:Q兼容洞洞板多好....

Randy 发表于 2012-12-10 23:37:22

看这车我感觉有巨无霸的味道...

老胖熊 发表于 2014-5-25 22:39:34

好长的代码，留下慢慢看。

Good_Morning 发表于 2014-8-5 18:59:56

高端大气上档次

查看完整版本: 偶的遥控小车－可以运行，但是有瑕疵