[Open Source]Salle de formation intelligente

2.Conception de l'interface utilisateur

1.Conception C51

Les principaux codes pour acquérir et mettre à jour des données telles que la température, l'humidité et l'altitude sur l'interface principale, et utiliser Modbus RTU pour contrôler les modules de contrôle de température, les moteurs, la détection d'alarme et d'autres machines esclaves sont les suivants

Référence du code de l'interface principale :

#include "main_win.h"

#include "modbus.h"

#include "sys_params.h"

#include "func_handler.h"

#include "uart2.h"

#inclure

#inclure

#définir TEMP_HUM_SLAVE_ADDR 2

#définir TEMP_HUM_VAL_MAX_NUM 2

#définir 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)

structure typedef{

date du caractère[17] ;

u8 desc;

}ALERTE;

#définir ALERT_TABLE_LEN 20

statique u8 btn_sta[MAIN_WIN_BTN_MAX_NUM] = {0} ;

statique 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 date_val[MAIN_WIN_DATE_MAX_NUM] = {0} ;

u8 alert_val[ALERT_BYTE_NUM] = {0} ;

u8 old_alert_val[ALERT_BYTE_NUM] = {0} ;

ALERTE alert_table[ALERT_TABLE_LEN] ;

u16 numéro_alerte = 0 ;

bit is_main_win = 0 ;

annuler main_win_update()

{

}

annuler 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);

}

annuler main_win_process_alert()

{

u8 je;

pour(i=0;i

{

si (GET_ALERT_BIT (old_alert_val, i))

continuer;

si(GET_ALERT_BIT(alert_val, i))

{

si (numéro_alerte>=ALERT_TABLE_LEN)

numéro_alerte = ALERT_TABLE_LEN-1 ;

alert_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]

);

numéro_alerte++ ;

}

}

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

}

annuler main_win_disp_alert()

