system.c.bak

mifarea卡程序mifarea卡程序mifarea卡程序

/****************************************
 * system.c                             *
 * Designe by 刘俐训                    *
 * configrations and status             *
 * create: 04-16-2007                   *
 * update: 05-01-2007                   *
 ****************************************/

#include "includes.h"

#define DBG_SYSTEM

static unsigned char code ver[] = "2030070501";
static unsigned char code sysinfo[] = "Icc Reader, Designed by Liu lixun";
static unsigned char code pcbinfo[] = "ECC/FT 7.827.155/156(V2.0)";

unsigned long code baud[6] = {4800L, 9600L, 19200L, 38400L, 57600L, 115200L};

// action on card in/out
bit fTCBeep;
bit fRFCBeep;
bit fNotice;
bit fStopOnACK;
bit fAutoSearchCard;
bit InvPack;
unsigned int CardConfirmTime;   // time period of conform a rf card exist

static unsigned char lorc;      // led on rf card
static unsigned char lotc;      // led on touch card
static unsigned char lobc;      // led on both card
static unsigned char lonc;      // led on none card
static bit fLed;                // enable or disable led operation when card in/out


// init parameters
void SysInit(void)
{
    int ch;
    
    ComWrite("System initializing...\r\n", 24);
    
    // read beep flag
    ch = ParaRead(PARA_SWITCHS);
    if(ch >= 0)
    {
        fTCBeep = ch & F_BOTC;
        fRFCBeep = ch & F_BORFC;
        fLed = ch & F_LED;
        fNotice = ch & F_NOTICE;
        fStopOnACK = ch & F_SNOA;
        fAutoSearchCard = ch & F_ASC;
        InvPack = ch & F_CINV;
        ComWrite("Success switch.\r\n", 17);
    }
    else
    {
        fTCBeep = 1;
        fRFCBeep = 1;
        fLed = 1;
        fNotice = 1;
        fStopOnACK = 1;
        fAutoSearchCard = 1;
        InvPack = 0;
        ch = F_BOTC | F_BORFC | F_LED | F_NOTICE | F_SNOA | F_ASC;
        ParaWrite(PARA_SWITCHS, ch);
        ComWrite("Failed switch.\r\n", 16);
    }
    
    // read led on rf card
    ch = ParaRead(PARA_LORC);
    if(ch >= 0)
    {
        lorc = ch;
        ComWrite("Success lorc.\r\n", 15);
    }
    else
    {
        lorc = 12;
        ParaWrite(PARA_LORC, 12);
        ComWrite("Failed lorc.\r\n", 14);
    }
    
    // read limit
    ch = ParaRead(PARA_LIMIT);
    if(ch >= 0)
    {
        ComWrite("Success limt.\r\n", 15);
    }
    else
    {
        ParaWrite(PARA_LIMIT, 0x64);
        ComWrite("Failed limt.\r\n", 14);
    }

    // read led on touch card
    ch = ParaRead(PARA_LOTC);
    if(ch >= 0)
    {
        lotc = ch;
        ComWrite("Success lotc.\r\n", 15);
    }
    else
    {
        lotc = 25;
        ParaWrite(PARA_LOTC, 25);
        ComWrite("Failed lotc.\r\n", 14);
    }

    // read led on both card
    ch = ParaRead(PARA_LOBC);
    if(ch >= 0)
    {
        lobc = ch;
        ComWrite("Success lobc.\r\n", 15);
    }
    else
    {
        lobc = 0xff;
        ParaWrite(PARA_LOBC, 0xff);
        ComWrite("Failed lobc.\r\n", 14);
    }

    // read led on none card
    ch = ParaRead(PARA_LONC);
    if(ch >= 0)
    {
        lonc = ch;
        ComWrite("Success lonc.\r\n", 15);
    }
    else
    {
        lonc = 0;
        ParaWrite(PARA_LONC, 0);
        ComWrite("Failed lonc.\r\n", 14);
    }
    
    // read rf card confirm time
    ch = ParaRead(PARA_RFCCT);
    if(ch >= 0)
    {
        CardConfirmTime = (unsigned int)ch * 10;
        ComWrite("Success rcct.\r\n", 15);
    }
    else
    {
        CardConfirmTime = 200;
        ParaWrite(PARA_RFCCT, 20);
        ComWrite("Failed rcct.\r\n", 14);
    }
    
    ComWrite("\r\n", 2);
}

