遗忘越来越快

参考资料:http://www.autolabor.com.cn/book/ROSTutorials/

对于试验，本质就是搭建一个机器人，从控制的角度看，机器人系统可以分为：传感系统、控制系统、驱动系统、执行机构。

执行机构: 执行机构只要满足能在蔗田环境下工作，采用四个直流编码电机带动四个主动轮进行行走，由于执行机构比较简单，不再做单独介绍。

驱动系统: 电池、arduino 以及电机驱动模块；

控制系统: 树莓派；

传感系统: 编码器、单线激光雷达、IMU；

其中，执行机构与驱动系统构成了机器人底盘。

执行机构和驱动系统

执行结构

硬件介绍

底盘是淘宝买的四驱mini小车，由于上位机是树莓派下的ROS，因此为了省事，把重点放在算法的研究上，驱动控制板选择了另一家和ros深度配合的驱动板，该驱动板基于stm32，并且集成了imu惯性传感器，所以把原来买的IMU退了。

经过仔细阅读说明书，发现小车底盘和深度定制的ros驱动板不太兼容，目前有两种方案：

1.驱动板和树莓派ros深度定制，例程丰富，开发手册详细，但是其配的小车不太适合我的的试验环境

2.例程很粗糙，开发手册没有，对应的小车比较适合我们的试验环境

最终我选择了第二种，因为首先试验要保证的是硬件条件能满足试验环境，对于软件环境，我觉得可以多看多学，慢慢研究，并且我也不是完全没基础，对于1中的教程有的显得太过于多余。对于方案2，要考虑的是使用arduino进行四驱小车的pid控制，对于imu信息的接收，可以由arduino承担，也可以直接由树莓派承担，最终的目的就是树莓派中的ros里有imu数据的话题，有编码器的话题，同时考虑将他们如何做成odom信息。

弃用的方案

这里要编写STM32的底层源码
ΜVISION5安装包和安装破解：HTTPS://WWW.MR-WU.CN/KEIL-MDK-UVISION-5-CRACKSTM32控制器程序执行图
初始化和任务对应的代码

接线

驱动系统

对于I2C,其实还有个更新的库，但是这里驱动板的示例程序是基于上面的，为了节约时间，新库以后有时间再研究，新库：

驱动板使用代码学习：

#include <Wire.h>

#define I2C_ADDR        0x34            //12C地址


#define ADC_BAT_ADDR                  0   //电压地址
#define MOTOR_TYPE_ADDR               20 //编码电机类型设置
#define MOTOR_ENCODER_POLARITY_ADDR   21 //设置编码方向极性，
//如果发现电机转速根本不受控制，要么最快速度转动，要么停止。可以将此地址的值重新设置一下
//范围0或1，默认0
#define MOTOR_FIXED_PWM_ADDR      31 //固定PWM控制，属于开环控制,范围（-100~100）
//#define SERVOS_ADDR_CMD 40        
#define MOTOR_FIXED_SPEED_ADDR    51 //固定转速控制，属于闭环控制，
//单位：脉冲数每10毫秒，范围（根据具体的编码电机来，受编码线数，电压大小，负载大小等影响，一般在±50左右）

#define MOTOR_ENCODER_TOTAL_ADDR  60 //4个编码电机各自的总脉冲值
//如果已知电机每转一圈的脉冲数为U，又已知轮子的直径D，那么就可以通过脉冲计数的方式得知每个轮子行进的距离
//比如读到电机1的脉冲总数为P，那么行进的距离为(P/U) * (3.14159*D)
//对于不同的电机可以自行测试每圈的脉冲数U，可以手动旋转10圈读出脉冲数，然后取平均值得出


//电机类型具体值
#define MOTOR_TYPE_WITHOUT_ENCODER        0  //无编码器的电机
#define MOTOR_TYPE_TT                     1  //TT编码电机
#define MOTOR_TYPE_N20                    2  //n20编码电机
#define MOTOR_TYPE_JGB37_520_12V_110RPM   3 //磁环每转是44个脉冲   减速比:90  默认

u8 data[20];
bool WireWriteByte(uint8_t val)
{
    Wire.beginTransmission(I2C_ADDR);//开始一次数据传输，发送一个I2C开始字符0x34
    Wire.write(val);//像从机发送数据
    if( Wire.endTransmission() != 0 ) { //返回值为0才成功，否则失败
        return false;
    }
    return true;
}
//向地址中写入数据 （reg：地址 val：数据内容 len：数据长度）
bool WireWriteDataArray(  uint8_t reg,uint8_t *val,unsigned int len)
{
    unsigned int i;

    Wire.beginTransmission(I2C_ADDR);
    Wire.write(reg);//发送地址数据
    for(i = 0; i < len; i++) {
        Wire.write(val[i]);//发送内容
    }
    if( Wire.endTransmission() != 0 ) {//结果判断
        return false;
    }

    return true;
}
//读取地址中的数据（reg：地址 val：数据内容）
bool WireReadDataByte(uint8_t reg, uint8_t &val)
{
    if (!WireWriteByte(reg)) {//如果WireWriteByte（）非真
        return false;
    }
    
    Wire.requestFrom(I2C_ADDR, 1);//主设备请求从设备I2C_ADDR地址处的一个字节，这个字节可以被主设备用 read()或available()接受
    while (Wire.available()) //接收获取的字节
    {
        val = Wire.read();//Wire.requestFrom()请求从机数据后，可以使用read接收
    }
    
    return true;
}
//读取地址中指定长度的数据（reg：地址 val：数据内容 len：数据长度）
int WireReadDataArray(   uint8_t reg, uint8_t *val, unsigned int len)
{
    unsigned char i = 0;
    
    /* Indicate which register we want to read from */
    if (!WireWriteByte(reg)) {
        return -1;
    }
    
    /* Read block data */
    Wire.requestFrom(I2C_ADDR, len);
    while (Wire.available()) {
        if (i >= len) {
            return -1;
        }
        val[i] = Wire.read();
        i++;
    }
    
    return i;
}


int serial_putc( char c, struct __file * )
{
  Serial.write( c );//Serial.print() 发送的是字符，Serial.write() 发送的字节.
  return c;
}
void printf_begin(void)
{
  fdevopen( &serial_putc, 0 );//将函数serial_putc指向串口
}




