通过电机编码器AB相输出确定电机转向

AB相输出相差90度，即当A相"正跳变"时如果B相是高电平那么是"正转"，反之是"反转"

图片:

正转

反转

#include <TimerOne.h>
#define D_Left_PIN 7  
#define D_Right_PIN 8
#define IN1 22
#define IN2 23
#define IN3 24
#define IN4 25
#define ENA 5
#define ENB 13
#define FIREPIN 9
#define Kp 0.5
#define Ki 0.5
#define Kd 0.0

#define MOTOR_GO_FORWARD  {STOP=0; digitalWrite(IN1,LOW);digitalWrite(IN2,HIGH);digitalWrite(IN3,LOW);digitalWrite(IN4,HIGH);}                                    
#define MOTOR_GO_BACK      {STOP=0; digitalWrite(IN1,HIGH);digitalWrite(IN2,LOW);digitalWrite(IN3,HIGH);digitalWrite(IN4,LOW);}    
#define MOTOR_GO_RIGHT      {STOP=0; digitalWrite(IN1,HIGH);digitalWrite(IN2,LOW);digitalWrite(IN3,LOW);digitalWrite(IN4,HIGH);}    
#define MOTOR_GO_LEFT      {STOP=0; digitalWrite(IN1,LOW);digitalWrite(IN2,HIGH);digitalWrite(IN3,HIGH);digitalWrite(IN4,LOW);}   
#define MOTOR_GO_STOP      {STOP=1; digitalWrite(IN1,LOW);digitalWrite(IN2,LOW);digitalWrite(IN3,LOW);digitalWrite(IN4,LOW);}    


int Left_Speed[10]={20,30,35,40,45,50,55,60,65,70};//左侧速度档位
int Right_Speed[10]={20,30,35,40,45,50,55,60,65,70};//右侧速度档位

int Left_Speed_Hold=5;//定义左侧速度变量
int Right_Speed_Hold=5;//定义右侧速度变量

byte Fireing=0;
long FireStopTime=0;
unsigned long lastSendTime=0;
unsigned long lastReceiveTime=0;
byte RecCache[512];
volatile int CacheIndex=0;

byte STOP=1;
//=============================PID Args===========================
float  left_LastError=0.0;          //  Error[-1]
float  left_SumError=0.0;           //  Sums of Errors
 
float  right_LastError=0.0;          //  Error[-1]
float  right_SumError=0.0;           //  Sums of Errors

int flag=0;                          //定义定时器中断标志，用于判断是否发生中断

long counter_val_right[2] = {0,0}; //定义数组，用于存放外部中断计数值
byte CurCnt_right = 0;         //定义当前计数器标志，用于判断当前正在计数的数组
byte Direction_right=2;
int rightSpeed=0;
float rightPWM=0.0;

long counter_val_left[2] = {0,0}; //定义数组，用于存放外部中断计数值
byte CurCnt_left = 0;         //定义当前计数器标志，用于判断当前正在计数的数组
byte Direction_left=2;
int leftSpeed = 0; 
float  leftPWM=0.0; 
unsigned long lastPrintTime=0;
//========================End PID=========================


void setup() {

 Serial.begin(38400);//初始化波特率为115200
 initWifi();
 initIO();
 setCache(0,512);

  attachInterrupt(0,counter_left,RISING);
  attachInterrupt(1,counter_right, RISING);//设置中断方式为上升沿
 
  Timer1.initialize(100000);// 设置定时器中断时间，单位微秒，此处为1秒
  Timer1.attachInterrupt( timerIsr ); // 打开定时器中断
  interrupts();  //打开外部中断
}
void initIO(){
  pinMode(D_Left_PIN,INPUT);
  pinMode(D_Right_PIN,INPUT);
  pinMode(IN1,OUTPUT);
  pinMode(IN2,OUTPUT);
  pinMode(IN3,OUTPUT);
  pinMode(IN4,OUTPUT);
  pinMode(ENA,OUTPUT);
  pinMode(ENB,OUTPUT);
  pinMode(FIREPIN,OUTPUT);
  digitalWrite(IN1,LOW);
  digitalWrite(IN2,LOW);
  digitalWrite(IN3,LOW);
  digitalWrite(IN4,LOW);
  
  digitalWrite(FIREPIN,LOW);

}
void loop()
{
  handleTXR();
  checkStopFire();
  speedControl();
   
}



