sudo mkdir /opt/jvm

mv jdk-8u151-linux-x64.tar.gz /opt/jvm （得先用su指令进入root权限)

cd /opt/jvm

tar zxvf jdk-8u121-linux-x64.tar.gz -C /opt

[Desktop Entry]
Encoding=UTF-8
Name=Eclipse
Comment=Eclipse
Exec=/opt/eclipse-installer/eclipse-inst
Icon=/opt/eclipse-installer/icon.xpm
Terminal=false
StartupNotify=true
Type=Application
Categories=Application;Development;

sudo apt-get install git wget make libncurses-dev flex bison gperf python python-serial

mkdir -p ~/esp
cd ~/esp
tar -xzf xtensa-esp32-elf-linux64-1.22.0-80-g6c4433a-5.2.0.tar.gz

echo "export PATH=$PATH:$HOME/esp/xtensa-esp32-elf/bin" >> ~/.bashrc
source ~/.bashrc

cd ~/esp
git clone --recursive https://github.com/espressif/esp-idf.git

cd ~/esp
git clone -b v3.3 --recursive https://github.com/espressif/esp-idf.git

git submodule update --init

echo "export IDF_PATH=~/esp/esp-idf" >> ~/.bashrc

cd examples/get-started/hello_world/
make

sudo chmod 777 /det/ttyUSB0
make flash monitor

	8只3mm LED灯，共4种颜色，可以学习流水灯，跑马灯基础编程。
	1只0.5寸共阳数码管，方便学习数码管显示的基本原理和使用数码管显示数据。
	8位0.36寸共阴数码管，2个74HC573锁存，通过控制段锁存和位锁存可进行数码管的静态显示与动态扫描显示的工作。 
	1只1.9mm红色8x8点阵，2个74HC573锁存。用于练习使用LED屏显示图形、字符。
	LCD1602插座，10K电位器调节比度，即插即用。可以实现多种模式的显示，如移动显示、滚动显示、反白显示、光标显示闪烁等。
	LCD12864液晶标准插座，10K电位器调节比度，可以连接多款并口液晶，也可以直接插接我们配套的彩屏，练习使用写入用户自编图形或者字符，显示图片，显示数字等。
	8个独立按键，人机接口输入部分重要模块，按键可以自由配置，可进行外部中断控制实验、数据的增减控制、继电器开关控制等
	4x4标准矩阵键盘，带有中断信号输入接口，可以学习行列扫描、反转扫描、定时扫描、中断扫描等。
	高精度热敏电阻，通过AD采集转换可以测量环境温度变化等。
	高精度光敏电阻，通过AD采集转换可以测量光照度变化等。
	2路独立的18B20温度传感器接口，预留扩展插针，自由度更高，可以实验温度采集，超温报警和温度上下限设置等
	蜂鸣器，可播放音乐，可进行多种声音模拟，如警笛、消防车声、电子琴等	时钟芯片DS1302，32.768KHz时钟源晶振，另配备用电源CR1220纽扣电池，可编写日历时钟的编程显示、上位机在线更新时钟等程序
	EEPROM存储器24c02，IIC总线接口。使用方便灵活，可实现单字节、多字节数据的存储，掉电保护数据、开机次数记忆等。
	串行信号转并行信号芯片74HC164，通过模拟串口信号输入，输出8位并口信号，多用于扩展单片机本身端口。
	反向器CD4069，可以做门电路基础实验，信号组合试验等
	PCF8591芯片，8位数模/模数转换芯片，提供4路AD输入，和1路DA输出。4路输入接口分别连接到2个电位器的电平测试引脚，电平调节值范围0-VCC，端口也可自行外接；DA端口连接到一只LED灯，端口也可外接。
	优质隔离性光耦，通过控制光耦的1、2引脚的开关来隔离控制3、4引脚的通断（开发板3、4引脚的通断用一只红色led反映）。
	2路红外避障电路，使用触发器CD40106振荡出38K基波调制信号，单片机只要控制芯片使能脚即可发出38K红外载波信号；1路高灵敏度，宽范围一体化红外接收头，可以做避障、通讯功能等实验。使用我们的配套遥控器可以实现遥控解码控制等。
	MAX232串口电平转换，2路串口（DB9公口和母口），可以使用串口进行程序下载、与上位机之间串口通信等。
	PL2303为USB转换下载芯片，通过一根USB线与电脑进行程序下载，数据交换通信。
	RS485芯片，学习485硬件控制原理。可以提高串口的通信距离。
	PS/2接口，可以连接PS/2标准输入设备，学习PS/2协议原理和技术。
	标准AT-ISP接口，选购标准AT下载器可以进行AT89s系列51芯片和Atmega公司的AVR芯片下载和使用

