Esempio n. 1
0
//CPU初始化//
int main(void) 
{
	
	EXCLK_DDR|=1<<EXCLK_BIT ;//en_exclk 引脚输出
	HC245_OE_DDR|=1<<HC245_OE_BIT;//en_245引脚输出
	CMOS_CLK_DDR|=1<<CMOS_CLK_BIT;//7660时钟允许引脚输出	
	DISEN_EXCLK;//禁止外部CLK,使单片机WR与TFT WR相连	
	DISEN_245;//禁止外部数据线,使单片机数据与TFT数据线相连
	CLK_init();//输出时钟到7660
	DATA_OUPUT(); //数据线输出,准备连数据线到TFT
    LCD_Init();
	//DATA_LCD_PORT=0xff;
	LCD_write_english_string(20,60,"Guanfu_Wang  2009-08-26",BLACK,RED);
	LCD_write_english_string(20,76,"Atmega32 & ILI9325 FOR OV7660 REV2.0",BLACK,RED);
	delay_ms(10000);
	LCD_write_english_string(20,96,"OV7660 Init......",BLACK,RED);
	while(1!=OV7660_init());//初始化ov7660
	LCD_write_english_string(20,96,"OV7660 Init  0K  ",BLACK,RED);
	delay_ms(10000);
	LCD_Clear(RED);
    DATA_INPUT(); 
	Init_INT0();
	/**/
    while(1)
    {
	}

}
Esempio n. 2
0
uint8_t noinline input_nibble(uint8_t rs, uint8_t en)
{
    /* configure data pins as input */
    DATA_INPUT();

    /* set write bit */
    PIN_SET(HD44780_RW);

    /* set rs, if given */
    PIN_CLEAR(HD44780_RS);
    if (rs)
        PIN_SET(HD44780_RS);

    uint8_t data = clock_read(en);

    /* reconfigure data pins as output */
    DATA_OUTPUT();

    /* delete RW bit */
    PIN_CLEAR(HD44780_RW);

    return data;
}
Esempio n. 3
0
__interrupt void USI_TXRX (void)
{
    if (START_ISSUED)
    {
        ChangeState(HANDLE_START_BIT);
    }
    
    switch(state)
    {
        case HANDLE_START_BIT:
            ChangeState(HANDLE_ADDRESS_AND_READ_WRITE);
            DATA_INPUT();
            set_bits_remaining(8);
            CLEAR_START();
            break;
            
        case HANDLE_ADDRESS_AND_READ_WRITE:
            if ((DATA_BUFFER & ADDRESS_MASK) == current_address)
            {
                read = DATA_BUFFER & READ_BIT;
                ChangeState(HANDLE_ADDRESS_ACK);
                DATA_OUTPUT();
                DATA_BUFFER = DATA_ACK;
                set_bits_remaining(1);
            }
            else // address did not match
            {
                DATA_INPUT();
                // TODO: should we just ignore bad addresses?
                //DATA_BUFFER = DATA_NACK;         // Send NAck
                ChangeState(IDLE);
            }
            break;
            
        case HANDLE_ADDRESS_ACK:
            if (read)
            {
                ChangeState(HANDLE_DATA_READ);
                DATA_OUTPUT();
                if (reg == I2C_ADDR_ADDRESS)
                {
                    DATA_BUFFER = current_address;
                }
                else if (reg == I2C_ADDR_TYPE)
                {
                    DATA_BUFFER = device_type;
                }
                else if (reg == I2C_ADDR_NUM_READ_ENDPOINTS)
                {
                    DATA_BUFFER = GetNumReadEndpoints();
                }
                else if (reg == I2C_ADDR_START_READ_ENDPOINTS)
                {
                    DATA_BUFFER = READ_ENDPOINTS_START;
                }
                else if (reg == I2C_ADDR_NUM_WRITE_ENDPOINTS)
                {
                    DATA_BUFFER = GetNumWriteEndpoints();
                }
                else if (reg == I2C_ADDR_START_WRITE_ENDPOINTS)
                {
                    DATA_BUFFER = WRITE_ENDPOINTS_START;
                }
                else if (reg >= READ_ENDPOINTS_START && reg < READ_ENDPOINTS_START + GetNumReadEndpoints())
                {
                    DATA_BUFFER = GetReadEndpoint(reg - READ_ENDPOINTS_START);
                }
                else
                {
                    // todo: this should nack as well I think - KSH
                    DATA_BUFFER = 0x00;
                }
                set_bits_remaining(8);                
            }
            else
            {
                ChangeState(HANDLE_REGISTER);
                DATA_INPUT();
                set_bits_remaining(8);
            }
            break;

        case HANDLE_REGISTER:
            reg = DATA_BUFFER;
            ChangeState(HANDLE_REGISTER_ACK);
            DATA_OUTPUT();
            DATA_BUFFER = DATA_ACK;
            set_bits_remaining(1);
            break;

        case HANDLE_REGISTER_ACK:
            ChangeState(HANDLE_DATA_WRITTEN);
            DATA_INPUT();
            set_bits_remaining(8);
            break;
        
        case HANDLE_DATA_READ:
            ChangeState(HANDLE_DATA_ACK);
            DATA_OUTPUT();
            DATA_BUFFER = DATA_ACK;
            set_bits_remaining(1);
            break;
            
        case HANDLE_DATA_WRITTEN:
            ChangeState(HANDLE_DATA_ACK);
            DATA_OUTPUT();
            if (reg == I2C_ADDR_ADDRESS)
            {
                // todo: find a way to store this in NVRAM
                current_address = DATA_BUFFER;
            }
            else if (reg >= WRITE_ENDPOINTS_START && reg < WRITE_ENDPOINTS_START + GetNumWriteEndpoints())
            {
                SetWriteEndpoint(reg - WRITE_ENDPOINTS_START, DATA_BUFFER);
            }
            else
            {
                DATA_BUFFER = DATA_NACK;
                set_bits_remaining(1);
                break;
            }
            DATA_BUFFER = DATA_ACK;
            set_bits_remaining(1);
            break;

        case HANDLE_DATA_ACK:
            DATA_INPUT();
            ChangeState(IDLE);
            break;
   
        default:
            break;
    }
    CLEAR_INT();
}