uint8_t MotorType = MOTOR_TYPE_TT;  //设定电机类型
uint8_t MotorEncoderPolarity = 1; 
void setup()
{
  Wire.begin();//初始化 I2C，以 Ardunio UNO 为例 I2C 口为：A4(SCL)、A5(CLK)
  Serial.begin(9600);
  printf_begin();
  delay(200);
  WireWriteDataArray(MOTOR_TYPE_ADDR,&MotorType,1);//在电机类型地址中写入电机类型编号
 //向地址中写入数据 （reg：地址 val：数据内容 len：数据长度）
 
  delay(5);
  WireWriteDataArray(MOTOR_ENCODER_POLARITY_ADDR,&MotorEncoderPolarity,1);//向编码方向极性地址中写入MotorEncoderPolarity地址，长度为1

}
/*用数组传递电机速度，正数为设置前进速度，负数为设置后退速度
以 p1、p2 为例：p1=4 个电机以 50 的速度前进 p2=4 个电机以 20 的速度后退*/
int8_t p1[4]={50,50,50,50};
int8_t p2[4]={-50,-50,-50,-50};
int8_t s1[4]={2,2,2,2};
int8_t s2[4]={-2,-2,-2,-2};
//int8_t s1[4]={2,20,10,30};
//int8_t s2[4]={-20,-20,-30,-9};
int32_t EncodeTotal[4]; //用于暂存电机累积转动量的值，正转递增，反转递减
int8_t result[4]={0,0,0,0};
void loop()
{
  u16 v;  //用于暂存电压值
  WireReadDataArray(ADC_BAT_ADDR,data,2);   //读取电压地址中存放的电压
  v = data[0]+ (data[1]<<8); //将电压转换为 mV
  Serial.print("V = ");Serial.print(v);Serial.println("mV     "); //打印电压的值

  WireReadDataArray(MOTOR_ENCODER_TOTAL_ADDR,(uint8_t*)EncodeTotal,16);  //读取电机累积转动量
  printf("Encode1 = %ld  Encode2 = %ld  Encode3 = %ld  Encode4 = %ld  \r\n", EncodeTotal[0], EncodeTotal[1], EncodeTotal[2], EncodeTotal[3]);
//打印四个电机的累积转动量
  
/*在电机转速地址中写入电机的转动方向和速度：WireWriteDataArray（转速控制地址，电
机转速数组，电机个数）*/
//  WireWriteDataArray(MOTOR_FIXED_PWM_ADDR,p1,4);//固定pwm控制，开环，属于开环控制,范围（-100~100）
  WireWriteDataArray(MOTOR_FIXED_SPEED_ADDR,s1,4);//固定转速控制，闭环，单位：脉冲数每10毫秒，范围（根据具体的编码电机来，受编码线数，电压大小，负载大小等影响，一般在±50左右）
  delay(700);

//  WireWriteDataArray(MOTOR_FIXED_PWM_ADDR,p2,4);
  WireWriteDataArray(MOTOR_FIXED_SPEED_ADDR,s2,4);
  delay(700);

  //读取4个电机10ms内的脉冲数据
  for(int i=0;i<10;i++)
  {
  WireReadDataArray(MOTOR_FIXED_SPEED_ADDR,result,4);
  printf("10ms内的脉冲数据为： %ld ， %ld  ， %ld ， %ld  \r\n", result[0], result[1], result[2], result[3]); 
  delay(2000);
  }
}

ros_arduino_bridge

上述代码只有驱动板与arduino交互的驱动，对于arduino与ros的交互，则需要自己编写才行，好在有相关的开源项目，因此在上面进行二次开发即可。我只使用其中的和ros进行交互的部分，对于其中的底盘控制，舵机控制则不使用。

rosserial arduino

ros_arduino-bridge问题较多，换成研究下rosserial arduino试试

1.安装Arduino（树莓派没安装桌面环境，这步可以忽略，编译上传在安装桌面环境的电脑上进行即可）

sudo apt-get install arduino

2.启动arduino并进行相关设置（树莓派没安装桌面环境，这步可以忽略，编译上传在安装桌面环境的电脑上进行即可）

arduino

3.安装软件包rosserial arduino

sudo apt-get install ros-melodic-rosserial-arduino
sudo apt-get install ros-melodic-rosserial

4.编译ros_lib文件，并复制到arduino libraries里（这里是负责编译和上传的电脑的arduino的库里，我的是Windows上的，压缩成zip,然后导入库）

编译：

rosrun rosserial_arduino make_libraries.py [这里写输出目录，中括号要去掉]

在windows上下载下来

然后压缩成zip,在arduino里导入

5.测试，创建helloworld话题

#include <ros.h>
#include <std_msgs/String.h>
ros::NodeHandle nh;
std_msgs::String str_msg;
ros::Publisher chatter("chatter", &str_msg);
char hello[13] = "hello world!";
void setup()
{
  nh.initNode();
  nh.advertise(chatter);
}
void loop()
{
  str_msg.data = hello;
  chatter.publish( &str_msg );
  nh.spinOnce();
  delay(1000);
}

然后插入arduino编译上传后把arduino插到树莓派上

接着在树莓派上分别开终端运行

终端1：

roscore

终端2：（这里硬件端口根据实际情况修改）

rosrun rosserial_python serial_node.py /dev/ttyACM0

终端3：

rostopic echo /chatter

如下图

参考文章

https://www.guyuehome.com/38503

实测电机参数

经过实际测试，电机数据和淘宝上以及卖家给的说明书都不太一致（淘宝的坑？），但是应该可以用。

知道以上参数，可以编写函数来实现测速，即单位位移除以单位时间。

测速函数如下：

long start_time = millis();//一个计算周期的开始时刻，初始值为 millis();
long interval_time = 50;//一个计算周期 50ms
double current_vel[4];
int32_t start_EncodeTotal[4];//构造用于储存开始时的脉冲数的数组
int32_t current_EncodeTotal[4];//构造用于储存当前脉冲数的数组
void get_current_vel()
{
  long right_now = millis();  
  long past_time = right_now - start_time;//计算逝去的时间
   
  if(past_time >= interval_time){//如果逝去时间大于等于一个计算周期
    //1.禁止中断
   // noInterrupts();
    //2.计算转速 转速单位可以是秒，也可以是分钟... 自定义即可
    WireReadDataArray(MOTOR_ENCODER_TOTAL_ADDR,(uint8_t*)current_EncodeTotal,16);//获取当前的转动量
    for(int i=0;i<4;i++)
    {
      current_vel[i]=(current_EncodeTotal[i]-start_EncodeTotal[i])*0.3625/past_time;//求当前各个轮子的速度，单位m/s
     
    }
    //3.重置计数器
        for(int i=0;i<4;i++)
    {
      start_EncodeTotal[i]=current_EncodeTotal[i];//求当前各个轮子的速度，单位m/s
    }
    //4.重置开始时间
    start_time = right_now;
    //5.重启中断
   // interrupts();

     Serial.println("四个轮子的速度分别为：");
     Serial.print(current_vel[0]);Serial.print("\t");Serial.print(current_vel[1]);Serial.print("\t");Serial.print(current_vel[2]);Serial.print("\t");Serial.print(current_vel[3]);Serial.println("\t");

  }
}

同时在setup中加入以下代码，获取开始时的转动脉冲数

 WireReadDataArray(MOTOR_ENCODER_TOTAL_ADDR,(uint8_t*)start_EncodeTotal,16);//获取开始时的转动量

编码器重置函数和各个电机速度控制函数如下

