[मुक्त स्रोत]बुद्धिमान प्रशिक्षण कक्ष

2.UI डिझाइन

1.C51 डिझाइन

मुख्य इंटरफेसवर तापमान, आर्द्रता आणि उंची यांसारखा डेटा मिळवणे आणि अपडेट करणे आणि तापमान नियंत्रण मॉड्यूल्स, मोटर्स, अलार्म डिटेक्शन आणि इतर स्लेव्ह मशीन नियंत्रित करण्यासाठी मोडबस आरटीयू वापरण्याचे मुख्य कोड खालीलप्रमाणे आहेत.

मुख्य इंटरफेस कोड संदर्भ:

# "main_win.h" समाविष्ट करा

# "modbus.h" समाविष्ट करा

# "sys_params.h" समाविष्ट करा

# "func_handler.h" समाविष्ट करा

# "uart2.h" समाविष्ट करा

#समाविष्ट करा

#समाविष्ट करा

#TEMP_HUM_SLAVE_ADDR 2 परिभाषित करा

#TEMP_HUM_VAL_MAX_NUM 2 परिभाषित करा

# ALERT_BIT_MAX_NUM 30 परिभाषित करा

#ALERT_BYTE_NUM (ALERT_BIT_MAX_NUM/8+((ALERT_BIT_MAX_NUM%8)!=0)) परिभाषित करा

#GET_ALERT_BIT(val, pos)(val[pos/8]>>(pos%8))&0x01) परिभाषित करा

typedef रचना{

चार तारीख[१७];

u8 desc;

इशारा;

#ALERT_TABLE_LEN 20 परिभाषित करा

स्थिर u8 btn_sta[MAIN_WIN_BTN_MAX_NUM] = {0};

स्थिर 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};

ALERT alert_table[ALERT_TABLE_LEN];

u16 alert_num = 0;

बिट is_main_win = 0;

void main_win_update()

{

}

void main_win_disp_date()

{

u8 लेन;

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 i;

साठी(i=0;i

{

जर(GET_ALERT_BIT(old_alert_val, i))

सुरू;

जर(GET_ALERT_BIT(alert_val, i))

{

जर(alert_num>=ALERT_TABLE_LEN)

alert_num = 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]

);

alert_num++;

}

}

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

}

void main_win_disp_alert()

