[Mã Nguồn Mở]Phòng Huấn Luyện Thông Minh

2.Thiết kế giao diện người dùng

Thiết kế 1.C51

Các mã chính để thu thập và cập nhật dữ liệu như nhiệt độ, độ ẩm và độ cao trên giao diện chính và sử dụng modbus rtu để điều khiển các mô-đun điều khiển nhiệt độ, động cơ, phát hiện cảnh báo và các máy phụ khác như sau

Tham khảo mã giao diện chính:

#include "main_win.h"

#include "modbus.h"

#include "sys_params.h"

#include "func_handler.h"

#include "uart2.h"

#bao gồm

#bao gồm

#define TEMP_HUM_SLAVE_ADDR 2

#define TEMP_HUM_VAL_MAX_NUM 2

#define ALERT_BIT_MAX_NUM 30

#define ALERT_BYTE_NUM (ALERT_BIT_MAX_NUM/8+((ALERT_BIT_MAX_NUM%8)!=0))

#define GET_ALERT_BIT(val, pos) ((val[pos/8]>>(pos%8))&0x01)

cấu trúc typedef{

ngày char[17];

u8 mô tả;

}BÁO ĐỘNG;

#define ALERT_TABLE_LEN 20

tĩnh u8 btn_sta[MAIN_WIN_BTN_MAX_NUM] = {0};

tĩnh u8 btn_addr[MAIN_WIN_BTN_MAX_NUM] = {50, 51, 52, 69, 53, 54, 55, 70, 56, 57, 58, 59};

u16 main_win_val[MAIN_WIN_VAL_MAX_NUM];

u16 temp_hum_val[TEMP_HUM_VAL_MAX_NUM] = {0};

u16 ngày_val[MAIN_WIN_DATE_MAX_NUM] = {0};

u8 cảnh báo_val[ALERT_BYTE_NUM] = {0};

u8 old_alert_val[ALERT_BYTE_NUM] = {0};

ALERT cảnh báo_bảng[ALERT_TABLE_LEN];

u16 cảnh báo_num = 0;

bit is_main_win = 0;

void main_win_update()

{

}

void main_win_disp_date()

{

u8 len;

len = sprintf(common_buf, "%u:%u", (u16)date_val[3], (u16)date_val[4]);

common_buf[len+1] = 0;

sys_write_vp(MAIN_WIN_DATE_VP, common_buf, len/2+2);

}

void main_win_process_alert()