{

u16 je;

u16val;

u16 len = 0;

common_buf[0] = 0;

pour(i=0;i

{

val = 0 ;

si je

{

val = alert_table.desc;

len += sprintf(common_buf+len, "%s\r\n", alert_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);

}

annuler main_win_init()

{

float valeur_fixe ;

u8 je;

est_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);

pour(i=0;i

{

si(i==0)

continuer;

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

}

valeur_fixe = main_win_val[0]/WIND_SPEED_SCALE+FLOAT_FIX_VAL ;

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

}

annuler main_win_click_handler (u16 btn_val)

{

indice u8 ;

si(btn_val==0x0B)

{

main_win_disp_alert();

retour;

}

index = btn_val-1 ;

btn_sta[index] = !btn_sta[index];

si((index==3)||(index==7))

btn_sta[index] = 1;

modbus_write_bit(btn_addr[index], btn_sta[index]?0xFF00:0x0000);

btn_val = btn_sta[index];

sys_write_vp(MAIN_WIN_BTN_STA_START_VP+MAIN_WIN_BTN_STA_OFFSET*index, (u8*)&btn_val, 1);

si(index==9)

est_main_win = 0 ;

sinon si((index==3)||(index==7))

{

while(sys_get_touch_sta());

modbus_write_bit(btn_addr[index], 0x0000);

}

}

void main_win_msg_handler(u8 *msg,u16 msg_len)

{

u8 f_code = msg[MODBUS_RESPOND_POS_FUNC_CODE];

u8 data_len = msg[MODBUS_RESPOND_POS_DATA_LEN];

u8 je;

décalage u8 ;

msg_len = msg_len;

si(!is_main_win)

retour;

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

{

décalage = MODBUS_RESPOND_POS_DATA ;

pour(i=0;i

{

main_win_val = SYS_GET_U16(msg[offset], msg[offset+1]);

décalage += 2 ;

}

main_win_update();

}sinon if((f_code==MODBUS_FUNC_CODE_01)&&(data_len==ALERT_BYTE_NUM))

{

décalage = MODBUS_RESPOND_POS_DATA ;

pour(i=0;i

{

alert_val = msg[offset];

décalage++ ;

}

main_win_process_alert();

}sinon if((f_code==MODBUS_FUNC_CODE_03)&&(data_len==TEMP_HUM_VAL_MAX_NUM*2))

{

décalage = MODBUS_RESPOND_POS_DATA ;

pour(i=0;i

{

temp_hum_val = SYS_GET_U16(msg[offset], msg[offset+1]);

décalage += 2 ;

modbus_write_word(5+i, temp_hum_val);

}

main_win_update();

}sinon if((f_code==MODBUS_FUNC_CODE_03)&&(data_len==MAIN_WIN_DATE_MAX_NUM*2))

{

décalage = MODBUS_RESPOND_POS_DATA ;

pour(i=0;i

{

date_val = SYS_GET_U16(msg[offset], msg[offset+1]);

décalage += 2 ;

}

main_win_disp_date();

}

}

vide 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;//Revert

}

annuler main_win_handler()

{

drapeau u8 statique = 0 ;

si (is_main_win)

{

si(alert_read_period==ALERT_READ_PERIOD)

{

alert_read_period = 0 ;

modbus_read_bits(510, ALERT_BIT_MAX_NUM);

retour;

}

si(date_update_period==DATE_UPDATE_PERIOD)

{

date_update_period = 0 ;

modbus_read_words(180, MAIN_WIN_DATE_MAX_NUM);

retour;

}

drapeau = !flag;

si (drapeau)

modbus_read_words(0, MAIN_WIN_VAL_MAX_NUM);

autre

main_win_read_temp_hum();

}

}

Référence du code modbus rtu :

#include "modbus.h"

#inclure "crc16.h"

#include "sys_params.h"

#définir UART_INCLUDE "uart2.h"

#définir UART_INIT uart2_init

#define UART_SEND_BYTES uart2_send_bytes

#définir UART_BAUD 9600

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

#définir MODBUS_SEND_INTERVAL 150

#include UART_INCLUDE

bit statique is_modbus_recv_complete = 0 ;

statique u8 modbus_recv_buff[270] ;

static u16 modbus_recv_len = 0;//Longueur totale des octets acceptés

statique u8 modbus_recv_timeout = 0 ; // Accepter le temps de débordement

statique volatile u16 modbus_send_interval = 0 ;

Paquet MODBUS_PACKET ;

annuler modbus_init()

{

UART_INIT(UART_BAUD);

}

void modbus_send_bytes (u8 * octets, u16 len)

{

UART_SEND_BYTES(octets,len);

}

void modbus_recv_byte (u8 octet)

{

si (is_modbus_recv_complete)

retour;

si (modbus_recv_len

modbus_recv_buff[modbus_recv_len++] = octet ;

}

annuler modbus_check_recv_timeout()

{

si (modbus_recv_timeout)

{

modbus_recv_timeout--;

si(modbus_recv_timeout==0)

{

is_modbus_recv_complete = 1 ;

}

}

}

u8 modbus_send_packet(u8 *paquet)

{

u16 len;

u16 crc;

u8 func_code = paquet[1];

while(modbus_send_interval);

si(func_code==MODBUS_FUNC_CODE_10)

{

((MODBUS_10_PACKET*)paquet)->byte_num = ((MODBUS_10_PACKET*)packet)->word_num*2 ;

len = 9+((MODBUS_10_PACKET*)paquet)->byte_num;

}sinon si(func_code==MODBUS_FUNC_CODE_0F)

{

len = ((MODBUS_0F_PACKET*)paquet) -> bit_num ;

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

len = 9+((MODBUS_0F_PACKET*)paquet)->byte_num;

}autre

{

len = taille de (MODBUS_PACKET);

}

crc = crc16(paquet,len-2);

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

paquet[len-1] = (u8)crc;

modbus_send_bytes(paquet,len);

modbus_send_interval = MODBUS_SEND_INTERVAL ;

retourner 0 ;//Succès

}

extern void modbus_msg_handler(u8 *msg,u16 msg_len);

annuler modbus_handler()

{

u16 crc;

si(!is_modbus_recv_complete)

retour;

//Vérifie la valeur crc

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

si(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)

{

paquet.slave_addr = SLAVE_ADDR ;

packet.func_code = fcode;//Code de fonction

packet.start_addr = addr;//Adresse

packet.data_len = len;//Valeur écrite

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

retourner len;

}