void rest_encode()//编码器计数清零
{
   EncodeTotal[0]=0,EncodeTotal[1]=0,EncodeTotal[2]=0,EncodeTotal[3]=0;//数组赋值0
  WireWriteDataArray(MOTOR_ENCODER_TOTAL_ADDR,(uint8_t*)EncodeTotal,16);//把驱动板上的编码器计数器归0
  start_EncodeTotal[0]=0;start_EncodeTotal[1]=0;start_EncodeTotal[2]=0;start_EncodeTotal[3]=0;//避免清0后第一次测速数据异常
}
void contrl_vel(int16_t *val)                                             //指定各轮的速度，单位：m/s
{//要把速度转化成脉冲数每10ms,result=val*10/0.3625
  int8_t vel2pulse[4]={0,0,0,0};
  for(int i=0;i<4;i++){
    //vel2pulse[i]=val[i]/100/0.3625;//这里会先把val[i]/100取整型再除以0.3625
    vel2pulse[i]=val[i]/36.25;
  }
    WireWriteDataArray(MOTOR_FIXED_SPEED_ADDR,vel2pulse,4);//由于输入的数据只能为整型，控制精度低，后期考虑自己写pid,用pwm
      Serial.println("四个轮子的目标速度（单位mm/s）为：");
     Serial.print(val[0]);Serial.print("\t");Serial.print(val[1]);Serial.print("\t");Serial.print(val[2]);Serial.print("\t");Serial.print(val[3]);Serial.println("\t");
      Serial.println("四个轮子的目标脉冲(单位脉冲/10ms)为：");
     Serial.print(vel2pulse[0]);Serial.print("\t");Serial.print(vel2pulse[1]);Serial.print("\t");Serial.print(vel2pulse[2]);Serial.print("\t");Serial.print(vel2pulse[3]);Serial.println("\t");
     for(int i=0;i<4;i++)
     {
     delay(2000);
     get_current_vel();
     }
}

上面我们把各个轮子单位时间内的脉冲数转化成了小车各个轮子单位时间内能行进的距离，但是要想让机器人运动，我们还是要进行机器人的运动学分析。

机器人运动学分析

参考文献1：https://mp.weixin.qq.com/s/Fzrpn5_3TB6apqG2Ds1v5Q

参考文献2：王雪松. 四驱轮式移动机器人运动控制系统研究与设计[D].上海电机学院,2016.

把机器人的目标速度转换成每个电机的目标速度，这个叫做机器人的运动学分析。

通过机器人各轮的速度求解出机器人沿X、Y、Z轴方向的速度，叫做运动学正解；

通过机器人沿X、Y、Z轴方向的速度求解出机器人各轮的速度，叫做运动学逆解。

卖家资料

细看卖家的最后的四个式子感觉推导的有点尴尬，好在通过阅读资料，我做了简化，控制时保证左侧轮子速度一致，右侧轮子速度也一致，就可以简化为两轮差速控制，如下：

 简化正运动学模型是基于虚拟左右驱动轮的速度来计算几何质心COM的速度，可表示为

        简化逆运动学模型是基于几何质心COM的速度分解出左右驱动轮的速度，可表示为

        若采用公式（9-10）来描述四轮驱动移动机器人(SSMR)，这里有两个点需要进一步讨论：
问题：在正运动学模型（9）中，左右虚拟轮的线速度vl和vr如何得到？
        根据公式（7）可知，两左（或右）侧轮的纵向线速度大小与左（或右）虚拟轮的线速度相同。但两轮的实际转速可能不同。 
        从简化实际运动控制的角度出发，两左（或右）侧轮应该尽可能保持一致。这里做一个假象实验：若机器人的两前轮的速度相同，两后轮的速度相同，但前后轮的速度不同，机器人肯定是以介于前轮速度和后轮速度之间的某一速度直线运动，可想象前轮拖着后轮加快运动，后轮扯着前轮减缓运动。 
        所以无论前后轮的速度如何变化，机器人只会以一个速度运动，由于前后轮速度不相等会引起轮胎与地面在纵向上同时存在滚动和滑动摩擦，这会加速磨损轮胎，且不利于准确运动控制。所以，结论是尽可能保持两左（或右）侧轮速度相同，用数学语言描述就是：、

        式中，[wM1 wM2 wM3 wM4]表示对应轮子的转动角速度，[RM1 RM2 RM3 RM4]表示对应的轮子的半径。
4
问题：虚拟轮间距dLR具体是多少？
        这也是四轮驱动移动机器人(SSMR)简化模型最难的一个参数，是一个随着工况变化的参数，且无法求得解析解。在参考文献[2]中给出的方法，是引入了无量纲参数γ：

       式中，dwb表示机器人的轮间距。 
        问题则转化为如何求γ，该参数与机器人的总负载、轮胎与地面的相对摩擦系数、转弯半径及质心位置都是有关系，是一个非常复杂的参数，所以常用的方法就是做实验，控制不再改动的机器人在特定地面上做差速转向运动，采集到多组实验数据后，拟合估算γ。
        再回过头来看四轮驱动移动机器人(SSMR)运动学模型，基于公式（9-12）可知
正运动学模型为

逆运动学模型为

踩坑

1.断电时一般先断开arduino和上位机（电脑或者树莓派的连线），再断开驱动板和电池的连线，特别是电机失控，要断电急停的时候，否则可能导致驱动板损坏。

2.arduino可以给驱动板供电，驱动板也可以给反向给arduino供电，不知道我是不是在某次操作中，进行了1中的操作，后来发觉驱动板不能给arduino供电了，检查原来是r如下图，重新在后面5v标注的焊点处焊上排针，耶，也可以用。

3.不知道是不是1的操作还把SCL 和SDA的上拉电阻给烧了（新板在路上，保险起见，又买了块），在调试程序中，发现Wire.endTransmission() 函数无响应，并且是间歇性出现，有时重新断开所有电源好了，但是过一会又死在那，然后查了资料（https://arduino.stackexchange.com/questions/5339/wire-endtransmission-hangs），把SCL 和SDA外接一个4.7K的5V上拉电阻，貌似再也没有卡住了

4.自带的示例程序里pwm控制根本没用，轮子只是抖一下，我以为是这板子太垃圾，不支持，于是就用了他的闭环控制，然后我自己又套了层PID，相当于套了2层PID,反应慢。突然我想起了，或许他示例的pwm只是给个脉冲，用循环持续的给脉冲，不就可以了吗，改了下，果真可以。唉，基础不牢，地动山摇。

5.但是使用4中的pwm控制发觉不能低速，最低速度也五秒3米左右，远高于试验要求，然后使用自带的闭环控制，速度可以慢一点，但是还是偏大（整体来说，买的电机减速比偏低），无奈，只能更改ros-arduino-bridge里的pid函数了

6.发觉就算加了上拉电阻，也会卡死，嗐，等新驱动板到了再试

7.为了验证是否是因为基于wire.h库的I2c挂起导致ros_arduino_bridge无法连接，编译上传不含有i2c的ros_arduino_bridge项目到arduino试试。经验证，果真是，嗐，卖家配的示例真坑

8.使用github另外一位大佬改编的IC2库（https://github.com/rambo/I2C），成功移植之前的代码，然后成功连接，现在就是改ros_arduino_python里的关于pid的代码，把他屏蔽掉就行

9.实测在连接书梅派串口后，i2c总线会卡死，导致连接不上，就算使用了新的I2C.h库，超时可以跳出，可以连接上，但三仍然功能不正常，暂时找不到解决方案，时间关系，以后再研究。

10.问题解决，arduino的供电来自树莓派，驱动板的供电来自电源，两个之前的vcc不用连接，连接gnd即可，在arduino程序启动的时候可以先不建立I2c通信，后面再初始话硬件然后通信

控制系统

使用ros控制电机转动从而控制小车运动，之前尝试有太多bug,并且也不是我试验的重点，花大量时间不值得，所以就修改为使用蓝牙遥控器控制，和arduino上的驱动系统相集成，因此arduino上一共集成了以下代码：I2C通信代码 红外控制电机代码 ros_arduino_bridge代码