{

u8 tôi;

vì(i=0;i

{

if(GET_ALERT_BIT(old_alert_val, i))

Tiếp tục;

if(GET_ALERT_BIT(alert_val, i))

{

if(alert_num>=ALERT_TABLE_LEN)

cảnh báo_num = ALERT_TABLE_LEN-1;

notification_table[alert_num].desc = i+1;

sprintf(alert_table[alert_num].date, "%u/%u/%u %u:%u",

date_val[0], date_val[1], date_val[2], date_val[3], date_val[4]

);

cảnh báo_num++;

}

}

memcpy(old_alert_val, Alert_val, sizeof(alert_val));

}

void main_win_disp_alert()

{

u16 tôi;

giá trị u16;

u16 len = 0;

common_buf[0] = 0;

vì(i=0;i

{

giá trị = 0;

nếu tôi

{

val = cảnh báo_table.desc;

len += sprintf(common_buf+len, "%s\r\n", notification_table.date);

}

sys_write_vp(ALERT_WIN_DESC_START_VP+i, (u8*)&val, 1);

}

common_buf[len+1] = 0;

sys_write_vp(ALERT_WIN_DATE_VP, common_buf, len/2+2);

}

void main_win_init()

{

float cố định_val;

u8 tôi;

is_main_win = 1;

 

main_win_val[5] = (u16)(temp_hum_val[0]/10.0+0.5f);

main_win_val[6] = (u16)(temp_hum_val[1]/10.0+0.5f);

vì(i=0;i

{

nếu(i==0)

Tiếp tục;

sys_write_vp(MAIN_WIN_WIND_SPEED_VP+MAIN_WIN_VAL_OFFSET*i, (u8*)&main_win_val, 1);

}

cố định_val = main_win_val[0]/WIND_SPEED_SCALE+FLOAT_FIX_VAL;

sys_write_vp(MAIN_WIN_WIND_SPEED_VP, (u8*)&fixed_val, 2);

}

void main_win_click_handler(u16 btn_val)

{

chỉ số u8;

nếu(btn_val==0x0B)

{

main_win_disp_alert();

trở lại;

}

chỉ số = btn_val-1;

btn_sta[index] = !btn_sta[index];

if((index==3)||(index==7))

btn_sta[chỉ mục] = 1;

modbus_write_bit(btn_addr[chỉ mục], btn_sta[chỉ mục]?0xFF00:0x0000);

btn_val = btn_sta[chỉ mục];

sys_write_vp(MAIN_WIN_BTN_STA_START_VP+MAIN_WIN_BTN_STA_OFFSET*chỉ mục, (u8*)&btn_val, 1);

nếu(chỉ số==9)

is_main_win = 0;

khác nếu((index==3)||(index==7))

{

while(sys_get_touch_sta());

modbus_write_bit(btn_addr[chỉ mục], 0x0000);

}

}

void main_win_msg_handler(u8 *msg,u16 msg_len)

{

u8 f_code = tin nhắn[MODBUS_RESPOND_POS_FUNC_CODE];

u8 data_len = tin nhắn[MODBUS_RESPOND_POS_DATA_LEN];

u8 tôi;

bù u8;

tin nhắn_len = tin nhắn_len;

if(!is_main_win)

trở lại;

if((f_code==MODBUS_FUNC_CODE_03)&&(data_len==MAIN_WIN_VAL_MAX_NUM*2))

{

bù đắp = MODBUS_RESPOND_POS_DATA;

vì(i=0;i

{

main_win_val = SYS_GET_U16(tin nhắn[offset], msg[offset+1]);

bù đắp += 2;

}

main_win_update();

}nếu không thì if((f_code==MODBUS_FUNC_CODE_01)&&(data_len==ALERT_BYTE_NUM))

{

bù đắp = MODBUS_RESPOND_POS_DATA;

vì(i=0;i

{

cảnh báo_val = tin nhắn[bù đắp];

bù đắp++;

}

main_win_process_alert();

}nếu không thì if((f_code==MODBUS_FUNC_CODE_03)&&(data_len==TEMP_HUM_VAL_MAX_NUM*2))

{

bù đắp = MODBUS_RESPOND_POS_DATA;

vì(i=0;i

{

temp_hum_val = SYS_GET_U16(tin nhắn[offset], msg[offset+1]);

bù đắp += 2;

modbus_write_word(5+i, temp_hum_val);

}

main_win_update();

}nếu không thì((f_code==MODBUS_FUNC_CODE_03)&&(data_len==MAIN_WIN_DATE_MAX_NUM*2))

{

bù đắp = MODBUS_RESPOND_POS_DATA;

vì(i=0;i

{

date_val = SYS_GET_U16(tin nhắn[offset], msg[offset+1]);

bù đắp += 2;

}

main_win_disp_date();

}

}

void main_win_read_temp_hum()

{

u8 old_slave_addr = SLAVE_ADDR;

        

sys_params.user_config[5] = TEMP_HUM_SLAVE_ADDR;

modbus_read_words(0, TEMP_HUM_VAL_MAX_NUM);

sys_params.user_config[5] = old_slave_addr;//Hoàn nguyên

}

void main_win_handler()

{

cờ u8 tĩnh = 0;

nếu(is_main_win)

{

if(alert_read_ Period==ALERT_READ_PERIOD)

{

cảnh báo_đọc_thời gian = 0;

modbus_read_bits(510, ALERT_BIT_MAX_NUM);

trở lại;

}

if(date_update_ Period==DATE_UPDATE_PERIOD)

{

ngày_update_thời gian = 0;

modbus_read_words(180, MAIN_WIN_DATE_MAX_NUM);

trở lại;

}

cờ = !cờ;

nếu (cờ)

modbus_read_words(0, MAIN_WIN_VAL_MAX_NUM);

khác

main_win_read_temp_hum();

}

}

tham chiếu mã modbus rtu:

#include "modbus.h"

#include "crc16.h"

#include "sys_params.h"

#define UART_INCLUDE "uart2.h"

#define UART_INIT uart2_init

#define UART_SEND_BYTES uart2_send_bytes

#define UART_BAUD 9600

#define MODBUS_RECV_TIMEOUT (u8)(35000.0f/UART_BAUD+2)

#define MODBUS_SEND_INTERVAL 150

#include UART_INCLUDE

bit tĩnh is_modbus_recv_complete = 0;

tĩnh u8 modbus_recv_buff[270];

static u16 modbus_recv_len = 0;//Tổng chiều dài byte được chấp nhận

static u8 modbus_recv_timeout = 0;//Chấp nhận thời gian tràn

biến động tĩnh u16 modbus_send_interval = 0;

gói MODBUS_PACKET;

void modbus_init()

{

UART_INIT(UART_BAUD);

}

void modbus_send_bytes(u8 *byte,u16 len)

{

UART_SEND_BYTES(byte,len);

}

void modbus_recv_byte(u8 byte)

{

if(is_modbus_recv_complete)

trở lại;

if(modbus_recv_len

modbus_recv_buff[modbus_recv_len++] = byte;

}

void modbus_check_recv_timeout()

{

if(modbus_recv_timeout)

{

modbus_recv_timeout--;

if(modbus_recv_timeout==0)

{

is_modbus_recv_complete = 1;

}

}

}

u8 modbus_send_packet(u8 *gói)

{

u16 len;

u16 crc;

u8 func_code = gói [1];

while(modbus_send_interval);

if(func_code==MODBUS_FUNC_CODE_10)

{

((MODBUS_10_PACKET*)gói)->byte_num = ((MODBUS_10_PACKET*)gói)->word_num*2;

len = 9+((MODBUS_10_PACKET*)gói)->byte_num;

}nếu không thì(func_code==MODBUS_FUNC_CODE_0F)

{

len = ((MODBUS_0F_PACKET*)gói)->bit_num;

((MODBUS_0F_PACKET*)gói)->byte_num = len/8+(len%8?1:0);

len = 9+((MODBUS_0F_PACKET*)gói)->byte_num;

}khác

{

len = sizeof(MODBUS_PACKET);

}

crc = crc16(gói,len-2);

packet[len-2] = (u8)(crc>>8);

gói[len-1] = (u8)crc;

modbus_send_bytes(gói, len);

modbus_send_interval = MODBUS_SEND_INTERVAL;

trả về 0;//Thành công

}

bên ngoài void modbus_msg_handler(u8 *msg,u16 msg_len);

void modbus_handler()

{

u16 crc;

if(!is_modbus_recv_complete)

trở lại;

//Kiểm tra giá trị crc

crc = ((u16)modbus_recv_buff[modbus_recv_len-2]<<8)+modbus_recv_buff[modbus_recv_len-1];

if(crc16(modbus_recv_buff,modbus_recv_len-2)==crc)

{

modbus_msg_handler(modbus_recv_buff,modbus_recv_len);

}

modbus_recv_len = 0;

is_modbus_recv_complete = 0;

}

u8 modbus_send_fcode(u8 fcode, u16 addr, u16 len)

{

packet.slave_addr = SLAVE_ADDR;

packet.func_code = fcode;//Mã hàm

packet.start_addr = addr;//Địa chỉ

packet.data_len = len;//Giá trị được ghi

len = modbus_send_packet((u8*)&packet);

trả lại len;

}