main.c

无线射频程序

                    SET_FLAG(g_ucKeyValueSend_Byte_Flag);
                    TWDR = g_ucKeyValueQueueBuff[0];
                }
                else
                {
                    TWDR = NO_BUTTON_PUSH_VALUE;
                }
            }
            if (g_ucTwi_Rx_Buff[0] == 2)
            {
                if (g_ucSpecialCommand_Byte_Flag == BYTE_FLAG_FALSE)
                {
                    LoadCheckString();
                    SET_FLAG(g_ucSpecialCommand_Byte_Flag);
                    g_ucTwi_Tx_Count = 0;
                }
                TWDR = g_ucTwi_Tx_Buff[g_ucTwi_Tx_Count++];
            }
            SetACK();
        }
        break;
        
        case 0x80:                                  /* SLA+W addressed! */
        {
            g_ucTwi_Rx_Buff[g_ucTwi_Rx_Count++] = TWDR;
            SetACK();
        }
        break;
        
        case 0x88:                                  /* SLA+W addressed! */
        {
            g_ucTwi_Rx_Buff[g_ucTwi_Rx_Count++] = TWDR;
            SetACK();
        }
        break;
        
        case 0xB8:                                  /* sending bytes */
        {
            TWDR = g_ucTwi_Tx_Buff[g_ucTwi_Tx_Count++];
            SetACK();
        }
        break;
        
        case 0xC0:
        {
            g_ucTwi_Rx_Count = 0;
            SetACK();
        }
        break;
        
        case 0xC8:                              /* last byte has sent! */
        {
            g_ucTwi_Tx_Count = 0;
            SetACK();
        }
        break;
        
        case 0x00:
        {
            TWCR |= _BV(TWSTO);
            SetNOACK();
        }
        break;
    }
}


void delay_ms(unsigned int ms)
{
	unsigned int i;
	for (i=0; i<ms; i++)
	    _delay_loop_2(4*250);
}

void InitCheckBuff(void)
{
	g_ucCheck_buff[0]  = 0x00;
	g_ucCheck_buff[1]  = 0x00;
	g_ucCheck_buff[2]  = 0x00;
	g_ucCheck_buff[3]  = 0x20;
	g_ucCheck_buff[4]  = 0;
	g_ucCheck_buff[5]  = 0;
	g_ucCheck_buff[6]  = 0;
	g_ucCheck_buff[7]  = 10;
	g_ucCheck_buff[8]  = 0;
	g_ucCheck_buff[9]  = 0x05;
	g_ucCheck_buff[10] = 0;
	g_ucCheck_buff[11] = 0;
	g_ucCheck_buff[12] = 0;
	g_ucCheck_buff[13] = 0x0b;
	g_ucCheck_buff[14] = 0;
	g_ucCheck_buff[15] = 0;
 	g_ucCheck_buff[16] = 0x43;
 	g_ucCheck_buff[17] = 0x6f;
 	g_ucCheck_buff[18] = 0x70;
 	g_ucCheck_buff[19] = 0x79;
 	g_ucCheck_buff[20] = 0x52;
 	g_ucCheck_buff[21] = 0x69;
 	g_ucCheck_buff[22] = 0x67;
 	g_ucCheck_buff[23] = 0x68;
 	g_ucCheck_buff[24] = 0x74;
 	g_ucCheck_buff[25] = 0x40;
 	g_ucCheck_buff[26] = 0x20;
 	g_ucCheck_buff[27] = 0x32;
 	g_ucCheck_buff[28] = 0x31;
 	g_ucCheck_buff[29] = 0x43;
 	g_ucCheck_buff[30] = 0x4f;
 	g_ucCheck_buff[31] = 0x4d;
	if (g_ucCheck_buff[7]  == 0)
	{
		while(1)
		{
		    wdt_reset();
			#ifdef ENABLE_INDICATOR_LED
		 		PORTB  ^= _BV(POWER_STD_LED);
			#endif
	 		delay_ms(200);
        }
    }
}