首先，检测遥控器的按键编码：（灯没必要接，接好红外传感器就行）

#include <IRremote.h>
int RECV_PIN = 11;
int LED1 = 2;
int LED2 = 3;
int LED3 = 4;
int LED4 = 5;
int LED5 = 6;
int LED6 = 7;
long on1  = 0x00FFA25D;//1
long off1 = 0x00FFE01F;
long on2 = 0x00FF629D;//2
long off2 = 0x00FFA857;
long on3 = 0x00FFE21D;//3
long off3 = 0x00FF906F;
long on4 = 0x00FF22DD;
long off4 = 0x00FF6897;
long on5 = 0x00FF02FD;//5
long off5 = 0x00FF9867;
long on6 = 0x00FFC23D;
long off6 = 0x00FFB04F;
IRrecv irrecv(RECV_PIN);
decode_results results;
// Dumps out the decode_results structure.
// Call this after IRrecv::decode()
// void * to work around compiler issue
//void dump(void *v) {
//  decode_results *results = (decode_results *)v
void dump(decode_results *results) {
  int count = results->rawlen;
  if (results->decode_type == UNKNOWN)
  {
    Serial.println("Could not decode message");
  }
  else
  {
    if (results->decode_type == NEC)
    {
      Serial.print("Decoded NEC: ");
    }
    else if (results->decode_type == SONY)
    {
      Serial.print("Decoded SONY: ");
    }
    else if (results->decode_type == RC5)
    {
      Serial.print("Decoded RC5: ");
    }
    else if (results->decode_type == RC6)
    {
      Serial.print("Decoded RC6: ");
    }
    Serial.print(results->value, HEX);
    Serial.print(" (");
    Serial.print(results->bits, DEC);
    Serial.println(" bits)");
  }
  Serial.print("Raw (");
  Serial.print(count, DEC);
  Serial.print("): ");

  for (int i = 0; i < count; i++)
  {
    if ((i % 2) == 1) {
      Serial.print(results->rawbuf[i]*USECPERTICK, DEC);
    }
    else
    {
      Serial.print(-(int)results->rawbuf[i]*USECPERTICK, DEC);
    }
    Serial.print(" ");
  }
  Serial.println("");
}

void setup()
{
  pinMode(RECV_PIN, INPUT);
  pinMode(LED1, OUTPUT);
  pinMode(LED2, OUTPUT);
  pinMode(LED3, OUTPUT);
  pinMode(LED4, OUTPUT);
  pinMode(LED5, OUTPUT);
  pinMode(LED6, OUTPUT);
  pinMode(13, OUTPUT);
  Serial.begin(9600);

  irrecv.enableIRIn(); // Start the receiver
}

int on = 0;
unsigned long last = millis();

void loop()
{
  if (irrecv.decode(&results))
  {
    // If it's been at least 1/4 second since the last
    // IR received, toggle the relay
    if (millis() - last > 250)
    {
      on = !on;
      //       digitalWrite(8, on ? HIGH : LOW);
      digitalWrite(13, on ? HIGH : LOW);
      dump(&results);
    }
    if (results.value == on1 )
    {
      Serial.println("1号键");
      digitalWrite(LED1, HIGH);
    }
    if (results.value == off1 )
    {
      digitalWrite(LED1, LOW); Serial.println("2号键");
    }
    if (results.value == on2 )
    {
      digitalWrite(LED2, HIGH); Serial.println("3号键");
    }
    if (results.value == off2 )
    {
      digitalWrite(LED2, LOW); Serial.println("4号键");
    }
    if (results.value == on3 )
    {
      digitalWrite(LED3, HIGH); Serial.println("5号键");
    }
    if (results.value == off3 )
      digitalWrite(LED3, LOW);
    if (results.value == on4 )
      digitalWrite(LED4, HIGH);
    if (results.value == off4 )
      digitalWrite(LED4, LOW);
    if (results.value == on5 )
      digitalWrite(LED5, HIGH);
    if (results.value == off5 )
      digitalWrite(LED5, LOW);
    if (results.value == on6 )
      digitalWrite(LED6, HIGH);
    if (results.value == off6 )
      digitalWrite(LED6, LOW);
    last = millis();
    irrecv.resume(); // Receive the next value
  }
}

然后编写控制逻辑代码，最后集成的时候在相关地方加入控制函数即可

#include <IRremote.h>
int RECV_PIN = 11;//11号引脚为数据引脚
long accelerate = 0x00FF629D;//2号数字键,前进/加速
long decelerate = 0x00FF02FD;//5号键，后退/减速
long  left=  0x00FFA25D;//1号数字键，左转
long right=  0x00FFE21D;//3号数字键，右转
long carstop =  0x00FF38C7;//停止，OK键
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup() {
pinMode(RECV_PIN, INPUT);
Serial.begin(9600);
irrecv.enableIRIn(); // Start the receiver
}
int on = 0;
unsigned long last = millis();
void loop() {
   if (irrecv.decode(&results))
  {
    // If it's been at least 1/4 second since the last
    // IR received, toggle the relay
    if (millis() - last > 250)
    {
      on = !on;
      digitalWrite(13, on ? HIGH : LOW);
      //dump(&results);
    }
    if (results.value == accelerate )
    {
      Serial.println("前进");
     
    }
    if (results.value == decelerate )
    {
      Serial.println("后退");
    }
    if (results.value == left )
    {
     Serial.println("左转");
    }
    if (results.value == right )
    {
      Serial.println("右转");
    }
    if (results.value == carstop )
    {
      Serial.println("停止");
    }
    last = millis();
    irrecv.resume(); // Receive the next value
  }
}

传感系统

查看局域网其他计算机ip

windows:
以管理员身份运行cmd输入net view后回车，即可查看到自己的计算机所在的局域网内的其他计算机的计算机名
ping 计算机名 ，可以查到其ip
或者使用局域网查看工具：

ubuntu:
使用sudo apt-get install arp-scan 安装(确保网络链接正常)

利用ifconfig 或ip addr 查看本机的ip地址,一般有线在interface en0/eth0, 无线在wlan0上.
ifconfig
然后使用arp-scan -I wlo1 –localnet 或 sudo arp-scan -I wlo1 –localnet 就可以查看同一局域网的其他设备
sudo arp-scan -I wlp3s0 –localnet
wlp3s0换成自己的网口名

sudo apt install arp-scan -y

sudo arp-scan -I wlp3s0 --localnet

ubuntu镜像下载：http://cdimage.ubuntu.com/releases/

由于我用到的ros arduino bridge 不支持我的ros-noetic,所以树莓派上必须安装ros-melodic,笔记本上可以用原来的不变。而ros-melodic是在ubuntu18.04环境下，故树莓派的安装版本为：ubuntu18.04+rosmelodic,但是官方的软件刷ubuntu18.04设置得wifi不生效，于是https://blog.csdn.net/qq_30613365/article/details/120739069

树莓派上部署ROS：

一行代码搭建机器人开发环境(ROS/ROS2/ROSDEP)

wget http://fishros.com/install -O fishros && . fishros