{

u16 i;

u16 व्हॅल;

u16 len = 0;

common_buf[0] = 0;

साठी(i=0;i

{

val = 0;

जर मी

{

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

}

void main_win_init()

{

फ्लोट fixed_val;

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

साठी(i=0;i

{

जर(i==0)

सुरू;

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

}

fixed_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)

{

u8 निर्देशांक;

जर(btn_val==0x0B)

{

main_win_disp_alert();

परत;

}

अनुक्रमणिका = btn_val-1;

btn_sta[index] = !btn_sta[इंडेक्स];

जर((इंडेक्स==3)||(इंडेक्स==7))

btn_sta[index] = 1;

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

btn_val = btn_sta[निर्देशांक];

sys_write_vp(MAIN_WIN_BTN_STA_START_VP+MAIN_WIN_BTN_STA_OFFSET*इंडेक्स, (u8*)&btn_val, 1);

जर(निर्देशांक==9)

is_main_win = 0;

अन्यथा जर((इंडेक्स==3)||(इंडेक्स==7))

{

असताना(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 i;

u8 ऑफसेट;

msg_len = msg_len;

जर(! is_main_win)

परत;

जर((f_code==MODBUS_FUNC_CODE_03)&&(data_len==MAIN_WIN_VAL_MAX_NUM*2))

{

ऑफसेट = MODBUS_RESPOND_POS_DATA;

साठी(i=0;i

{

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

ऑफसेट += 2;

}

main_win_update();

}अन्यथा जर((f_code==MODBUS_FUNC_CODE_01)&&(data_len==ALERT_BYTE_NUM))

{

ऑफसेट = MODBUS_RESPOND_POS_DATA;

साठी(i=0;i

{

alert_val = msg[ऑफसेट];

ऑफसेट++;

}

main_win_process_alert();

}अन्यथा जर((f_code==MODBUS_FUNC_CODE_03)&&(data_len==TEMP_HUM_VAL_MAX_NUM*2))

{

ऑफसेट = MODBUS_RESPOND_POS_DATA;

साठी(i=0;i

{

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

ऑफसेट += 2;

modbus_write_word(5+i, temp_hum_val);

}

main_win_update();

}अन्यथा जर((f_code==MODBUS_FUNC_CODE_03)&&(data_len==MAIN_WIN_DATE_MAX_NUM*2))

{

ऑफसेट = MODBUS_RESPOND_POS_DATA;

साठी(i=0;i

{

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

ऑफसेट += 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;//परत करा

}

void main_win_handler()

{

स्थिर u8 ध्वज = 0;

जर(मुख्य_जिंक)

{

जर(alert_read_period==ALERT_READ_PERIOD)

{

alert_read_period = 0;

modbus_read_bits(510, ALERT_BIT_MAX_NUM);

परत;

}

जर(date_update_period==DATE_UPDATE_PERIOD)

{

date_update_period = 0;

modbus_read_words(180, MAIN_WIN_DATE_MAX_NUM);

परत;

}

ध्वज = !ध्वज;

जर (ध्वज)

modbus_read_words(0, MAIN_WIN_VAL_MAX_NUM);

इतर

main_win_read_temp_hum();

}

}

मोडबस आरटीयू कोड संदर्भ:

# "modbus.h" समाविष्ट करा

# "crc16.h" समाविष्ट करा

# "sys_params.h" समाविष्ट करा

#UART_INCLUDE "uart2.h" परिभाषित करा

#UART_INIT uart2_init परिभाषित करा

#UART_SEND_BYTES uart2_send_bytes परिभाषित करा

#UART_BAUD 9600 परिभाषित करा

#MODBUS_RECV_TIMEOUT (u8)(35000.0f/UART_BAUD+2) परिभाषित करा

#MODBUS_SEND_INTERVAL 150 परिभाषित करा

#UART_INCLUDE समाविष्ट करा

स्थिर बिट is_modbus_recv_complete = 0;

स्थिर u8 modbus_recv_buff[270];

स्टॅटिक u16 modbus_recv_len = 0;// स्वीकारलेल्या बाइट्सची एकूण लांबी

स्थिर u8 modbus_recv_timeout = 0;//ओव्हरफ्लो वेळ स्वीकारा

स्थिर अस्थिर u16 modbus_send_interval = 0;

MODBUS_PACKET पॅकेट;

void modbus_init()

{

UART_INIT(UART_BAUD);

}

void modbus_send_bytes(u8 *bytes,u16 len)

{

UART_SEND_BYTES(बाइट्स,लेन);

}

void modbus_recv_byte(u8 बाइट)

{

जर(is_modbus_recv_complete)

परत;

जर(modbus_recv_len

modbus_recv_buff[modbus_recv_len++] = बाइट;

}

void modbus_check_recv_timeout()

{

जर(modbus_recv_timeout)

{

modbus_recv_timeout--;

जर(modbus_recv_timeout==0)

{

is_modbus_recv_complete = 1;

}

}

}

u8 modbus_send_packet(u8 *पॅकेट)

{

u16 लेन;

u16 crc;

u8 func_code = पॅकेट[1];

असताना(modbus_send_interval);

जर(func_code==MODBUS_FUNC_CODE_10)

{

((MODBUS_10_PACKET*)पॅकेट)->byte_num = ((MODBUS_10_PACKET*)पॅकेट)->word_num*2;

len = 9+((MODBUS_10_PACKET*)पॅकेट)->byte_num;

}अन्यथा जर(func_code==MODBUS_FUNC_CODE_0F)

{

len = ((MODBUS_0F_PACKET*)पॅकेट)->bit_num;

((MODBUS_0F_PACKET*)पॅकेट)->byte_num = len/8+(len%8?1:0);

len = 9+((MODBUS_0F_PACKET*)पॅकेट)->byte_num;

}इतर

{

len = sizeof(MODBUS_PACKET);

}

crc = crc16 (पॅकेट, लेन-2);

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

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

modbus_send_bytes(पॅकेट, लेन);

modbus_send_interval = MODBUS_SEND_INTERVAL;

परतावा 0;//यश

}

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

void modbus_handler()

{

u16 crc;

जर(!is_modbus_recv_complete)

परत;

//सीआरसी मूल्य तपासा

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;//फंक्शन कोड

packet.start_addr = addr;//पत्ता

packet.data_len = len;//मूल्य लिहिलेले

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

रिटर्न लेन;

}