void setSpeed(){
  
  float leftP=0.0,rightP=0.0,leftD=0.0,rightD=0.0;
  
  //  比例常数 Proportional Const
  leftP=(Left_Speed[Left_Speed_Hold]- leftSpeed);
  rightP=(Right_Speed[Right_Speed_Hold]  - rightSpeed);
  
  //积分常数 Integral Const
  left_SumError +=leftP;
  right_SumError+=rightP;
  
  //微分常数 Derivative Const
//  leftD=leftP-left_LastError;
//  rightD=rightP-right_LastError;
//  left_LastError=leftD;
//  right_LastError=rightD;
// leftPWM=(leftP * Kp) + (left_SumError * Ki) +(leftD * Kd);
// rightPWM=((rightP) * Kp) + (right_SumError * Ki) +(rightD * Kd) ; 
 
 leftPWM=(leftP * Kp) + (left_SumError * Ki) ;
 rightPWM=((rightP) * Kp) + (right_SumError * Ki)  ; 

 if(leftPWM>255)leftPWM=255;
 if(leftPWM<0)leftPWM=0;
 
 if(rightPWM>255)rightPWM=255;
 if(rightPWM<0)rightPWM=0;

 analogWrite(ENA,rightPWM);
 analogWrite(ENB,leftPWM);
}

void speedControl(){

  if(flag==1)   //判断是否发生定时器中断，即定时时间是否到达
   {
     flag=0;   //清除定时器中断标志位
    if((CurCnt_left&0x01) == 0) //当前使用的是偶数计数器，则上次频率值存放在第二个元素中
     {
         leftSpeed =counter_val_left[1];  //读取数组第二个元素中的数值
         counter_val_left[1]=0;       //读完清除原来的数值，以便下次使用
     }
     else   //当前使用的是奇数计数器，则上次频率值存放在第一个元素中
     {
       leftSpeed =counter_val_left[0];  //读取数组第二个元素中的数值
       counter_val_left[0]=0;  //读完清除原来的数值，以便下次使用
     }
     
     if((CurCnt_right&0x01) == 0) //当前使用的是偶数计数器，则上次频率值存放在第二个元素中
     {
         rightSpeed =counter_val_right[1];  //读取数组第二个元素中的数值
         counter_val_right[1]=0;       //读完清除原来的数值，以便下次使用
     }
     else   //当前使用的是奇数计数器，则上次频率值存放在第一个元素中
     {
       rightSpeed =counter_val_right[0];  //读取数组第二个元素中的数值
       counter_val_right[0]=0;  //读完清除原来的数值，以便下次使用
     }
     
     
   if(!STOP)  setSpeed();
    
    
    if((millis()-lastPrintTime)>500){
       Serial.print("L:");    //发送帧头大写S
       Serial.print( leftSpeed);  //发送频率数据，并回车换行
       Serial.print(",");
       Serial.print(Direction_left);
       Serial.print(",R:");
       Serial.print(rightSpeed);
       Serial.print(",");
       Serial.print(Direction_right);
       Serial.println("");
        Serial.println(leftPWM);
        Serial.println(rightPWM);
       lastPrintTime=millis();
      }
     } 
}
//外部中断处理函数

void counter_left(){
  counter_val_left[CurCnt_left & 0x01] +=1;
  Direction_left=digitalRead(D_Left_PIN);
}

void counter_right()
{
   //通过当前计数器来实现对外部中断计数值存储的切换
    counter_val_right[CurCnt_right& 0x01] += 1;   //发生一次中断则加1
    Direction_right=digitalRead(D_Right_PIN);
}

//定时器中断处理函数
void timerIsr()
{
  flag=1;     //置位定时器中断标志位
  CurCnt_right++; //当前计数器的值加1，实现另一个计数值切换
  CurCnt_left++;
}

