protocol.c

小区巡检系统,MSPF437,里面主要参考的内容为TI单片机的低功耗处理,仅供参考,不能用于商业.

#include "protocol.h"
#include "uart.h"
#include "pub_func.h"
#include "sys_time.h"
#include "storage.h"
#include "data_flash.h"
#include "sys_event.h"
#include "string.h"
#include "rf256_drv.h"
#include "sys_card.h"

/* get patrol's id
* req: 0xA1+CSUM = 2 bytes
* resp:
*     right----0xE5+patrol id(4 bytes)+CSUM = 6 bytes
*     wrong----0xEA+patrol id(4 bytes)+CSUM+CSUM = 7 bytes
*/
unsigned char _slvs_read_patrol_id(void)
{
    return (COMM_LOAD_DATA);
}

/* count of records
* req: 0xA2+CSUM = 2 bytes
* resp: 
*     right----0xE5+record count(4 bytes)+CSUM = 6 bytes
*     wrong----0xEA+record count(4 bytes)+CSUM+CSUM = 7 bytes
*/
unsigned char _slvs_read_record_count(void)
{
    unsigned long cnt[3];
    unsigned char rc;

    rc=load_record_count(cnt);
    cnt[0]=Hex2BcdLong(cnt[0]);
    memcpy((unsigned char *)&_frm_buf.buffer[1],(unsigned char *)&cnt[0],LEN_RECORD_CNT);
    
    if(rc==OK)
    {
        return (COMM_SEND_RIGHT_RESP);
    }
    else
    {
        _data_flash_read(ADDR_RECORD_CNT+LEN_RECORD_CNT,(unsigned char *)&_frm_buf.buffer[5],OFFSET_CHKSUM);
        return (COMM_SEND_WRONG_RESP);
    }
}

/* count of records
* req: 0xA3+CSUM = 2 bytes
* resp: 
*     right----0xE5+record count(4 bytes)+CSUM = 6 bytes
*     wrong----0xEA+record count(4 bytes)+CSUM+CSUM = 7 bytes
*/
unsigned char _slvs_read_new_record_count(void)
{
    unsigned long cnt[3];
    unsigned char rc;

    rc=load_record_count(cnt);
    cnt[1]=Hex2BcdLong(cnt[1]);
    memcpy((unsigned char *)&_frm_buf.buffer[1],(unsigned char *)&cnt[1],LEN_RECORD_CNT);
    
    if(rc==OK)
    {
        return (COMM_SEND_RIGHT_RESP);
    }
    else
    {
        _data_flash_read(ADDR_NEW_RECORD_CNT+LEN_RECORD_CNT,(unsigned char *)&_frm_buf.buffer[5],OFFSET_CHKSUM);
        return (COMM_SEND_WRONG_RESP);
    }
}

/* read record
* req: 0xA4+record id(4 bytes)+CSUM = 6 bytes
* resp: 
*     right----0xE5+person id(4 bytes)+line number(2 byte)+type(1 byte)+card id(4 bytes)+time(7 bytes)+state(1 byte)+CSUM = 21 bytes
*     wrong----0xEA+real data in flash(19 bytes)+CSUM+CSUM = 22 bytes
*/
unsigned char _slvs_read_record(void)
{
    unsigned long addr,record_id;

    // get record id
    memcpy((unsigned char *)&record_id,(unsigned char *)&_frm_buf.buffer[1],4);
    record_id=Bcd2HexLong(record_id);
    record_id%=MAX_RECORD_COUNT;
    // get record address
    addr=ADDR_RECORD+record_id*(LEN_RECORD+OFFSET_CHKSUM);
    // read record
    if(_load_data(addr,(unsigned char *)&_frm_buf.buffer[1],LEN_RECORD)==OK)
    {
        // right response
        return (COMM_SEND_RIGHT_RESP);
    }
    else
    {
        _data_flash_read(addr+LEN_RECORD,(unsigned char *)&_frm_buf.buffer[19],OFFSET_CHKSUM);
        // wrong response
        return (COMM_SEND_WRONG_RESP);
    }
}

/* get patrol's id
* req: 0xC1+patrol id(4 bytes)+CSUM = 6 bytes
* resp: 
*     right----0xE5+CSUM = 2 bytes
*     wrong----0xEACSUM = 2 bytes
*/
unsigned char _slvs_write_patrol_id(void)
{
    return (COMM_SAVE_DATA);
}

