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

[feat] add cali function, first complete of linux enviroment

Browse Source
This commit is contained in:
zhji 2024-06-02 17:11:47 +08:00
parent 4982262f6d
commit 42b77a3290
3 changed files with 458 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

181
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;
@ -243,6 +242,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 +266,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;
}

9
lark1s/lark1s.h
View File

@ -9,6 +9,11 @@
#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 (0xFFFD)
#define LARK1S_CALI_ZERO_SPAN (0xFFFC)
struct lark1s_gas_info_s {
uint32_t gas_id;
@ -60,11 +65,11 @@ 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_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);

282
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) {
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);
}