使用树莓派官方的工具刷入ubuntu20.04，刷入之前设置好用户名、密码、wifi等信息（这里我设置成收手机的，因为以后试验也是用手机共享热点当成无线路由器），同时记得打开ssh，为了方便远程连接(这里主要是不想电脑也连接手机wifi)，我们进入系统后首先安装zerotier，然后再使用上面小鱼的一键安装命令安装无桌面版ros，安装结束后添加到环境变量：

echo "source /opt/ros/melodic/setup.bash" >> ~/.bashrc
source ~/.bashrc

然后用小鱼工具箱安装rosdepc

rosdepc init
rosdepc update

最后roscore启动，没错误，ros环境部署成功。

树莓派配置网络出现问题之解决办法

踩坑

创建工作空间并初始化

mkdir -p field_trial/src

cd field_trial/

catkin_make

如果提示没安装catkin，安装又发现和ros的依赖冲突，这里可以先卸载ros然后先安装catkin，再安装ros

1.catkin_make报错：IOError: [Errno 13] Permission denied:

https://answers.ros.org/question/246820/ros_arduino_bridge-reconnection-error/

https://blog.csdn.net/gongdiwudu/article/details/123983828

原因是创建工作空间时用了sudo或者在root下，解决方案：

sudo chown $USER: -R /home/pi/ros_catkin_ws

2.diagnostic_updater“,CMake did not find diagnostic_updater.

缺少相应的依赖包，可以：

sudo apt-cache search diagnostics updater #在apt源里寻找同样名字的包

根据返回安装合适的依赖包

sudo apt install ros-humble-diagnostic-updater

激光雷达相关

连接上激光雷达，并认当前的 USB 转串口终端并修改权限，

USB查看命令:

ll /dev/ttyUSB*

如果找不到，可能是数据线问题，换一根数据线即可。

使用

ls -l /dev/ttyUSB0

发现，当前用户没有使用它的权限，因此要添加权限

sudo usermod -a -G dialout 你的用户名

之后要重启才能生效

由于本次试验有多个外接设备，为了不造成串口混乱，可以绑定串口设备

雷达驱动包安装：

进入src工作空间，然后下载驱动包

git clone https://github.com/slamtec/rplidar_ros

返回工作空间，并catkin_make编译，并source ./devel/setup.bash，把功能包里的launch文件的设备端口改成之前映射好的端口。

测试

启动驱动包里的例程，如果不报错且能正确获取到当前雷达的信息，则没问题，我这里暂时没有做分布式，树莓派上安装的是无桌面版本，所以就不能通过rviz查看。

roslaunch rplidar_ros rplidar.launch

通过 rostopic list和rostopic echo /scan也能看到相关信息输出

IMU相关

参考资料：https://blog.csdn.net/ganjb1/article/details/118153554

参考项目：https://github.com/COONEO/Arduino_Jetson_nano_ROS_Car/tree/melodic/Jetson_nano_ROS_code/catkin_ws/src/imu_901

如何将 IMU （惯性测量单元） 传感器与 Arduino 对接

开源！手把手教你搭建Arduino+英伟达Jetson的ROS小车（中）

https://blog.csdn.net/zhuoyueljl/article/details/75453808

1.在windows电脑上使用商家提供的上位机软件设置IMU参数

2.然后把设备插到ubuntu设备的usb口上

安装串口功能包：

sudo apt-get install ros-melodic-serial

然后创建imu信息读取解析的相关功能包（参考教程：https://blog.csdn.net/qqliuzhitong/article/details/114384297）

catkin_create_pkg serial_demo roscpp serial

能再屏幕上打印后根据芯片的开发手册对串口数据进行解码，最后编写数据发布代码发布/imu

相关代码如下：

编码器相关

我的是arduino接收编码器的信息，然后arduino再通过ros_arduino_bridge和编码器交互，在ros端，我主要使用的是ros_arduino_python 下的arduino_drive.py.

查看权限

ls -l /dev/ttyACM0

授权（前面雷达部分已经弄过就可以不弄了）

sudo usermod -a -G dialout your_user_name

ros_arduino_bridge是依赖于python-serial功能包的

sudo apt-get install python-serial

在ros_arduino_msg中添加自定义编码器消息

Header header
int16 voltage
int32[4] enc

然后按照ros自定义消息的步骤进行配置和编译，最后在arduino_drive.py中进行解析和发布话题

odom里程计

odom里程计数据由编码器和imu数据融合而成，https://blog.csdn.net/baimei4833953/article/details/80768762

imu tool:
http://wiki.ros.org/imu_complementary_filter?distro=noetic

论文：https://www.mdpi.com/1424-8220/15/8/19302

两种融合的方法
（1） 一种简单的方法
从imu得到的数据为一个相对角度(主要使用yaw，roll和pitch 后面不会使用到)，使用该角度来替代由编码器计算得到的角度。
这个方法较为简单，出现打滑时候因yaw不会受到影响，即使你抬起机器人转动一定的角度，得到的里程也能正确反映出来

（2）扩展的卡尔曼滤波
官方提供了个扩展的卡尔曼滤波的包robot_pose_ekf，robot_pose_ekf开启扩展卡尔曼滤波器生成机器人姿态，支持

odom（编码器）
imu_data（IMU）
vo（视觉里程计）
还可以支持GPS
引用官方图片

chatGPT真是个神器：

集成

TF坐标变换

预备知识：https://www.jianshu.com/p/cb99188fec49

在launch文件中增加以下节点的代码：

<node pkg="tf2_ros" type="static_transform_publisher" name="imu_transform_publisher" args="0 0 0 0 0 0 base_link imu_link 100" />

<node pkg="tf2_ros" type="static_transform_publisher" name="imu_static_transform_publisher" args="x y z yaw pitch roll base_link imu_link 100" />

ROS std_msgs/Header 数据含义

https://blog.csdn.net/qq_18676517/article/details/109270525

创建功能包

catkin_create_pkg integration roscpp rospy std_msgs ros_arduino_python usb_cam rplidar_ros

功能包下创建launch文件夹，launch文件夹中新建run.launch文件,内容如下：

<!-- 机器人启动文件：
        1.启动底盘
        2.启动激光雷达
        3.IMU
        4.启动编码器
        5.启动odom
        6.录制数据
 -->
<launch>
        <!-- <include file="$(find ros_arduino_python)/launch/arduino.launch" /> -->
        <!-- <include file="$(find usb_cam)/launch/usb_cam-test.launch" /> -->
         <!-- 2.启动激光雷达 -->
        <include file="$(find rplidar_ros)/launch/rplidar.launch" />
        <!-- 6.录制数据 -->
        <!-- <node pkg="rosbag" type="record" name="record" args="/imu /odom /scan /tf /tf_static  -o /home/daoker/vscode_ws/src/sugarcane_car/bag/onece.bag"/> -->
        <node pkg="rosbag" type="record" name="record" args="/scan   -o /home/daoker/field_trial/src/integration/bag/onece.bag"/>
         <node pkg="tf2_ros" type="static_transform_publisher" name="static_transform_publisher" args="0 0 0 -1.57 0 -1.57 /front_bumper_link /front_bumper_link_depth" />
    <node pkg="tf" type="static_transform_publisher" name="odom_to_world" args="0.0 0.0 0.0 0 0 0.0 /odom /world 1000"/>
    <node pkg="rosbag" type="record" name="record" args="/imu /odom /scan /tf /tf_static  -o /home/daoker/vscode_ws/src/sugarcane_car/bag/onece.bag"/>