"D:\Program Files\MDK516\ARM\ARMCC\bin\fromelf.exe" --bin -o ./obj/test_app.bin ./obj/test_app.axf"

$K\ARM\ARMCC\bin\fromelf.exe --bin --output=@L.bin !L

$K\ARM\ARMCC\bin\fromelf.exe --bin --output=Bin\@L.bin !L

/**************************实现函数********************************************
*函数原型:		void IIC_Start(void)
*功　　能:		产生IIC起始信号
*******************************************************************************/
void IIC_Start(void)
{
	SDA_OUT();     //sda线输出
	IIC_SDA_1;	  	  
	IIC_SCL_1;
	
	delay_us(5);
 	IIC_SDA_0;//START:when CLK is high,DATA change form high to low 
	
	delay_us(5);
	IIC_SCL_0;//钳住I2C总线，准备发送或接收数据 
}

/**************************实现函数********************************************
*函数原型:		void IIC_Stop(void)
*功　　能:	    //产生IIC停止信号
*******************************************************************************/	  
void IIC_Stop(void)
{
	SDA_OUT();//sda线输出
	IIC_SCL_0;
	IIC_SDA_0;//STOP:when CLK is high DATA change form low to high

	delay_us(5);
	IIC_SCL_1; 
	IIC_SDA_1;//发送I2C总线结束信号

	delay_us(5);							   	
}

/**************************实现函数********************************************
*函数原型:		u8 IIC_Wait_Ack(void)
*功　　能:	    等待应答信号到来 
//返回值：1，接收应答失败
//        0，接收应答成功
*******************************************************************************/
u8 IIC_Wait_Ack(void)
{
	u8 ucErrTime=0; 
	SDA_IN();      //SDA设置为输入  
	IIC_SDA_1;
		delay_us(5);	  
	while(READ_SDA)
	{
		ucErrTime++;
		if(ucErrTime>50)
		{
			IIC_Stop();
			return 1;
		}
		delay_us(5);
	}  
	IIC_SCL_1;
	delay_us(5); 
	IIC_SCL_0;//时钟输出0  
	return 0;  
} 

/**************************实现函数********************************************
*函数原型:		void IIC_Ack(void)
*功　　能:	    产生ACK应答
*******************************************************************************/
void IIC_Ack(void)
{
	IIC_SCL_0;
	SDA_OUT();
	IIC_SDA_0;
	delay_us(5);
	IIC_SCL_1;
	delay_us(5);
	IIC_SCL_0;
}
	
/**************************实现函数********************************************
*函数原型:		void IIC_NAck(void)
*功　　能:	    产生NACK应答
*******************************************************************************/	    
void IIC_NAck(void)
{
	IIC_SCL_0;
	SDA_OUT();
	IIC_SDA_1;
    delay_us(5);
    IIC_SCL_1;
    delay_us(5);
    IIC_SCL_0;
}					 				     

/**************************实现函数********************************************
*函数原型:		void IIC_Send_Byte(u8 txd)
*功　　能:	    IIC发送一个字节
*******************************************************************************/		  
void IIC_Send_Byte(u8 txd)
{                        
    u8 t; 
		SDA_OUT(); 	    
    IIC_SCL_0;//拉低时钟开始数据传输
    for(t=0;t<8;t++)
    {              
	   if(txd&0x80)
		  IIC_SDA_1; //IIC_SDA=1;
	   else
		  IIC_SDA_0; //IIC_SDA=0;
        txd<<=1; 	  
		delay_us(2);   
		IIC_SCL_1;
		delay_us(5);
		IIC_SCL_0;	
		delay_us(3);
    }	 
} 	 
   