void LoadCheckString(void)
{
    g_ucTwi_Tx_Buff[0]  = 0x00;
	g_ucTwi_Tx_Buff[1]  = 0x00;
	g_ucTwi_Tx_Buff[2]  = 0x00;
	g_ucTwi_Tx_Buff[3]  = 0x20;
	g_ucTwi_Tx_Buff[4]  = 0;
	g_ucTwi_Tx_Buff[5]  = 0;
	g_ucTwi_Tx_Buff[6]  = 0;
	g_ucTwi_Tx_Buff[7]  = 10;
	g_ucTwi_Tx_Buff[8]  = 0;
	g_ucTwi_Tx_Buff[9]  = 0x05;
	g_ucTwi_Tx_Buff[10] = 0;
	g_ucTwi_Tx_Buff[11] = 0;
	g_ucTwi_Tx_Buff[12] = 0;
	g_ucTwi_Tx_Buff[13] = 0x0b;
	g_ucTwi_Tx_Buff[14] = 0;
	g_ucTwi_Tx_Buff[15] = 0;
 	g_ucTwi_Tx_Buff[16] = 0x43;
 	g_ucTwi_Tx_Buff[17] = 0x6f;
 	g_ucTwi_Tx_Buff[18] = 0x70;
 	g_ucTwi_Tx_Buff[19] = 0x79;
 	g_ucTwi_Tx_Buff[20] = 0x52;
 	g_ucTwi_Tx_Buff[21] = 0x69;
 	g_ucTwi_Tx_Buff[22] = 0x67;
 	g_ucTwi_Tx_Buff[23] = 0x68;
 	g_ucTwi_Tx_Buff[24] = 0x74;
 	g_ucTwi_Tx_Buff[25] = 0x40;
 	g_ucTwi_Tx_Buff[26] = 0x20;
 	g_ucTwi_Tx_Buff[27] = 0x32;
 	g_ucTwi_Tx_Buff[28] = 0x31;
 	g_ucTwi_Tx_Buff[29] = 0x43;
 	g_ucTwi_Tx_Buff[30] = 0x4f;
 	g_ucTwi_Tx_Buff[31] = 0x4d;
}

#define READ_KEYVALUE_DELAY             3
#define VALID_KEYVALUE                  0x0E
#define ReadPinDelay()                  {Nop();Nop();Nop();Nop();Nop();}

void AddVaildKeyValueToQueue(unsigned char key_value)
{
    if ((key_value != NO_BUTTON_PUSH_VALUE) && (g_ucLockKeyBoard_Byte_Flag == BYTE_FLAG_FALSE))
    {
        SET_FLAG(g_ucLockKeyBoard_Byte_Flag);
        if (g_ucKeyValueQueueCount < MAX_KEYVALUE_BUFF_SIZE)
        {
            g_ucKeyValueQueueBuff[g_ucKeyValueQueueCount++]  = key_value;
        }
        else
        {
            g_ucKeyValueQueueBuff[MAX_KEYVALUE_BUFF_SIZE-1]  = key_value;
        }
    }
}

void DecKeyValueQueue(void)
{
    unsigned char i;
    
    if (g_ucKeyValueQueueCount != 0)
    {
        for (i=0; i<g_ucKeyValueQueueCount; i++)
        {
            g_ucKeyValueQueueBuff[i] = g_ucKeyValueQueueBuff[i+1];
        }
        g_ucKeyValueQueueCount--;
    }
}