</launch>

前几天在小黄鱼搞了个4005U的小主机，直接刷了openwrt，网卡为AR9382，可惜找不到无线网卡驱动，于是拆开想看下换块网卡，可惜和我台式机的不兼容，比台式机的小了一半，恰巧发现背板上留了个stata支架，貌似还可以扩充个stata硬盘，然后看了下主板的接口，群里的大佬说买根ph2.0的线转接成硬盘的电源线就行，不过没有闲置的硬盘，感觉买来也大概率闲置，就不管了。

后来在折腾openwrt过程中知道了网心云容器魔方这个docker项目，就是把自己闲置的硬盘和宽带共享给别人进行边缘计算，然后就试着布置了下，收益有点低啊，感觉我来晚了，看贴吧说以前高。但是单口小主机真不方便，于是买了usb转网卡的接线，想扩充一个网口，然后又下单了一个可能兼容的无线网卡（有点后悔，应该加点钱买多网口小主机的），然后某次看到这个stata固态，咦这价格还挺香，买来挂网心云，假如每天收入1块5，那也只要半年就白得一块固态硬盘，真香，于是开搞，买ph2.0的线，但是看介绍说接线注意电压，我这没电压表，于是想着能不能用arduino测电压，于是找到了这个帖子：使用arduino测量电压的超级简单的方法

/*
 *使用俩个相同的电阻串联，并将其中一个电阻的两端分别接入arduino的A0接口与GND接口实现电压的测量
 *注意所测的电压不能超过"串联电阻数量"乘"5V"，否则可能会烧掉！！！！！！！！！！！！
 *注意所测的电压不能超过"串联电阻数量"乘"5V"，否则可能会烧掉！！！！！！！！！！！！
 *注意所测的电压不能超过"串联电阻数量"乘"5V"，否则可能会烧掉！！！！！！！！！！！！
 *注意所测的电压不能超过"串联电阻数量"乘"5V"，否则可能会烧掉！！！！！！！！！！！！
 *注意所测的电压不能超过"串联电阻数量"乘"5V"，否则可能会烧掉！！！！！！！！！！！！
 */



#define BV 0.0048875855327468   //analog将5V分成了1023个单位——5/1023
#define num 2;                  //串联所接的电阻的数量
int v;                          //定义analog所测得的数字（1~1023）
long double lv;                 //定义所测电阻的电压
double zv;                      //定义整个电路的电压
void setup() {
  Serial.begin(9600);
  pinMode(A0,INPUT);

}

void loop() {
  v = analogRead(A0);
  lv = v * BV;
  zv = lv * num;                //因为两个电阻是一样的大小，所以直接相乘就可以得到所测电压的大小
  Serial.println(zv);
}

后来线到了，实际也没测，想着应该只要接口对应，就不会有啥问题，于是直接插了上去，能用，就是网卡，还是找不到能用的驱动，也懒得退了，先不管了，安装网心云docker容器实例代码

部署容器魔方

基于虚拟网卡的多开

docker run -d --name=wxedge --restart=always --privileged --net=host --tmpfs /run --tmpfs /tmp -v /media/wxedge_storage:/storage:rw registry.hub.docker.com/onething1/wxedge:latest

然后在浏览器输入宿主机ip:18888进入后台管理界面

必选参数说明：

–privileged 必须打开（爱快docker不支持）。

–net 目前只支持host（推荐）和macvlan两种网络模式（不熟悉docker和网络知识的用户不要尝试macvlan，非常复杂！）。

“磁盘路径”是磁盘的目录，请根据自己实际磁盘目录更改，必须挂载到容器内的/storage目录，推荐磁盘是ext4文件系统，至少需要50G以上的空间，建议是固态硬盘。

可选参数说明（建议新手都不要设置）：

-e NIC=eth0 有多网卡多线路时，可以使用该参数指定路由网卡，不配置会自动选默认路由网卡，如果是openwrt系统，可以使用-e NIC=br-lan，业务申请到和局域网同一个网段的IP。

-e REC=false 第一次安装设置为false时，不会启动默认任务，默认为true，仅第一次安装有效。

-e LISTEN_ADDR=”0.0.0.0:28888″ 支持设置绑定页面的监听地址和端口，监听全地址设置-e LISTEN_ADDR=”:28888″，默认监听全地址18888端口。多开容器也可以参考用该参数，比如容器A使用参数-e LISTEN_ADDR=”:18888″，容器B使用参数 -e LISTEN_ADDR=”:28888″（已经实现同一业务可多次添加，不建议多开容器）

-v 磁盘路径:/var/lib/containerd 如果系统盘较小时，可以增加该参数修改安装路径，注意“磁盘路径”修改成自己的磁盘目录。

如果想安装第二个同样的容器实例，可以使用macvlan网络的创建方法，首先创建网络环境

docker network create -d macvlan --subnet=192.168.1.199/24 --gateway=192.168.1.1 -o parent=eth0 macvlan

参数含义：

• –subnet=192.168.1.99/24 网段，这个地方要修改成你创建docker的设备的IP段，比如设备IP是192.168.1.200，那这个地方参数就是192.168.1.199
• –gateway=192.168.1.1 网关，这个地方要修改成你创建docker的设备的网关
• -o parent=etho 这个地方vmbr0要修改成你设备中使用的网卡名称
• 其他参数默认

创建好macvlan网络之后

docker run -d --name=wxedge3 --restart=always --privileged --net=macvlan --ip=192.168.1.88 --tmpfs /run --tmpfs /tmp -v /docker/wxedge_storage3:/storage:rw registry.hub.docker.com/onething1/wxedge:latest

• #name=wxedge2 因为是第二个，所以添加数字2
• #ip=192.168.3.66 macvlan网络可以指定容器IP ， 这里修改成你要指定的IP,建议指定，这样方便web管理。
• #/media/wxedge_storage2 因为是第二个容器， 所以缓存目录要添加数字2

基于host改端口的多开

第一个容器命令

docker run -d --name=wxedge1 --restart=always --privileged --net=host  --tmpfs /run --tmpfs /tmp -e REC=false -v /docker/wxedge_storage1:/storage:rw registry.hub.docker.com/onething1/wxedge:latest

默认端口18888

第二个容器命令

docker run -d --name=wxedge5 --restart=always --privileged --net=host -e LISTEN_ADDR="192.168.1.200:28888" --tmpfs /run --tmpfs /tmp -e REC=false -v /mnt/sdb1/wxedge_storage4:/storage:rw registry.hub.docker.com/onething1/wxedge:latest

改端口为28888

查看业务信息文件

创建容器时挂载的目录/.onething_data/task/你的cg任务名/logs/server.log，cg任务名我这边是ba开头的，不好区分的话可以手动加几个，根据后缀判断，同一业务第n个就是_n

网络相关

修改docker0默认网段

docker0 默认网段和我的校园网认证页面的网段冲突，导致安装docker后无法认证，从而无法上网，所以可以修改docker0网段。

解决办法：改路由比较办法，可以一开始就将docker配置的bip改成169.254.0.1/24，可以避免冲突。在daemon配置文件里加个”bip”:“169.254.0.1/24”，重启docker就可以了

