设为首页收藏本站
切换到宽版

极客工坊

 找回密码
 注册

QQ登录

只需一步，快速开始

极客工坊»首页 › Aduino与它的朋友们 › Arduino › 偶的遥控小车－可以运行，但是有瑕疵
返回列表 发新帖
查看: 13018|回复: 7

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

[复制链接]
萧芸凤
发表于 2012-12-10 19:30:01 | 显示全部楼层 |阅读模式
本帖最后由 萧芸凤 于 2012-12-10 19:44 编辑

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



然后是比较冗长繁琐的代码。
摇控器部分
[pre lang="arduino" line="1" file="ctrl"]#include <Wire.h>
///////////////////////////////  方向控制引脚（电位计输入） ////////////
#define DIRECT_INPUT  A6
///////////////////////////////  速度控制引脚（电位计输入)  ////////////
#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_RECEIVE  20
////////////////////////////////////  帧头帧尾定义 /////////////////////
#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[i * 4 + j] = arraylong >> (j * 8 );
      //Serial.print(arraybyte[i * 4 + j],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[i * 4 + j] = arrayint >> (j * 8 );
      //Serial.print(arraybyte[i * 4 + j],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    datasend  rc(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[8];                 // 数据发送数组
  

  while (digitalRead(ON_OFF_CTRL))  // 电源按键控制
  {
   
    datasend[0] = 'P';
    datasend[1] = 'L';
    datasend[2] = 0xFF;
    datasend[3] = 0xFF;
    datasend[4] = 0xFF;
    datasend[5] = 0xFF;
    datasend[6] = 0xFF;
    datasend[7] = 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[0] = 'M';
        datasend[1] = 'D';
        datasend[2] = 0xFE;
        datasend[3] = 0xFE;
        datasend[4] = ledcur;
        datasend[5] = directcur;
        datasend[6] = speedcur;
        datasend[7] = 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[0] = 'S';
        datasend[1] = 'D';
        datasend[2] = 0xFE;
        datasend[3] = 0xFE;
        datasend[4] = ledcur;
        datasend[5] = 0xFF;
        datasend[6] = 0xFF;
        datasend[7] = 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[5];
      byte cmd;
      byte masscur ;
      byte masspre ;
      masscur   = 'A';                     // 需要改变 的变量，可以使按键等
      
      //infcur = 'T';

      if (masscur != masspre)               // 发送数据请求
      {
        datasend[0] = 'G';
        datasend[1] = 'D';
        datasend[2] = 0xFE;
        datasend[3] = 0xFE;
        datasend[4] = masscur;
        datasend[5] = 0xFE;
        datasend[6] = 0xFE;
        datasend[7] = 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[0];
        switch(cmd)
        {
          case 'A' :
                    while(!Serial1.available())   // 酒精量测试数据
                    {
                      int alcohol;
                      byte alcoholbyte[2];
                      alcoholbyte[0] = datareceive[1];
                      alcoholbyte[1] = datareceive[2];
                      bytetoInt(alcoholbyte,&alcohol,1);
                      Serial.print( " alcohol : " );    // 调试用
                      Serial.println(alcohol);
                    }
                    break;

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

          case 'T' :
                    while(!Serial1.available())   // 温度测试数据
                    {
                      int temperature;
                      byte temperaturebyte[2];
                      temperaturebyte[0] = datareceive[1];
                      temperaturebyte[1] = datareceive[2];
                      bytetoInt(temperaturebyte,&temperature,1);
                      Serial.print( " temperature : " );    // 调试用
                      Serial.println(temperature);
                    }
                    break;
          default :
                    break;
        }
      }
    }
  }  
}  
[/code]
小车部分
[pre lang="arduino" line="1" file="car"]
#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_AINPUT  A13
#define COMBUST_AINPUT  A14
#define ALCOHOL_DINPUT  43
#define COMBUST_DINPUT  44
//////////////////////////// 麦克风输出引脚 ///////////////////////////////
#define MIC_DINPUT      42
#define MIC_AINPUT      A12
///////////////////////////  光敏传感器输入引脚 ///////////////////////////
#define LIGHT_SONSER    A15
/////////////////////////// 超声波测距输入引脚 ///////////////////////////
#define TRIQ  8          // 触发输入
#define ECHO  9          // 回响输出
/////////////////////////// 距离传感器输入引脚 ///////////////////////////
#define DISTANCE_LEFT   11
#define DISTANCE_RIGHT  10
/////////////////////////// 七段码 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_MAX  135
#define DIRECT_RIGHT_MIN  91
#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_RECEIVE  30
///////////////////// 帧头帧尾定义 //////////////////////////////////////
#define FRAME_HEAD_H  0xFA
#define FRAME_HEAD_L  0xFB
#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[i * 4 + j] = arraylong >> (j * 8 );
      //Serial.print(arraybyte[i * 4 + j],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[i * 4 + j] = arrayint >> (j * 8 );
      //Serial.print(arraybyte[i * 4 + j],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    datasend  rc(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[8];
    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[0];
      switch(cmd)
      {
        case 'P'  :
                while(!Serial1.available())         //电源未打开
                {
                  byte inf;
                  inf = datareceive[1];
                  digitalWrite(MOTOR_DIRECT,LOW);
                  digitalWrite(SPEED_CTRL,LOW);     //停止
                  ledSpark(POWER_LED,1000);
                }  
                  break;
        case 'M'  :
                while(!Serial1.available())         // 手动模式
                {                 
                  byte inf;
                  inf      = datareceive[1];
                  led      = datareceive[4];
                  directIn = datareceive[5];
                  speedIn  = datareceive[6];
                  directCtrl(directIn,led);
                  speedCtrl(speedIn,led);

                  //manualCtrl(speedIn,directIn,led);
                 
                  carRunStatus(speedIn,directIn);
                }
                  break;              
        case 'S'  :
                while(!Serial1.available())         // 智能模式
                {
                  byte inf;
                  inf   = datareceive[1];
                  led   = datareceive[4];
                  smartCtrl(led);
                }
                  break;
        case 'G'  :
                while(!Serial1.available())         // 数据获取模式
                {
                  int gascur,gaspre;
                  byte gasbyte[2],datasend[5];
                  byte mass;
                  inf   = datareceive[1];
                  mass  = datareceive[4];
                  if ( mass == 'A')
                  {
                    gascur = alcoholRead();         // 酒精数据采集与发送
                    if (gascur != gaspre )
                    {
                      inttoByte(&gascur,gasbyte,1);
                      datasend[0] = 'A';
                      datasend[1] = gasbyte[0];
                      datasend[2] = gasbyte[1];
                      datasend[3] = 0xFF;
                      datasend[4] = 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[0] = 'B';
                      datasend[1] = gasbyte[0];
                      datasend[2] = gasbyte[1];
                      datasend[3] = 0xFF;
                      datasend[4] = 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[0] = 'T';
                      datasend[1] = gasbyte[0];
                      datasend[2] = gasbyte[1];
                      datasend[3] = 0xFF;
                      datasend[4] = 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 ");                        // 调试用

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

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有帐号？注册

x
回复

使用道具 举报

tgyfish
发表于 2012-12-10 19:38:40 | 显示全部楼层
这代码~凤~我晕！
回复 支持 反对

使用道具 举报

萧芸凤
 楼主| 发表于 2012-12-10 19:47:52 | 显示全部楼层
tgyfish 发表于 2012-12-10 19:38
这代码~凤~我晕！

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

使用道具 举报

txmg
发表于 2012-12-10 21:26:46 | 显示全部楼层
代码是很长！！！
回复 支持 反对

使用道具 举报

smfox10
发表于 2012-12-10 23:30:51 | 显示全部楼层
lz威武，有米之人啊...这车的一身装备arduino的硬伤啊，看上去好乱呢，就是不知道为什么要把arduino设计那么特别兼容洞洞板多好....
回复 支持 反对

使用道具 举报

Randy
发表于 2012-12-10 23:37:22 | 显示全部楼层
看这车我感觉有巨无霸的味道...
回复 支持 反对

使用道具 举报

老胖熊
发表于 2014-5-25 22:39:34 | 显示全部楼层
好长的代码，留下慢慢看。
回复 支持 反对

使用道具 举报

Good_Morning
发表于 2014-8-5 18:59:56 | 显示全部楼层
高端大气上档次
回复 支持 反对

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

Archiver|联系我们|极客工坊

GMT+8, 2026-6-14 16:37 , Processed in 0.068335 second(s), 25 queries .

Powered by Discuz! X3.4

Copyright © 2001-2021, Tencent Cloud.

快速回复 返回顶部 返回列表