/* count of records
* req: 0xC2+record count(4 bytes)+CSUM = 6 bytes
* resp: 
*     right----0xE5+CSUM = 2 bytes
*     wrong----0xEACSUM = 2 bytes
*/
unsigned char _slvs_write_record_count(void)
{
    memcpy((unsigned char *)&_record_cnt[0],(unsigned char *)&_frm_buf.buffer[1],4);
    _record_cnt[0]=Bcd2HexLong(_record_cnt[0]);
    _record_cnt[2]=_record_cnt[0]+_record_cnt[1];
    if(save_record_count(SAVE_RECORD_COUNT)==OK)
    {
        return (COMM_SEND_RIGHT_RESP);
    }
    else
    {
        return (COMM_SEND_WRONG_RESP);
    }
}

/* count of records
* req: 0xC3+record count(4 bytes)+CSUM = 6 bytes
* resp: 
*     right----0xE5+CSUM = 2 bytes
*     wrong----0xEACSUM = 2 bytes
*/
unsigned char _slvs_write_new_record_count(void)
{
    memcpy((unsigned char *)&_record_cnt[1],(unsigned char *)&_frm_buf.buffer[1],4);
    _record_cnt[1]=Bcd2HexLong(_record_cnt[1]);
    _record_cnt[2]=_record_cnt[0]+_record_cnt[1];
    if(save_record_count(SAVE_NEW_RECORD_COUNT)==OK)
    {
        return (COMM_SEND_RIGHT_RESP);
    }
    else
    {
        return (COMM_SEND_WRONG_RESP);
    }
}

/* set patrol's system time
* req: 0xD1+time(3 bytes,ssmmhh)+week(1 byte)+date(3 bytes,ddmmyy)+CSUM = 9 bytes
*     right----0xE5+CSUM = 2 bytes
*     wrong----0xEACSUM = 2 bytes
*/
unsigned char _slvs_set_sys_time(void)
{
    // set time
    _set_sys_time_hex(&_frm_buf.buffer[1]);
    // right response
    return (COMM_SEND_RIGHT_RESP);
}

/* get patrol's system time
* req: 0xB1+CSUM = 2 bytes
* resp: 0xE5+time(3 bytes,ssmmhh)+week(1 byte)+date(3 bytes,ddmmyy)+CSUM = 9 bytes
*/
unsigned char _slvs_get_sys_time(void)
{
    // get time
    _get_sys_time_bcd(&_frm_buf.buffer[1]);
    // right response
    return (COMM_SEND_RIGHT_RESP);
}

/* Get version
* req: 0xB2+CSUM = 2 bytes
* resp: 0xE5+distribute date(3 bytes,ddmmyy)+version(2 bytes)+CSUM = 7 bytes
*/
unsigned char _slvs_get_version(void)
{
    // distribute date(04-11-14)
    _frm_buf.buffer[1]=0x14;
    _frm_buf.buffer[2]=0x11;
    _frm_buf.buffer[3]=0x04;
    // version(1.0)
    _frm_buf.buffer[4]=0x00;
    _frm_buf.buffer[5]=0x01;
    // right response
    return (COMM_SEND_RIGHT_RESP);
}

/* Read RF card
* req: 0xB3+CSUM = 2 bytes
* resp: 
*     right----0xE5+card data(4 bytes)+CSUM = 6 bytes
*     wrong----0xEA+card data(4 bytes)+CSUM = 6 bytes
*/
unsigned char _slvs_read_rfcard(void)
{
    long cd_buf=0;
    unsigned char rc;
    
    rc=_card_read(&cd_buf);
    memcpy(&_frm_buf.buffer[1],(unsigned char *)&cd_buf,4);
    if(rc!=ERROR)
    {
        return (COMM_SEND_RIGHT_RESP);
    }
    return (COMM_SEND_WRONG_RESP);
}

#ifdef _RF_WRITE
/* Write RF card
* req: 0xD3+card data(8 bytes)+CSUM = 10 bytes
* resp: 
*     right----0xE5+CSUM = 2 bytes
*     wrong----0xEACSUM = 2 bytes
*/
unsigned char _slvs_write_rfcard(void)
{
    rf_on();
    _delay(0x1FFF);
    if(_card_read()==OK)
    {
        // read powerup data
        if(rf_writepage((char *)&_frm_buf.buffer[1],0)==OK)
        {
            // read page 1
            if(rf_writepage((char *)&_frm_buf.buffer[5],1)==OK)
            {
                rf_off();
                // right response
                return (COMM_SEND_RIGHT_RESP);
            }
        }
    }
    rf_off();
    return (COMM_SEND_WRONG_RESP);
}
#endif

/* Get version
* req: 0xD4+CSUM = 2 bytes
* resp: 
*     right----0xE5+CSUM = 2 bytes
*/
unsigned char _slvs_card_proc(void)
{
    _sys_evt_add(SYS_EVT_CARD);
    return (COMM_SEND_RIGHT_RESP);
}

