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

2.यूआई डिज़ाइन

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)

टाइपडेफ़ संरचना {

चार दिनांक[17];

यू8 विवरण;

}चेतावनी;

#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_BYTE_NUM] = {0};

u8 पुराना_अलर्ट_वैल[ALERT_BYTE_NUM] = {0};

अलर्ट अलर्ट_टेबल[ALERT_TABLE_LEN];

u16 अलर्ट_नम = 0;

बिट is_main_win = 0;

शून्य मुख्य_विन_अपडेट()

{

}

शून्य मुख्य_विन_डिस्प_डेट()

{

यू8 लेन;

लेन = स्प्रिंटफ(कॉमन_ब्यूफ, "%u:%u", (u16)date_val[3], (u16)date_val[4]);

सामान्य_बफ़[लेन+1] = 0;

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

}

शून्य मुख्य_विन_प्रोसेस_अलर्ट()

{

u8 मैं;

for(i=0;i

{

यदि(GET_ALERT_BIT(old_alert_val, i))

जारी रखना;

यदि(GET_ALERT_BIT(अलर्ट_वैल, i))

{

यदि(अलर्ट_नम>=ALERT_TABLE_LEN)

अलर्ट_नम = ALERT_TABLE_LEN-1;

अलर्ट_टेबल[अलर्ट_नम].desc = i+1;

स्प्रिंटफ(अलर्ट_टेबल[अलर्ट_नम].दिनांक, "%u/%u/%u %u:%u",

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

);

अलर्ट_नम++;

}

}

memcpy(old_alert_val, चेतावनी_val, sizeof(alert_val));

}

शून्य मुख्य_विन_डिस्प_अलर्ट()

{

यू16 मैं;

यू16 वैल;

यू16 लेन = 0;

आम_बफ़[0] = 0;

for(i=0;i

{

वैल = 0;

अगर मुझे

{

वैल = अलर्ट_टेबल.डेस्क;

लेन += स्प्रिंटफ(common_buf+len, "%s\r\n", अलर्ट_टेबल.डेट);

}

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

}

सामान्य_बफ़[लेन+1] = 0;

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

}

शून्य मुख्य_विन_इनिट()

{

फ्लोट फिक्स्ड_वैल;

u8 मैं;

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

for(i=0;i

{

अगर(मैं==0)

जारी रखना;

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

}

फिक्स्ड_वैल = मेन_विन_वैल[0]/WIND_SPEED_SCALE+FLOAT_FIX_VAL;

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

}

शून्य मुख्य_विन_क्लिक_हैंडलर(u16 btn_val)

{

u8 सूचकांक;

यदि(btn_val==0x0B)

{

main_win_disp_alert();

वापस करना;

}

सूचकांक = btn_val-1;

btn_sta[सूचकांक] = !btn_sta[सूचकांक];

यदि((सूचकांक==3)||(सूचकांक==7))

btn_sta[सूचकांक] = 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*index, (u8*)&btn_val, 1);

यदि(सूचकांक==9)

is_main_win = 0;

अन्यथा यदि((सूचकांक==3)||(सूचकांक==7))

{

जबकि(sys_get_touch_sta());

modbus_write_bit(btn_addr[index], 0x0000);

}

}

शून्य मुख्य_विन_msg_हैंडलर(u8 *msg,u16 msg_len)

{

u8 f_code = संदेश[MODBUS_RESPOND_POS_FUNC_CODE];

u8 data_len = संदेश[MODBUS_RESPOND_POS_DATA_LEN];

u8 मैं;

u8 ऑफसेट;

संदेश_लेन = संदेश_लेन;

यदि(!is_main_win)

वापस करना;

यदि((f_code==MODBUS_FUNC_CODE_03)&&(data_len==MAIN_WIN_VAL_MAX_NUM*2))

{

ऑफसेट = MODBUS_RESPOND_POS_DATA;

for(i=0;i

{

main_win_val = SYS_GET_U16(msg[ऑफ़सेट], संदेश[ऑफ़सेट+1]);

ऑफसेट += 2;

}

main_win_update();

}अन्यथा यदि((f_code==MODBUS_FUNC_CODE_01)&&(data_len==ALERT_BYTE_NUM))

{

ऑफसेट = MODBUS_RESPOND_POS_DATA;

for(i=0;i

{

अलर्ट_वैल = संदेश[ऑफ़सेट];

ऑफसेट++;

}

main_win_process_alert();

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

{

ऑफसेट = MODBUS_RESPOND_POS_DATA;

for(i=0;i

{

temp_hum_val = SYS_GET_U16(msg[ऑफ़सेट], संदेश[ऑफ़सेट+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;

for(i=0;i

{

दिनांक_वैल = SYS_GET_U16(संदेश[ऑफ़सेट], संदेश[ऑफ़सेट+1]);

ऑफसेट += 2;

}

main_win_disp_date();

}

}

शून्य मुख्य_विन_रीड_टेम्प_हम()

{

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;//वापस लाएँ

}

शून्य मुख्य_विन_हैंडलर()

{

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

यदि(is_main_win)

{

यदि(अलर्ट_रीड_अवधि==ALERT_READ_PERIOD)

{

अलर्ट_रीड_अवधि = 0;

modbus_read_bits(510, ALERT_BIT_MAX_NUM);

वापस करना;

}

यदि(दिनांक_अद्यतन_अवधि==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 को परिभाषित करें_शामिल करें "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 पैकेट;

शून्य modbus_init()

{

UART_INIT(UART_BAUD);

}

शून्य modbus_send_bytes(u8 *बाइट्स,u16 len)

{

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

}

शून्य modbus_recv_byte(u8 बाइट)

{

यदि(is_modbus_recv_complete)

वापस करना;

यदि(modbus_recv_len

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

}

शून्य modbus_check_recv_timeout()

{

यदि(modbus_recv_timeout)

{

modbus_recv_timeout--;

यदि(modbus_recv_timeout==0)

{

is_modbus_recv_complete = 1;

}

}

}

u8 modbus_send_packet(u8 *पैकेट)

{

यू16 लेन;

यू16 सीआरसी;

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

जबकि(modbus_send_interval);

यदि(func_code==MODBUS_FUNC_CODE_10)

{

((MODBUS_10_PACKET*)पैकेट)->बाइट_नम = ((MODBUS_10_PACKET*)पैकेट)->वर्ड_नम*2;

लेन = 9+((MODBUS_10_PACKET*)पैकेट)->byte_num;

}अन्यथा यदि(func_code==MODBUS_FUNC_CODE_0F)

{

लेन = ((MODBUS_0F_PACKET*)पैकेट)->bit_num;

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

लेन = 9+((MODBUS_0F_PACKET*)पैकेट)->byte_num;

}अन्य

{

लेन = आकार(MODBUS_PACKET);

}

सीआरसी = सीआरसी16(पैकेट,लेन-2);

पैकेट[लेन-2] = (u8)(crc>>8);

पैकेट[लेन-1] = (यू8)सीआरसी;

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

modbus_send_interval = MODBUS_SEND_INTERVAL;

वापसी 0;//सफलता

}

बाहरी शून्य modbus_msg_handler(u8 *msg,u16 msg_len);

शून्य modbus_हैंडलर()

{

यू16 सीआरसी;

यदि(!is_modbus_recv_complete)

वापस करना;

// सीआरसी मान जांचें

सीआरसी = ((u16)modbus_recv_buff[modbus_recv_len-2]<<8)+modbus_recv_buff[modbus_recv_len-1];

यदि(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)

{

पैकेट.slave_addr = SLAVE_ADDR;

पैकेट.func_code = fcode;//फंक्शन कोड

पैकेट.स्टार्ट_एड्र = पता;//पता

पैकेट.डेटा_लेन = लेन;//मूल्य लिखा गया है

लेन = modbus_send_packet((u8*)&packet);

वापसी लेन;

}