/**************************实现函数********************************************
*函数原型:		u8 IIC_Read_Byte(unsigned char ack)
*功　　能:	    //读1个字节，ack=1时，发送ACK，ack=0，发送nACK 
*******************************************************************************/  
u8 IIC_Read_Byte(unsigned char ack)
{
	unsigned char i,receive=0;
	SDA_IN();//SDA设置为输入
    for(i=0;i<8;i++ )
	{
        IIC_SCL_0; 
        
		delay_us(5);
		IIC_SCL_1;
        receive<<=1;
        if(READ_SDA)receive++;   
		delay_us(5); 
    }					 
    if (ack)
        IIC_Ack(); //发送ACK 
    else
        IIC_NAck();//发送nACK  
    return receive;
}

/**************************实现函数********************************************
*功　　能:	    读取指定设备 指定寄存器的 length个值
输入	dev  目标设备地址
		reg	  寄存器地址
		length 要读的字节数
		*data  读出的数据将要存放的指针
返回   读出来的字节数量
*******************************************************************************/ 

u8 IICreadBytes(u8 dev, u8 reg, u8 *data , uint16_t length)
{
    u8 count = 0;
	
	IIC_Start();
	IIC_Send_Byte(dev<<1);	   //发送写命令
	IIC_Wait_Ack();
	IIC_Send_Byte(reg);   //发送地址
	IIC_Wait_Ack();	  
	IIC_Start();
	IIC_Send_Byte((dev<<1)+1);  //进入接收模式	
	IIC_Wait_Ack();
	
    for(count=0;count<length;count++){
		 
		 if(count!=length-1)data[count]=IIC_Read_Byte(1);  //带ACK的读数据
		 	else  data[count]=IIC_Read_Byte(0);	 //最后一个字节NACK
	}
    IIC_Stop();//产生一个停止条件
    return 0;
}

/**************************实现函数********************************************
*功　　能:	    将多个字节写入指定设备 指定寄存器
输入	dev  目标设备地址
		reg	  寄存器地址
		length 要写的字节数
		*data  将要写的数据的首地址
返回   返回是否成功
*******************************************************************************/ 
u8 IICwriteBytes(u8 dev, u8 reg, u8 *data , uint16_t length)
{
 	u8 count = 0;
	IIC_Start();
	IIC_Send_Byte(dev<<1);	   //发送写命令
	IIC_Wait_Ack();
	IIC_Send_Byte(reg);   //发送地址
	IIC_Wait_Ack();	  
	for(count=0;count<length;count++){
		IIC_Send_Byte(data[count]); 
		IIC_Wait_Ack(); 
 }
	IIC_Stop();//产生一个停止条件

    return 0; //status == 0;
	
}