// cardtype: 0: tic, 1: rfc
// cardin:   0: out, 1: in
void CardLed(bit cardtype, bit cardin)
{
    static bit frfc = 0;
    static bit ftic = 0;
    
    if(cardtype)        // rfc
        frfc = cardin;
    else
        ftic = cardin;
        
    if(fLed)
    {
        if(frfc && ftic)
        {
            led(lobc);
        }
        else if(ftic)
        {
            led(lotc);
        }
        else if(frfc)
        {
            led(lorc);
        }
        else
        {
            led(lonc);
        }
    }
}

// command on sec
unsigned int SecCommand(unsigned char *cmd, int len)
{
    int ch;
    
    switch(cmd[1])
    {
        case CMD_RDSEC:
            if(len != 10)
            {
                cmd[0] = ERRORCMD;
                return 1;
            }
            if(memcmp(cmd+2, "rdselock", 8) != 0)
            {
                cmd[0] = ERRORCMD;
                return 1;
            }

            ch = ParaRead(PARA_LIMIT);
            if(ch >= 0)
            {
                cmd[0] = SUCCESS;
                cmd[1] = (unsigned char)ch;
                return 2;
            }
            else
            {
                cmd[0] = FAIL;
                cmd[1] = (char)ch;
                return 2;
            }
            
        case CMD_WRSEC:
            if(len != 10)
            {
                cmd[0] = ERRORCMD;
                return 1;
            }
            if(memcmp(cmd+3, "wselock", 7) != 0)
            {
                cmd[0] = ERRORCMD;
                return 1;
            }
            
            if(ParaWrite(PARA_LIMIT, cmd[2]) != cmd[2])
            {
                cmd[0] = FAIL;
                return 1;
            }
            else
            {
                cmd[0] = SUCCESS;
                cmd[1] = cmd[2];
                return 2;
            }
            
        case CMD_RDMEM:
            if(len != 10)
            {
                cmd[0] = ERRORCMD;
                return 1;
            }
            if(memcmp(cmd+3, "rdmemff", 7) != 0)
            {
                cmd[0] = ERRORCMD;
                return 1;
            }
            
            for(ch=0x1c00; ch<0x1d00; ch++)
            {
                uchar cc;
                cc = FlashRdByte(ch);
                ComWrite(&cc, 1);
            }
            return 0;
            
        default:
            cmd[0] = ERRORCMD;
            return 1;
    }
}