void ScanKeyboard(void)
{
    unsigned char tmp_KeyValue;
    
    if (g_ucLockKeyBoard_Byte_Flag == BYTE_FLAG_FALSE)
    {
        #ifdef SCAN_WIRE_KEYBOARD
        /*---------------------------------------------------------*/
        tmp_KeyValue = ReadPINCKeyBoard();                  /* read PINC port keyboard value */
        if (tmp_KeyValue < PINC_KEYBOARD_MASK_VALUE)
        {
            ReadPinDelay();
            if (tmp_KeyValue == ReadPINCKeyBoard())
            {
                if (tmp_KeyValue == nSURE_KEY_VALUE)        /* sure key */
                {
                    AddVaildKeyValueToQueue(IIC_OK_KEYVALUE);
                }
                else if (tmp_KeyValue == nDOWN_KEY_VALUE)   /* down key */
                {
                    AddVaildKeyValueToQueue(IIC_DOWN_KEYVALUE);
                }
                else if (tmp_KeyValue == nUP_KEY_VALUE)     /* up key */
                {
                    AddVaildKeyValueToQueue(IIC_UP_KEYVALUE);
                }
                else if (tmp_KeyValue == nMENU_KEY_VALUE)   /* menu key */
                {
                    AddVaildKeyValueToQueue(IIC_MENU_KEYVALUE);
                }
            }
        }
        /*---------------------------------------------------------*/
        tmp_KeyValue = ReadPINDKeyBoard();
        if (tmp_KeyValue < PIND_KEYBOARD_MASK_VALUE)
        {
            ReadPinDelay();
            if (tmp_KeyValue == ReadPINDKeyBoard())
            {
                if (tmp_KeyValue == nPOWER_KEY_VALUE)           /* power key */
                {
                    if (g_ucPowerSwitch_Byte_Flag == BYTE_FLAG_FALSE)
                    {
                        OpenPowerSupply();
                        SET_FLAG(g_ucPowerSwitch_Byte_Flag);
                    }
                    else
                    {
                        if (g_ucNormal_Byte_Flag == BYTE_FLAG_TRUE)
		    			{
		    				AddVaildKeyValueToQueue(IIC_POWER_KEYVALUE);
		    			}
		    			else
		    			{
		    				ClosePowerSupply();
                            CLEAR_FLAG(g_ucPowerSwitch_Byte_Flag);
		    			}
                    }
                    SET_FLAG(g_ucLockKeyBoard_Byte_Flag);
                }
                else if (tmp_KeyValue == nREC_KEY_VALUE)        /* record key */
                {
                    AddVaildKeyValueToQueue(IIC_TV_LCD_KEYVALUE);       //0x1C
                }
            }
        }
        /*---------------------------------------------------------*/
    #else
        /*---------------------------------------------------------*/
        Enable_Key_Y1();
        ReadPinDelay();
        tmp_KeyValue = ReadKeyBoard();
        Disable_Key_Y1();
        if (tmp_KeyValue != VALID_KEYVALUE)
        {
            #ifdef LONG_DELAY
            delay_ms(READ_KEYVALUE_DELAY);
            #else
            ReadPinDelay();
            #endif
            Enable_Key_Y1();
            if (tmp_KeyValue == ReadKeyBoard())
            {
                if (tmp_KeyValue == 0x06)               /* press rec */
                {
                    AddVaildKeyValueToQueue(IIC_TV_LCD_KEYVALUE);       //0x1C
                }
                else if (tmp_KeyValue == 0x0A)          /* press left */
                {
                    AddVaildKeyValueToQueue(IIC_LEFT_ARROW_KEYVALUE);
                }
                else if (tmp_KeyValue == 0x0C)
                {
                    AddVaildKeyValueToQueue(IIC_DOWN_KEYVALUE);
                }
            }
            Disable_Key_Y1();
        }
        /*---------------------------------------------------------*/
        Enable_Key_Y2();
        ReadPinDelay();
        tmp_KeyValue = ReadKeyBoard();
        Disable_Key_Y2();
        if (tmp_KeyValue != VALID_KEYVALUE)
        {
            #ifdef LONG_DELAY
            delay_ms(READ_KEYVALUE_DELAY);
            #else
            ReadPinDelay();
            #endif
            Enable_Key_Y2();
            if (tmp_KeyValue == ReadKeyBoard())
            {
                if (tmp_KeyValue == 0x06)
                {
                    AddVaildKeyValueToQueue(IIC_UP_KEYVALUE);
                }
                else if (tmp_KeyValue == 0x0A)
                {
                    AddVaildKeyValueToQueue(IIC_OK_KEYVALUE);
                }
                else if (tmp_KeyValue == 0x0C)
                {
                    AddVaildKeyValueToQueue(IIC_MENU_KEYVALUE);
                }
            }
            Disable_Key_Y2();
        }
        /*---------------------------------------------------------*/
        Enable_Key_Y3();
        ReadPinDelay();
        tmp_KeyValue = ReadKeyBoard();
        Disable_Key_Y3();
        if (tmp_KeyValue != VALID_KEYVALUE)
        {
            #ifdef LONG_DELAY
            delay_ms(READ_KEYVALUE_DELAY);
            #else
            ReadPinDelay();
            #endif
            
            Enable_Key_Y3();
            if (tmp_KeyValue == ReadKeyBoard())
            {
                if (tmp_KeyValue == 0x06)
                {
                    AddVaildKeyValueToQueue(IIC_EXIT_KEYVALUE);
                }
                else if (tmp_KeyValue == 0x0A)
                {
                    AddVaildKeyValueToQueue(IIC_RIGHT_ARROW_KEYVALUE);
                }
            }
            Disable_Key_Y3();
        }
        /*---------------------------------------------------------*/
    #endif
    }
}

void Timer0Task(void)
{
    if (g_ucTimer0_IRQ_Count >= TIMER0_TASK_INTERVAL)
    {
        ClearTimer0IRQCount();
        wdt_reset();
        if (g_ucLockKeyBoard_Byte_Flag == BYTE_FLAG_FALSE) ScanKeyboard();
        if (g_ucKeyValueSend_Byte_Flag == BYTE_FLAG_TRUE)
        {
            if (g_ucKeyValueSendDelay++ == KEYVALUE_SEND_INTERVAL)
            {
                ClearKeyValueSendDelay();
                DecKeyValueQueue();
                CLEAR_FLAG(g_ucKeyValueSend_Byte_Flag);
            }
        }
    }
}

void RespondRMTData(void)
{
    if (g_ucISRmtStart_Byte_Flag == BYTE_FLAG_TRUE)
    {
        ReceiveRemoteDataString();
        GICR |= _BV(INT0);
        CLEAR_FLAG(g_ucISRmtStart_Byte_Flag);
    }
}

void ProcessAllTask(void)
{
    Timer0Task();
    RespondRMTData();
    ProcessRMTData();
}

int main(void)
{
    PowerOnInitFunction();
    while(1)
    {
        ProcessAllTask();
    }
}