sys_card.c

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

#include "sys_card.h"
#include "sys_event.h"
#include "rf256_drv.h"
#include "pub_func.h"
#include "indication.h"
#include "storage.h"
#include "data_flash.h"
#include "string.h"
#include "hal.h"
#include "indication.h"

typedef unsigned char (*CARD_PROC_PTR)(void);

//buffer of card data
long _sys_card_buf;
long _tmp_sys_card_buf;

#define CARD_PROC_MAX     (sizeof(_sys_card_proc) / sizeof(CARD_PROC_PTR))

#define _CARD_PROC(pos)  _sys_card_proc[pos]()

/* station card
   0001 XXXX XXXX XXXX XXXX XXXX RCCC CCCC = 32 bits
*/
unsigned char card_station(void)
{
    return(save_record());
}

/* person card
   0010 XXXX XXXX XXXX XXXX XXXX RCCC CCCC = 32 bits
*/
unsigned char card_person(void)
{
    unsigned char *ptr_card=(unsigned char *)&_tmp_sys_card_buf;
    unsigned char personid[4];

    if((_NewRecord.type==CARD_CMD_START_STATION)||(_NewRecord.type==CARD_CMD_STATION))
    {
        return ERROR;
    }
    
    //memcpy(personid,(unsigned char *)&ptr_card[1],4);
    personid[0]=(ptr_card[0]&0x0F)|(ptr_card[1]&0xF0);
    personid[1]=(ptr_card[1]&0x0F)|(ptr_card[2]&0xF0);
    personid[2]=(ptr_card[2]>>4)&0x0F;
    personid[3]=0;
    if(_save_data(ADDR_PERSON_ID,personid,LEN_PERSON_ID)==OK)
    {
        memcpy(_person_id,personid,4);
        _person_id[4]=sys_do_checksum(_person_id,LEN_PERSON_ID);
        return OK;
    }
    return ERROR;
}

/* line card
   0011 RRRR XXXX XXXX XXXX XXXX RCCC CCCC = 32 bits
*/
unsigned char card_line(void)
{
    unsigned char *ptr_card=(unsigned char *)&_tmp_sys_card_buf;
    unsigned short linenum;

    if((_NewRecord.type==CARD_CMD_START_STATION)||(_NewRecord.type==CARD_CMD_STATION))
    {
        return ERROR;
    }
    
    linenum=(ptr_card[1]<<8)|ptr_card[2];
    if(_save_data(ADDR_LINE_NUM,(unsigned char *)&linenum,LEN_LINE_NUM)==OK)
    {
        _line_num[0]=linenum;
        _line_num[1]=linenum;
        return OK;
    }
    return ERROR;
}

/* first station card
   0100 XXXX XXXX XXXX XXXX XXXX RCCC CCCC = 32 bits
*/
unsigned char card_start_station(void)
{
    return(save_record());
}

/* last station card
   0101 XXXX XXXX XXXX XXXX XXXX RCCC CCCC = 32 bits
*/
unsigned char card_stop_station(void)
{
    unsigned char temp[4];

    if(save_record()!=OK)
    {
        return ERROR;
    }
    temp[0]=0xFF;
    temp[1]=0xFF;
    temp[2]=0xFF;
    temp[3]=0xFF;
    if(_save_data(ADDR_LINE_NUM,temp,LEN_LINE_NUM)!=OK)
    {
        return ERROR;
    }
    if(_save_data(ADDR_PERSON_ID,temp,LEN_PERSON_ID)!=OK)
    {
        return ERROR;
    }
    _person_id[0]=0xFF;
    _person_id[1]=0xFF;
    _person_id[2]=0xFF;
    _person_id[3]=0xFF;
    _person_id[4]=0xFC;
    _line_num[0]=0xFFFF;
    _line_num[1]=0xFFFF;
    return OK;
}

/* event card
   0110 RRRR XXXX XXXX RRRR RRRR RCCC CCCC = 32 bits
*/
unsigned char card_event(void)
{
    unsigned long addr,id=_record_cnt[0];
    //_chk_record _record;
    unsigned char *ptr_card=(unsigned char *)&_tmp_sys_card_buf;
    
    addr=id+_record_cnt[1];
    if(addr==_record_cnt[2])
    {
        id=(id+MAX_RECORD_COUNT-1)%MAX_RECORD_COUNT;
        // get record address
        addr=ADDR_RECORD+id*(LEN_RECORD+OFFSET_CHKSUM);
        _NewRecord.station_state=ptr_card[1];
        if(_save_data(addr,(unsigned char *)&_NewRecord.person_id[0],LEN_RECORD)==OK)
        {
            return OK;
        }
    }
    return ERROR;
}

