[ମୁକ୍ତ ଉତ୍ସ] ବୁଦ୍ଧିଜୀବୀ ତାଲିମ କକ୍ଷ |

2.UI ଡିଜାଇନ୍ |

1.C51 ଡିଜାଇନ୍ |

ମୂଖ୍ୟ ଇଣ୍ଟରଫେସରେ ତାପମାତ୍ରା, ଆର୍ଦ୍ରତା, ଏବଂ ଉଚ୍ଚତା ଭଳି ତଥ୍ୟ ହାସଲ ଏବଂ ଅଦ୍ୟତନ କରିବା ଏବଂ ତାପମାତ୍ରା ନିୟନ୍ତ୍ରଣ ମଡ୍ୟୁଲ୍, ମୋଟର, ଆଲାର୍ମ ଚିହ୍ନଟ ଏବଂ ଅନ୍ୟାନ୍ୟ ଦାସ ମେସିନ୍ ନିୟନ୍ତ୍ରଣ କରିବା ପାଇଁ ମୋଡବସ୍ rtu ବ୍ୟବହାର କରିବା ପାଇଁ ମୁଖ୍ୟ ସଂକେତଗୁଡ଼ିକ ନିମ୍ନଲିଖିତ ଅଟେ |

ମୁଖ୍ୟ ଇଣ୍ଟରଫେସ୍ କୋଡ୍ ରେଫରେନ୍ସ:

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

#define GET_ALERT_BIT (val, pos) ((val [pos / 8] >> (pos% 8)) ଏବଂ 0x01)

typedef struct {

ଚାର୍ ତାରିଖ [17];

u8 ତଳକୁ;

} ALERT;

# ନିର୍ଦ୍ଦିଷ୍ଟ 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 ତାରିଖ_ଭାଲ୍ [MAIN_WIN_DATE_MAX_NUM] = {0};

u8 alert_val [ALERT_BYTE_NUM] = {0};

u8 old_alert_val [ALERT_BYTE_NUM] = {0};

ALERT ଆଲର୍ଟ_ ଟେବୁଲ୍ [ALERT_TABLE_LEN];

u16 alert_num = 0;

ବିଟ୍ is_main_win = 0;

void main_win_update ()

{

}

ଶୂନ୍ୟ 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);

}

ଶୂନ୍ୟ main_win_process_alert ()

{

u8 i;

ପାଇଁ (i = 0; i

{

ଯଦି (GET_ALERT_BIT (ପୁରୁଣା_ ଆଲର୍ଟ_ଭାଲ୍, i))

ଜାରି ରଖ;

ଯଦି (GET_ALERT_BIT (ଆଲର୍ଟ_ଭାଲ୍, 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));

}

ଶୂନ୍ୟ main_win_disp_alert ()

{

u16 i;

u16 val;

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

{

ଫ୍ଲୋଟ୍ ସ୍ଥିର_ଭାଲ୍;

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 *) & ସ୍ଥିର_ଭାଲ୍, 2);

}

ଶୂନ୍ୟ main_win_click_handler (u16 btn_val)

{

u8 ସୂଚକାଙ୍କ;

ଯଦି (btn_val == 0x0B)

{

main_win_disp_alert ();

ଫେରସ୍ତ;

}

ସୂଚକାଙ୍କ = btn_val-1;

btn_sta [index] =! btn_sta [index];

if ((index == 3) || (index == 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 ();

}

}

ଶୂନ୍ୟ 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;

ଯଦି (is_main_win)

{

ଯଦି (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 rtu କୋଡ୍ ରେଫରେନ୍ସ:

# modbus.h ଅନ୍ତର୍ଭୂକ୍ତ କରନ୍ତୁ |

# crc16.h ଅନ୍ତର୍ଭୂକ୍ତ କରନ୍ତୁ |

# sys_params.h ଅନ୍ତର୍ଭୂକ୍ତ କରନ୍ତୁ |

#define 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];

static u16 modbus_recv_len = 0; // ବାଇଟ୍ ର ମୋଟ ଲମ୍ବ ଗ୍ରହଣ କରାଯାଇଛି |

static u8 modbus_recv_timeout = 0; // ଓଭରଫ୍ଲୋ ସମୟ ଗ୍ରହଣ କରନ୍ତୁ |

ଷ୍ଟାଟିକ୍ ଅସ୍ଥିର u16 modbus_send_interval = 0;

MODBUS_PACKET ପ୍ୟାକେଟ୍;

ଶୂନ୍ୟ modbus_init ()

{

UART_INIT (UART_BAUD);

}

ଶୂନ୍ୟ modbus_send_bytes (u8 * ବାଇଟ୍, u16 ଲେନ୍)

{

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 * ପ୍ୟାକେଟ୍)

{

u16 len;

u16 crc;

u8 func_code = ପ୍ୟାକେଟ୍ [1];

ଯେତେବେଳେ (modbus_send_interval);

ଯଦି (func_code == MODBUS_FUNC_CODE_10)

{

((MODBUS_10_PACKET *) ପ୍ୟାକେଟ୍) -> ବାଇଟ୍_ନମ୍ = ((MODBUS_10_PACKET *) ପ୍ୟାକେଟ୍) -> ଶବ୍ଦ_ନମ୍ * 2;

len = 9 + ((MODBUS_10_PACKET *) ପ୍ୟାକେଟ୍) -> ବାଇଟ୍_ନମ୍;

} ଅନ୍ୟଥା ଯଦି (func_code == MODBUS_FUNC_CODE_0F)

{

len = ((MODBUS_0F_PACKET *) ପ୍ୟାକେଟ୍) -> ବିଟ୍_ନମ୍;

((MODBUS_0F_PACKET *) ପ୍ୟାକେଟ୍) -> ବାଇଟ୍_ନମ୍ = ଲେନ୍ / 8 + (ଲେନ୍% 8? 1: 0);

len = 9 + ((MODBUS_0F_PACKET *) ପ୍ୟାକେଟ୍) -> ବାଇଟ୍_ନମ୍;

} ଅନ୍ୟ

{

len = sizeof (MODBUS_PACKET);

}

crc = crc16 (ପ୍ୟାକେଟ୍, ଲେନ୍ -2);

ପ୍ୟାକେଟ୍ [len-2] = (u8) (crc >> 8);

ପ୍ୟାକେଟ୍ [len-1] = (u8) crc;

modbus_send_bytes (ପ୍ୟାକେଟ୍, ଲେନ୍);

modbus_send_interval = MODBUS_SEND_INTERVAL;

ଫେରସ୍ତ 0; // ସଫଳତା |

}

ବାହ୍ୟ ଶୂନ୍ୟ modbus_msg_handler (u8 * msg, u16 msg_len);

ଶୂନ୍ୟ modbus_handler ()

{

u16 crc;

ଯଦି (! is_modbus_recv_complete)

ଫେରସ୍ତ;

// crc ମୂଲ୍ୟ ଯାଞ୍ଚ କରନ୍ତୁ |

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

{

packet.slave_addr = SLAVE_ADDR;

packet.func_code = fcode; // କାର୍ଯ୍ୟ କୋଡ୍ |

packet.start_addr = addr; // ଠିକଣା |

packet.data_len = len; // ମୂଲ୍ୟ ଲେଖାଯାଇଛି |

len = modbus_send_packet ((u8 *) & ପ୍ୟାକେଟ୍);

ଫେରସ୍ତ len;

}