[root@st-dev6 ~]# vim /etc/docker/daemon.json
{
"bip":"169.254.0.1/24"
}

NAT类型检测

NAT全称“Network Address Translation”，意思是“网络地址转换”。通过NAT可以让局域网内的众多主机使用一个公网IP访问Internet。由于IPV4紧缺，家用网络大部分都在NAT环境中。目前NAT分为4个类型：NAT1、NAT2、NAT3、NAT4，具体的：

NAT1：Full Cone NAT（全锥形NAT）；

NAT2：Address Restricted Cone NAT（受限锥型NAT）；

NAT3：Port Restricted Cone NAT（端口受限锥型NAT）；

NAT4：Symmetric NAT（对称型NAT）；

从NAT1到NAT4限制越多，而家用网络最常见的是NAT3和NAT4。怎么测试网络nat类型呢?我推荐2个实用工具：

Windows系统可以使用nattypetester，如果软件默认的STUN server地址不可用，可以填写国内小米的服务器stun.miwifi.com。点击Test按钮然后在RFC 3489可以看到NAT类型数据。

Linux可以使用pystun3（如果是python2环境，可使用pystun），pystun3基于python可用pip安装：

pip install pystun3
pystun3

然后即可返回NAT类型结果：

我把pystun3安装到我的红米2小主机上，只要连上局域网wifi，检测非常方便。

NAT类型主要影响游戏延时（数据转发次数越多延时越高，网络波动越明显），和一些远程软件的数据连接。一般来说NAT3还能接受，NAT4可以换网络服务商了。

ubuntu修改dns设置让应用使用全锥网络

在使用ubuntu过程中，我发现，即使使用以上方法检测到网络类型为full-nat，但是部署docker网心云后网络类型变成了未知，所以前期我的docker容器魔方一般都是部署在openwrt里，这样感觉多了很多不需要的动能，并且使用也不方便，后来经过不断的探索，终于有人推荐了一篇文章：

温馨提示: 此处内容需要在文末评论本文并刷新页面后才能查看.

问题：
ubuntu18.04LTS搭建k8s coredns组件报错
因为/etc/resolve.conf中存在 nameserver 127.0.0.53回环地址造成循环引用
手动修改无果，每次重启依旧会覆盖

原因：
ubuntu17.0之后特有，systemd-resolvd服务会一直覆盖

解决办法：

sudo systemctl stop systemd-resolved
sudo systemctl disable systemd-resolved
sudo apt install unbound
sudo rm -rf /etc/resolv.conf
sudo vim /etc/NetworkManager/NetworkManager.conf

在[main]
下面添加
dns=unbound
将dns服务替换为unbound
reboot
重启电脑即可，开机查看resolve.conf发现nameserver自动配置

WIN10/WIN11开启UPNP

• 1、按下“Win+R”打开运行，输入“services.msc”点击确定打开“服务”；
• 2、双击打开“Funtion Discovery Resource Publication”，将其启动类型修改为“自动”，点击应用，点击启用，点击确定；
• 3、按照此方法按顺序将“SSDP Discovery Service”、“UPnP Device Host”服务进行设置即可！

原理分析：
a,b,c,d,e,f,g,dp控制8段灯，其他4针脚控制位显示。
但是如何控制不同位同时显示不同数字，比如第一位显示1，第二位显示二，其实实际上是不同时显示，只不过是视觉效果。我们先选择1位置，然后点亮数字1，然后熄灭1位置，打开2位置，点亮2，整个过程十分迅速，所以看起来是显示12.
这里用同时点亮1位置b段和2位置c段做测试

void setup() {
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(9,OUTPUT);
pinMode(10,OUTPUT);
}
//使用共阳4位数码管，相应的数字位为高电平则选中，相应的段位低电平在点亮
void loop() {
digitalWrite(9,1);   //9号端口高电平
digitalWrite(2,0);	//2号端口低电平
digitalWrite(2,1);
digitalWrite(9,0);
digitalWrite(10,1);
digitalWrite(3,0);
digitalWrite(10,0);
digitalWrite(3,1);

}

//显示23.45
int a=2;
#define w1 10
int const  num[11][8]={
    {0,0,0,0,0,0,1,1},  //0
    {1,0,0,1,1,1,1,1},  //1
    {0,0,1,0,0,1,0,1},  //2
    {0,0,0,0,1,1,0,1},  //3
    {1,0,0,1,1,0,0,1},  //4
    {0,1,0,0,1,0,0,1},  //5
    {0,1,0,0,0,0,0,1},  //6
    {0,0,0,1,1,1,1,1},  //7
    {0,0,0,0,0,0,0,1},  //8
    {0,0,0,0,1,0,0,1},  //9
    {1,1,1,1,1,1,1,0},  //10
};

void setup() {
for(int i=a;i<w1+4;i++){
  pinMode(i,OUTPUT);
}
Serial.begin(9600);
}
void clc(){ //清屏
  for(int i=a;i<a+8;i++){
  digitalWrite(i,1); //段高电平熄灭
}
for(int i=w1;i<w1+4;i++){
  digitalWrite(i,0); //位低电平熄灭
}
}
void led(int x,int y){
  clc();
  if(x>4)return;
  digitalWrite(w1+x-1,1);
  for(int i=0;i<8;i++)
  digitalWrite(a+i,num[y][i]);
}
void loop() {
 led(1,2);
 led(2,3);
 led(2,10);
 led(3,4);
 led(4,5);
}

参考文献

1-7,15号端口接8个LED或者8位数码管；
8号口接地；
9号口连接下一个595或者置空；
10号口接vcc；
11号口接D2；
11脚SRCLK移位寄存器时钟输入：当一个新的位数据要进来时，已经进入的位数据就在移位寄存器时钟脉冲的控制下，整体后移，让出位置。
12号口D3；
12脚RCLK存储寄存器：数据从位移寄存器转移到存储寄存器，也是需要时钟脉冲驱动的，这就是12脚的作用。它也是上升沿有效。
13号接口置空或者接GND;
14号接D4;
14脚串行输入：595的数据来源只有这一个口，一次只能输入一个位，那么连续输入8次，就可以积攒为一个字节了。
16号口接vcc

//淘宝店主配的代码，发觉后2个函数根本没用到，而是直接用shiftout函数
int data = 4; 
int clock = 3;
int latch = 2;
int ledState = 0;
const int ON = HIGH;
const int OFF = LOW;
void setup()
{
pinMode(data, OUTPUT);
pinMode(clock, OUTPUT);
pinMode(latch, OUTPUT);
}
void loop()
{
int delayTime = 100;
for(int i = 0; i < 256; i++)
{
updateLEDs(i);
delay(delayTime);
}
}
void updateLEDs(int value)
{
digitalWrite(latch, LOW);    //移位寄存器
shiftOut(data, clock, MSBFIRST, value);
digitalWrite(latch, HIGH);
}
/*void updateLEDsLong(int value)
    {
  digitalWrite(latch, LOW);
  for(int i = 0; i < 8; i++)
  {
  int bit = value & B10000000;
  value = value << 1;
  if(bit == 128){digitalWrite(data, HIGH);}
  else{digitalWrite(data, LOW);}
  digitalWrite(clock, HIGH);
  delay(1);
  digitalWrite(clock, LOW);
  }
  digitalWrite(latch, HIGH);
  }
int bits[]={B00000001, B00000010, B00000100, B00001000, B00010000, B00100000,
B01000000, B10000000};
int masks[] ={B11111110, B11111101, B11111011, B11110111, B11101111, B11011111,
B10111111, B01111111};
void changeLED(int led, int state)
{
ledState = ledState & masks[led];
if(state == ON){ledState = ledState | bits[led];}
updateLEDs(ledState);
}*/

