jzh/lark1s_demo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: jzh:4982262f6da2cbabbe28e95de71ad6f1ce88bd94
Branches Tags
jzh:master
...
compare: jzh:f4679c931232dd0b3237e579281a15e208ee755f
Branches Tags
jzh:master

10 Commits
4982262f6d ... f4679c9312

Author SHA1 Message Date
zhji
f4679c9312 [fix] use 0xFFFC as span active cmd 2024-08-19 11:40:31 +08:00
zhji
e028381241 [update] match new image 2024-08-11 20:29:57 +08:00
zhji
9333988e74 [feat] first complete 2024-07-14 21:27:23 +08:00
zhji
9261aaa842 [feat] add addr and baudrate setting 2024-07-14 18:44:05 +08:00
zhji
e743e09fbe [feat] add dwin display 2024-07-13 22:59:41 +08:00
zhji
817b91d2cd [feat] add cali data 2024-07-13 22:57:08 +08:00
zhji
b5c3737eeb [feat] add basic usart for dwin 2024-07-07 21:37:22 +08:00
zhji
283685ff35 [feat] add rs485(UART3) baseic driver 2024-06-23 21:50:41 +08:00
zhji
787f8d20ad [feat] first add demo of windows 2024-06-02 20:51:44 +08:00
zhji
42b77a3290 [feat] add cali function, first complete of linux enviroment 2024-06-02 17:11:47 +08:00
11 changed files with 1644 additions and 29 deletions
Show Stats Expand all files Collapse all files

234
lark1s/lark1s.c
View File