/* table of event handler
*/
const CARD_PROC_PTR _sys_card_proc[]=
{ 
    card_station,
    card_person,
    card_line,
    card_start_station,
    card_stop_station,
    card_event,
};

/* table of command
*/
const unsigned char _sys_card_cmd[]=
{ 
    CARD_CMD_STATION,
    CARD_CMD_PERSON,
    CARD_CMD_LINE,
    CARD_CMD_START_STATION,
    CARD_CMD_STOP_STATION,
    CARD_CMD_EVENT,
};

const unsigned char _sys_card_data_len[]=
{
    LEN_RECORD,
    LEN_PERSON_ID,
    LEN_LINE_NUM,
    LEN_RECORD,
    LEN_RECORD,
    1,
};

//#ifdef _RF_WRITE
void _card_swap(unsigned short *key)
{
    unsigned short key2;
        
    key2 = key[1];
    key[1] = (key[0] & 0xFF) | (key[1] & 0xFF00);
    key[0] = (key2 & 0xFF) | (key[0] & 0xFF00);
}

void _card_xor(unsigned short *key)
{
    key[0] ^= 0x0312;
    key[1] ^= 0x1225;
}

void _card_decrypt(unsigned short *key)
{
    _card_xor(key);
    _card_swap(key);
    
    key[0] = (key[0]<<11) |(key[0]>>5);
    key[1] = ((key[1]>>9)&0x1F)  | ((key[1]<<5)&0x3FE0)  | (key[1]&0xC000);
}

void _card_encrypt(unsigned short *key)
{
    key[0] = (key[0]<<5) |(key[0]>>11);
    key[1] = ((key[1]>>5)&0x1FF)  | ((key[1]<<9)&0x3E00)  | (key[1]&0xC000);
    
    _card_swap(key);
    _card_xor(key);
}
//#endif

#ifdef _RF_WRITE
/*write back a page
*/
int _card_write_back(int pos)
{
    long wlong;
    wlong = _sys_card_buf[pos];
    _card_encrypt((unsigned short *)&wlong);
    pos = rf_writepage((char *)&wlong, pos);

    return pos;
}
#endif

#ifdef _RF_WRITE
/* card generate password
*/
static void _card_gen_pass(unsigned short *key)
{
    unsigned short time = 32;
    unsigned short sum = 0x3720;

    while(time-->0)
    {
        key[0] -= ((key[1]<<4)+0x1225) ^ (key[1]+sum) ^ ((key[1]>>5) + 0x2500);
        key[1] -= ((key[0]<<4)+0x0003) ^ (key[0]+sum) ^ ((key[0]>>5) + 0x0312);
        sum -= 0x79b9;
    }

    key[1] &= 0x7FFF;
}
#endif

unsigned char _card_read(long *cd_buf)
{
    unsigned char *ptr_card=(unsigned char *)cd_buf;
    unsigned char flg=0,i,sum;
    
    // turn on and wait for power up
    rf_on();
    _delay(0xFF);
    // read powerup data
    rf_read_puf(cd_buf);
    rf_off();
    //*cd_buf=(*cd_buf)&0x7FFFFFFF;

HOHO:
    if(flg==1)
    {
        //if((ptr_card[0]>>1)&0x70==0x70)
        //{
            *cd_buf>>=1;
        //}
        //else
        //{
            //return ERROR;
        //}
    }
    _tmp_sys_card_buf=*cd_buf&0x7FFFFFFF;

    sum=0;
    for(i=0;i<3;i++)
    {
        sum+=ptr_card[i];
    }
    sum=(~sum)&0x7F;
    i=ptr_card[3]&0x7F;
    //if(sys_do_checksum((unsigned char *)&ptr_card[0],6)==ptr_card[6])
    if(sum==i)
    {
        if(_sys_card_buf==*cd_buf)
        {
            return ALARM;
        }
        return OK;
    }
    if(flg)
    {
        return ERROR;
    }
    else
    {
        flg=1;
        goto HOHO;
    }
}

/*process card data
* unused(1)+type(4)+data(20)+csum(7)
*/
void card_proc(void)
{
    long cd_buf=0;
    unsigned char item;
    unsigned char *ptr_card=(unsigned char *)&cd_buf;

    if(_card_read(&cd_buf)==OK)
    {
        //if(sys_do_checksum(ptr_card,7)==ptr_card[7])
        {
            item=find_item(_sys_card_cmd,ptr_card[0]>>4);
        
            if(item!=ERROR)
            {
                _tmp_sys_card_buf=cd_buf;
                if(_sys_card_proc[item]()==OK)
                {
                    _sys_card_buf=cd_buf;
                    IND_ON();
                    _delay(0x1FFF);
                    IND_OFF();
                    return;
                }
            }
        }
    }
}