548 lines
13 KiB
C++
548 lines
13 KiB
C++
#include "IS3.h"
|
||
#define IS3_usart_port 1
|
||
#define IS3_TX 42
|
||
#define IS3_RX 41
|
||
#define IS3_RST 17
|
||
|
||
IS3::IS3()
|
||
{
|
||
a1 = 0.0;
|
||
a2 = 0.0;
|
||
a3 = 0.0;
|
||
a4 = 0.0;
|
||
}
|
||
|
||
void IS3::init()
|
||
{
|
||
Serial1.setRxBufferSize(1024*2);
|
||
Serial1.setTimeout(10);
|
||
Serial1.setTxBufferSize(1024*2);
|
||
Serial1.begin(921600, SERIAL_8N1, IS3_RX, IS3_TX);
|
||
|
||
// Serial1.onReceive(onUart1Data, true); // 建议用 true
|
||
pinMode(IS3_RST,OUTPUT);
|
||
on();
|
||
IS3::reset();
|
||
// IS3::reset();
|
||
// vTaskDelay(1000);
|
||
|
||
IS3::integration_time = 12;
|
||
bool success = false;
|
||
String is3_info;
|
||
double aa1, aa2, aa3, aa4;
|
||
uint32_t is3_bandnum;
|
||
|
||
do
|
||
{
|
||
// Serial0.println("IS3 set_shutter_time");
|
||
success = IS3::set_shutter_time(IS3::integration_time);
|
||
vTaskDelay(10);
|
||
} while (!success);
|
||
// Serial0.printf("set_shutter_time : %d\n",)
|
||
do
|
||
{
|
||
// Serial0.println("IS3 get_is3_info");
|
||
success = IS3::get_is3_info(&is3_info);
|
||
vTaskDelay(10);
|
||
} while (!success);
|
||
// Serial0.printf("IS3_info %s\n", is3_info.c_str());
|
||
do
|
||
{
|
||
// Serial0.println("IS3 get_bochangxishu");
|
||
success = IS3::get_bochangxishu(&aa1, &aa2, &aa3, &aa4);
|
||
vTaskDelay(10);
|
||
} while (!success);
|
||
// Serial0.printf("aa1:%f aa2:%f aa3:%f aa4:%f\n",aa1,aa2,aa3,aa4);
|
||
do
|
||
{
|
||
// Serial0.println("IS3 get_bandnum");
|
||
success = IS3::get_bandnum(&is3_bandnum);
|
||
vTaskDelay(10);
|
||
} while (!success);
|
||
// Serial0.printf("is3_bandnum:%d\n",is3_bandnum);
|
||
}
|
||
|
||
void IS3::reset()
|
||
{
|
||
digitalWrite(IS3_RST,LOW);
|
||
vTaskDelay(200);
|
||
digitalWrite(IS3_RST,HIGH);
|
||
vTaskDelay(1000);
|
||
}
|
||
|
||
|
||
|
||
void IS3::on()
|
||
{
|
||
digitalWrite(IS3_RST,HIGH);
|
||
}
|
||
|
||
void IS3::off()
|
||
{
|
||
digitalWrite(IS3_RST,LOW);
|
||
}
|
||
|
||
void IS3::write(uint8_t command,uint8_t *pData, uint16_t Size)
|
||
{
|
||
uart_flush_input(IS3_usart_port);
|
||
uint8_t send_buff[200];
|
||
uint32_t send_lenth;
|
||
|
||
send_lenth = IRIS_Protocol_Pack(command,Size,pData,send_buff);
|
||
Serial1.write(send_buff,send_lenth);
|
||
}
|
||
|
||
// int IS3::read1(uint8_t *data_type,uint8_t *read_buf)
|
||
// {
|
||
|
||
// unsigned char command_data[1024 * 2];
|
||
// uint16_t data_length = 0;
|
||
// // int a = 200;
|
||
// int a = is3.integration_time * 3;
|
||
// while (a--)
|
||
// {
|
||
// while(Serial1.available())
|
||
// {
|
||
// data_length += Serial1.readBytes(&command_data[data_length],1024*2);
|
||
// a = 2;
|
||
// }
|
||
// // if(a< 10) a--;
|
||
// vTaskDelay(1);
|
||
// }
|
||
// if (data_length <= 0)
|
||
// {
|
||
// return -1;
|
||
// }
|
||
|
||
// data_length = IRIS_Cut_Befor_Header(command_data, data_length);
|
||
// int ret = IRIS_STM32_Protocol_Unpack(command_data,data_length,data_type,read_buf);
|
||
// if (ret < 0)
|
||
// {
|
||
// return -1;
|
||
// }
|
||
|
||
// return ret;
|
||
|
||
// }
|
||
|
||
|
||
uint32_t my_usart_available(uart_port_t uart_port)
|
||
{
|
||
|
||
size_t available = 0;
|
||
uart_get_buffered_data_len(uart_port, &available);
|
||
// Serial0.printf("available:%d\n",available);
|
||
return available;
|
||
// if (uart->has_peek) available++;
|
||
}
|
||
|
||
|
||
int IS3::read(uint8_t *data_type,uint8_t *read_buf)
|
||
{
|
||
IS3::read_sta = 1;
|
||
unsigned char command_data[1024 * 2];
|
||
uint16_t data_length = 0;
|
||
// int a = 200;
|
||
int a = is3.integration_time * 3 + 50;
|
||
while (a--)
|
||
{
|
||
// while(Serial1.available())
|
||
// uint32_t len =0;
|
||
|
||
// uart_get_buffered_data_len(IS3_usart_port,&len);
|
||
while(my_usart_available(IS3_usart_port))
|
||
{
|
||
// data_length += Serial1.readBytes(&command_data[data_length],1024*2);
|
||
data_length += uart_read_bytes(IS3_usart_port,&command_data[data_length],1024*2,10);
|
||
a = 2;
|
||
}
|
||
|
||
// if(a< 10) a--;
|
||
vTaskDelay(1);
|
||
}
|
||
if (data_length <= 0)
|
||
{
|
||
IS3::read_sta = 0;
|
||
return -1;
|
||
}
|
||
data_length = IRIS_Cut_Befor_Header(command_data, data_length);
|
||
int ret = IRIS_STM32_Protocol_Unpack(command_data,data_length,data_type,read_buf);
|
||
if (ret < 0)
|
||
{
|
||
IS3::read_sta = 0;
|
||
memset(read_buf,0,sizeof(read_buf));
|
||
return -1;
|
||
}
|
||
IS3::read_sta = 0;
|
||
return ret;
|
||
}
|
||
|
||
bool IS3::get_is3_info(String *is3_info)
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t data = 0;
|
||
IS3::write(0x50,&data,1);
|
||
uint8_t data_type;
|
||
uint8_t command_data[20];
|
||
|
||
int data_lenth = IS3::read(&data_type,command_data);
|
||
if (data_lenth <= 0 || data_type != 0x50)
|
||
{
|
||
return false;
|
||
}
|
||
*is3_info = String(command_data,data_lenth);
|
||
IS3::info = *is3_info;
|
||
return true;
|
||
}
|
||
|
||
bool IS3::set_shutter_time(uint32_t shutter_time)
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t data[4]={0,0,0,0};
|
||
data[0] |= shutter_time >> 24;
|
||
data[1] |= shutter_time >> 16;
|
||
data[2] |= shutter_time >> 8;
|
||
data[3] |= shutter_time ;
|
||
IS3::write(0x51,data,4);
|
||
|
||
uint8_t data_type;
|
||
uint8_t command_data[20];
|
||
|
||
int data_lenth = IS3::read(&data_type,command_data);
|
||
if (data_type != 0x51)
|
||
{
|
||
return false;
|
||
}
|
||
IS3::integration_time = shutter_time;
|
||
return true;
|
||
}
|
||
|
||
//有问题
|
||
bool IS3::opt()
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t data = 0;
|
||
IS3::write(0x52,&data,1);
|
||
uint8_t data_type;
|
||
uint8_t command_data[20];
|
||
|
||
int data_lenth = IS3::read(&data_type,command_data);
|
||
if(data_lenth <= 0 || data_type != 0x52)
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
bool IS3::get_shutter_time(uint32_t *shutter_time)
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t data = 0;
|
||
IS3::write(0x53,&data,1);
|
||
|
||
uint8_t data_type;
|
||
uint8_t command_data[20];
|
||
|
||
int data_lenth = IS3::read(&data_type,command_data);
|
||
if (data_lenth <= 0 || data_type != 0x53)
|
||
{
|
||
return false;
|
||
}
|
||
*shutter_time = command_data[0] << 24 | command_data[1] << 16 | command_data[2] << 8 | command_data[3];
|
||
IS3::integration_time = *shutter_time;
|
||
return true;
|
||
}
|
||
|
||
|
||
bool IS3::get_is3_temperature(float *temp)
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t data = 0;
|
||
IS3::write(0x54,&data,1);
|
||
|
||
uint8_t data_type;
|
||
uint8_t command_data[20];
|
||
|
||
int data_lenth = IS3::read(&data_type,command_data);
|
||
if (data_lenth <= 0 || data_type != 0x54)
|
||
{
|
||
return false;
|
||
}
|
||
*temp = command_data[0] << 24 | command_data[1] << 16 | command_data[2] << 8 | command_data[3];
|
||
IS3::temperature = *temp;
|
||
return true;
|
||
}
|
||
|
||
|
||
bool IS3::close_shutter()
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t shutter_num = 1;
|
||
IS3::write(0x55,&shutter_num,1);
|
||
|
||
uint8_t data_type;
|
||
uint8_t command_data[20];
|
||
|
||
int data_lenth = IS3::read(&data_type,command_data);
|
||
if(data_lenth <= 0 || data_type != 0x55)
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool IS3::open_shutter()
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t shutter_num = 1;
|
||
IS3::write(0x56,&shutter_num,1);
|
||
|
||
uint8_t data_type;
|
||
uint8_t command_data[20];
|
||
|
||
int data_lenth = IS3::read(&data_type,command_data);
|
||
if(data_lenth <= 0 || data_type != 0x56)
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
bool IS3::get_bandnum(uint32_t *is3_bandnum)
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t data = 0;
|
||
IS3::write(0x57,&data,1);
|
||
uint8_t data_type;
|
||
uint8_t command_data[20];
|
||
|
||
int data_lenth = IS3::read(&data_type,command_data);
|
||
if(data_lenth <= 0 || data_type != 0x57)
|
||
{
|
||
return false;
|
||
}
|
||
*is3_bandnum = command_data[0] << 24 | command_data[1] << 16 | command_data[2] << 8 | command_data[3];
|
||
IS3::bandnum = *is3_bandnum;
|
||
return true;
|
||
}
|
||
|
||
|
||
// bool set_bochangxishu(struct bochangxishu *bochangxishu);
|
||
// bool IS3::set_bochangxishu(double aa1,double aa2,double aa3,double aa4)
|
||
// {
|
||
// uint8_t bochangxishu[32] = {0};
|
||
|
||
|
||
// IS3::write(0x58, (uint8_t *)bochangxishu, 32);
|
||
|
||
// uint8_t data_type;
|
||
// uint8_t command_data[20];
|
||
// int data_lenth = IS3::read(&data_type,command_data);
|
||
// if(data_lenth <= 0 || data_type != 0x58)
|
||
// {
|
||
// return false;
|
||
// }
|
||
// return true;
|
||
// }
|
||
|
||
// 转换每个 double 为大端格式并写入缓冲区
|
||
void double_to_big_endian(double value, uint8_t* out) {
|
||
uint8_t* p = (uint8_t*)&value;
|
||
for (int i = 0; i < 8; ++i) {
|
||
out[i] = p[7 - i]; // 反转字节序
|
||
}
|
||
}
|
||
|
||
bool IS3::set_bochangxishu(double aa1, double aa2, double aa3, double aa4)
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t bochangxishu[32] = {0}; // 4 * 8 = 32 bytes
|
||
|
||
// 转换每个 double 为大端格式并写入缓冲区
|
||
double_to_big_endian(aa1, &bochangxishu[0]);
|
||
double_to_big_endian(aa2, &bochangxishu[8]);
|
||
double_to_big_endian(aa3, &bochangxishu[16]);
|
||
double_to_big_endian(aa4, &bochangxishu[24]);
|
||
|
||
// 写入地址 0x58
|
||
IS3::write(0x58, bochangxishu, 32);
|
||
|
||
// 读取设备返回数据
|
||
uint8_t data_type;
|
||
uint8_t command_data[20];
|
||
|
||
int data_lenth = IS3::read(&data_type, command_data);
|
||
|
||
// 检查响应类型是否正确
|
||
if (data_lenth <= 0 || data_type != 0x58) {
|
||
return false;
|
||
}
|
||
IS3::a1 = aa1;
|
||
IS3::a2 = aa2;
|
||
IS3::a3 = aa3;
|
||
IS3::a4 = aa4;
|
||
|
||
return true;
|
||
}
|
||
|
||
// 从大端格式转换为 double（适配 ESP32 小端架构）
|
||
double big_endian_to_double(const uint8_t* in) {
|
||
uint8_t temp[8];
|
||
for (int i = 0; i < 8; ++i) {
|
||
temp[i] = in[7 - i]; // 字节反转
|
||
}
|
||
double result;
|
||
memcpy(&result, temp, sizeof(double));
|
||
return result;
|
||
}
|
||
|
||
bool IS3::get_bochangxishu(double *aa1, double *aa2, double *aa3, double *aa4)
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t data = 0;
|
||
IS3::write(0x59, &data, 1);
|
||
|
||
uint8_t data_type;
|
||
uint8_t command_data[32];
|
||
|
||
int data_lenth = IS3::read(&data_type, command_data);
|
||
|
||
if(data_lenth <= 0 || data_type != 0x59) {
|
||
return false;
|
||
}
|
||
|
||
// 解码 4 个 double（每个 8 字节，大端）
|
||
*aa1 = big_endian_to_double(&command_data[0]);
|
||
*aa2 = big_endian_to_double(&command_data[8]);
|
||
*aa3 = big_endian_to_double(&command_data[16]);
|
||
*aa4 = big_endian_to_double(&command_data[24]);
|
||
|
||
// 可选：存到 IS3 的静态成员变量中（如果需要）
|
||
IS3::a1 = *aa1;
|
||
IS3::a2 = *aa2;
|
||
IS3::a3 = *aa3;
|
||
IS3::a4 = *aa4;
|
||
|
||
return true;
|
||
}
|
||
|
||
bool IS3::set_data_processing(enum IS3_data_processing IS3_data_processing,uint32_t average_num)
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t data_buff[5];
|
||
switch (IS3_data_processing)
|
||
{
|
||
case none:
|
||
data_buff[0] = 0;
|
||
break;
|
||
case average:
|
||
data_buff[0] = 1;
|
||
break;
|
||
case sgi:
|
||
data_buff[0] = 2;
|
||
break;
|
||
case average_sgi:
|
||
data_buff[0] = 3;
|
||
break;
|
||
case move_average:
|
||
data_buff[0] = 4;
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
// memcpy(data_buff+1,(uint8_t *)&average_num, 5);
|
||
|
||
data_buff[1] |= average_num >> 24;
|
||
data_buff[2] |= average_num >> 16;
|
||
data_buff[3] |= average_num >> 8;
|
||
data_buff[4] |= average_num;
|
||
|
||
IS3::write(0x60,data_buff, 5);
|
||
|
||
uint8_t data_type;
|
||
uint8_t command_data[32];
|
||
|
||
int data_lenth = IS3::read(&data_type,command_data);
|
||
if(data_lenth <= 0 || data_type != 0x60)
|
||
{
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
|
||
bool IS3::get_data(uint8_t *data)
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t b = 0 ;
|
||
IS3::write(0x61,&b, 1);
|
||
uint8_t data_type;
|
||
int data_lenth = IS3::read(&data_type,data);
|
||
|
||
if(data_lenth <= 0 || data_type != 0x61)
|
||
{
|
||
memset(data,0,515*2);
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
// bool IS3::get_data(uint8_t *data)
|
||
// {
|
||
// uint8_t b = 0 ;
|
||
// unsigned char command_data[1024 * 2];
|
||
// uint16_t data_length = 0;
|
||
// int a = is3.integration_time * 3;
|
||
// uint8_t data_type;
|
||
// IS3::write(0x61,&b, 1);
|
||
// while(a--)
|
||
// {
|
||
// while(Serial1.available())
|
||
// {
|
||
// data_length += Serial1.readBytes(&command_data[data_length],1024*2);
|
||
// a = 10;
|
||
// }
|
||
// if(data_length == 1037) break;
|
||
// // if(a <= 10 ) a--;
|
||
// vTaskDelay(1);
|
||
// }
|
||
|
||
// data_length = IRIS_Cut_Befor_Header(command_data, data_length);
|
||
// int ret = IRIS_STM32_Protocol_Unpack(command_data,data_length,&data_type,data);
|
||
|
||
// if (ret < 0)
|
||
// {
|
||
// return false;
|
||
// }
|
||
|
||
// if(data_type != 0x61)
|
||
// {
|
||
// return false;
|
||
// }
|
||
|
||
// return true;
|
||
// }
|
||
|
||
|
||
|
||
bool IS3::get_data_processing(uint8_t *is3_processing)
|
||
{
|
||
if(IS3::read_sta == 1) return false;
|
||
uint8_t b = 0 ;
|
||
IS3::write(0x62,&b, 1);
|
||
uint8_t data_type;
|
||
uint8_t command_data[32];
|
||
|
||
int data_lenth = IS3::read(&data_type,command_data);
|
||
if(data_lenth <= 0 || data_type != 0x62)
|
||
{
|
||
return false;
|
||
}
|
||
*is3_processing = command_data[0];
|
||
IS3::is3_processing = *is3_processing;
|
||
return true;
|
||
}
|