//===================End PID ===============
void  initWifi(){
   Serial2.begin(115200);

  delayAndRead(100);
  Serial2.println("AT+CIOBAUD=38400");
  delayAndRead(100);
  Serial2.println("AT+RST");
  delayAndRead(3000);
  Serial2.begin(38400);
  Serial2.println("AT+CIPMUX=1");
  delayAndRead(500);
  Serial2.println("AT+CIPSERVER=1");
  delayAndRead(200);
  Serial2.println("AT+CIPSTO=60");
  delayAndRead(300); 
  
}

void fire(long fireDelay){
  if(Fireing==1)return;
  digitalWrite(FIREPIN,HIGH);
  Fireing=1;
  FireStopTime=millis() + fireDelay;
  Serial.println(FIREPIN);
  Serial.println("fireDelay" + (String)fireDelay);
  Serial.println(FireStopTime);
}
void checkStopFire(){
      //check stop fire
    if(Fireing==1 && (FireStopTime <=millis())){
       Fireing=0;
       digitalWrite(FIREPIN,LOW);
    }
}

void reply(bool isOk,String cmd,String msg){
 String rStr="";
 if(isOk){
  rStr="$FOK-" + cmd +":" +msg +"$E";
  Serial2.println("AT+CIPSEND=0," + (String)rStr.length());  
  delay(10);
  Serial2.println(rStr);
 }else{
    rStr="$FEE-" + cmd +":" +msg +"$E";
    Serial2.println("AT+CIPSEND=0," + (String)rStr.length());  
    delay(10);
    Serial2.println(rStr);
    
 } 
  
}

void replyBytes(bool isOk,String cmd,byte msg[],int msgLen){
 String rStr="";
 int  sendLen=0;
 if(isOk){
  rStr="$FOK-" + cmd +":" ;
    sendLen= rStr.length() + msgLen +2; //2 is "$E"
  Serial2.println("AT+CIPSEND=0," + (String)sendLen);  
  delay(10);
  Serial2.print(rStr);
  for(int i=0;i<msgLen;i++){
    Serial2.write(msg[i]);
  }
  Serial2.println("$E");
 }else{
  rStr="$FEE-" + cmd +":" ;
  sendLen= rStr.length() + msgLen +2; //2 is "$E"
  Serial2.println("AT+CIPSEND=0," + (String)sendLen);  
  delay(10);
  Serial2.print(rStr);
  for(int i=0;i<msgLen;i++){
    Serial2.write(msg[i]);
  }
  Serial2.println("$E");
 } 
  
}

void cls(){
   while(Serial2.available()){
     Serial2.read();
  }
}

void delayAndRead(int waitTime){
   delay(waitTime);
   while(Serial2.available()){
     Serial.write(Serial2.read()); 
   }
}


void handleTXR(){

  
  while(Serial2.available()){
    byte c=(byte) Serial2.read();
    RecCache[CacheIndex++]=c;

  }
   if(CacheIndex>512){
      CacheIndex=0;
      setCache(0,512); 
      Serial.println("Cut");
    }
    
  int bIndex=bIndexOf("$F",0);
  if(bIndex>=0){
    int eIndex=bIndexOf("$E",bIndex);
    if(eIndex>bIndex){
       //Extra Data
       int dataLen= eIndex - (bIndex +2);
       byte data[dataLen];
       for(int i=0;i<dataLen;i++){
         data[i]= RecCache[bIndex+2 +i] ;

       }

       for(int w=(eIndex +2);w<CacheIndex && w<512;w++){
          RecCache[w-(eIndex + 2)]=RecCache[w]; 
       }
       CacheIndex = CacheIndex - (eIndex +2);
       setCache(CacheIndex,512);
       
       lastReceiveTime=millis();
       handleCmd(data,dataLen);

    }
  }
  
    if(CacheIndex>512){
      CacheIndex=0;
      setCache(0,512); 
    }
  
}

void setCache(int start,int endIndex){
  for(int i=start;i<endIndex;i++){
     RecCache[i]=0;
  }  
}
boolean bStartsWith(byte data[],int len, String fStr){
    int fLen=fStr.length() ;
   byte fBytes[fLen + 1];
   fStr.getBytes(fBytes,fLen+1);

   if(len<=0)return false;
   if(len<fLen)return false;
   byte flag=1;
   for(int j=0;j<fLen;j++){
       if(fBytes[j]!=data[j])
       {
                flag=0;
                break; 
        }
              
    }
   if(flag) return true; 
  
   return false;
}