struct bmi160_dev bmi160sensor ;
void mybmi160_init(void)//BMI160初始化
{
//	struct bmi160_dev bmi160sensor;
	int8_t rslt = BMI160_OK;
	bmi160sensor.id = BMI160_I2C_ADDR;
	bmi160sensor.interface = BMI160_I2C_INTF;
	bmi160sensor.read = IICreadBytes;
	bmi160sensor.write = IICwriteBytes;
	bmi160sensor.delay_ms = delay_ms;
	bmi160sensor.chip_id=0;
	IICreadBytes(BMI160_I2C_ADDR,BMI160_CHIP_ID_ADDR, &bmi160sensor.chip_id, 1);
	printf("bmi_id=%d\n",bmi160sensor.chip_id);
//	bmi160_get_regs2(BMI160_CHIP_ID_ADDR, &bmi160sensor.chip_id, 1, dev);
	rslt = bmi160_init(&bmi160sensor);
	/* Select the Output data rate, range of accelerometer bmi160sensor */
	bmi160sensor.accel_cfg.odr = BMI160_ACCEL_ODR_800HZ;
	bmi160sensor.accel_cfg.range = BMI160_ACCEL_RANGE_4G;
	bmi160sensor.accel_cfg.bw = BMI160_ACCEL_BW_NORMAL_AVG4;

	/* Select the power mode of accelerometer bmi160sensor */
	bmi160sensor.accel_cfg.power = BMI160_ACCEL_NORMAL_MODE;

	/* Select the Output data rate, range of Gyroscope bmi160sensor */
	bmi160sensor.gyro_cfg.odr = BMI160_GYRO_ODR_800HZ;
	bmi160sensor.gyro_cfg.range = BMI160_GYRO_RANGE_2000_DPS;
	bmi160sensor.gyro_cfg.bw = BMI160_GYRO_BW_NORMAL_MODE;

	/* Select the power mode of Gyroscope bmi160sensor */
	bmi160sensor.gyro_cfg.power = BMI160_GYRO_NORMAL_MODE; 

	/* Set the bmi160sensor configuration */
	rslt = bmi160_set_sens_conf(&bmi160sensor);
	/* After the above function call, accel and gyro parameters in the device structure 
	are set with default values, found in the datasheet of the bmi160sensor */
}

//获取数据
void get_accel_gyro_data2(void)
{
	uint8_t data_array[15] = {0};
	uint8_t lsb;
	uint8_t msb;
	int16_t msblsb;
	int16_t  gx,gy,gz,ax,ay,az;

	IICreadBytes(BMI160_I2C_ADDR,BMI160_GYRO_DATA_ADDR,data_array,15);//获取陀螺仪的数据

	lsb = data_array[0];
	msb = data_array[1];
	msblsb = (int16_t)((msb << 8) | lsb);
	gx = msblsb; /* gyro X axis data */

	lsb = data_array[2];
	msb = data_array[3];
	msblsb = (int16_t)((msb << 8) | lsb);
	gy = msblsb; /* gyro Y axis data */

	lsb = data_array[4];
	msb = data_array[5];
	msblsb = (int16_t)((msb << 8) | lsb);
	gz = msblsb; /* gyro Z axis data */

	/* Accel Data */
	lsb = data_array[6];
	msb = data_array[7];
	msblsb = (int16_t)((msb << 8) | lsb);
	ax = (int16_t)msblsb; /* accel X axis data */

	lsb = data_array[8];
	msb = data_array[9];
	msblsb = (int16_t)((msb << 8) | lsb);
	ay = (int16_t)msblsb; /* accel Y axis data */

	lsb = data_array[10];
	msb = data_array[11];
	msblsb = (int16_t)((msb << 8) | lsb);
	az = (int16_t)msblsb; /* accel Z axis data */
	printf("gyro->x=%d,y=%d,z=%d,accel->x=%d,y=%d,z=%d \n",gx,gy,gz,ax,ay,az);
}

void bmi160_Interrupt(void)//设置任意方向中断
{
	struct bmi160_int_settg int_config;
	int8_t rslt = BMI160_OK;
	/* Select the Interrupt channel/pin */
	int_config.int_channel = BMI160_INT_CHANNEL_1;// Interrupt channel/pin 1

	/* Select the Interrupt type */
	int_config.int_type = BMI160_ACC_ANY_MOTION_INT;// Choosing Any motion interrupt
	/* Select the interrupt channel/pin settings */
	int_config.int_pin_settg.output_en = BMI160_ENABLE;// Enabling interrupt pins to act as output pin
	int_config.int_pin_settg.output_mode = BMI160_DISABLE;// Choosing push-pull mode for interrupt pin
	int_config.int_pin_settg.output_type = BMI160_ENABLE;// Choosing active low output
	int_config.int_pin_settg.edge_ctrl = BMI160_ENABLE;// Choosing edge triggered output
	int_config.int_pin_settg.input_en = BMI160_DISABLE;// Disabling interrupt pin to act as input
	int_config.int_pin_settg.latch_dur = BMI160_LATCH_DUR_40_MILLI_SEC;// non-latched output

	/* Select the Any-motion interrupt parameters */
	int_config.int_type_cfg.acc_any_motion_int.anymotion_en = BMI160_ENABLE;// 1- Enable the any-motion, 0- disable any-motion 
	int_config.int_type_cfg.acc_any_motion_int.anymotion_x = BMI160_ENABLE;// Enabling x-axis for any motion interrupt
	int_config.int_type_cfg.acc_any_motion_int.anymotion_y = BMI160_ENABLE;// Enabling y-axis for any motion interrupt
	int_config.int_type_cfg.acc_any_motion_int.anymotion_z = BMI160_ENABLE;// Enabling z-axis for any motion interrupt
	int_config.int_type_cfg.acc_any_motion_int.anymotion_dur = 0;// any-motion duration
	int_config.int_type_cfg.acc_any_motion_int.anymotion_thr = 100;
	/* Set the Any-motion interrupt */
	rslt=bmi160_set_int_config(&int_config, &bmi160sensor); /* bmi160sensor is an instance of the structure bmi160_dev  */
}