unsigned int SysCommand(unsigned char *cmd, int len)
{
    int ch;
    unsigned char snr[4];
    static unsigned char limitcnt = 0;
    
    ch = ParaRead(PARA_LIMIT);
    if(ch <= 0)
    {
        ParaWrite(PARA_LIMIT, 1);
        return 0;
    }
    
    if((unsigned int)0xff != ch)
    {
        limitcnt ++;
        if(limitcnt == 0)
        {
            ch --;
            ch = ParaWrite(PARA_LIMIT, (unsigned char)ch);
            // ComWrite((unsigned char *)&ch+1, 1);
        }
    }
    
    switch(cmd[1])
    {
        case CMD_SETBAUD:
            if(len != 4)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            if((cmd[2] >= 6) || (cmd[3] >= 6))
            {
                cmd[0] = ERRORCMD;
                return 1;
            }
            // cmd[3]: reserved for format
            snr[0] = SUCCESS;
            snr[1] = cmd[2];
            snr[2] = cmd[3];
            if(CommSend(snr, 3))
            {
                delay(50);
                // if communicate success, change baudrate
                ComOpen(SYSCLOCK, baud[cmd[2]]);
            }
            return 0;
            
        case CMD_EJECTCARD:
            if(len != 2)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            if(IccUserEject())
                cmd[0] = SUCCESS;
            else
                cmd[0] = FAIL;
            return 1;
        
        case CMD_SETMODE:
            if(len != 3)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            fLed = cmd[2] & F_LED;
            fTCBeep = cmd[2] & F_BOTC;
            fRFCBeep = cmd[2] & F_BORFC;
            InvPack = cmd[2] & F_CINV;
            fNotice = cmd[2] & F_NOTICE;
            fStopOnACK = cmd[2] & F_SNOA;
            fAutoSearchCard = cmd[2] & F_ASC;

            if(ParaWrite(PARA_SWITCHS, cmd[2]) == cmd[2])
            {
                cmd[0] = SUCCESS;
            }
            else
            {
                cmd[0] = FAIL;
            }
            return 1;
            
        case CMD_GETMODE:
            if(len != 2)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            ch = ParaRead(PARA_SWITCHS);
            if(ch >= 0)
            {
                cmd[0] = SUCCESS;
                cmd[1] = (unsigned char)ch;
                return 2;
            }
            else
            {
                cmd[0] = FAIL;
                cmd[1] = (char)ch;
                return 2;
            }
            
        case CMD_SETRFRXGAIN:
            if(len != 3)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            M500SetRcvGain(cmd[2]);
            // write parameter to flash
            if(ParaWrite(PARA_RFRXGAIN, cmd[2]) == cmd[2])
                cmd[0] = SUCCESS;
            else
                cmd[0] = FAIL;
            return 1;
            
        case CMD_GETVER:
            if(len != 2)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            cmd[0] = SUCCESS;
            strcpy(cmd+1, ver);
            return strlen(ver)+1;
            
        case CMD_GETSYSINFO:
            if(len != 2)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            cmd[0] = SUCCESS;
            strcpy(cmd+1, sysinfo);
            return strlen(sysinfo)+1;
            
        case CMD_SYSRESET:
            if(len != 2)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            cmd[0] = CMD_SYSRESET;
			cmd[1] = SUCCESS;
            CommSend(cmd, 2);
            delay(10);              // delay to wait send ok
            disable();
            while(1) {LED = ~LED;}  // wait watchdog reset
            // continue;
    
        case CMD_TESTCARD:
            if(len != 2)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            cmd[0] = SUCCESS;
            cmd[1] = IccUserTest();
            cmd[2] = M1Search(snr);
            return 3;
            
        case CMD_SETICCBRATE: 
            if(len != 3)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            //todo: init icc etu!!!!!!!!!!
            cmd[0] = SUCCESS;
            return 1;
            
        case CMD_USEDEBUG:
            if(len != 3)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            if(cmd[2])
                CommUseDbg(1);
            else
                CommUseDbg(0);
                
            cmd[0] = SUCCESS;
            return 1;
            
        case CMD_BEEP:
            if(len != 4)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            beep(cmd[2], cmd[3]);   // cmd[1]: times, cmd[2]: time
            cmd[0] = SUCCESS;
            return 1;
            
        case CMD_INV_PACK:
            if(len != 3)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            InvPack = cmd[2] ? 1 : 0;
            cmd[0] = SUCCESS;
            return 1;
            
        case CMD_RFRESET:
            if(len != 2)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            if(M500PcdInit() == MI_OK)
                cmd[0] = SUCCESS;
            else
                cmd[0] = FAIL;
            return 1;
            
        case CMD_GETHDINFO:
            if(len != 2)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            cmd[0] = SUCCESS;
            strcpy(cmd+1, pcbinfo);
            return strlen(pcbinfo)+1;
            
        case CMD_SETTOCRF:
            if(len != 3)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            CardConfirmTime = (unsigned int)cmd[2] * 10;
            if(ParaWrite(PARA_RFCCT, cmd[2]) == cmd[2])
            {
                cmd[0] = SUCCESS;
            }
            else
            {
                cmd[0] = FAIL;
            }
            return 1;
            
        case CMD_USERPOWER:
            if(len != 3)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            IccUserPower(cmd[2]);
            cmd[0] = SUCCESS;
            return 1;
            
        case CMD_SETLED:
            if(len != 6)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            lorc = cmd[2];
            lotc = cmd[3];
            lobc = cmd[4];
            lonc = cmd[5];
            
            cmd[0] = SUCCESS;
            cmd[1] = ParaWrite(PARA_LORC, lorc);
            cmd[2] = ParaWrite(PARA_LOTC, lotc);
            cmd[3] = ParaWrite(PARA_LOBC, lobc);
            cmd[4] = ParaWrite(PARA_LONC, lonc);
            return 5;
         
         case CMD_CTRLLED:
            if(len != 3)
            {
                cmd[0] = ERRORCMDLEN;
                return 1;
            }
            
            led(cmd[2]);
            cmd[0] = SUCCESS;
            return 1;
            
        // todo: test over load error.
            
        /*
        case CMD_STARTISP:
        */
        
        default:
            cmd[0] = ERRORCMD;
            return 1;
    }
}