[Atvērtā koda] Inteliģentā apmācības telpa

2. UI dizains

1.C51 Dizains

Galvenie kodi tādu datu kā temperatūras, mitruma un augstuma iegūšanai un atjaunināšanai galvenajā interfeisā un modbus rtu izmantošanai, lai kontrolētu temperatūras kontroles moduļus, motorus, trauksmes detektorus un citas vergu mašīnas, ir šādi.

Galvenā interfeisa koda atsauce:

#include "main_win.h"

#include "modbus.h"

#include "sys_params.h"

#include "func_handler.h"

#include "uart2.h"

#iekļauts

#iekļauts

#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, poz) ((val[pos/8]>>(pos%8))&0x01)

typedef struct{

rakstzīmju datums[17];

u8 desc;

}BRĪDINĀJUMS;

#define ALERT_TABLE_LEN 20

static u8 btn_sta[MAIN_WIN_BTN_MAX_NUM] = {0};

statisks 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 brīdinājuma_numurs = 0;

bits ir_galvenais_uzvars = 0;

spēkā neesošs galvenais_win_update()

{

}

spēkā neesošs 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 i;

for(i=0;i

{

if(GET_ALERT_BIT(vecais_brīdinājuma_val., i))

Turpināt;

if(GET_ALERT_BIT(brīdinājuma_val., i))

{

if(brīdinājuma_numurs>=ALERT_TABLE_LEN)

brīdinājuma_numurs = ALERT_TABLE_LEN-1;

brīdinājuma_tabula[trauksmes_numurs].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]

);

brīdinājuma_numurs++;

}

}

memcpy(old_brīdinājuma_val., brīdinājuma_val., izmērs(brīdinājuma_val.));

}

spēkā neesošs main_win_disp_alert()

{

u16 i;

u16 val;

u16 len = 0;

common_buf[0] = 0;

for(i=0;i

{

val = 0;

ja (i

{

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

}

spēkā neesošs main_win_init()

{

pludiņš fiksēts_val.;

u8 i;

ir_galvenais_uzvars = 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

{

ja(i==0)

Turpināt;

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

}

fiksētais_valūts = galvenais_uzvaras_vērtums[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 indekss;

if(btn_val==0x0B)

{

main_win_disp_alert();

atgriešanās;

}

indekss = btn_val-1;

btn_sta[indekss] = !btn_sta[indekss];

if((indeks==3)||(indeks==7))

btn_sta[indekss] = 1;

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

btn_val = btn_sta[indekss];

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

if(indekss==9)

ir_galvenais_uzvars = 0;

cits if((indeks==3)||(indeks==7))

{

while(sys_get_touch_sta());

modbus_write_bit(btn_addr[indekss], 0x0000);

}

}

void main_win_msg_handler(u8 *msg,u16 msg_len)

{

u8 f_kods = msg[MODBUS_RESPOND_POS_FUNC_CODE];

u8 data_len = msg[MODBUS_RESPOND_POS_DATA_LEN];

u8 i;

u8 nobīde;

msg_len = msg_len;

if(!is_main_win)

atgriešanās;

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

{

nobīde = MODBUS_RESPOND_POS_DATA;

for(i=0;i

{

main_win_val = SYS_GET_U16(msg[nobīde], msg[nobīde+1]);

nobīde += 2;

}

galvenais_win_update();

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

{

nobīde = MODBUS_RESPOND_POS_DATA;

for(i=0;i

{

alert_val = msg[nobīde];

nobīde++;

}

main_win_process_alert();

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

{

nobīde = MODBUS_RESPOND_POS_DATA;

for(i=0;i

{

temp_hum_val = SYS_GET_U16(msg[nobīde], msg[nobīde+1]);

nobīde += 2;

modbus_write_word(5+i, temp_hum_val);

}

galvenais_win_update();

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

{

nobīde = MODBUS_RESPOND_POS_DATA;

for(i=0;i

{

date_val = SYS_GET_U16(msg[nobīde], msg[nobīde+1]);

nobīde += 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;//Atgriezt

}

Void main_win_handler()

{

statiskais u8 karogs = 0;

ja(ir_galvenais_uzvars)

{

if(brīdinājuma_lasīšanas_periods==ALERT_READ_PERIOD)

{

brīdinājuma_lasīšanas_periods = 0;

modbus_read_bits(510, ALERT_BIT_MAX_NUM);

atgriešanās;

}

if(date_update_period==DATE_UPDATE_PERIOD)

{

datuma_atjaunināšanas_periods = 0;

modbus_lasīti_vārdi (180, MAIN_WIN_DATE_MAX_NUM);

atgriešanās;

}

karogs = !karogs;

ja (karogs)

modbus_read_words(0, MAIN_WIN_VAL_MAX_NUM);

cits

main_win_read_temp_hum();

}

}

modbus RTU koda atsauce:

#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_baiti

#define UART_BAUD 9600

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

#define MODBUS_SEND_INTERVAL 150

#include UART_INCLUDE

statiskais bits ir_modbus_recv_complete = 0;

statisks u8 modbus_recv_buff[270];

static u16 modbus_recv_len = 0;//Pieņemts kopējais baitu garums

static u8 modbus_recv_timeout = 0;//Pieņemt pārpildes laiku

statiski gaistošs u16 modbus_send_interval = 0;

MODBUS_PACKET pakete;

nevar modbus_init()

{

UART_INIT(UART_BAUD);

}

void modbus_send_bytes(u8 *baiti,u16 len)

{

UART_SEND_BYTES(baiti,len);

}

nevar modbus_recv_byte(u8 baits)

{

if(ir_modbus_recv_complete)

atgriešanās;

if(modbus_recv_len

modbus_recv_buff[modbus_recv_len++] = baits;

}

nevar 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 *pakete)

{

u16 len;

u16 crc;

u8 func_code = pakete[1];

while(modbus_send_interval);

if(funkcijas_kods==MODBUS_FUNC_CODE_10)

{

((MODBUS_10_PAKETA*)pakete)->baitu_numurs = ((MODBUS_10_PAKETA*)pakete)->vārda_numurs*2;

len = 9+((MODBUS_10_PAKETA*)pakete)->baitu_numurs;

}else if(func_code==MODBUS_FUNC_CODE_0F)

{

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

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

len = 9+((MODBUS_0F_PACKET*)pakete)->baitu_numurs;

}cits

{

len = izmērs(MODBUS_PAKETE);

}

crc = crc16(pakete,len-2);

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

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

modbus_send_bytes(pakete,len);

modbus_send_interval = MODBUS_SEND_INTERVAL;

atgriezt 0;//Veiksme

}

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

nevar modbus_handler()

{

u16 crc;

if(!is_modbus_recv_complete)

atgriešanās;

//Pārbaudiet crc vērtību

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 adr, u16 len)

{

packet.slave_addr = SLAVE_ADDR;

packet.func_code = fkods;//Funkcijas kods

packet.start_addr = adr;//Adrese

packet.data_len = len;//Uzrakstīta vērtība

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

atgriezties len;

}