@ -12,13 +12,9 @@
#define LARK1S_SIZE_DATA (52)
/* writable register */
#define LARK1S_REG_GAS3_CALI_ZERO_RECORD (0x1012)
#define LARK1S_SIZE_GAS3_CALI_ZERO_RECORD (1)
#define LARK1S_REG_GAS3_CALI_SPAN_RECORD (0x1028)
#define LARK1S_SIZE_GAS3_CALI_SPAN_RECORD (1)
#define LARK1S_REG_GAS3_CALI_ACTIVE (0x103E)
#define LARK1S_SIZE_GAS3_CALI_ACTIVE (1)
#define LARK1S_REG_GAS3_CALI_RESTORE (0x1042)
#define LARK1S_SIZE_GAS3_CALI_RESTORE (1)
/* status register */
#define LARK1S_REG_STATUS (0x0600)
#define LARK1S_SIZE_STATUS (11)
@ -108,9 +104,6 @@ static int lark1s_frame_check(uint8_t *p, uint16_t len)
{
struct crc16_result_s crc;
if (len < 5) {
return LARK1S_PARSE_FRAME_ERROR;
}
if (p[0] != mb_addr) {
return LARK1S_PARSE_MB_ADDR_NOT_MATCH;
}
@ -154,6 +147,9 @@ int lark1s_parse_sn(uint8_t *buffer, int length, char *sn)
int ret;
int i = 0;
if (length != LARK1S_SIZE_SN * 2 + 5) {
return LARK1S_PARSE_FRAME_ERROR;
}
ret = lark1s_frame_check(buffer, length);
if (ret) {
return ret;
@ -195,6 +191,9 @@ int lark1s_parse_gas3_info(uint8_t *buffer, int length, struct lark1s_gas_info_s
int ret;
int i = 0;
if (length != LARK1S_SIZE_GAS3_INFO * 2 + 5) {
return LARK1S_PARSE_FRAME_ERROR;
}
ret = lark1s_frame_check(buffer, length);
if (ret) {
return ret;
@ -215,7 +214,58 @@ int lark1s_parse_gas3_info(uint8_t *buffer, int length, struct lark1s_gas_info_s
info->unit_name[j] = buffer[i + 20 + j];
}
info->range = MB_GET_UWORD(buffer + i + 32);
info->min_cali = MB_GET_UWORD(buffer + i + 56);
info->min_cali = MB_GET_UWORD(buffer + i + 76);
return LARK1S_PARSE_OK;
}
int lark1s_req_gas3_cali_data(uint8_t *buffer)
{
struct crc16_result_s crc;
int i = 0;
buffer[i++] = mb_addr;
buffer[i++] = MODBUS_FUNCTION_CODE_READ_INPUT;
buffer[i++] = (LARK1S_REG_GAS3_CALI_DATA >> 8) & 0xFF;
buffer[i++] = LARK1S_REG_GAS3_CALI_DATA & 0xFF;
buffer[i++] = (LARK1S_SIZE_GAS3_CALI_DATA >> 8) & 0xFF;
buffer[i++] = LARK1S_SIZE_GAS3_CALI_DATA & 0xFF;
crc16_8005_calc(buffer, i, &crc);
buffer[i++] = crc.crcl;
buffer[i++] = crc.crch;
return i;
}
int lark1s_parse_gas3_cali_data(uint8_t *buffer, int length, struct lark1s_gas_cali_data_s *data)
{
int ret;
int i = 0;
if (length != LARK1S_SIZE_GAS3_CALI_DATA * 2 + 5) {
return LARK1S_PARSE_FRAME_ERROR;
}
ret = lark1s_frame_check(buffer, length);
if (ret) {
return ret;
}
i++;
if (buffer[i++] != MODBUS_FUNCTION_CODE_READ_INPUT) {
return LARK1S_PARSE_FUNCTION_CODE_ERROR;
}
if (buffer[i++] != LARK1S_SIZE_GAS3_CALI_DATA * 2) {
return LARK1S_PARSE_DATA_LENGTH_ERROR;
}
data->available = MB_GET_UWORD(buffer + i);
data->zero_sig_cts = MB_GET_UWORD(buffer + i + 4);
data->zero_ref_cts = MB_GET_UWORD(buffer + i + 8);
data->zero_det_temp = MB_GET_UWORD(buffer + i + 12);
data->zero_lamp_temp = MB_GET_UWORD(buffer + i + 16);
data->span_concentration = MB_GET_UWORD(buffer + i + 28);
data->span_sig_cts = MB_GET_UWORD(buffer + i + 32);
data->span_ref_cts = MB_GET_UWORD(buffer + i + 36);
data->span_det_temp = MB_GET_UWORD(buffer + i + 40);
data->span_lamp_temp = MB_GET_UWORD(buffer + i + 44);
return LARK1S_PARSE_OK;
}
@ -243,6 +293,9 @@ int lark1s_parse_data(uint8_t *buffer, int length, struct lark1s_data_s *data)
int ret;
int i = 0;
if (length != LARK1S_SIZE_DATA * 2 + 5) {
return LARK1S_PARSE_FRAME_ERROR;
}
ret = lark1s_frame_check(buffer, length);
if (ret) {
return ret;
@ -264,67 +317,222 @@ int lark1s_parse_data(uint8_t *buffer, int length, struct lark1s_data_s *data)
return LARK1S_PARSE_OK;
}
int lark1s_req_gas3_cali_zero_record(uint8_t *buffer);
int lark1s_req_gas3_cali_zero_record(uint8_t *buffer, uint16_t type)
{
struct crc16_result_s crc;
int i = 0;
buffer[i++] = mb_addr;
buffer[i++] = MODBUS_FUNCTION_CODE_WRITE_SINGLE;
buffer[i++] = (LARK1S_REG_GAS3_CALI_ZERO_RECORD >> 8) & 0xFF;
buffer[i++] = LARK1S_REG_GAS3_CALI_ZERO_RECORD & 0xFF;
buffer[i++] = (type >> 8) & 0xFF;
buffer[i++] = type & 0xFF;
crc16_8005_calc(buffer, i, &crc);
buffer[i++] = crc.crcl;
buffer[i++] = crc.crch;
return i;
}
int lark1s_parse_gas3_cali_zero_record(uint8_t *buffer, int length)
{
int ret;
int i = 0;
if (length != 8) {
return LARK1S_PARSE_FRAME_ERROR;
}
ret = lark1s_frame_check(buffer, length);
if (ret) {
return ret;
}
i++;
if (buffer[i++] != MODBUS_FUNCTION_CODE_WRITE_SINGLE) {
return LARK1S_PARSE_FUNCTION_CODE_ERROR;
}
if(LARK1S_REG_GAS3_CALI_ZERO_RECORD != MB_GET_HWORD(buffer + i)) {
return LARK1S_PARSE_CALI_REG_ERROR;
}
return LARK1S_PARSE_OK;
}
int lark1s_req_gas3_cali_span_record(uint8_t *buffer, uint32_t concentration);
int lark1s_req_gas3_cali_span_record(uint8_t *buffer, uint32_t concentration)
{
struct crc16_result_s crc;
int i = 0;
buffer[i++] = mb_addr;
buffer[i++] = MODBUS_FUNCTION_CODE_WRITE_MULTI;
buffer[i++] = (LARK1S_REG_GAS3_CALI_SPAN_RECORD >> 8) & 0xFF;
buffer[i++] = LARK1S_REG_GAS3_CALI_SPAN_RECORD & 0xFF;
buffer[i++] = 0;
buffer[i++] = 2; /* register number */
buffer[i++] = 4; /* data byte number */
buffer[i++] = (concentration >> 24) & 0xFF;
buffer[i++] = (concentration >> 16) & 0xFF;
buffer[i++] = (concentration >> 8) & 0xFF;
buffer[i++] = concentration & 0xFF;
crc16_8005_calc(buffer, i, &crc);
buffer[i++] = crc.crcl;
buffer[i++] = crc.crch;
return i;
}
int lark1s_parse_gas3_cali_span_record(uint8_t *buffer, int length)
{
int ret;
int i = 0;
if (length != 8) {
return LARK1S_PARSE_FRAME_ERROR;
}
ret = lark1s_frame_check(buffer, length);
if (ret) {
return ret;
}
i++;
if (buffer[i++] != MODBUS_FUNCTION_CODE_WRITE_MULTI) {
return LARK1S_PARSE_FUNCTION_CODE_ERROR;
}
if(LARK1S_REG_GAS3_CALI_SPAN_RECORD != MB_GET_HWORD(buffer + i)) {
return LARK1S_PARSE_CALI_REG_ERROR;
}
if(2 != MB_GET_HWORD(buffer + i + 2)) {
return LARK1S_PARSE_DATA_LENGTH_ERROR;
}
return LARK1S_PARSE_OK;
}
int lark1s_req_gas3_cali_active(uint8_t *buffer);
int lark1s_req_gas3_cali_active(uint8_t *buffer, uint16_t type)
{
struct crc16_result_s crc;
int i = 0;
buffer[i++] = mb_addr;
buffer[i++] = MODBUS_FUNCTION_CODE_WRITE_SINGLE;
buffer[i++] = (LARK1S_REG_GAS3_CALI_ACTIVE >> 8) & 0xFF;
buffer[i++] = LARK1S_REG_GAS3_CALI_ACTIVE & 0xFF;
buffer[i++] = (type >> 8) & 0xFF;
buffer[i++] = type & 0xFF;
crc16_8005_calc(buffer, i, &crc);
buffer[i++] = crc.crcl;
buffer[i++] = crc.crch;
return i;
}
int lark1s_parse_gas3_cali_active(uint8_t *buffer, int length)
{
int ret;
int i = 0;
if (length != 8) {
return LARK1S_PARSE_FRAME_ERROR;
}
ret = lark1s_frame_check(buffer, length);
if (ret) {
return ret;
}
i++;
if (buffer[i++] != MODBUS_FUNCTION_CODE_WRITE_SINGLE) {
return LARK1S_PARSE_FUNCTION_CODE_ERROR;
}
if(LARK1S_REG_GAS3_CALI_ACTIVE != MB_GET_HWORD(buffer + i)) {
return LARK1S_PARSE_CALI_REG_ERROR;
}
return LARK1S_PARSE_OK;
}
int lark1s_req_gas3_cali_restore(uint8_t *buffer);
int lark1s_req_gas3_cali_restore(uint8_t *buffer)
{
struct crc16_result_s crc;
int i = 0;
buffer[i++] = mb_addr;
buffer[i++] = MODBUS_FUNCTION_CODE_WRITE_SINGLE;
buffer[i++] = (LARK1S_REG_GAS3_CALI_RESTORE >> 8) & 0xFF;
buffer[i++] = LARK1S_REG_GAS3_CALI_RESTORE & 0xFF;
buffer[i++] = 0x00;
buffer[i++] = 0xFF;
crc16_8005_calc(buffer, i, &crc);
buffer[i++] = crc.crcl;
buffer[i++] = crc.crch;
return i;
}
int lark1s_parse_gas3_cali_restore(uint8_t *buffer, int length)
{
int ret;
int i = 0;
if (length != 8) {
return LARK1S_PARSE_FRAME_ERROR;
}
ret = lark1s_frame_check(buffer, length);
if (ret) {
return ret;
}
i++;
if (buffer[i++] != MODBUS_FUNCTION_CODE_WRITE_SINGLE) {
return LARK1S_PARSE_FUNCTION_CODE_ERROR;
}
if(LARK1S_REG_GAS3_CALI_RESTORE != MB_GET_HWORD(buffer + i)) {
return LARK1S_PARSE_CALI_REG_ERROR;
}
return LARK1S_PARSE_OK;
}
int lark1s_req_status(uint8_t *buffer);
int lark1s_req_status(uint8_t *buffer)
{
struct crc16_result_s crc;
int i = 0;
buffer[i++] = mb_addr;
buffer[i++] = MODBUS_FUNCTION_CODE_READ_INPUT;
buffer[i++] = (LARK1S_REG_STATUS >> 8) & 0xFF;
buffer[i++] = LARK1S_REG_STATUS & 0xFF;
buffer[i++] = (LARK1S_SIZE_STATUS >> 8) & 0xFF;
buffer[i++] = LARK1S_SIZE_STATUS & 0xFF;
crc16_8005_calc(buffer, i, &crc);
buffer[i++] = crc.crcl;
buffer[i++] = crc.crch;
return i;
}
int lark1s_parse_status(uint8_t *buffer, int length, struct lark1s_status_s *status)
{
int ret;
int i = 0;
ret = lark1s_frame_check(buffer, length);
if (ret) {
return ret;
}
i++;
if (buffer[i++] != MODBUS_FUNCTION_CODE_READ_INPUT) {
return LARK1S_PARSE_FUNCTION_CODE_ERROR;
}
if (buffer[i++] != LARK1S_SIZE_STATUS * 2) {
return LARK1S_PARSE_DATA_LENGTH_ERROR;
}
status->zero_record[0] = MB_GET_HWORD(buffer + i + 0);
status->zero_record[1] = MB_GET_HWORD(buffer + i + 2);
status->zero_record[2] = MB_GET_HWORD(buffer + i + 4);
status->zero_record[3] = MB_GET_HWORD(buffer + i + 6);
status->span_record[0] = MB_GET_HWORD(buffer + i + 8);
status->span_record[1] = MB_GET_HWORD(buffer + i + 10);
status->span_record[2] = MB_GET_HWORD(buffer + i + 12);
status->span_record[3] = MB_GET_HWORD(buffer + i + 14);
status->active = MB_GET_HWORD(buffer + i + 16);
status->restore = MB_GET_HWORD(buffer + i + 18);
return LARK1S_PARSE_OK;
}

10
lark1s/lark1s.h
View File

@ -9,6 +9,10 @@
#define LARK1S_PARSE_FRAME_ERROR (3)
#define LARK1S_PARSE_CRC_ERROR (4)
#define LARK1S_PARSE_DATA_LENGTH_ERROR (5)
#define LARK1S_PARSE_CALI_REG_ERROR (6)
#define LARK1S_CALI_ZERO (0xFFFE)
#define LARK1S_CALI_SPAN (0xFFFC)
struct lark1s_gas_info_s {
uint32_t gas_id;
@ -58,13 +62,15 @@ int lark1s_req_sn(uint8_t *buffer);
int lark1s_parse_sn(uint8_t *buffer, int length, char *sn);
int lark1s_req_gas3_info(uint8_t *buffer);
int lark1s_parse_gas3_info(uint8_t *buffer, int length, struct lark1s_gas_info_s *info);
int lark1s_req_gas3_cali_data(uint8_t *buffer);
int lark1s_parse_gas3_cali_data(uint8_t *buffer, int length, struct lark1s_gas_cali_data_s *cali);
int lark1s_req_data(uint8_t *buffer);
int lark1s_parse_data(uint8_t *buffer, int length, struct lark1s_data_s *data);
int lark1s_req_gas3_cali_zero_record(uint8_t *buffer);
int lark1s_req_gas3_cali_zero_record(uint8_t *buffer, uint16_t type);
int lark1s_parse_gas3_cali_zero_record(uint8_t *buffer, int length);
int lark1s_req_gas3_cali_span_record(uint8_t *buffer, uint32_t concentration);
int lark1s_parse_gas3_cali_span_record(uint8_t *buffer, int length);
int lark1s_req_gas3_cali_active(uint8_t *buffer);
int lark1s_req_gas3_cali_active(uint8_t *buffer, uint16_t type);
int lark1s_parse_gas3_cali_active(uint8_t *buffer, int length);
int lark1s_req_gas3_cali_restore(uint8_t *buffer);
int lark1s_parse_gas3_cali_restore(uint8_t *buffer, int length);

288
linux/main.c
View File

@ -7,9 +7,9 @@
#include <string.h>
#include "../lark1s/lark1s.h"
#define MB_ADDRESS 9
#define MB_RESP_TIME 1
#define BUFFER_SIZE 1024
#define MB_ADDRESS (7)
#define MB_RESP_TIME (1)
#define BUFFER_SIZE (1024)
uint8_t buffer_w[BUFFER_SIZE];
uint8_t buffer_r[BUFFER_SIZE];
@ -23,15 +23,20 @@ void print_sn(int fd, uint8_t *out, uint8_t *in)
write(fd, out, ret);
} else {
printf("Error: lark1s_req_sn failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_sn(in, ret, sn);
if (ret) {
printf("Error: lark1s_parse_sn failed, %d\r\n", ret);
return;
} else {
printf("SN: ");
for (int j = 0; j < 16; j++) {
if (sn[j] <= ' ') {
continue;
}
printf("%c", sn[j]);
}
printf("\r\n");
@ -48,22 +53,30 @@ void print_gas3_info(int fd, uint8_t *out, uint8_t *in)
write(fd, out, ret);
} else {
printf("Error: lark1s_req_gas3_info failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_gas3_info(in, ret, &info);
if (ret) {
printf("Error: lark1s_parse_gas_info failed, %d\r\n", ret);
return;
} else {
printf("gas3_info.gas_id: %d\r\n", info.gas_id);
printf("gas3_info.gas_name: ");
for (int j = 0; j < 12; j++) {
if (info.gas_name[j] <= ' ') {
continue;
}
printf("%c", info.gas_name[j]);
}
printf("\r\n");
printf("gas3_info.unit_id: %d\r\n", info.unit_id);
printf("gas3_info.unit_name: ");
for (int j = 0; j < 8; j++) {
if (info.unit_name[j] <= ' ') {
continue;
}
printf("%c", info.unit_name[j]);
}
printf("\r\n");
@ -82,12 +95,14 @@ void print_data(int fd, uint8_t *out, uint8_t *in)
write(fd, out, ret);
} else {
printf("Error: lark1s_req_data failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_data(in, ret, &data);
if (ret) {
printf("Error: lark1s_parse_data failed, %d\r\n", ret);
return;
} else {
printf("data.det_temp: %d\r\n", data.det_temp);
printf("data.air_pressure: %d\r\n", data.air_pressure);
@ -98,8 +113,253 @@ void print_data(int fd, uint8_t *out, uint8_t *in)
}
}
void print_status(int fd, uint8_t *out, uint8_t *in)
{
struct lark1s_status_s status;
int ret;
ret = lark1s_req_status(out);
if (ret) {
write(fd, out, ret);
} else {
printf("Error: lark1s_req_status failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_status(in, ret, &status);
if (ret) {
printf("Error: lark1s_parse_status failed, %d\r\n", ret);
return;
} else {
printf("status.zero_record: %d\r\n", status.zero_record[2]);
printf("status.span_record: %d\r\n", status.span_record[2]);
printf("status.active: %d\r\n", status.active);
printf("status.restore: %d\r\n", status.restore);
}
}
void cali_zero(int fd, uint8_t *out, uint8_t *in)
{
struct lark1s_status_s status;
int ret;
/* zero record */
ret = lark1s_req_gas3_cali_zero_record(out, LARK1S_CALI_ZERO);
if (ret) {
write(fd, out, ret);
} else {
printf("Error: lark1s_req_gas3_cali_zero_record failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_gas3_cali_zero_record(in, ret);
if (ret) {
printf("Error: lark1s_parse_gas3_cali_zero_record failed, %d\r\n", ret);
return;
}
/* get zero record status */
ret = lark1s_req_status(out);
if (ret) {
write(fd, out, ret);
} else {
printf("Error: lark1s_req_status failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_status(in, ret, &status);
if (ret) {
printf("Error: lark1s_parse_status failed, %d\r\n", ret);
return;
} else {
if (0 == status.zero_record[2]) {
printf("cali zero record success\r\n");
} else {
printf("cali zero record failed, ret = %d\r\n", status.zero_record[2]);
return;
}
}
/* zero active */
ret = lark1s_req_gas3_cali_active(out, LARK1S_CALI_ZERO);
if (ret) {
write(fd, out, ret);
} else {
printf("Error: lark1s_req_gas3_cali_zero_active failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_gas3_cali_active(in, ret);
if (ret) {
printf("Error: lark1s_parse_gas3_cali_zero_active failed, %d\r\n", ret);
return;
}
/* get zero active status */
ret = lark1s_req_status(out);
if (ret) {
write(fd, out, ret);
} else {
printf("Error: lark1s_req_status failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_status(in, ret, &status);
if (ret) {
printf("Error: lark1s_parse_status failed, %d\r\n", ret);
return;
} else {
if (0 == status.active) {
printf("cali zero active success\r\n");
} else {
printf("cali zero active failed, ret = %d\r\n", status.active);
return;
}
}
}
void cali_span(int fd, uint8_t *out, uint8_t *in, int concentration)
{
struct lark1s_status_s status;
int ret;
/* span record */
ret = lark1s_req_gas3_cali_span_record(out, concentration);
if (ret) {
write(fd, out, ret);
} else {
printf("Error: lark1s_req_gas3_cali_span_record failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_gas3_cali_span_record(in, ret);
if (ret) {
printf("Error: lark1s_parse_gas3_cali_span_record failed, %d\r\n", ret);
return;
}
/* get span record status */
ret = lark1s_req_status(out);
if (ret) {
write(fd, out, ret);
} else {
printf("Error: lark1s_req_status failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_status(in, ret, &status);
if (ret) {
printf("Error: lark1s_parse_status failed, %d\r\n", ret);
return;
} else {
if (0 == status.span_record[2]) {
printf("cali span record success\r\n");
} else {
printf("cali span record failed, ret = %d\r\n", status.span_record[2]);
return;
}
}
/* span active */
ret = lark1s_req_gas3_cali_active(out, LARK1S_CALI_SPAN);
if (ret) {
write(fd, out, ret);
} else {
printf("Error: lark1s_req_gas3_cali_span_active failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_gas3_cali_active(in, ret);
if (ret) {
printf("Error: lark1s_parse_gas3_cali_span_active failed, %d\r\n", ret);
return;
}
/* get span active status */
ret = lark1s_req_status(out);
if (ret) {
write(fd, out, ret);
} else {
printf("Error: lark1s_req_status failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_status(in, ret, &status);
if (ret) {
printf("Error: lark1s_parse_status failed, %d\r\n", ret);
return;
} else {
if (0 == status.active) {
printf("cali span active success\r\n");
} else {
printf("cali span active failed, ret = %d\r\n", status.active);
return;
}
}
}
void cali_restore(int fd, uint8_t *out, uint8_t *in)
{
struct lark1s_status_s status;
int ret;
ret = lark1s_req_gas3_cali_restore(out);
if (ret) {
write(fd, out, ret);
} else {
printf("Error: lark1s_req_gas3_cali_restore failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_gas3_cali_restore(in, ret);
if (ret) {
printf("Error: lark1s_parse_gas3_cali_restore failed, %d\r\n", ret);
return;
}
/* get restore status */
ret = lark1s_req_status(out);
if (ret) {
write(fd, out, ret);
} else {
printf("Error: lark1s_req_status failed\r\n");
return;
}
sleep(MB_RESP_TIME);
ret = read(fd, in, BUFFER_SIZE);
ret = lark1s_parse_status(in, ret, &status);
if (ret) {
printf("Error: lark1s_parse_status failed, %d\r\n", ret);
return;
} else {
if (0 == status.active) {
printf("cali restore success\r\n");
} else {
printf("cali restore failed, ret = %d\r\n", status.active);
return;
}
}
}
void print_help(void)
{
printf("Usage:\r\n");
printf("1: print sn\r\n");
printf("2: print gas3 info\r\n");
printf("3: print data\r\n");
printf("4: print status\r\n");
printf("5: cali restore\r\n");
printf("0: cali zero\r\n");
printf("other number: cali span\r\n");
printf("\r\n");
}
int main(void) {
int fd;
int sel;
struct termios options;
fd = open("/dev/ttyS3", O_RDWR | O_NOCTTY | O_NDELAY);
@ -118,12 +378,28 @@ int main(void) {
tcsetattr(fd, TCSANOW, &options);
lark1s_set_mb_address(MB_ADDRESS);
print_help();
while (1) {
print_sn(fd, buffer_w, buffer_r);
print_gas3_info(fd, buffer_w, buffer_r);
print_data(fd, buffer_w, buffer_r);
scanf("%d", &sel);
if (sel == 1) {
print_sn(fd, buffer_w, buffer_r);
} else if (sel == 2) {
print_gas3_info(fd, buffer_w, buffer_r);
} else if (sel == 3) {
print_data(fd, buffer_w, buffer_r);
} else if (sel == 4) {
print_status(fd, buffer_w, buffer_r);
} else if (sel == 5) {
cali_restore(fd, buffer_w, buffer_r);
} else if (sel == 0) {
cali_zero(fd, buffer_w, buffer_r);
} else if (sel > 0) {
cali_span(fd, buffer_w, buffer_r, sel);
} else {
}
printf("\r\n");
print_help();
fflush(stdout);
}

4
stm32f4/CMakeLists.txt
View File

@ -24,7 +24,9 @@ add_definitions(-DUSE_STDPERIPH_DRIVER)
enable_language(ASM)
add_executable(${PROJ_NAME}.elf main.c)
target_sources(${PROJ_NAME}.elf PUBLIC start.S)
target_sources(${PROJ_NAME}.elf PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/start.S)
target_sources(${PROJ_NAME}.elf PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../lark1s/lark1s.c)
target_include_directories(${PROJ_NAME}.elf PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../lark1s)
add_subdirectory(./driver driver)
target_link_libraries(${PROJ_NAME}.elf driver)

12
stm32f4/main.c
View File

@ -1,6 +1,8 @@
#include "stm32f4xx_rcc.h"
#include "led.h"
#include "lcd.h"
// #include "lcd.h"
#include "rs485.h"
#include "dwin.h"
volatile uint32_t system_tick_cnt;
@ -28,7 +30,9 @@ void system_init(void)
{
led_init();
system_tick_init();
lcd_init();
// lcd_init();
rs485_init();
dwin_init();
}
int main(void)
@ -39,7 +43,9 @@ int main(void)
__enable_irq();
while (1) {
led_loop();
lcd_loop();
// lcd_loop();
rs485_loop();
dwin_loop();
}
return 0;
}

11
stm32f4/src/CMakeLists.txt
View File

@ -1,11 +1,14 @@
file(GLOB FILELIST
led.c
lcd.c
# lcd.c
rs485.c
dwin.c
)
add_library(src STATIC ${FILELIST})
target_include_directories(src PUBLIC ../driver/cmsis)
target_include_directories(src PUBLIC ../driver/inc)
target_include_directories(src PUBLIC .)
target_include_directories(src PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../driver/cmsis)
target_include_directories(src PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../driver/inc)
target_include_directories(src PUBLIC ${CMAKE_CURRENT_SOURCE_DIR})
target_include_directories(src PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/../../lark1s)
target_link_libraries(src driver)

359
stm32f4/src/dwin.c Normal file
View File

@ -0,0 +1,359 @@
#include "stm32f4xx_rcc.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_usart.h"
#include "stm32f4xx_dma.h"
#include "lark1s.h"
#include "dwin.h"
#include "rs485.h"
#define DWIN_TX_STREAM DMA1_Stream6
#define DWIN_RX_STREAM DMA1_Stream5
#define DWIN_BUFF_TX_LEN (4096)
#define DWIN_BUFF_RX_LEN (4096)
uint8_t dwin_buff_tx[DWIN_BUFF_TX_LEN] __attribute__((aligned(16)));
uint8_t dwin_buff_rx[DWIN_BUFF_RX_LEN] __attribute__((aligned(16)));
static int __attribute__((section(".bss_ccm"))) sm = 0;
extern uint32_t system_tick_cnt;
extern uint8_t cali_succeed;
void dwin_init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
GPIO_PinAFConfig(DWIN_PORT, GPIO_PinSource2, GPIO_AF_USART2);
GPIO_PinAFConfig(DWIN_PORT, GPIO_PinSource3, GPIO_AF_USART2);
GPIO_InitStructure.GPIO_Pin = DWIN_PIN_TX | DWIN_PIN_RX;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(DWIN_PORT, &GPIO_InitStructure);
USART_DeInit(USART2);
USART_OverSampling8Cmd(USART2, ENABLE);
USART_InitStructure.USART_BaudRate = DWIN_BAUDRATE;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(USART2, &USART_InitStructure);
USART_DMACmd(USART2, USART_DMAReq_Tx, ENABLE);
USART_DMACmd(USART2, USART_DMAReq_Rx, ENABLE);
USART_Cmd(USART2, ENABLE);
DMA_InitStructure.DMA_BufferSize = DWIN_BUFF_TX_LEN;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_PeripheralBaseAddr =(uint32_t)(&(USART2->DR));
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_InitStructure.DMA_Channel = DMA_Channel_4;
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)dwin_buff_tx;
DMA_Init(DWIN_TX_STREAM, &DMA_InitStructure);
/* Configure DMA controller to manage USART RX request */
DMA_InitStructure.DMA_BufferSize = DWIN_BUFF_RX_LEN;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)dwin_buff_rx;
DMA_Init(DWIN_RX_STREAM, &DMA_InitStructure);
/* Configure interrupt for USART2 RX */
NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 12;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
USART_ITConfig(USART2, USART_IT_IDLE, ENABLE);
USART_ITConfig(USART2, USART_IT_TC, ENABLE);
/* clear IT flag */
USART_GetITStatus(USART2, USART_IT_IDLE);
USART_ReceiveData(USART2);
USART_ClearITPendingBit(USART2, USART_IT_IDLE);
USART_ClearITPendingBit(USART2, USART_IT_TC);
dwin_send(5);
}
void dwin_send(uint16_t len)
{
DMA_SetCurrDataCounter(DWIN_TX_STREAM, len);
DMA_Cmd(DWIN_TX_STREAM, ENABLE);
}
static void dwin_endian_reverse_4byte(uint8_t *buffer, uint32_t val)
{
buffer[0] = (uint8_t)((val >> 24) & 0xFF);
buffer[1] = (uint8_t)((val >> 16) & 0xFF);
buffer[2] = (uint8_t)((val >> 8) & 0xFF);
buffer[3] = (uint8_t)(val & 0xFF);
}
static void dwin_endian_reverse_2byte(uint8_t *buffer, uint16_t val)
{
buffer[0] = (uint8_t)((val >> 8) & 0xFF);
buffer[1] = (uint8_t)(val & 0xFF);
}
static void dwin_endian_reverse_4byte_float(uint8_t *buffer, float val)
{
uint32_t u32;
u32 = *((uint32_t *)(&val));
buffer[0] = (uint8_t)((u32 >> 24) & 0xFF);
buffer[1] = (uint8_t)((u32 >> 16) & 0xFF);
buffer[2] = (uint8_t)((u32 >> 8) & 0xFF);
buffer[3] = (uint8_t)(u32 & 0xFF);
}
void dwin_rx_parse(uint8_t *buffer, uint16_t len)
{
uint32_t u32;
uint8_t *p = buffer;
if (p[0] != 0x5A || p[1] != 0xA5 || p[2] != (DWIN_DATA_CTRL_LENG * 2 + 4) || p[3] != 0x83 || p[4] != 0x51 || p[5] != 0x00 || p[6] != DWIN_DATA_CTRL_LENG) {
/* read data error or other commands */
if (cali_succeed) {
cali_succeed = 0;
sm = 7;
return;
}
sm++;
if (sm > 1) {
sm = 0;
}
return;
}
/* read data from dwin screen */
p += 7;
rs485_cfg_dwin.init = p[0 * 2 + 1];
rs485_cfg_dwin.address = p[1 * 2 + 1];
rs485_cfg_dwin.confirm = p[4 * 2 + 1];
rs485_cfg_dwin.cali_zero = p[5 * 2 + 1];
rs485_cfg_dwin.cali_span = p[6 * 2 + 1];
rs485_cfg_dwin.cali_restore = p[9 * 2 + 1];
u32 = (uint32_t)p[7];
u32 |= (uint32_t)p[6] << 8;
u32 |= (uint32_t)p[5] << 16;
u32 |= (uint32_t)p[4] << 24;
rs485_cfg_dwin.baudrate = u32;
u32 = (uint32_t)p[17];
u32 |= (uint32_t)p[16] << 8;
u32 |= (uint32_t)p[15] << 16;
u32 |= (uint32_t)p[14] << 24;
rs485_cfg_dwin.cali_span_concentration = u32;
if (rs485_cfg_dwin.cali_restore) {
rs485_cfg_dwin.cali_restore_bak = 1;
sm = 2;
return;
}
if (rs485_cfg_dwin.cali_span) {
rs485_cfg_dwin.cali_span_bak = 1;
sm = 3;
return;
}
if (rs485_cfg_dwin.cali_zero) {
rs485_cfg_dwin.cali_zero_bak = 1;
sm = 4;
return;
}
if (rs485_cfg_dwin.confirm) {
rs485_cfg_dwin.confirm_bak = 1;
sm = 5;
return;
}
if (rs485_cfg_dwin.cali_span_concentration == 0) {
rs485_cfg_dwin.cali_span_concentration = lark1s_gas_info.range / 2;
sm = 6;
return;
}
sm++;
if (sm > 1) {
sm = 0;
}
}
void dwin_loop(void)
{
static uint32_t ms = 0;
uint16_t len;
uint16_t i;
if (system_tick_cnt < (ms + 200)) {
return;
}
ms = system_tick_cnt;
len = 0;
if (sm == 0) {
/* read control data */
dwin_buff_tx[len++] = 0x5A;
dwin_buff_tx[len++] = 0xA5; /* frame head */
dwin_buff_tx[len++] = 0x04; /* length */
dwin_buff_tx[len++] = 0x83; /* read operation */
dwin_buff_tx[len++] = (DWIN_DATA_CTRL_ADDR >> 8) & 0xFF; /* address high byte */
dwin_buff_tx[len++] = DWIN_DATA_CTRL_ADDR & 0xFF; /* address low byte */
dwin_buff_tx[len++] = DWIN_DATA_CTRL_LENG; /* data length to be read */
} else if (sm == 1) {
/* write display data */
dwin_buff_tx[len++] = 0x5A;
dwin_buff_tx[len++] = 0xA5; /* frame head */
dwin_buff_tx[len++] = DWIN_DATA_DISP_LENG * 2 + 3; /* length */
dwin_buff_tx[len++] = 0x82; /* write operation */
dwin_buff_tx[len++] = (DWIN_DATA_DISP_ADDR >> 8) & 0xFF; /* address high byte */
dwin_buff_tx[len++] = DWIN_DATA_DISP_ADDR & 0xFF; /* address low byte */
/* gas name */
for (i = 0; i < 12; i++) { /* lark-1s gas name max 12 byte */
if (lark1s_gas_info.gas_name[i] > ' ') {
break;
}
}
for (uint16_t j = 0; j < 12 - i; j++) { /* lark-1s gas name max 12 byte */
dwin_buff_tx[len++] = lark1s_gas_info.gas_name[i + j];
}
for (uint16_t j = 0; j < 16 - (12 - i); j++) { /* dwin support max 16 byte */
dwin_buff_tx[len++] = ' ';
}
/* range */
dwin_endian_reverse_4byte(dwin_buff_tx + len, lark1s_gas_info.range);
len += 4;
/* detector temperature */
dwin_endian_reverse_4byte_float(dwin_buff_tx + len, ((float)(lark1s_data.det_temp - 27300)) / 100.0f);
len += 4;
/* concentration */
dwin_endian_reverse_4byte(dwin_buff_tx + len, lark1s_data.gas3_reading);
len += 4;
/* unit name */
for (i = 0; i < 8; i++) { /* lark-1s unit name max 8 byte */
if (lark1s_gas_info.unit_name[i] > ' ') {
break;
}
}
for (uint16_t j = 0; j < 8 - i; j++) { /* lark-1s unit name max 8 byte */
dwin_buff_tx[len++] = lark1s_gas_info.unit_name[i + j];
}
for (uint16_t j = 0; j < 16 - (8 - i); j++) { /* dwin support max 16 byte */
dwin_buff_tx[len++] = ' ';
}
/* sn */
for (uint16_t j = 0; j < 16; j++) {
dwin_buff_tx[len++] = sn[j];
}
/* sig CTS */
dwin_endian_reverse_4byte(dwin_buff_tx + len, lark1s_data.cts_gas3);
len += 4;
/* ref CTS */
dwin_endian_reverse_4byte(dwin_buff_tx + len, lark1s_data.cts_ref);
len += 4;
/* air pressure */
dwin_endian_reverse_4byte_float(dwin_buff_tx + len, ((float)(lark1s_data.air_pressure)) / 100.0f);
len += 4;
} else if (sm == 2) {
/* clear restore request data */
dwin_buff_tx[len++] = 0x5A;
dwin_buff_tx[len++] = 0xA5; /* frame head */
dwin_buff_tx[len++] = 0x05; /* length */
dwin_buff_tx[len++] = 0x82; /* write operation */
dwin_buff_tx[len++] = ((DWIN_DATA_CTRL_ADDR + 9) >> 8) & 0xFF; /* address high byte */
dwin_buff_tx[len++] = (DWIN_DATA_CTRL_ADDR + 9) & 0xFF; /* address low byte */
dwin_buff_tx[len++] = 0x00; /* data */
dwin_buff_tx[len++] = 0x00; /* data */
} else if (sm == 3) {
/* clear cali span request data */
dwin_buff_tx[len++] = 0x5A;
dwin_buff_tx[len++] = 0xA5; /* frame head */
dwin_buff_tx[len++] = 0x05; /* length */
dwin_buff_tx[len++] = 0x82; /* write operation */
dwin_buff_tx[len++] = ((DWIN_DATA_CTRL_ADDR + 6) >> 8) & 0xFF; /* address high byte */
dwin_buff_tx[len++] = (DWIN_DATA_CTRL_ADDR + 6) & 0xFF; /* address low byte */
dwin_buff_tx[len++] = 0x00; /* data */
dwin_buff_tx[len++] = 0x00; /* data */
} else if (sm == 4) {
/* clear cali zero request data */
dwin_buff_tx[len++] = 0x5A;
dwin_buff_tx[len++] = 0xA5; /* frame head */
dwin_buff_tx[len++] = 0x05; /* length */
dwin_buff_tx[len++] = 0x82; /* write operation */
dwin_buff_tx[len++] = ((DWIN_DATA_CTRL_ADDR + 5) >> 8) & 0xFF; /* address high byte */
dwin_buff_tx[len++] = (DWIN_DATA_CTRL_ADDR + 5) & 0xFF; /* address low byte */
dwin_buff_tx[len++] = 0x00; /* data */
dwin_buff_tx[len++] = 0x00; /* data */
} else if (sm == 5) {
/* clear confirm request data */
dwin_buff_tx[len++] = 0x5A;
dwin_buff_tx[len++] = 0xA5; /* frame head */
dwin_buff_tx[len++] = 0x05; /* length */
dwin_buff_tx[len++] = 0x82; /* write operation */
dwin_buff_tx[len++] = ((DWIN_DATA_CTRL_ADDR + 4) >> 8) & 0xFF; /* address high byte */
dwin_buff_tx[len++] = (DWIN_DATA_CTRL_ADDR + 4) & 0xFF; /* address low byte */
dwin_buff_tx[len++] = 0x00; /* data */
dwin_buff_tx[len++] = 0x00; /* data */
} else if (sm == 6) {
/* set default span concentration */
uint32_t range = lark1s_gas_info.range / 2;
dwin_buff_tx[len++] = 0x5A;
dwin_buff_tx[len++] = 0xA5; /* frame head */
dwin_buff_tx[len++] = 0x07; /* length */
dwin_buff_tx[len++] = 0x82; /* write operation */
dwin_buff_tx[len++] = ((DWIN_DATA_CTRL_ADDR + 7) >> 8) & 0xFF; /* address high byte */
dwin_buff_tx[len++] = (DWIN_DATA_CTRL_ADDR + 7) & 0xFF; /* address low byte */
dwin_buff_tx[len++] = (uint8_t)((range >> 24) & 0xFF); /* data */
dwin_buff_tx[len++] = (uint8_t)((range >> 16) & 0xFF); /* data */
dwin_buff_tx[len++] = (uint8_t)((range >> 8) & 0xFF); /* data */
dwin_buff_tx[len++] = (uint8_t)((range >> 0) & 0xFF); /* data */
} else if (sm == 7) {
/* pop one window for cali succeed */
dwin_buff_tx[len++] = 0x5A;
dwin_buff_tx[len++] = 0xA5; /* frame head */
dwin_buff_tx[len++] = 0x07; /* length */
dwin_buff_tx[len++] = 0x82; /* write operation */
dwin_buff_tx[len++] = 0x00;
dwin_buff_tx[len++] = 0x84; /* cmd: picture set */
dwin_buff_tx[len++] = 0x5A; /* must */
dwin_buff_tx[len++] = 0x01; /* must */
dwin_buff_tx[len++] = 0x00;
dwin_buff_tx[len++] = 0x02; /* picture id */
}
dwin_send(len);
}
void USART2_IRQHandler(void)
{
uint16_t len;
if (USART_GetITStatus(USART2, USART_IT_TC) != RESET)
{
USART_ClearITPendingBit(USART2, USART_IT_TC);
DMA_ClearFlag(DWIN_TX_STREAM, DMA_FLAG_TCIF6 | DMA_FLAG_HTIF6 | DMA_FLAG_TEIF6 | DMA_FLAG_DMEIF6 | DMA_FLAG_FEIF6);
DMA_Cmd(DWIN_TX_STREAM, DISABLE);
/* after tx complete, config rx */
USART_ReceiveData(USART2);
USART_ClearITPendingBit(USART2, USART_IT_IDLE);
DMA_SetCurrDataCounter(DWIN_RX_STREAM, DWIN_BUFF_RX_LEN);
DMA_Cmd(DWIN_RX_STREAM, ENABLE);
USART_ITConfig(USART2, USART_IT_IDLE, ENABLE);
}
if (USART_GetITStatus(USART2, USART_IT_IDLE) != RESET) {
USART_ITConfig(USART2, USART_IT_IDLE, DISABLE);
USART_ReceiveData(USART2);
USART_ClearITPendingBit(USART2, USART_IT_IDLE);
DMA_Cmd(DWIN_RX_STREAM, DISABLE);
DMA_ClearFlag(DWIN_RX_STREAM, DMA_FLAG_TCIF5 | DMA_FLAG_HTIF5 | DMA_FLAG_TEIF5 | DMA_FLAG_DMEIF5 | DMA_FLAG_FEIF5);
len = DMA_GetCurrDataCounter(DWIN_RX_STREAM);
len = DWIN_BUFF_RX_LEN - len;
dwin_rx_parse(dwin_buff_rx, len);
}
}

34
stm32f4/src/dwin.h Normal file
View File

@ -0,0 +1,34 @@
#ifndef __DWIN_H__
#define __DWIN_H__
#ifdef __cplusplus
extern "C" {
#endif
#include "stm32f4xx.h"
#define DWIN_PORT (GPIOA)
#define DWIN_PIN_TX (GPIO_Pin_2)
#define DWIN_PIN_RX (GPIO_Pin_3)
#define DWIN_BAUDRATE (115200)
#define DWIN_DATA_DISP_ADDR (0x5000)
#define DWIN_DATA_DISP_LENG (0x24)
#define DWIN_DATA_CTRL_ADDR (0x5100)
#define DWIN_DATA_CTRL_LENG (0x0A)
extern char sn[16];
extern struct lark1s_gas_info_s lark1s_gas_info;
extern struct lark1s_gas_cali_data_s lark1s_gas_cali_data;
extern struct lark1s_data_s lark1s_data;
extern struct lark1s_status_s lark1s_status;
void dwin_init(void);
void dwin_send(uint16_t len);
void dwin_loop(void);
#ifdef __cplusplus
}
#endif
#endif /* __DWIN_H__ */

258
stm32f4/src/rs485.c Normal file
View File

@ -0,0 +1,258 @@
#include "stm32f4xx_rcc.h"
#include "stm32f4xx_gpio.h"
#include "stm32f4xx_usart.h"
#include "stm32f4xx_dma.h"
#include "rs485.h"
#include "lark1s.h"
#include "dwin.h"
#define RS485_TX_STREAM DMA1_Stream3
#define RS485_RX_STREAM DMA1_Stream1
#define RS485_BUFF_TX_LEN (4096)
#define RS485_BUFF_RX_LEN (4096)
uint8_t rs485_buff_tx[RS485_BUFF_TX_LEN] __attribute__((aligned(16)));
uint8_t rs485_buff_rx[RS485_BUFF_RX_LEN] __attribute__((aligned(16)));
static int __attribute__((section(".bss_ccm"))) sm = 0;
struct rs485_cfg_dwin rs485_cfg_dwin __attribute__((section(".bss_ccm")));
char sn[16] __attribute__((section(".bss_ccm")));
struct lark1s_gas_info_s lark1s_gas_info __attribute__((section(".bss_ccm")));
struct lark1s_gas_cali_data_s lark1s_gas_cali_data __attribute__((section(".bss_ccm")));
struct lark1s_data_s lark1s_data __attribute__((section(".bss_ccm")));
struct lark1s_status_s lark1s_status __attribute__((section(".bss_ccm")));
uint8_t cali_type __attribute__((section(".bss_ccm"))); /* 0:none, 1:zero, 2:span, 3:restore */
uint8_t cali_succeed __attribute__((section(".bss_ccm")));
extern uint32_t system_tick_cnt;
static void rs485_mode_tx(void)
{
GPIO_SetBits(RS485_PORT, RS485_PIN_DIR);
}
static void rs485_mode_rx(void)
{
GPIO_ResetBits(RS485_PORT, RS485_PIN_DIR);
}
void rs485_init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
USART_InitTypeDef USART_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_DMA1, ENABLE);
GPIO_InitStructure.GPIO_Pin = RS485_PIN_DIR,
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT,
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP,
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz,
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL,
GPIO_Init(RS485_PORT, &GPIO_InitStructure);
rs485_mode_tx();
GPIO_PinAFConfig(RS485_PORT, GPIO_PinSource10, GPIO_AF_USART3);
GPIO_PinAFConfig(RS485_PORT, GPIO_PinSource11, GPIO_AF_USART3);
GPIO_InitStructure.GPIO_Pin = RS485_PIN_TX | RS485_PIN_RX;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(RS485_PORT, &GPIO_InitStructure);
USART_DeInit(USART3);
USART_OverSampling8Cmd(USART3, ENABLE);
USART_InitStructure.USART_BaudRate = rs485_cfg_dwin.baudrate;
USART_InitStructure.USART_WordLength = USART_WordLength_8b;
USART_InitStructure.USART_Parity = USART_Parity_No;
USART_InitStructure.USART_StopBits = USART_StopBits_1;
USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
USART_Init(USART3, &USART_InitStructure);
USART_DMACmd(USART3, USART_DMAReq_Tx, ENABLE);
USART_DMACmd(USART3, USART_DMAReq_Rx, ENABLE);
USART_Cmd(USART3, ENABLE);
DMA_InitStructure.DMA_BufferSize = RS485_BUFF_TX_LEN;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_1QuarterFull;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_PeripheralBaseAddr =(uint32_t)(&(USART3->DR));
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_InitStructure.DMA_Channel = DMA_Channel_4;
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)rs485_buff_tx;
DMA_Init(RS485_TX_STREAM, &DMA_InitStructure);
/* Configure DMA controller to manage USART RX request */
DMA_InitStructure.DMA_BufferSize = RS485_BUFF_RX_LEN;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralToMemory;
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)rs485_buff_rx;
DMA_Init(RS485_RX_STREAM, &DMA_InitStructure);
/* Configure interrupt for USART3 RX */
NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 12;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
USART_ITConfig(USART3, USART_IT_IDLE, ENABLE);
USART_ITConfig(USART3, USART_IT_TC, ENABLE);
/* clear IT flag */
USART_GetITStatus(USART3, USART_IT_IDLE);
USART_ReceiveData(USART3);
USART_ClearITPendingBit(USART3, USART_IT_IDLE);
USART_ClearITPendingBit(USART3, USART_IT_TC);
}
void rs485_send(uint16_t len)
{
USART_ITConfig(USART3, USART_IT_IDLE, DISABLE);
rs485_mode_tx();
DMA_SetCurrDataCounter(RS485_TX_STREAM, len);
DMA_Cmd(RS485_TX_STREAM, ENABLE);
}
void rs485_state_machine_tx(void)
{
int len;
switch (sm) {
case 0: len = lark1s_req_sn(rs485_buff_tx); break;
case 1: len = lark1s_req_gas3_info(rs485_buff_tx); break;
case 2: len = lark1s_req_gas3_cali_data(rs485_buff_tx); break;
case 3: len = lark1s_req_data(rs485_buff_tx); break;
case 4: len = lark1s_req_status(rs485_buff_tx); break;
case 5: len = lark1s_req_gas3_cali_zero_record(rs485_buff_tx, LARK1S_CALI_ZERO); break;
case 6: len = lark1s_req_gas3_cali_active(rs485_buff_tx, LARK1S_CALI_ZERO); break;
case 7: len = lark1s_req_gas3_cali_span_record(rs485_buff_tx, rs485_cfg_dwin.cali_span_concentration); break;
case 8: len = lark1s_req_gas3_cali_active(rs485_buff_tx, LARK1S_CALI_SPAN); break;
case 9: len = lark1s_req_gas3_cali_restore(rs485_buff_tx); break;
default: len = 0; break;
}
rs485_send((uint16_t)len);
}
void rs485_state_machine_rx(int len)
{
int ret = LARK1S_PARSE_OK;
switch (sm) {
case 0: ret = lark1s_parse_sn(rs485_buff_rx, len, sn); break;
case 1: ret = lark1s_parse_gas3_info(rs485_buff_rx, len, &lark1s_gas_info); break;
case 2: ret = lark1s_parse_gas3_cali_data(rs485_buff_rx, len, &lark1s_gas_cali_data); break;
case 3: ret = lark1s_parse_data(rs485_buff_rx, len, &lark1s_data); break;
case 4: ret = lark1s_parse_status(rs485_buff_rx, len, &lark1s_status); break;
case 5: ret = lark1s_parse_gas3_cali_zero_record(rs485_buff_rx, len); break;
case 6: ret = lark1s_parse_gas3_cali_active(rs485_buff_rx, len); break;
case 7: ret = lark1s_parse_gas3_cali_span_record(rs485_buff_rx, len); break;
case 8: ret = lark1s_parse_gas3_cali_active(rs485_buff_rx, len); break;
case 9: ret = lark1s_parse_gas3_cali_restore(rs485_buff_rx, len); break;
default: break;
}
switch (sm) {
case 6: cali_type = 1; break;
case 8: cali_type = 2; break;
case 9: cali_type = 3; break;
default: break;
}
/* check cali status */
if (sm == 4) {
if (cali_type == 1) {
/* cali zero */
cali_type = 0;
if (lark1s_status.zero_record[2] == 0 && lark1s_status.active == 0) {
cali_succeed = 1;
}
} else if (cali_type == 2) {
/* cali span */
cali_type = 0;
if (lark1s_status.span_record[2] == 0 && lark1s_status.active == 0) {
cali_succeed = 1;
}
} else if (cali_type == 3) {
/* cali restore */
cali_type = 0;
if (lark1s_status.restore == 0) {
cali_succeed = 1;
}
}
}
if ((ret != LARK1S_PARSE_OK) && (sm >= 5)) {
sm = 0;
return;
}
if ((sm == 4) ||(sm == 6) || (sm == 8) || (sm == 9)) {
sm = 0;
return;
}
sm++;
if (sm > 9) {
sm = 0;
}
if (sm < 4) {
if (rs485_cfg_dwin.cali_restore_bak) {
rs485_cfg_dwin.cali_restore_bak = 0;
sm = 9;
} else if (rs485_cfg_dwin.cali_span_bak) {
rs485_cfg_dwin.cali_span_bak = 0;
sm = 7;
} else if (rs485_cfg_dwin.cali_zero_bak) {
rs485_cfg_dwin.cali_zero_bak = 0;
sm = 5;
}
}
}
void rs485_loop(void)
{
static uint32_t ms = 0;
if (system_tick_cnt < (ms + 200)) {
return;
}
ms = system_tick_cnt;
if (rs485_cfg_dwin.confirm_bak) {
rs485_cfg_dwin.confirm_bak = 0;
rs485_init();
lark1s_set_mb_address(rs485_cfg_dwin.address);
}
rs485_state_machine_tx();
}
void USART3_IRQHandler(void)
{
uint16_t len;
if (USART_GetITStatus(USART3, USART_IT_TC) != RESET)
{
USART_ClearITPendingBit(USART3, USART_IT_TC);
DMA_ClearFlag(RS485_TX_STREAM, DMA_FLAG_TCIF3 | DMA_FLAG_HTIF3 | DMA_FLAG_TEIF3 | DMA_FLAG_DMEIF3 | DMA_FLAG_FEIF3);
DMA_Cmd(RS485_TX_STREAM, DISABLE);
/* after tx complete, config rx */
USART_ReceiveData(USART3);
USART_ClearITPendingBit(USART3, USART_IT_IDLE);
DMA_SetCurrDataCounter(RS485_RX_STREAM, RS485_BUFF_RX_LEN);
DMA_Cmd(RS485_RX_STREAM, ENABLE);
USART_ITConfig(USART3, USART_IT_IDLE, ENABLE);
rs485_mode_rx();
}
if (USART_GetITStatus(USART3, USART_IT_IDLE) != RESET) {
USART_ITConfig(USART3, USART_IT_IDLE, DISABLE);
USART_ReceiveData(USART3);
USART_ClearITPendingBit(USART3, USART_IT_IDLE);
DMA_Cmd(RS485_RX_STREAM, DISABLE);
DMA_ClearFlag(RS485_RX_STREAM, DMA_FLAG_TCIF1 | DMA_FLAG_HTIF1 | DMA_FLAG_TEIF1 | DMA_FLAG_DMEIF1 | DMA_FLAG_FEIF1);
len = DMA_GetCurrDataCounter(RS485_RX_STREAM);
len = RS485_BUFF_RX_LEN - len;
rs485_state_machine_rx((uint16_t)len);
}
}

44
stm32f4/src/rs485.h Normal file
View File

@ -0,0 +1,44 @@
#ifndef __RS485_H__
#define __RS485_H__
#ifdef __cplusplus
extern "C" {
#endif
#include "stm32f4xx.h"
#define RS485_PORT (GPIOB)
#define RS485_PIN_TX (GPIO_Pin_10)
#define RS485_PIN_RX (GPIO_Pin_11)
#define RS485_PIN_DIR (GPIO_Pin_1)
struct rs485_cfg_dwin {
uint32_t baudrate;
uint32_t cali_span_concentration;
uint8_t cali_zero;
uint8_t cali_zero_bak;
uint8_t cali_span;
uint8_t cali_span_bak;
uint8_t cali_restore;
uint8_t cali_restore_bak;
uint8_t address;
uint8_t confirm;
uint8_t confirm_bak;
uint8_t init;
uint8_t init_bak;
uint8_t cali_succeed;
};
extern struct rs485_cfg_dwin rs485_cfg_dwin;
void rs485_init(void);
void rs485_send(uint16_t len);
void rs485_state_machine_tx(void);
void rs485_state_machine_rx(int len);
void rs485_loop(void);
#ifdef __cplusplus
}
#endif
#endif /* __RS485_H__ */

419
windows/main.c Normal file
View File

@ -0,0 +1,419 @@
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <windows.h>
#include "../lark1s/lark1s.h"
#define MB_ADDRESS (7)
#define MB_RESP_TIME (100)
#define BUFFER_SIZE (1024)
uint8_t buffer_w[BUFFER_SIZE];
uint8_t buffer_r[BUFFER_SIZE];
void print_sn(HANDLE hComm, uint8_t *out, uint8_t *in)
{
uint8_t sn[16];
int ret;
DWORD actual_len;
ret = lark1s_req_sn(out);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_sn failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_sn(in, actual_len, sn);
if (ret) {
printf("Error: lark1s_parse_sn failed, %d\r\n", ret);
return;
} else {
printf("SN: ");
for (int j = 0; j < 16; j++) {
if (sn[j] <= ' ') {
continue;
}
printf("%c", sn[j]);
}
printf("\r\n");
}
}
void print_gas3_info(HANDLE hComm, uint8_t *out, uint8_t *in)
{
struct lark1s_gas_info_s info;
int ret;
DWORD actual_len;
ret = lark1s_req_gas3_info(out);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_gas3_info failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_gas3_info(in, actual_len, &info);
if (ret) {
printf("Error: lark1s_parse_gas_info failed, %d\r\n", ret);
return;
} else {
printf("gas3_info.gas_id: %d\r\n", info.gas_id);
printf("gas3_info.gas_name: ");
for (int j = 0; j < 12; j++) {
if (info.gas_name[j] <= ' ') {
continue;
}
printf("%c", info.gas_name[j]);
}
printf("\r\n");
printf("gas3_info.unit_id: %d\r\n", info.unit_id);
printf("gas3_info.unit_name: ");
for (int j = 0; j < 8; j++) {
if (info.unit_name[j] <= ' ') {
continue;
}
printf("%c", info.unit_name[j]);
}
printf("\r\n");
printf("gas3_info.range: %d\r\n", info.range);
printf("gas3_info.min_cali: %d\r\n", info.min_cali);
}
}
void print_data(HANDLE hComm, uint8_t *out, uint8_t *in)
{
struct lark1s_data_s data;
int ret;
DWORD actual_len;
ret = lark1s_req_data(out);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_data failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_data(in, actual_len, &data);
if (ret) {
printf("Error: lark1s_parse_data failed, %d\r\n", ret);
return;
} else {
printf("data.det_temp: %d\r\n", data.det_temp);
printf("data.air_pressure: %d\r\n", data.air_pressure);
printf("data.gas3_reading: %d\r\n", data.gas3_reading);
printf("data.cts_ref: %d\r\n", data.cts_ref);
printf("data.cts_gas3: %d\r\n", data.cts_gas3);
printf("data.gas3_compensated_reading: %d\r\n", data.gas3_compensated_reading);
}
}
void print_status(HANDLE hComm, uint8_t *out, uint8_t *in)
{
struct lark1s_status_s status;
int ret;
DWORD actual_len;
ret = lark1s_req_status(out);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_status failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_status(in, actual_len, &status);
if (ret) {
printf("Error: lark1s_parse_status failed, %d\r\n", ret);
return;
} else {
printf("status.zero_record: %d\r\n", status.zero_record[2]);
printf("status.span_record: %d\r\n", status.span_record[2]);
printf("status.active: %d\r\n", status.active);
printf("status.restore: %d\r\n", status.restore);
}
}
void cali_zero(HANDLE hComm, uint8_t *out, uint8_t *in)
{
struct lark1s_status_s status;
int ret;
DWORD actual_len;
/* zero record */
ret = lark1s_req_gas3_cali_zero_record(out, LARK1S_CALI_ZERO);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_gas3_cali_zero_record failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_gas3_cali_zero_record(in, actual_len);
if (ret) {
printf("Error: lark1s_parse_gas3_cali_zero_record failed, %d\r\n", ret);
return;
}
/* get zero record status */
ret = lark1s_req_status(out);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_status failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_status(in, actual_len, &status);
if (ret) {
printf("Error: lark1s_parse_status failed, %d\r\n", ret);
return;
} else {
if (0 == status.zero_record[2]) {
printf("cali zero record success\r\n");
} else {
printf("cali zero record failed, ret = %d\r\n", status.zero_record[2]);
return;
}
}
/* zero active */
ret = lark1s_req_gas3_cali_active(out, LARK1S_CALI_ZERO);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_gas3_cali_zero_active failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_gas3_cali_active(in, actual_len);
if (ret) {
printf("Error: lark1s_parse_gas3_cali_zero_active failed, %d\r\n", ret);
return;
}
/* get zero active status */
ret = lark1s_req_status(out);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_status failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_status(in, actual_len, &status);
if (ret) {
printf("Error: lark1s_parse_status failed, %d\r\n", ret);
return;
} else {
if (0 == status.active) {
printf("cali zero active success\r\n");
} else {
printf("cali zero active failed, ret = %d\r\n", status.active);
return;
}
}
}
void cali_span(HANDLE hComm, uint8_t *out, uint8_t *in, int concentration)
{
struct lark1s_status_s status;
int ret;
DWORD actual_len;
/* span record */
ret = lark1s_req_gas3_cali_span_record(out, concentration);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_gas3_cali_span_record failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_gas3_cali_span_record(in, actual_len);
if (ret) {
printf("Error: lark1s_parse_gas3_cali_span_record failed, %d\r\n", ret);
return;
}
/* get span record status */
ret = lark1s_req_status(out);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_status failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_status(in, actual_len, &status);
if (ret) {
printf("Error: lark1s_parse_status failed, %d\r\n", ret);
return;
} else {
if (0 == status.span_record[2]) {
printf("cali span record success\r\n");
} else {
printf("cali span record failed, ret = %d\r\n", status.span_record[2]);
return;
}
}
/* span active */
ret = lark1s_req_gas3_cali_active(out, LARK1S_CALI_SPAN);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_gas3_cali_span_active failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_gas3_cali_active(in, ret);
if (ret) {
printf("Error: lark1s_parse_gas3_cali_span_active failed, %d\r\n", ret);
return;
}
/* get span active status */
ret = lark1s_req_status(out);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_status failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_status(in, actual_len, &status);
if (ret) {
printf("Error: lark1s_parse_status failed, %d\r\n", ret);
return;
} else {
if (0 == status.active) {
printf("cali span active success\r\n");
} else {
printf("cali span active failed, ret = %d\r\n", status.active);
return;
}
}
}
void cali_restore(HANDLE hComm, uint8_t *out, uint8_t *in)
{
struct lark1s_status_s status;
int ret;
DWORD actual_len;
ret = lark1s_req_gas3_cali_restore(out);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_gas3_cali_restore failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_gas3_cali_restore(in, ret);
if (ret) {
printf("Error: lark1s_parse_gas3_cali_restore failed, %d\r\n", ret);
return;
}
/* get restore status */
ret = lark1s_req_status(out);
if (ret) {
WriteFile(hComm, out, ret, &actual_len, NULL);
} else {
printf("Error: lark1s_req_status failed\r\n");
return;
}
ReadFile(hComm, in, BUFFER_SIZE, &actual_len, NULL);
ret = lark1s_parse_status(in, actual_len, &status);
if (ret) {
printf("Error: lark1s_parse_status failed, %d\r\n", ret);
return;
} else {
if (0 == status.active) {
printf("cali restore success\r\n");
} else {
printf("cali restore failed, ret = %d\r\n", status.active);
return;
}
}
}
void print_help(void)
{
printf("Usage:\r\n");
printf("1: print sn\r\n");
printf("2: print gas3 info\r\n");
printf("3: print data\r\n");
printf("4: print status\r\n");
printf("5: cali restore\r\n");
printf("0: cali zero\r\n");
printf("other number: cali span\r\n");
printf("\r\n");
}
int main(void) {
int sel;
HANDLE hComm = CreateFile(
"\\\\.\\COM3", /* serial port name */
GENERIC_READ | GENERIC_WRITE, /* write & read privilege */
0, /* share mode */
NULL, /* secure attribute */
OPEN_EXISTING, /* open current device */
0, /* file attribute */
NULL /* template file */
);
if (hComm == INVALID_HANDLE_VALUE) {
/* open serial port failed */
printf("Error: open serial port failed\r\n");
return -1;
} else {
DCB dcb = { 0 };
dcb.DCBlength = sizeof(dcb);
if (GetCommState(hComm, &dcb)) {
dcb.BaudRate = 115200;
dcb.ByteSize = 8;
dcb.Parity = NOPARITY;
dcb.StopBits = ONESTOPBIT;
if (!SetCommState(hComm, &dcb)) {
printf("Error: Set serial port parameter failed\r\n");
return -1;
}
} else {
printf("Error: Get serial port parameter failed\r\n");
return -1;
}
COMMTIMEOUTS timeouts = { 0 };
timeouts.ReadIntervalTimeout = MB_RESP_TIME;
timeouts.ReadTotalTimeoutConstant = MB_RESP_TIME;
timeouts.ReadTotalTimeoutMultiplier = MB_RESP_TIME;
SetCommTimeouts(hComm, &timeouts);
printf("Succeed: open serial port\r\n");
}
lark1s_set_mb_address(MB_ADDRESS);
print_help();
while (1) {
scanf("%d", &sel);
if (sel == 1) {
print_sn(hComm, buffer_w, buffer_r);
} else if (sel == 2) {
print_gas3_info(hComm, buffer_w, buffer_r);
} else if (sel == 3) {
print_data(hComm, buffer_w, buffer_r);
} else if (sel == 4) {
print_status(hComm, buffer_w, buffer_r);
} else if (sel == 5) {
cali_restore(hComm, buffer_w, buffer_r);
} else if (sel == 0) {
cali_zero(hComm, buffer_w, buffer_r);
} else if (sel > 0) {
cali_span(hComm, buffer_w, buffer_r, sel);
} else {
}
printf("\r\n");
print_help();
FlushFileBuffers(hComm);
}
CloseHandle(hComm);
return 0;
}