// request frame lenth
const unsigned char _slvs_req_frm_len[]=
{
    2,2,2,6,6,6,6,9,2,2,2
#ifdef _RF_WRITE
    ,2
#endif
    ,2
};

// response frame lenth
const unsigned char _slvs_right_resp_len[]=
{
    6,6,6,21,2,2,2,2,9,7,6
#ifdef _RF_WRITE
    ,2
#endif
    ,2
};

// response frame lenth
const unsigned char _slvs_wrong_resp_len[]=
{
    7,7,7,22,2,2,2,2,9,7,6
#ifdef _RF_WRITE
    ,2
#endif
    ,2
};


// address
const unsigned char _slvs_resp_addr[]=
{
    ADDR_PATROL_ID,
    ADDR_RECORD_CNT,
    ADDR_NEW_RECORD_CNT,
    0,
    ADDR_PATROL_ID,
    ADDR_RECORD_CNT,
    ADDR_NEW_RECORD_CNT,
    0,
    0,
    0,
    0,
#ifdef _RF_WRITE
    0,
#endif
    0,
};

// commands
const unsigned char _slvs_cmd[]=
{
    CMD_READ_PATROL_ID,
    CMD_READ_RECORD_CNT,
    CMD_READ_NEW_RECORD_CNT,
    CMD_READ_RECORD,
    CMD_WRITE_PATROL_ID,
    CMD_WRITE_RECORD_CNT,
    CMD_WRITE_NEW_RECORD_CNT,
    CMD_SET_SYS_TIME,
    CMD_GET_SYS_TIME,
    CMD_GET_VERSION,
    CMD_READ_RFCARD,
#ifdef _RF_WRITE
    CMD_WRITE_RFCARD,
#endif
    CMD_CARD_PROC,
};

// processes
const COMM_PROC_PTR _slvs_proc[]=
{
    _slvs_read_patrol_id,
    _slvs_read_record_count,
    _slvs_read_new_record_count,
    _slvs_read_record,
    _slvs_write_patrol_id,
    _slvs_write_record_count,
    _slvs_write_new_record_count,
    _slvs_set_sys_time,
    _slvs_get_sys_time,
    _slvs_get_version,
    _slvs_read_rfcard,
#ifdef _RF_WRITE
    _slvs_write_rfcard,
#endif
    _slvs_card_proc,
};

/* prase frame
*/
void parse_frame(void)
{
    unsigned long addr;
    unsigned char rc,item=_frm_buf.proc_id;

    // communication process
    rc=_slvs_proc[item]();
    addr=_slvs_resp_addr[item];
        
    if(rc&COMM_LOAD_DATA)
    {
        if(_load_data(addr,&_frm_buf.buffer[1],_slvs_right_resp_len[item]-2)==OK)
        {
            rc|=COMM_SEND_RIGHT_RESP;
        }
        else
        {
            addr+=(_slvs_right_resp_len[item]-2);
            _data_flash_read(addr,&_frm_buf.buffer[_slvs_right_resp_len[item]-1],1);
            rc|=COMM_SEND_WRONG_RESP;
        }
    }
      
    if(rc&COMM_SAVE_DATA)
    {
        if(_save_data(addr,&_frm_buf.buffer[1],_slvs_req_frm_len[item]-2)==OK)
        {
            rc|=COMM_SEND_RIGHT_RESP;
        }
        else
        {
            rc|=COMM_SEND_WRONG_RESP;
        }
    }
    
    if(rc&COMM_SEND_RIGHT_RESP)
    {
        // right response
        _frm_buf.buffer[FRM_CMD]=CMD_RIGNT_RESP;
#ifndef TEST_UART
        _disable_interrupt();
        _frm_buf.len=_slvs_right_resp_len[item];
        _enable_interrupt();
#endif
    }
    else
    {
        // wrong response
        _frm_buf.buffer[FRM_CMD]=CMD_WRONG_RESP;
#ifndef TEST_UART
        _disable_interrupt();
        _frm_buf.len=_slvs_wrong_resp_len[item];
        _enable_interrupt();
#endif
    }

    if(!(rc&COMM_NO_RESP))
    {
        _disable_interrupt();
        _frm_ptr=0;
        _enable_interrupt();
        _frm_buf.buffer[_frm_buf.len-1]=sys_do_checksum((unsigned char *)&_frm_buf.buffer[0],_frm_buf.len-1);
        // send response
        uart_start_to_tx();
    }
    
    // uart rx
    _disable_interrupt();
    _frm_ptr=0;
    _enable_interrupt();
    uart_start_to_rx();
}