int bIndexOf(String fStr,int start){
    int fLen=fStr.length() ;
   byte fBytes[fLen + 1];
   fStr.getBytes(fBytes,fLen+1);

   for(int i=start;i<(CacheIndex + 1 -fLen);i++){
  
       if(RecCache[i]==fBytes[0])
       {
         byte flag=1;
          for(int j=1;j<fLen;j++){
              if(fBytes[j]!=RecCache[i+j])
              {
                flag=0;
                break; 
              }
          }
          if(flag)return i;
       }
   }
   return -1;
}

void handleCmd(byte data[], int len){


  
 if(bStartsWith(data,len,"HB:")){
     hbCmd();
 }else if(bStartsWith(data,len,"F:")){
    fireCmd(data,len);
 }else if(bStartsWith(data,len,"C:")){
    controlCmd(data,len);
 }
}

void hbCmd(){
    byte bs[4];
    unsigned long mlis=millis();
    long2byte(mlis,bs);
    Serial.println(mlis);
    replyBytes(true,"HB",bs,4); 
}

void fireCmd(byte data[], int len){


  byte duration=data[2];
  if(duration>15) duration=15;
  if(duration<=0)duration=1;
  

  
  long longDuration= duration * 1000;
  fire(longDuration);
  reply(true,"F","");
}

void controlCmd(byte data[], int len){
  byte bs[2]={0,0};
  bs[0]=data[2];bs[1]=data[3];
  byte isMatch=0;
  
  if(data[2]==0x01 && data[3]==0x01){
    //Forward
    isMatch=1;
    MOTOR_GO_FORWARD;
  }else if(data[2]==0x01 && data[3]==0x02){
    //Back
     isMatch=1;
     MOTOR_GO_BACK;
  }else if(data[2]==0x01 && data[3]==0x03){
    //Turn Left
     isMatch=1;
     MOTOR_GO_LEFT;
  }else if(data[2]==0x01 && data[3]==0x04){
    //Turn Right
     isMatch=1;
     MOTOR_GO_RIGHT;
  }else if(data[2]==0x01 && data[3]==0x05){
    //Stop
     isMatch=1;
     MOTOR_GO_STOP;
     Serial.println("Stop");
  }else if(data[2]==0x02 && data[3]==0x01){
    //Left Speed
     isMatch=1;
     byte ena=data[4];
     if(ena>=0 && ena<=9){
        Left_Speed_Hold=ena; 
     }
     
  }else if(data[2]==0x02 && data[3]==0x02){
    //Right Speed
     isMatch=1;
     byte enb=data[4];
     if(enb>=0 && enb<=9){
        Right_Speed_Hold=enb;
     }
     
  }
  if(isMatch==1)replyBytes(true,"C",bs,2); 
  
}

 void long2byte(unsigned long res,byte targets[] ) {  
        targets[0] = (byte) (res & 0xff);// 鏈�浣庝綅  
        targets[1] = (byte) ((res >> 8) & 0xff);// 娆′綆浣�  
        targets[2] = (byte) ((res >> 16) & 0xff);// 娆￠珮浣�  
        targets[3] = (byte) (res >> 24);// 鏈�楂樹綅,鏃犵�鍙峰彸绉汇��  
              
    }  
    
unsigned long bytes2long(byte buf[]) {  
        unsigned long firstByte = 0;  
        unsigned long secondByte = 0;  
        unsigned long thirdByte = 0;  
        unsigned long fourthByte = 0;  
        int index = 0;  
        firstByte = (0x000000FFU & ( buf[index+3]));  
        secondByte = (0x000000FFU & ( buf[index + 2]));  
        thirdByte = (0x000000FFU & ( buf[index + 1]));  
        fourthByte = (0x000000FFU & ( buf[index ]));  
        index = index + 4;  
        return ((unsigned long) (firstByte << 24 | secondByte << 16 | thirdByte << 8 | fourthByte)) & 0xFFFFFFFFUL;  
    }