[Avatud lähtekoodiga]Intelligentne koolitusruum

2. Kasutajaliidese kujundus

1.C51 Disain

Peamised koodid andmete (nt temperatuur, niiskus ja kõrgus merepinnast) hankimiseks ja värskendamiseks põhiliideses ning modbus rtu kasutamine temperatuuri juhtimismoodulite, mootorite, häiretuvastuse ja muude alluvate masinate juhtimiseks on järgmised.

Peamise liidese koodi viide:

#include "main_win.h"

#include "modbus.h"

#include "sys_params.h"

#include "func_handler.h"

#include "uart2.h"

#kaasa

#kaasa

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

typedef struct{

tähe kuupäev[17];

u8 desc;

}ALERT;

#define ALERT_TABLE_LEN 20

staatiline u8 btn_sta[MAIN_WIN_BTN_MAX_NUM] = {0};

staatiline 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 häiretabel[ALERT_TABLE_LEN];

u16 märguande_arv = 0;

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

for(i=0;i

{

if(GET_ALERT_BIT(vana_alert_val, i))

jätkata;

if(GET_ALERT_BIT(alert_val, i))

{

if(alert_num>=ALERT_TABLE_LEN)

alarm_num = ALERT_TABLE_LEN-1;

häiretabel[häire_arv].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]

);

märguande_number++;

}

}

memcpy(vana_häire_val., häire_val., suurus(alert_val));

}

void main_win_disp_alert()

{

u16 i;

u16 val;

u16 len = 0;

common_buf[0] = 0;

for(i=0;i

{

val = 0;

kui ma

{

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

{

ujuki fikseeritud_valik;

u8 i;

on_peamine_võit = 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

{

if(i==0)

jätkata;

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

}

fikseeritud_väärtus = 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 indeks;

if(btn_val==0x0B)

{

main_win_disp_alert();

tagastamine;

}

indeks = btn_val-1;

btn_sta[indeks] = !btn_sta[indeks];

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

btn_sta[indeks] = 1;

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

btn_val = btn_sta[indeks];

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

if(indeks==9)

on_peamine_võit = 0;

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

{

while(sys_get_touch_sta());

modbus_write_bit(btn_addr[indeks], 0x0000);

}

}

void main_win_msg_handler(u8 *msg,u16 msg_len)

{

u8 f_kood = msg[MODBUS_RESPOND_POS_FUNC_CODE];

u8 data_len = msg[MODBUS_RESPOND_POS_DATA_LEN];

u8 i;

u8 nihe;

msg_len = msg_len;

if(!on_main_win)

tagastamine;

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

{

nihe = MODBUS_RESPOND_POS_DATA;

for(i=0;i

{

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

nihe += 2;

}

main_win_update();

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

{

nihe = MODBUS_RESPOND_POS_DATA;

for(i=0;i

{

alert_val = msg[nihe];

nihe++;

}

main_win_process_alert();

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

{

nihe = MODBUS_RESPOND_POS_DATA;

for(i=0;i

{

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

nihe += 2;

modbus_write_word(5+i, temp_hum_val);

}

main_win_update();

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

{

nihe = MODBUS_RESPOND_POS_DATA;

for(i=0;i

{

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

nihe += 2;

}

main_win_disp_date();

}

}

void main_win_read_temp_hum()

{

u8 vana_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;//Taasta

}

void main_win_handler()

{

staatiline u8 lipp = 0;

if(on_main_win)

{

if(alert_read_period==ALERT_READ_PERIOD)

{

märguande_lugemisperiood = 0;

modbus_read_bits(510, ALERT_BIT_MAX_NUM);

tagastamine;

}

if(date_update_period==DATE_UPDATE_PERIOD)

{

kuupäev_värskenduse_periood = 0;

modbus_read_words(180, MAIN_WIN_DATE_MAX_NUM);

tagastamine;

}

lipp = !lipp;

kui (lipp)

modbus_read_words(0, MAIN_WIN_VAL_MAX_NUM);

muidu

main_win_read_temp_hum();

}

}

modbus RTU koodi viide:

#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

staatiline bitt on_modbus_recv_complete = 0;

staatiline u8 modbus_recv_buff[270];

static u16 modbus_recv_len = 0;//Aktsepteeritud baitide kogupikkus

static u8 modbus_recv_timeout = 0;//Accept overflow time

staatiline lenduv u16 modbus_send_interval = 0;

pakett MODBUS_PACKET;

void modbus_init()

{

UART_INIT(UART_BAUD);

}

void modbus_send_bytes(u8 *baiti,u16 len)

{

UART_SEND_BYTES(baiti,len);

}

void modbus_recv_byte(u8 bait)

{

if(on_modbus_recv_complete)

tagastamine;

if(modbus_recv_len

modbus_recv_buff[modbus_recv_len++] = bait;

}

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 *pakett)

{

u16 len;

u16 crc;

u8 func_code = pakett[1];

while(modbus_send_interval);

if(func_code==MODBUS_FUNC_CODE_10)

{

((MODBUS_10_PACKET*)pakett)->baidi_arv = ((MODBUS_10_PACKET*)pakett)->sõna_arv*2;

len = 9+((MODBUS_10_PACKET*)pakett)->baidi_arv;

}else if(func_code==MODBUS_FUNC_CODE_0F)

{

len = ((MODBUS_0F_PACKET*)pakett)->biti_arv;

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

len = 9+((MODBUS_0F_PACKET*)pakett)->baidi_arv;

}muu

{

len = suurus(MODBUS_PAKET);

}

crc = crc16(pakett,len-2);

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

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

modbus_send_bytes(pakett,len);

modbus_send_interval = MODBUS_SEND_INTERVAL;

tagasta 0;//Edu

}

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

void modbus_handler()

{

u16 crc;

if(!is_modbus_recv_complete)

tagastamine;

//Kontrollige crc väärtust

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 = fkood;//Funktsioonikood

packet.start_addr = adr;//Aadress

packet.data_len = len;//Väärtus kirjutatud

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

tagasi len;

}