/******************************************
1-Wire器件复位, 并检查应答;有应答返回0, 无应答返回1
*******************************************/
 unsigned char Reset( void )
{
	unsigned char testCount = 50;
    GPIO_DS28E05_Out_Mode();
    DS28E05_Write_1();
    DS28E05_Write_0();
    delay_us(60);                //复位60us低脉冲保持
    DS28E05_Write_1();                //释放总线后9us读应答
	GPIO_DS28E05_Input_Mode();
    while(testCount--)
    {
        if( 0 == DS28E05_ReadBit() )
        {
            delay_us(2); 
            return 0;
        }
    }	
	return 1;
}

/******************************************
               写数据位1
*******************************************/
void WriteBit_1( void )
{
    DS28E05_Write_1();
    DS28E05_Write_0();        //拉低总线保持1us
    delay_us(1);
    DS28E05_Write_1();        //释放总线延时大于12us
    delay_us(20);//20us
}
/******************************************
                写数据位0
*******************************************/
void WriteBit_0( void )
{
 
    DS28E05_Write_1();
    DS28E05_Write_0();        //拉低总线保持8-16us
    delay_us(12);	//9-10us
    DS28E05_Write_1();        //释放总线延时6us
    delay_us(9);
}

/******************************************
                读数据位
*******************************************/
unsigned char value1;
static unsigned char Read_Bit( void )
{
		GPIO_DS28E05_Out_Mode();
		DS28E05_Write_1();
		DS28E05_Write_0();          //拉低总线保持1us
		delay_us(1);
		DS28E05_Write_1();                
		DS28e05_IO_IN();//最重要的一步，一定要用寄存器操作，否则会错过读取的时间，经检测，整个读取周期为2-3微妙
		value1 = DS28E05_ReadBit();   
		delay_us(2);
    return value1;   
}

/******************************************
                写字节
*******************************************/
static void Write_Byte( unsigned char value )
{
    unsigned char i;
	GPIO_DS28E05_Out_Mode();
    for( i = 0; i < 8; i++ )
    {
        if( value & 0x01 )
        {
            WriteBit_1();
        }
        else
        {
            WriteBit_0();
        }
        value = value >> 1;
    }
}

/******************************************
                读字节
*******************************************/
static unsigned char Read_Byte( void )
{
    int i, value;
    value = 0;
    for( i = 0; i < 8; i++ )
    {
        value >>= 1;
        if( Read_Bit() ) 
            value |= 0x80;   
    }
    return value;
}

