[עפֿן מקור] ינטעליגענט טראַינינג רום

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(וואַל, פּאָס) ((וואַל[פּאָס/8]>>(פּאָס% 8))&0קס01)

typedef struct{

char date[17];

ו8 דיסק;

} ALERT;

#define ALERT_TABLE_LEN 20

סטאַטיק ו8 בטנ_סטאַ [MAIN_WIN_BTN_MAX_NUM] = {0};

סטאַטיק ו8 בטנ_אַדדר[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];

ו16 temp_hum_val[TEMP_HUM_VAL_MAX_NUM] = {0};

ו16 דאַטע_וואַל [MAIN_WIN_DATE_MAX_NUM] = {0};

u8 alert_val[ALERT_BYTE_NUM] = {0};

ו8 old_alert_val[ALERT_BYTE_NUM] = {0};

ALERT alert_table[ALERT_TABLE_LEN];

ו16 אַלערט_נום = 0;

ביסל איז_מאַין_ווין = 0;

void main_win_update ()

{

}

void main_win_disp_date()

{

ו8 לן;

len = sprintf(common_buf, "% ו:% ו", (u16)date_val[3], (u16)date_val[4]);

פּראָסט_בוף[לענ+1] = 0;

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

}

void main_win_process_alert()

{

ו8 איך;

פֿאַר (איך=0; איך

{

אויב (GET_ALERT_BIT (אַלט_אַלערט_וואַל, איך))

פאָרזעצן;

אויב (GET_ALERT_BIT (אַלערט_וואַל, איך))

{

if (alert_num>=ALERT_TABLE_LEN)

אַלערט_נום = ALERT_TABLE_LEN-1;

אַלערט_טאַבלע [אַלערט_נום].דעסק = איך+1;

sprintf(alert_table[alert_num].date, "%u/%u/%u%u:%u",

דאַטע_וואַל[0], דאַטע_וואַל[1], דאַטע_וואַל[2], דאַטע_וואַל[3], דאַטע_וואַל[4]

);

alert_num++;

}

}

memcpy (אַלט_אַלערט_וואַל, אַלערט_וואַל, גרייס פון (אַלערט_וואַל));

}

void main_win_disp_alert()

{

ו16 איך;

u16 val;

ו16 לן = 0;

פּראָסט_בוף [קסנומקס] = קסנומקס;

פֿאַר (איך=0; איך

{

וואַל = 0;

אויב איך

{

וואַל = אַלערט_טאַבלע.דעסק;

len += sprintf (common_buf+len, "%s\r\n", alert_table.date);

}

sys_write_vp (ALERT_WIN_DESC_START_VP+i, (u8*)&וואַל, 1);

}

פּראָסט_בוף[לענ+1] = 0;

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

}

void main_win_init()

{

לאָזנ שווימען פאַרפעסטיקט_וואַל;

ו8 איך;

איז_מיין_ווין = 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);

פֿאַר (איך=0; איך

{

אויב (איך==0)

פאָרזעצן;

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

}

פאַרפעסטיקט_וואַל = הויפּט_ווין_וואַל[0]/ווינד_ספּעעד_סקאַלע + FLOAT_FIX_VAL;

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

}

void main_win_click_handler (u16 btn_val)

{

ו8 אינדעקס;

אויב (בטנ_וואַל==0קס0ב)

{

main_win_disp_alert();

צוריקקומען;

}

אינדעקס = בטנ_וואַל-1;

בטנ_סטאַ[אינדעקס] = !בטנ_סטאַ[אינדעקס];

אויב ((אינדעקס==3)||(אינדעקס==7))

בטנ_סטאַ [אינדעקס] = 1;

מאָדבוס_רייטע_ביט (בטנ_אַדדר [אינדעקס], בטנ_סטאַ [אינדעקס]? 0xFF00: 0x0000);

בטנ_וואַל = בטנ_סטאַ [אינדעקס];

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

אויב (אינדעקס==9)

איז_מיין_ווין = 0;

אַנדערש אויב ((אינדעקס==3)||(אינדעקס==7))

{

בשעת (סיס_געט_טאָוטש_סטאַ ());

modbus_write_bit (btn_addr [אינדעקס], 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];

ו8 איך;

ו8 פאָטאָ;

msg_len = msg_len;

אויב (!איז_מיין_ווין)

צוריקקומען;

אויב ((פ_קאָדע== MODBUS_FUNC_CODE_03)&&(דאַטאַ_לענ==MAIN_WIN_VAL_MAX_NUM*2))

{

פאָטאָ = MODBUS_RESPOND_POS_DATA;

פֿאַר (איך=0; איך

{

main_win_val = SYS_GET_U16(מסג[אָפסעט], מסג[אָפסעט+1]);

פאָטאָ += קסנומקס;

}

main_win_update ();

} אַנדערש אויב ((פ_קאָדע== MODBUS_FUNC_CODE_01)&&(דאַטאַ_לענ== ALERT_BYTE_NUM))

{

פאָטאָ = MODBUS_RESPOND_POS_DATA;

פֿאַר (איך=0; איך

{

אַלערט_וואַל = מסג [אָפסעט];

אָפסעט ++;

}

main_win_process_alert();

} אַנדערש אויב ((פ_קאָדע== MODBUS_FUNC_CODE_03)&&(דאַטאַ_לען==TEMP_HUM_VAL_MAX_NUM*2))

{

פאָטאָ = MODBUS_RESPOND_POS_DATA;

פֿאַר (איך=0; איך

{

temp_hum_val = SYS_GET_U16(מסג[אָפסעט], מסג[אָפסעט+1]);

פאָטאָ += קסנומקס;

modbus_write_word (5+i, temp_hum_val);

}

main_win_update ();

} אַנדערש אויב ((פ_קאָדע== MODBUS_FUNC_CODE_03)&&(דאַטן_לענ==MAIN_WIN_DATE_MAX_NUM*2))

{

פאָטאָ = MODBUS_RESPOND_POS_DATA;

פֿאַר (איך=0; איך

{

דאַטע_וואַל = SYS_GET_U16 (מסג [אָפסעט], מסג [אָפסעט+1]);

פאָטאָ += קסנומקס;

}

main_win_disp_date ();

}

}

void main_win_read_temp_hum()

{

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

{

סטאַטיק ו8 פאָן = 0;

אויב (איז_מיין_ווין)

{

if (alert_read_period==ALERT_READ_PERIOD)

{

אַלערט_רעד_פּעריאָד = 0;

modbus_read_bits (510, ALERT_BIT_MAX_NUM);

צוריקקומען;

}

אויב (דאַטע_ופּדאַטע_פּעריאָד ==דאַטע_ופּדאַטע_פּעריאָד)

{

דאַטע_ופּדאַטע_פּעריאָד = קסנומקס;

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"

#define UART_INCLUDE "uart2.h"

#define UART_INIT uart2_init

#define UART_SEND_BYTES uart2_send_bytes

# דעפינירן UART_BAUD 9600

# דעפינירן MODBUS_RECV_TIMEOUT (u8) (35000.0f/UART_BAUD+2)

# דעפינירן MODBUS_SEND_INTERVAL 150

# אַרייַננעמען UART_INCLUDE

סטאַטיק ביסל איז_מאָדבוס_רעקוו_קאָמפּלעטע = 0;

סטאַטיק u8 modbus_recv_buff[270];

סטאַטיק ו16 modbus_recv_len = 0;// גאַנץ לענג פון ביטעס אנגענומען

סטאַטיק ו8 מאָדבוס_רעקוו_טימעאָוט = 0; // אָננעמען אָוווערפלאָו צייט

סטאַטיק וואַלאַטאַל ו16 מאָדבוס_סענד_ינטערוואַל = 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 byte)

{

אויב (איז_מאָדבוס_רעקוו_קאָמפּלעטע)

צוריקקומען;

אויב (מאָדבוס_רעקוו_לען

מאָדבוס_רעקוו_באַף [מאָדבוס_רעקוו_לענ ++] = ביטע;

}

void modbus_check_recv_timeout ()

{

אויב (מאָדבוס_רעקוו_טימעאָוט)

{

modbus_recv_timeout--;

אויב (מאָדבוס_רעקוו_טימעאָוט ==0)

{

איז_מאָדבוס_רעקוו_קאָמפּלעטע = 1;

}

}

}

u8 modbus_send_packet (u8 * פּאַקאַט)

{

ו16 לן;

ו16 קרק;

u8 func_code = פּאַקאַט [1];

בשעת (מאָדבוס_סענד_ינטערוואַל);

אויב (פונק_קאָדע == MODBUS_FUNC_CODE_10)

{

((מאָדבוס_10_פּאַקקעט *) פּאַקאַט)->בייט_נום = ((מאָדבוס_10_פּאַקקעט *) פּאַקאַט) -> וואָרט_נום * 2;

len = 9+((מאָדבוס_10_פּאַקקעט*) פּאַקאַט)->בייט_נום;

} אַנדערש אויב (פונק_קאָדע == MODBUS_FUNC_CODE_0F)

{

len = ((MODBUS_0F_PACKET*) פּאַקאַט)->ביט_נום;

((MODBUS_0F_PACKET*) פּאַקאַט)->ביטע_נום = len/8+(len%8?1:0);

len = 9+((MODBUS_0F_PACKET*) פּאַקאַט)->ביטע_נום;

} אַנדערש

{

len = sizeof(MODBUS_PACKET);

}

קרק = קרק16 (פּאַקקעט, לענ-2);

פּאַקאַט[len-2] = (ו8)(קרק>>8);

פּאַקאַט[len-1] = (ו8)קרק;

מאָדבוס_סענד_ביטעס (פּאַקקעט, לען);

מאָדבוס_סענד_ינטערוואַל = מאָדבוס_סענד_ינטערוואַל;

צוריקקומען 0;// הצלחה

}

עקסטערן פּאָסל מאָדבוס_מסג_האַנדלער (ו8 *מסג,ו16 מסג_לען);

void modbus_handler ()

{

ו16 קרק;

אויב (!איז_מאָדבוס_רעקוו_קאָמפּלעטע)

צוריקקומען;

// טשעק קרק ווערט

קרק = ((ו16)מאָדבוס_רעקוו_באַף[מאָדבוס_רעקוו_לענ-2]<<8)+מאָדבוס_רעקוו_באַף[מאָדבוס_רעקוו_לענ-1];

אויב (קרק16 (מאָדבוס_רעקוו_באַף, מאָדבוס_רעקוו_לענ-2) = = קרק)

{

מאָדבוס_מסג_האַנדלער (מאָדבוס_רעקוו_באַף, מאָדבוס_רעקוו_לען);

}

מאָדבוס_רעקוו_לען = 0;

איז_מאָדבוס_רעקוו_קאָמפּלעטע = 0;

}

u8 modbus_send_fcode (u8 fcode, u16 adr, u16 len)

{

פּאַקעט.סלאַוו_אַדדר = סלאַווע_אַדדר;

packet.func_code = fcode;// פֿונקציע קאָד

פּאַקעט.סטאַרט_אַדדר = אַדר;// אַדרעס

packet.data_len = len;// ווערט געשריבן

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

צוריקקומען לן;

}