Arduino中shiftOut怎么用？

二.接线说明
参考文献：Arduino uno r3 使用 ESP8266 wifi 模块完整流程

这里我chpd（en)直接接3.3v也没事
把代码上传到arduino，测试接线正确与否。

const int tx = 1;
const int rx = 0;
void setup() {
  //Serial.begin(9600); 注意！！千万别加这行代码
  pinMode(rx,INPUT_PULLUP);
  pinMode(tx,INPUT_PULLUP); 

}

void loop() {

}

每个版本的ESP8266波特率不同，一般是115200，你可以多测试几次。

SP8266 的 AT 命令可以在网上查，比如下面的这几个

AT+RST 重启模块
AT+GMR 查看版本信息
AT+CIOBAUD=9600 修改波特率
T+CWMODE? //查询工作模式 1.Station （客户端模式）2.AP （接入点模式）3.Station+AP （两种模式共存）

三.程序烧录至ESP8266
我看网上有的教程说要取掉arduino的啥啥啥芯片，我这个貌似不可拆，还有的是用专门的下载线和烧录软件，这个我也没有。
直到找到了这篇文章
Arduino和ESP8266-模块安装及代码上传
简单介绍，就是：
1.添加开发板管理网站http://arduino.esp8266.com/stable/package_esp8266com_index.json
2.在开发板管理器里安装ESP8266 Community。此步骤可能需要fq,如果没有可以下载离线包，也可以用这个帖子里分享的Arduino IDE安装esp8266 SDK（Windows10），或者自己去github下载
3.选择开发板，可以按照参考文献里的来配置
Arduino和ESP8266-模块安装及代码上传
Arduino烧录ESP8266模块，实现WiFi通信，连接OneNET平台（一）
我是选了Generic ESP8266 Module，其他都是默认没动，这里我最高版本的ARDUINO IDE里编程器下面没有选项，查了很多资料也没有这个问题的解释，所以我换了低一点版本的IDE就有了，我选skII。
4.烧录，在IDE里写好代码后，

将ESP8266设定为FLASH（烧写）模式：当GPIO0（上图紫色线）接地线时，ESP8266是以bootloader模式（编程模式）启动的，这也就是你可以烧写ESP8266（将Arduino上的代码转移到ESP8266上）的时候。在Arduino代码加载完毕时，你将看到Arduino IDE底部提示“上传结束”的信息，然后代码就会开始运行了。
程序上传结束后，将紫色线移除：当你不想将ESP8266一直设定为烧写模式时，将紫色线移除即可，程序将会一直在ESP8266上执行。
来源Arduino结合ESP8266 Serial WIFI模块访问远程服务器
实际操作：
【3】确保如上面连线图所示，A、B两条连线断开，即esp8266的EN、IO0针脚和UNO板子之间是断开的，
【4】点击IDE的 [上传] 按钮，开始通过UNO板子向esp8266烧写程序，
【5】当日志窗口出现 “Connecting…………………_” 字样时，
【6.1】首先，将ESP8266的IO0和UNO板子的GND连接，
【6.2】接着，将ESP8266的EN和UNO的3.3V连接，
程序继续烧写，继而完成。
烧写完成，提示“上传成功”，
【7.1】然后，断开8266的EN、IO0和板子的连接。如果不再需要和Arduino进行串口通信，TX、RX针脚也可以断开。
【7.2】再次将EN和3.3V连接，模块就进入工作模式了。
来源：Arduino和ESP8266-模块安装及代码上传

简单点说就是；在编译快完成时拉低IOO然后，rst低-高-低重启模块进入下载模式。
OK，下面可以写各种程序happy了。
刷at固件，连接和烧写程序一样ESP8266: Reflash Dance!

/*
    This sketch demonstrates how to set up a simple HTTP-like server.
    The server will set a GPIO pin depending on the request
      http://server_ip/gpio/0 will set the GPIO2 low,
      http://server_ip/gpio/1 will set the GPIO2 high
    server_ip is the IP address of the ESP8266 module, will be
    printed to Serial when the module is connected.
*/

#include <ESP8266WiFi.h>

const char* ssid = "401-2G";
const char* password = "415408807";

// Create an instance of the server
// specify the port to listen on as an argument
WiFiServer server(80);

void setup() {
  Serial.begin(9600);
  delay(10);

  // prepare GPIO2
  pinMode(LED_BUILTIN, OUTPUT);//在arduino里默认#define LED_BUILTIN 13，esp8266里默认为GIO2
  digitalWrite(LED_BUILTIN, 0);

  // Connect to WiFi network
  Serial.println();
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");

  // Start the server
  server.begin();
  Serial.println("Server started");

  // Print the IP address
  Serial.println(WiFi.localIP());
}
void loop() {
  // Check if a client has connected
  WiFiClient client = server.available();
  if (!client) {
    return;
  }

  // Wait until the client sends some data
  Serial.println("new client");
  while (!client.available()) {
    delay(1);
  }

  // Read the first line of the request
  String req = client.readStringUntil('\r');
  Serial.println(req);
  client.flush();

  // Match the request
  int val;
  Serial.printf("%d\n", req.indexOf("/gpio/0")); //查找是否包含/gpio/0，找不到返回-1
  Serial.printf("%d\n", req.indexOf("/gpio/1"));
  if (req.indexOf("/gpio/0") != -1)
    val = 0;
  else if (req.indexOf("/gpio/1") != -1)
    val = 1;
  else {
    Serial.println("invalid request");
    client.stop();
    return;
  }


  // Set GPIO2 according to the request
  digitalWrite(LED_BUILTIN, val);

  client.flush();

  // Prepare the response

  //  String s = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html>\r\nGPIO is now ";
  //  s += (val) ? "high" : "low";
  //  s += "</html>\n";
  //  // Send the response to the client
  //  client.print(s);
  client.print("<html><body><p>GPIO is now ");
  client.print((val) ? "high" : "low");
  client.println(" </p>");
  client.print("<a href=\"http://");
  client.print(WiFi.localIP());
  client.println("/gpio/1\">开</a>");//当遇到要输出"时，为了避免和print（""),可以写成print("\"")
  client.print("<a href=\"http://");
  client.print(WiFi.localIP());
  client.println("/gpio/0 \">关</a>");
  client.println("</body></html>");

  delay(1);
  Serial.println("Client disonnected");

  // The client will actually be disconnected
  // when the function returns and 'client' object is detroyed
}

编程时的注意事项：

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14 | GPIO_Pin_13; 此处本用||，这里应该不是或的意思。

/********************************
  板载led，即pc13为低电平点亮，高电平熄灭
  **********************************/
    GPIO_SetBits(GPIOC,GPIO_Pin_13);
    GPIO_ResetBits(GPIOC, GPIO_Pin_13);  

写代码烧录后不运行，注意几处设置：