/******************************************
功能：读8位家族码;48位序列号;8位CRC码;读取成功返回0
参数：*id--读取的数据存放地址
返回：0--操作成功；1--总线不可用;
*******************************************/
unsigned char DS28E05_ReadRom( unsigned char *id )
{
    unsigned char i,j;
		while(Reset());
		Write_Byte( Rom_Read_Cmd );        //写命令
		for( i = 0; i < 8; i++ )
		{
				j= Read_Byte();
				*id++ =  j;     
		}
		return ( 0 );	
}
/******************************************
功能：  读EPROM
参数：  tgaddr--目标地址;
        len--要读取的字节数;
        *buffer--存放地址
返回：0--操作成功；1--总线不可用;
*******************************************/
unsigned char DS28E05_ReadMemory( unsigned char tgaddr, unsigned char len, unsigned char * buffer )
{
    unsigned char i;
    if( Reset() != 0 )
        return ( 1 );
        Write_Byte( Rom_Skip_Cmd );                		//写命令  
        Write_Byte( Memory_Read_Cmd );        				//写命令
        Write_Byte( tgaddr );                         //写地址低字节
        Write_Byte( 0 );                              //写地址高字节
		for( i = 0; i < len; i++ )
		{
			buffer[ i ] = Read_Byte();
		}
        Reset();
        return ( 0 );        
}
//写eeprom

int ds28e05WriteMemory(uint8_t address, char *buffer, int length)
{
  uint8_t a,b;
  uint8_t sf,ef;
  uint8_t sb[2]={0};
  uint8_t eb[2]={0};
  uint8_t spage, epage, npage, wpage;
  uint8_t nseg, wseg=0;
  uint8_t wBytes=0, rBytes=0, wAddr = 0;
 
  // Calculate pages
  spage = ((address & PAGE_MASK) >> 4);
  epage = (((address + length) & PAGE_MASK) >> 4);
  if (epage == NUM_PAGES) epage = NUM_PAGES - 1;
  npage = epage - spage;
	printf("spage=%d,epage=%d\n",spage,epage);
	printf("npage=%d,length=%d\n",npage,length);
  //This memory must be written respecting 16bits boundaries
  sf = (address&0x01) != 0;
  ef = ((address+length)&0x01) != 0;
	printf("sf=%d,ef=%d\n",sf,ef);
  if (ef)
  {
    DS28E05_ReadMemory( address+length,1, &eb[1]);
    eb[0] = buffer[length-1];
    length++;
  }
  if (sf)
  {
    DS28E05_ReadMemory(address-1,1, &sb[0]);
    sb[1] = buffer[0];
    length++;
    address--;
  }
  // Write pages
  for (wpage = 0; wpage <= npage; wpage++)
  {
    wAddr = address + wBytes;
    // Calculate segments to write
    if ((length - wBytes) > (BYTES_PER_PAGE))
      // Will we pass a page boudary
      if (wAddr % (SEG_SIZE * BYTES_PER_SEG) == 0)
        nseg = SEG_SIZE;
      else
        nseg = (BYTES_PER_PAGE - (wAddr % (BYTES_PER_PAGE))) >> 1;
    else
      nseg = ((length - wBytes) & SEG_MASK) >> 1;

	printf("nseg=%d\n",nseg);

    if( Reset() != 0 )
        return ( 1 );
	Write_Byte( Rom_Skip_Cmd );  
    Write_Byte(DS28E05_WRITE_MEMORY);
    Write_Byte(wAddr);
    Write_Byte(0xff);
    // Write segments within page
    for (wseg = 0; wseg < nseg; wseg++)
    {
      if (sf)
      {
        Write_Byte(sb[0]);
        Write_Byte(sb[1]);
        wBytes += 2;
        rBytes++;
        sf = 0;
      }
      else if (ef && (length - wBytes) <= 2)
      {
        Write_Byte(eb[0]);
        Write_Byte(eb[1]);
        wBytes += 2;
        rBytes++;
        ef = 0;
      }
      else
      {
        Write_Byte(buffer[rBytes]);
        Write_Byte(buffer[rBytes+1]);
        wBytes += 2;
        rBytes += 2;
      }

      a = Read_Byte();
      b = Read_Byte();

      printf("Readback: %02x %02x (%c%c)\n", a, b, a, b);

      Write_Byte(0xff);

      delay_ms(16);

      a = Read_Byte();

      printf("Verification byte: %02x\n", a);

      if(a !=0xAA)
        goto error;
    }

    Reset();;
  }

  return 1;
error:
  Reset();
  return 0;
}