示例#1
0
int main(void)
{
	uint8_t i;
	uint8_t temperature[BUFFER_SIZE];
	uint8_t light[BUFFER_SIZE];
	uint8_t value_disp[5];
	uint32_t adc_value;
	double temp;

	// Initialize clocks.
	sysclk_init();

	// Initialize GPIO states.
	board_init();

	// Configure ADC for light sensor.
	configure_adc();

	// Initialize at30tse.
	at30tse_init();

	// Configure IO1 buttons.
	configure_buttons();

	// Initialize SPI and SSD1306 controller.
	ssd1306_init();
	ssd1306_clear();

	// Clear internal buffers.
	for (i = 0; i < BUFFER_SIZE; ++i)
	{
		temperature[i] = 0;
		light[i] = 0;
	}

	while (true)
	{
		/* Refresh page title only if necessary. */
		if (app_mode_switch > 0)
		{
			app_mode = app_mode_switch - 1;

			// Clear screen.
			ssd1306_clear();
			ssd1306_set_page_address(0);
			ssd1306_set_column_address(0);

			/* Temperature mode. */
			if (app_mode == 0)
			{
				ioport_set_pin_level(IO1_LED1_PIN, IO1_LED1_ACTIVE);
				ioport_set_pin_level(IO1_LED2_PIN, !IO1_LED2_ACTIVE);
				ioport_set_pin_level(IO1_LED3_PIN, !IO1_LED3_ACTIVE);
				ssd1306_write_text("Temperature sensor:");
			}
			/* Light mode. */
			else if (app_mode == 1)
			{
				ioport_set_pin_level(IO1_LED2_PIN, IO1_LED2_ACTIVE);
				ioport_set_pin_level(IO1_LED1_PIN, !IO1_LED1_ACTIVE);
				ioport_set_pin_level(IO1_LED3_PIN, !IO1_LED3_ACTIVE);
				ssd1306_write_text("Light sensor:");
			}
			/* SD mode. */
			else
			{
				ioport_set_pin_level(IO1_LED3_PIN, IO1_LED3_ACTIVE);
				ioport_set_pin_level(IO1_LED1_PIN, !IO1_LED1_ACTIVE);
				ioport_set_pin_level(IO1_LED2_PIN, !IO1_LED2_ACTIVE);

				display_sd_info();
			}
			app_mode_switch = 0;
		}

		// Shift graph buffers.
		for (i = 0; i < BUFFER_SIZE - 1; ++i)
		{
			temperature[i] = temperature[i + 1];
			light[i] = light[i + 1];
		}

		// Get temperature in a range from 0 to 40 degrees.
		if (at30tse_read_temperature(&temp) == TWI_SUCCESS)
		{
			// Don't care about negative temperature.
			if (temp < 0)
				temp = 0;

			// Update temperature for display.
			// Note: -12 in order to rescale for better rendering.
			if (temp < 12)
				temperature[BUFFER_SIZE - 1] = 0;
			else
				temperature[BUFFER_SIZE - 1] = temp - 12;
		}
		else
		{
			// Error print zero values.
			temperature[BUFFER_SIZE - 1] = 0;
		}

		// Get light sensor information.
		// Rescale for better rendering.
		adc_start(ADC);
		adc_value = adc_get_channel_value(ADC, ADC_CHANNEL_4);
		light[BUFFER_SIZE - 1] = 24 - adc_value * 24 / 4096;

		// Print temperature in text format.
		if (app_mode == 0)
		{
			sprintf(value_disp, "%d", (uint8_t)temp);
			ssd1306_set_column_address(95);
			ssd1306_write_command(SSD1306_CMD_SET_PAGE_START_ADDRESS(0));
			ssd1306_write_text(" ");
			ssd1306_write_text(value_disp);
			// Display degree symbol.
			ssd1306_write_data(0x06);
			ssd1306_write_data(0x06);
			ssd1306_write_text("c");

			// Refresh graph.
			ssd1306_draw_graph(0, 1, BUFFER_SIZE, 3, temperature);
		}
		else if (app_mode == 1)
		{
			sprintf(value_disp, "%lu", 100 - (adc_value * 100 / 4096));
			ssd1306_set_column_address(98);
			ssd1306_write_command(SSD1306_CMD_SET_PAGE_START_ADDRESS(0));
			ssd1306_write_text(" ");
			ssd1306_write_text(value_disp);
			ssd1306_write_text("%");

			// Refresh graph.
			ssd1306_draw_graph(0, 1, BUFFER_SIZE, 3, light);
		}
		else
		{
			// Is card has been inserted or removed?
			if (sd_status_update == 1)
			{
				// Clear screen.
				ssd1306_clear();
				ssd1306_set_page_address(0);
				ssd1306_set_column_address(0);

				// Show SD card info.
				display_sd_info();

				sd_status_update = 0;
			}

		}

		/* Wait and stop screen flickers. */
		delay_ms(50);
	}
}
示例#2
0
文件: main.c 项目: Eacaen/Quadrotor
 int main(void)
 {		
	u16 sta , i=0;
	int t = 200;
	delay_init();	    	 //延时函数初始化	
	LED_Init();
	LED0 = 0;delay_ms(200); LED0 = 1;
	LED1 = 0;delay_ms(200); LED1 = 1;
	LED2 = 0;delay_ms(200); LED2 = 1;
	LED3 = 0;delay_ms(200); LED3 = 1;
	 
	NVIC_Configuration(); 	 //设置NVIC中断分组2:2位抢占优先级,2位响应优先级
	uart_init(9600);	 	//串口初始化为9600
	 
	EXTIX_Init( );
 	NRF24L01_Init();    	//初始化NRF24L01 
	
	NRF24L01_RX_Mode();		
 	while(NRF24L01_Check() == 1)//检查NRF24L01是否在位.	
	{
			LED3=!LED3;				printf("NRF ERROR!!\r\n");

			delay_ms(100 );
	}
	printf("NRF okk!!\r\n");
	sta=NRF24L01_Read_Reg(STATUS);  //读取状态寄存器的值    	 
	NRF24L01_Write_Reg(WRITE_REG_NRF+STATUS,sta); //清除TX_DS或MAX_RT中断标志
	NRF24L01_Write_Reg(FLUSH_RX,0xff);//清除RX FIFO寄存器
	
	
	TIM2_PWM_Init(999,9);  //PWM OUT
	TIM3_Int_Init(0xffff,71);  //做计时器用

	IIC_Init();	 
	InitMPU6050();
	Init_HMC5883();
	suanfa_GetOrigin(); //初始欧拉角 
	

	
	TIM4_Int_Init(49,7199);	  		//PID调速中断 放在最后初始化,防止打断角度校准
	LOCK = 1;
	UN_LOCK = 0;
	
	while(1){
		
		
		if(LOCK)
		{
			
			lock();
			LED0 = 0;delay_ms(500);LED0 = 1;
			Power = 0;
			Target_x = 0;
			Target_y = 0;
				
		}
		
		if(UN_LOCK)
		{
			suanfa();
			printf("%.2lf  %.2lf  %.2lf\r\n",EA.Roll,EA.Pitch,EA.Yaw);	
// 			TIM_Cmd(TIM4, ENABLE);
			Data_Receive_Anl();
		}
		
// 		printf("--p\r\n");
			 
			
					}
}
示例#3
0
文件: rtc.c 项目: Yegz/STM32_Project
u8 p_dr_RtcInit(void)
{
    //检查是不是第一次配置时钟
    u8 temp=0;
    RTC_NVIC_Config();
    //if(BKP->DR1!=0X5050)//第一次配置
    if (BKP_ReadBackupRegister(BKP_DR1) != 0x5050)      //从指定的后备寄存器中读出数据:读出了与写入的指定数据不相乎
    {
        /* Enable PWR and BKP clocks */
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);    //使能PWR和BKP外设时钟

        /* Allow access to BKP Domain */
        PWR_BackupAccessCmd(ENABLE);    //使能RTC和后备寄存器访问

        /* Reset Backup Domain */
        BKP_DeInit();   //将外设BKP的全部寄存器重设为缺省值


        /* Enable LSE */
        RCC_LSEConfig(RCC_LSE_ON);  //设置外部低速晶振(LSE),使用外设低速晶振
        /* Wait till LSE is ready */
        while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET) //检查指定的RCC标志位设置与否,等待低速晶振就绪
        {
            temp++;
            delay_ms(10);
        }
        if(temp>=250)return 1;//初始化时钟失败,晶振有问题
        /* Select LSE as RTC Clock Source */
        RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);     //设置RTC时钟(RTCCLK),选择LSE作为RTC时钟
        /* Enable RTC Clock */
        RCC_RTCCLKCmd(ENABLE);  //使能RTC时钟
        /* Wait for RTC registers synchronization */
        RTC_WaitForSynchro();       //等待最近一次对RTC寄存器的写操作完成
        /* Wait until last write operation on RTC registers has finished */
        RTC_WaitForLastTask();  //等待最近一次对RTC寄存器的写操作完成
        /* Enable the RTC Second */
        RTC_ITConfig(RTC_IT_SEC, ENABLE);       //使能RTC秒中断
        /* Wait until last write operation on RTC registers has finished */
        RTC_WaitForLastTask();  //等待最近一次对RTC寄存器的写操作完成
        /* Set RTC prescaler: set RTC period to 1sec */
        /* RTC period = RTCCLK/RTC_PR = (32.768 KHz)/(32767+1) */
        RTC_SetPrescaler(32767); //设置RTC预分频的值
        /* Wait until last write operation on RTC registers has finished */
        RTC_WaitForLastTask();  //等待最近一次对RTC寄存器的写操作完成
        p_dr_RtcSet(2009,12,2,10,0,55);  //设置时间
        BKP_WriteBackupRegister(BKP_DR1, 0X5050);   //向指定的后备寄存器中写入用户程序数据
    }
    else//系统继续计时
    {
        /* Check if the Power On Reset flag is set */
        if (RCC_GetFlagStatus(RCC_FLAG_PORRST) != RESET)    //检查指定的RCC标志位设置与否:POR/PDR复位
        {
            //printf("\rPower On Reset occurred....");
        }
        /* Check if the Pin Reset flag is set */
        else if (RCC_GetFlagStatus(RCC_FLAG_PINRST) != RESET)   //检查指定的RCC标志位设置与否:管脚复位
        {
            //printf("\rExternal Reset occurred....");
        }

        //printf("\rNo need to configure RTC....");
        /* Wait for RTC registers synchronization */
        RTC_WaitForSynchro();   //等待最近一次对RTC寄存器的写操作完成

        /* Enable the RTC Second */
        RTC_ITConfig(RTC_IT_SEC, ENABLE);   //使能RTC秒中断
        /* Wait until last write operation on RTC registers has finished */
        RTC_WaitForLastTask();  //等待最近一次对RTC寄存器的写操作完成
    }
    p_dr_RtcGet();//更新时间

    /* Clear reset flags */
    RCC_ClearFlag();    //清除RCC的复位标志位

    return 0; //ok
}
示例#4
0
void main()
{		
			uchar i=0, j=0;
			uint chksum=0;
			uchar buffer[17];
			uchar temp=0;
			init();	
			LED1 = 1;								// Blink LED twice - slave
			delay_ms(500);			
			LED1 = 0;
			delay_ms(500);
			LED1 = 1;								// Blink LED twice - slave
			delay_ms(500);
			LED1 = 0;
			
			WriteCMD(0xCA81);
			WriteCMD(0xCA83);						// Enable FIFO	
		
			while(1)
			{
				while(RFM12_IRQ==0)
				{	
					temp=	ReadFifo();		// read in next Rx byte					
					buffer[i++] = temp;
					if(temp!=0){
						for(t=0;t<4;t++){
							LED1=1;						// turn on led
							delay_ms(25);
							LED1=0;						// turn on led
							delay_ms(25);
							}
					}
					
					if (i==17)							// received data + checksum = 17 bytes
					{
						i=0;
						WriteCMD(0xCA81);				// disable FIFO
	
						
						chksum=0;
						for(j=0 ; j<16 ; j++)			// calc checksum
							chksum+=buffer[j];
						chksum&=0x0FF;
						if(chksum==buffer[16]&&buffer[16]!=0)			// if checksum ok
						{
							for(t=0;t<4;t++){
							LED1=1;						// turn on led
							delay_ms(25);
							LED1=0;						// turn on led
							delay_ms(25);
							}
							
						}
					///	LED1=0;
						WriteCMD(0xCA81);				// disable FIFO
						WriteCMD(0xCA83);				// enable FIFO, re-Sync
					}//if
				}//while

			} //while
}
示例#5
0
void peSetup(void) {
    // setup peripheral
    // SPI Setup
    // SPI interrupt is not used.
    int i;
    
    IFS2bits.SPI2IF = 0; // Clear the Interrupt Flag
    IEC2bits.SPI2IE = 0; // Disable the Interrupt

    // SPI1CON1 Register Settings
    SPI_CON1bits.MSTEN = 1; // Master mode Enabled
        
    SPI_CON1bits.DISSDO = 0; // SDOx pin is controlled by the module
    SPI_CON1bits.SSEN = 0; // SS1 pin controlled by module
    
    SPI_CON1bits.DISSCK = 0; // Internal Serial Clock is Enabled
    
    // Set up SCK frequency of 625kHz for 40 MIPS
    SPI_CON1bits.SPRE = 0b111; // Secondary prescale    1:1
    SPI_CON1bits.PPRE = 0b00; // Primary prescale       64:1

    SPI_CON1bits.SMP = 0; // Input data is sampled at middle of data output time
    SPI_CON1bits.CKE = 0; // Serial output data changes on idle to active transition
    SPI_CON1bits.CKP = 0; // Idle state for clock is a low level;
                            // active state is a high level
    
    SPI_CON1bits.MODE16 = 0; // Communication is byte-wide (8 bits)
    // SPI2CON2 Register Settings
    SPI_CON2 = 0x0000; // Framed SPI2 support disabled

    // SPI2STAT Register Settings
    SPI_STATbits.SPISIDL = 1; // Discontinue module when device enters idle mode
    SPI_STATbits.SPIROV = 0; // Clear Overflow
    
    SPI_STATbits.SPIEN = 1; // Enable SPI module
    
    CS_DIR = 0;
    FAKE_CS_DIR = 0;
    
    cmdPld = payCreateEmpty(1);
    cmdPld->pld_data[0] = 0;
    cmdPld->pld_data[1] = CMD_PYROELEC_COMMAND;
    
    dataPld = payCreateEmpty(8);
    dataPld->pld_data[0] = 0;
    dataPld->pld_data[1] = CMD_PYROELEC_DATA;
    
    for(i=0; i<4; i++) {
        framePlds[i] = payCreateEmpty(66);
        framePlds[i]->pld_data[0] = 0;
        framePlds[i]->pld_data[1] = CMD_PYROELEC_FRAME;
        framePlds[i]->pld_data[2] = (i&1);
        framePlds[i]->pld_data[3] = 0;
    }
    
    for(i=0;i<N_HIST;i++)
        centerHist[i] = 0;
    
    peResetModule();
    
    peSendCommand('M');
    
    delay_ms(5);
    
    peTransaction(NULL,0,NULL,100);
}
示例#6
0
void spi_reset ()
{
	BYTE spicmd[2] = { FLAG, SPI_RESET };


	switch (PortType) {
		case TY_COMM :
			_outp(COM_MCR, 0);		/* RESET,SCK = "L" */
			delay_ms(10);			/* 10msec */
			_outp(COM_MCR, C_RES);	/* RESET = "H" */
			iodly(); iodly();		/* delay */
			_outp(COM_MCR, 0);		/* RESET = "L" */
			break;

		case TY_VCOM :
			EscapeCommFunction(hComm, CLRDTR);
			EscapeCommFunction(hComm, CLRRTS);
			delay_ms(10);
			EscapeCommFunction(hComm, SETDTR);
			iodly(); iodly();
			EscapeCommFunction(hComm, CLRDTR);
			break;

		case TY_BRIDGE :
			delay_ms(10);
			send_bridge(spicmd, 2);
			break;

		case TY_AVRSP :
			_outp(LPT_DAT, B_ENA);
			delay_ms(10);
			_outp(LPT_DAT, B_ENA|B_RES);
			iodly(); iodly();
			_outp(LPT_DAT, B_ENA);
			break;

		case TY_STK200 :
			_outp(LPT_DAT, 0);
			delay_ms(10);
			_outp(LPT_DAT, BS_RES);
			iodly(); iodly();
			_outp(LPT_DAT, 0);
			break;

		case TY_XILINX :
			_outp(LPT_DAT, BX_DIS2);
			delay_ms(10);
			_outp(LPT_DAT, BX_DIS2|BX_RES);
			iodly(); iodly();
			_outp(LPT_DAT, BX_DIS2);
			break;

		case TY_LATTICE :
			_outp(LPT_DAT, 0);
			delay_ms(10);
			_outp(LPT_DAT, BL_RES);
			iodly(); iodly();
			_outp(LPT_DAT, 0);
			break;

		case TY_ALTERA :
			_outp(LPT_DAT, 0);
			delay_ms(10);
			_outp(LPT_DAT, BA_RES);
			iodly(); iodly();
			_outp(LPT_DAT, 0);
			break;

	}
	RcvrFifo.Rp = 0;					/* Flush FIFO */
	RcvrFifo.Wp = 0;
	RcvrFifo.Ctr = 0;
	delay_ms(30);						/* 30msec */
}
示例#7
0
void LED_simple_all_colors(){ //simple all colors
	TIM_Cmd(LPC_TIM0,DISABLE);	// To start timer 0
//	while(1){
	for (uint8_t i=0;i<16;i++){
//		xprintf(OK "%d",i+1);FFL_();
		GPIO_ClearValue(LED_LE_PORT, LED_LE_BIT);
		for (uint8_t j=0;j<11;j++){
			SSP_SendData(LED_SPI_CHN, 0x0000);
			while(LED_SPI_CHN->SR & SSP_STAT_BUSY);
		}
//		SSP_SendData(LED_SPI_CHN, 0x0001<<i);
		SSP_SendData(LED_SPI_CHN, 0x1249);
		while(LED_SPI_CHN->SR & SSP_STAT_BUSY);
		for (uint8_t k=0;k<0;k++){
			SSP_SendData(LED_SPI_CHN, 0x0000);
			while(LED_SPI_CHN->SR & SSP_STAT_BUSY);
		}
		GPIO_SetValue(LED_LE_PORT, LED_LE_BIT);
		GPIO_ClearValue(LED_LE_PORT, LED_LE_BIT);
		GPIO_ClearValue(LED_OE_PORT, LED_OE_BIT);//LED's on. active low
		delay_ms(150);
	};
	for (uint8_t i=0;i<16;i++){
//		xprintf(OK "%d",i+1);FFL_();
		GPIO_ClearValue(LED_LE_PORT, LED_LE_BIT);
		for (uint8_t j=0;j<11;j++){
			SSP_SendData(LED_SPI_CHN, 0x0000);
			while(LED_SPI_CHN->SR & SSP_STAT_BUSY);
		}
//		SSP_SendData(LED_SPI_CHN, 0x0001<<i);
		SSP_SendData(LED_SPI_CHN, 0x2492);
		while(LED_SPI_CHN->SR & SSP_STAT_BUSY);
		for (uint8_t k=0;k<0;k++){
			SSP_SendData(LED_SPI_CHN, 0x0000);
			while(LED_SPI_CHN->SR & SSP_STAT_BUSY);
		}
		GPIO_SetValue(LED_LE_PORT, LED_LE_BIT);
		GPIO_ClearValue(LED_LE_PORT, LED_LE_BIT);
		GPIO_ClearValue(LED_OE_PORT, LED_OE_BIT);//LED's on. active low
		delay_ms(150);
	};
	for (uint8_t i=0;i<16;i++){
	xprintf(OK "%d",i+1);FFL_();
	GPIO_ClearValue(LED_LE_PORT, LED_LE_BIT);
	for (uint8_t j=0;j<11;j++){
		SSP_SendData(LED_SPI_CHN, 0x0000);
		while(LED_SPI_CHN->SR & SSP_STAT_BUSY);
	}
//	SSP_SendData(LED_SPI_CHN, 0x0001<<i);
	SSP_SendData(LED_SPI_CHN, 0x4924);
	while(LED_SPI_CHN->SR & SSP_STAT_BUSY);
	for (uint8_t k=0;k<0;k++){
		SSP_SendData(LED_SPI_CHN, 0x0000);
		while(LED_SPI_CHN->SR & SSP_STAT_BUSY);
	}
	GPIO_SetValue(LED_LE_PORT, LED_LE_BIT);
	GPIO_ClearValue(LED_LE_PORT, LED_LE_BIT);
	GPIO_ClearValue(LED_OE_PORT, LED_OE_BIT);//LED's on. active low
	delay_ms(150);
	};
	for (uint8_t i=0;i<16;i++){
//		xprintf(OK "%d",i+1);FFL_();
		GPIO_ClearValue(LED_LE_PORT, LED_LE_BIT);
		for (uint8_t j=0;j<11;j++){
			SSP_SendData(LED_SPI_CHN, 0x0000);
			while(LED_SPI_CHN->SR & SSP_STAT_BUSY);
		}
//		SSP_SendData(LED_SPI_CHN, 0x0001<<i);
		SSP_SendData(LED_SPI_CHN, 0xffff);
		while(LED_SPI_CHN->SR & SSP_STAT_BUSY);
		for (uint8_t k=0;k<0;k++){
			SSP_SendData(LED_SPI_CHN, 0x0000);
			while(LED_SPI_CHN->SR & SSP_STAT_BUSY);
		}
		GPIO_SetValue(LED_LE_PORT, LED_LE_BIT);
		GPIO_ClearValue(LED_LE_PORT, LED_LE_BIT);
		GPIO_ClearValue(LED_OE_PORT, LED_OE_BIT);//LED's on. active low
		delay_ms(150);
	};
//	};
	TIM_Cmd(LPC_TIM0,ENABLE);	// To start timer 0
	LED_PATTERN=0;
}
示例#8
0
void motor_test()
{
	static char m1_back = 0, m2_back = 0;
	char m1_char, m2_char;

	if(button_is_pressed(BUTTON_A))
	{
		if(m1_speed == 0)
		{
			delay_ms(200);

			// If the button is pressed quickly when the motor is off,
			// reverse direction.
			if(!button_is_pressed(BUTTON_A))
				m1_back = !m1_back;
		}
		
		m1_speed += 10;
	}
	else
		m1_speed -= 20;

	if(button_is_pressed(BUTTON_C))
	{
		if(m2_speed == 0)
		{
			delay_ms(200);

			// If the button is pressed quickly when the motor is off,
			// reverse direction.
			if(!button_is_pressed(BUTTON_C))
				m2_back = !m2_back;
		}

		m2_speed += 10;
	}
	else
		m2_speed -= 20;

	if(m1_speed < 0)
		m1_speed = 0;

	if(m1_speed > 255)
		m1_speed = 255;

	if(m2_speed < 0)
		m2_speed = 0;

	if(m2_speed > 255)
		m2_speed = 255;

	// 255/26 = 9, so this gives values in the range of 0 to 9
	m1_char = bar_graph_characters[m1_speed / 26];
	m2_char = bar_graph_characters[m2_speed / 26];
	print_character(m1_char);
	print_character(m1_back ? 'a' : 'A');
	print_character(m1_char);
	lcd_goto_xy(5,0);
	print_character(m2_char);
	print_character(m2_back ? 'c' : 'C');
	print_character(m2_char);

	set_motors(m1_speed * (m1_back ? -1 : 1), m2_speed * (m2_back ? -1 : 1));
	delay_ms(50);
}
示例#9
0
// *** triggered by middle button ***
// This function tests the eight user I/O pins and the trimmer potentiometer.
// At any given time, one pin is being driven low while the rest are weakly
// pulled high (to 5 V).  At the same time, the LCD is displaying the input
// values on the eight user I/O pins.  If you short a pin to *GROUND* (note:
// do not short the pin to power, only short it to one of the ground pads
// along the top edge of the board), you will see the corresponding bit on
// the LCD go to zero.  The PD1 bit will always read zero as it is being
// pulled down through the red user LED.
unsigned char IOTest()
{
	// the bits of the "outputs" byte will correspond to the pin states of
	// the user I/O lines as follows:

	// outputs:   b7  b6  b5  b4  b3  b2  b1  b0
	// user I/O: PC5 PC4 PC3 PC2 PC1 PC0 PD1 PD0

	// Only one bit of "outputs" will ever be set (1) at a time; the rest will
	// be cleared (0).  The user I/O pin that corresponds to the set bit will
	// be an output that is driven low while all of the other user I/O pins
	// will be inputs with internal pull-ups enabled (i.e. they will be weakly
	// pulled to 5V and will read as high).
	unsigned int outputs = 0x8000;	// binary: 10000000 00000000
	unsigned char *outputsA = (unsigned char *)&outputs;	// pointer to low byte of outputs
	unsigned char *outputsD = outputsA + 1;					// pointer to high byte of outputs
	unsigned char direction = 0;
	unsigned char button;

	red_led(1);
	green_led(1);

	clear();		// clear the LCD
	print("User I/O");
	lcd_goto_xy(0, 1);
	print("DDDDDDDD AAAAAAAA");
	lcd_goto_xy(0, 2);
	print("76543210 76543210");

	set_analog_mode(MODE_8_BIT);	// configure ADC for 8-bit readings

	while (1)			// loop here until we detect a button press and return
	{
		time_reset();				// reset millisecond timer count to zero

		DDRA = 0;					// make PA0 - PA7 inputs
		PORTA = 0;					// PA0 - PA7 -> high impedance inputs
		DDRD = 0;					// make PD0 - PD7 inputs
		PORTD = 0;					// PD0 - PD7 -> high impedance inputs

		PORTD |= ~(*outputsD);
		DDRD |= *outputsD;
		PORTA |= (~(*outputsA)) & 0x3F;
		DDRA |= *outputsA & 0x3F;	// never make PA6 and PA7 outputs


		// The following loop will execute for an amount of time determined
		// by the position of the user trimmer potentiometer (trimpot).
		// When the trimpot is at one extreme, the loop will take 256*2 = 512
		// milliseconds.  When the trimpot is at the other extreme, the
		// loop will only execute once, which takes slightly more than 20 ms.
		// In this way, the trimpot controls the speed at which the output
		// byte changes.
		do
		{
			// The bits of the "inputs" byte reflect the input values of pins
			// PD0, PD1, and PC0 - PC5.  Bit 0 corresponds to PD0, bit 1 to
			// PD1, and bits 2 - 7 to PC0 - PC5, respectively.
			unsigned char inputsA = PINA;
			unsigned char inputsD = PIND;
			lcd_goto_xy(0, 3);		// go to the start of the fourth LCD line
			print_binary(inputsD);	// print the "input" byte in binary
			print(" ");
			print_binary(inputsA);
			delay_ms(20);			// delay here for 20 milliseconds
			// check if top or bottom buttons have been pressed
			button = button_is_pressed(TOP_BUTTON | BOTTOM_BUTTON);
			if (button != 0)	// if so, reset I/O states, return button ID
			{
				DDRA = 0;					// make PA0 - PA7 inputs
				PORTA = 0;					// PA0 - PA7 -> high impedance inputs
				DDRD = 0;					// make PD0 - PD7 inputs
				PORTD = 0;					// PD0 - PD7 -> high impedance inputs
				return button;
			}
		}
		while (get_ms() < read_trimpot() * 2);

		if (direction)
			outputs <<= 1;		// bit-shift our output byte left by one bit
		else
			outputs >>= 1;		// bit-shift our output byte right by one bit

		if (outputs == 1)		// if we have reached the right edge
			direction = 1;		// switch direction to "left"
		if (outputs == 0x8000)	// if we have reached the left edge
			direction = 0;		// switch direction to "right"
	}
}
示例#10
0
void  Pic_Data_Process(void)
{
    u8  tmp[40];
    u8   pic_buf[600];
    u16 i = 0;

    DF_TAKE;
    // 1.    Judge   last  package
    PackageLen = _485_content_wr;
    if(PackageLen < PageSIZE)
        CameraState.last_package = 1;
    else if((CameraState.last_package == 0) && (_485_content[510] == 0xFF) && (_485_content[511] == 0xD9))
    {
        CameraState.last_package = 1;
    }
    //  2.    Block ++
    CameraState.block_counter++;
    //   3.    Check   first   packet
    if(CameraState.create_Flag == 1)  // 如果是第一包则创建文件 hhmmss_x.jpg
    {
        CameraState.create_Flag = 0; // clear
        memset(tmp, 0, sizeof(tmp));
        memset(PictureName, 0, sizeof(PictureName));
        //-----------  创建图片文件处理  -------------
        /*
         每张图片占32个page    其中第1个page 为图片索引,后边127个Page为图片内容
         SST25 开辟个区域做图片缓存
        */
        if(CameraState.Camera_Number == 1)
        {
            pic_current_page = PicStart_offset; //起始page 固定为缓存起始地址
            //擦除一个64K的区域用于图片存储

            Api_DFdirectory_Delete(camera_1);

        }
        else if(CameraState.Camera_Number == 2)
        {
            pic_current_page = PicStart_offset2; //起始page 固定为缓存起始地址
            //擦除一个64K的区域用于图片存储
            Api_DFdirectory_Delete(camera_2);
            ;
        }
        else if(CameraState.Camera_Number == 3)
        {
            pic_current_page = PicStart_offset3; //起始page 固定为缓存起始地址
            //擦除一个64K的区域用于图片存储
            Api_DFdirectory_Delete(camera_3);
        }
        else if(CameraState.Camera_Number == 4)
        {
            pic_current_page = PicStart_offset4; //起始page 固定为缓存起始地址
            //擦除一个64K的区域用于图片存储
            Api_DFdirectory_Delete(camera_4);
        }
        DF_delay_ms(150);
        WatchDog_Feed();
        pic_current_page++;  // 图片内容从 第二个page 开始 第一个Page 存储的是图片索引
        pic_PageIn_offset = 0; // 页内偏移清空
        pic_size = 0; // 清除图片大小
        //------------------------------------------
        memset(PictureName, 0, sizeof(PictureName));
		// sprintf((char*)PictureName,"0:%02d%02d%02d%02d%02d%02d-%d.jpg",time_now.year,time_now.month,time_now.day,time_now.hour,time_now.min,time_now.sec,CameraState.Camera_Number); 	
		sprintf((char*)PictureName,"%02d%02d%02d%02d%02d%02d-%d.jpg",time_now.year,time_now.month,time_now.day,time_now.hour,time_now.min,time_now.sec,CameraState.Camera_Number);	 
        if(GB19056.workstate == 0)
            rt_kprintf("\r\n              创建图片名称: %s \r\n           ", PictureName);
        WatchDog_Feed();


        WatchDog_Feed();
        // -----    写图片索引 -------
        Save_MediaIndex(0, PictureName, CameraState.Camera_Number, 0);
    }

    //  4.   填写存储图片内容数据  --------------------
    WatchDog_Feed();
    DF_WriteFlashDirect(pic_current_page, 0, _485_content, PackageLen); // 写一次一个Page 512Bytes
    delay_ms(150);

#ifdef TFCARD
    if(sd_ok)
        sd_writefile(PictureName, _485_content, PackageLen);
#endif
    //  rt_kprintf(" \r\n ---- pkg=%d  \r\n",CameraState.block_counter);

    //---  read compare
    memset(pic_buf, 0, 600);
    DF_ReadFlash(pic_current_page, 0, pic_buf, PackageLen);
    delay_ms(10);
    for(i = 0; i < PackageLen; i++)
    {
        if(pic_buf[i] != _485_content[i])
        {
            if(GB19056.workstate == 0)
                rt_kprintf(" \r\n write--read Error");
            // rt_kprintf(" \r\n ----read not equal write  where i=%d  Rd[i]=%2X  WR[i]=%2X \r\n",i,pic_buf[i],_485_content[i]);
            DF_WriteFlashDirect(pic_current_page, 0, _485_content, PackageLen); // 再写一次一个Page 512Bytes
            delay_ms(100);
            break;
        }
    }
    pic_size += PackageLen; // 图片大小累加
    pic_current_page++; //写一页加一
    // pic_PageIn_offset+=PackageLen;
    //  DF_delay_ms(50);
    //   5.   最后一包 ,即拍照结束
    if(CameraState.last_package == 1)
    {
        memset(_485_content, 0, sizeof(_485_content));
        _485_content_wr = 0;

        //-------------  图片拍照结束 相关处理  ------------------------------------
        //  1. 写图片索引
        if(CameraState.Camera_Number == 1)
            pic_current_page = PicStart_offset; //计算图片起始page
        else if(CameraState.Camera_Number == 2)
            pic_current_page = PicStart_offset2; //计算图片起始page
        else if(CameraState.Camera_Number == 3)
            pic_current_page = PicStart_offset3; //计算图片起始page
        else if(CameraState.Camera_Number == 4)
            pic_current_page = PicStart_offset4; //计算图片起始page
        PictureName[18] = CameraState.Camera_Number;
        memcpy(PictureName + 19, (u8 *)&pic_size, 4);
        DF_WriteFlashDirect(pic_current_page, 0, PictureName, 23);
        DF_delay_ms(8);

        //  5.1   更新图片读写记录
        //--------------------------------------------------------------------------
        if(GB19056.workstate == 0)
            rt_kprintf("\r\n        PicSize: %d Bytes\r\n    Camera  %d   End\r\n", pic_size, CameraState.Camera_Number);
        CameraState.SingleCamra_TakeResualt_BD = 0;	  //  单路摄像头拍照
        SD_ACKflag.f_BD_CentreTakeAck_0805H = 1; //  发送中心拍照命令应答
        //----------  Normal process ---------------------
        Camera_End(MultiTake.Taking);


        // 5.2   拍照完成后检查有没有多路 拍-----------Multi Take process--------------------
        if(1 == MultiTake.Taking)
        {
            switch(CameraState.Camera_Number)
            {
            case  1:
                //-------- old process---------------
                MultiTake.TakeResult[0] = Take_Success; // 表示第一路摄像头拍照失败
                //--------- new   process-------------
                MultiTake.Take_retry = 0;
                //-------------------------------------------
                if(CHKendTake_ReadyToSend())// 检查是否是最后的拍照线路
                    break;
                //----------拍照下一路摄像头-----------
                CameraState.Camera_Number = 2;
                //-------------------------
                Camera_Start(CameraState.Camera_Number);

                break;
            case  2:
                //-------- old process---------------
                MultiTake.TakeResult[1] = Take_Success; // 表示第一路摄像头拍照失败
                //--------- new   process-------------
                MultiTake.Take_retry = 0;
                //-------------------------------------------
                if(CHKendTake_ReadyToSend())// 检查是否是最后的拍照线路
                    break;
                //----------拍照下一路摄像头-----------
                CameraState.Camera_Number = 3;
                //-------------------------
                Camera_Start(CameraState.Camera_Number);

                break;
            case  3:
                //-------- old process---------------
                MultiTake.TakeResult[2] = Take_Success; // 表示第一路摄像头拍照失败
                //--------- new   process-------------
                MultiTake.Take_retry = 0;
                //-------------------------------------------
                if(CHKendTake_ReadyToSend())// 检查是否是最后的拍照线路
                    break;
                //----------拍照下一路摄像头-----------
                CameraState.Camera_Number = 4;
                //-------------------------
                Camera_Start(CameraState.Camera_Number);

                break;
            case  4:
                //-------- old process---------------
                MultiTake.TakeResult[3] = Take_Success; // 表示第一路摄像头拍照失败
                //--------- new   process-------------
                MultiTake.Take_retry = 0;

                //-------------------------------------------
                if(CHKendTake_ReadyToSend())// 检查是否是最后的拍照线路
                    break;

                break;
            default:
                MultiTake_End();
                break;

            }

        }
        else if((0 == MultiTake.Taking) && (0 == MultiTake.Transfering))
        {
            //------ 判断车门开关拍照是否上传状态 ------
            if((OpenDoor_StartTakeFlag == 1) && (Opendoor_transFLAG == 0))
            {
                MultiTake_End();   // 车门开关不上传
                OpenDoor_StartTakeFlag = 0;
            }
            else
            {
                //rt_kprintf("\r\n Single Camera !\r\n");
                if(CameraState.Camera_Take_not_trans == 0)
                    Photo_send_start(CameraState.Camera_Number);  //在不是多路拍照的情况下拍完就可以上传了
                else
                    CameraState.Camera_Take_not_trans = 0;
            }
        }
        //  拍照结束
    }
    else
    {

        //------- change state  -------
        CameraState.status = transfer;
        CameraState.OperateFlag = 0; // clear

        CameraState.TX_485const_Enable = 1; // 发送485 命令
        _485_RXstatus._485_receiveflag = IDLE_485;
        memset(_485_content, 0, sizeof(_485_content));
        _485_content_wr = 0;
        //rt_kprintf("\r\n  One Packet Over!\r\n");

    }
    DF_RELEASE;
}
示例#11
0
void LoopMonitorIsm::LM_Scan_A_Loop(U32 FCinstance)
{
	U32				 chip = FCLOOPCHIP(FCinstance);
	PINSTANCE_DATA	 Id = &Instance_Data[chip];
	LM_CONTEXT		*pLmc;
	STATUS			 status;
	U16				 state, type;
	U8				 loop_ids;
	U8				*buffer = (U8 *)new(tPCI) char[2048];
	U8				*map = (U8 *)new(tPCI) char[128];
	U32				 portType = 0;
	U16				 vp_index = 0, id;
	FCPortDatabaseRecord	*pDb;
	LM_FCDB_STATE	*pFCDBState;
	
	TRACE_ENTRY(LM_Scan_A_Loop);

	// allocate our context
	status = FCP_Get_Firmware_State(Id, &state);
	
	if (status != MB_STS_GOOD)
	{
		TRACE_HEX(TRACE_L2, "\n\rLM_Scan_Loops: FCP_Get_Firmware_State Failed - ", status);
	}
	else
	{
		TRACEF(TRACE_L2, ("\n\r\n\rLoop:%d state=%x", FCinstance, state));
	}
	
	if (state != 0x0003)
	{
		// loop is not ready
		LoopFlags[chip] = LM_STS_LOOP_DOWN;
		LM_Loop_Desc[chip]->ActualLoopState = LoopDown;
		
		// Update tables
		goto UpdateTable;
	}
	
	// get the AL_PA map for this loop
	status = FCP_Get_FC_AL_Position_Map(Id, map, &type);
	
	if (status != MB_STS_GOOD)
	{
		TRACE_HEX(TRACE_L2, "\n\rLM_Scan_Loops: LM_Get_Pos_Map Failed - ", status);
	}
	else
	{
		TRACE_HEX16(TRACE_L8, "\n\rMap Type = ", type);
		TRACE_DUMP_HEX(TRACE_L3, "\n\rFC_AL Map:", map, 128);
	}
	
	// set our portType based on the loop
	if ((Instance_Data[chip].FCP_config.enable_initiator_mode) &&
			(Instance_Data[chip].FCP_config.enable_target_mode))
		portType = FC_PORT_TYPE_TARGET_INITIATOR;
	else if (Instance_Data[chip].FCP_config.enable_initiator_mode)
		portType = FC_PORT_TYPE_INITIATOR;
	else if (Instance_Data[chip].FCP_config.enable_target_mode)
		portType = FC_PORT_TYPE_TARGET;
	
	TRACE_HEX(TRACE_L3, "\n\rLM_Scan_Loops: num containers: ", pPDB[chip]->Count());

	// get the number of IDs
	loop_ids = map[0];
	num_IDs[chip] = map[0];
	TRACE_HEX16(TRACE_L3, "\n\rNumber of IDs found = ", num_IDs[chip]);
		
	// Make an entry for us if it does not exist,
	// first try to get the record from the list
	id = AL_PA_ID[map[1]];
	if ((pPDB[chip]->Get((CONTAINER_ELEMENT &)pFCDBState, (CONTAINER_KEY)id)) == FALSE)
	{
		// did not exist
		pFCDBState = new(tPCI) LM_FCDB_STATE;
		memset(pFCDBState, 0, sizeof(LM_FCDB_STATE));
		pDb = new(tPCI) FCPortDatabaseRecord;
		pFCDBState->pDBR = pDb;
		//pFCDBState->state = FCDB_STATE_ADD;	// Add new entry
		memset(pDb, 0, sizeof(FCPortDatabaseRecord));
		
		// fill in the record
		pDb->version = FC_PORT_DATABASE_TABLE_VERSION;
		pDb->size = sizeof(FCPortDatabaseRecord);
		// assumes this is already valid
		pDb->ridLoopDescriptor = LM_Loop_Desc[chip]->rid;
		pDb->id = id;
		// TODO: wwn support
		//memcpy(&pDb->wwName[0], &buffer[20], 8);
		//memcpy(&pDb->wwnNodeName[0], &buffer[12], 8);
		// always mark active
		pDb->portStatus = FC_PORT_STATUS_ACTIVE;
		// set portType
		pDb->portType = portType;
		
		pDb->attribs = FC_PORT_OWNER_INTERNAL;		// ours
						
		// add to the list
		pPDB[chip]->Add((CONTAINER_ELEMENT)pFCDBState, (CONTAINER_KEY)id);
	}
	
	// skip self (must be at least 2 ?)
	loop_ids--;
	// read the Port Database for each loop ID
	for (int i = 2; loop_ids; i++, loop_ids--)
	{
		int trys = 200;		// set number of retries for get database
		
		id = AL_PA_ID[map[i]];
			
		if (id == 0xff)
			continue;		// invalid AL_PA, skip this one
		
		TRACE_HEX16(TRACE_L2, "\n\rID = ", id);

retry:
		status = FCP_Get_Port_Data_Base(Id, buffer, id, vp_index);
		
		if (status != MB_STS_GOOD)
		{
			TRACE_HEX(TRACE_L2, "\n\rLM_Scan_Loops: FCP_Get_Port_Data_Base Failed - ", status);
		}
		else
		{
			// check for a valid Port Database
			if ((buffer[0x4e] & 0x30) == 0)
			{
				// zero is not valid
				if (--trys)
				{
					// delay 10ms here
					delay_ms(10);
					
					TRACE_HEX16(TRACE_L3, "\n\rLM_Scan_Loops: FCP_Get_Port_Data_Base Rety = ", trys);
					goto retry;
				}
				else
				{
					// no more trys, Get Port DB is never going to work for this ID
					TRACEF(TRACE_L2, ("\n\rLM_Scan_Loops(%d): FCP_Get_Port_Data_Base, no more retries", FCinstance));
					
					status = MB_STS_INVALID_CMD;
				}
			}
			else
			{
				if (trys != 200)
				{
					TRACEF(TRACE_L2, ("\n\rLM_Scan_Loops(%d): FCP_Get_Port_Data_Base, retries=%d", 
															FCinstance, (200 - trys)));
				}
			}
			
			TRACE_DUMP_HEX(TRACE_L3, "\n\rPort Database:", buffer, 128);
			
			// try to get the record from the list
			if ((pPDB[chip]->Get((CONTAINER_ELEMENT &)pFCDBState, (CONTAINER_KEY)id)) == FALSE)
			{
				// did not exist
				pFCDBState = new(tPCI) LM_FCDB_STATE;
				memset(pFCDBState, 0, sizeof(LM_FCDB_STATE));
				pDb = new(tPCI) FCPortDatabaseRecord;
				pFCDBState->pDBR = pDb;
				//pFCDBState->state = FCDB_STATE_ADD;	// Add new entry
				memset(pDb, 0, sizeof(FCPortDatabaseRecord));
				
				// fill in the record
				pDb->version = FC_PORT_DATABASE_TABLE_VERSION;
				pDb->size = sizeof(FCPortDatabaseRecord);
				// assumes this is already valid
				pDb->ridLoopDescriptor = LM_Loop_Desc[chip]->rid;
				pDb->id = id;

				// add to the list
				pPDB[chip]->Add((CONTAINER_ELEMENT)pFCDBState, (CONTAINER_KEY)id);
			}
			else
			{
				pDb = pFCDBState->pDBR;
			}
			
			if (status != MB_STS_GOOD)
			{
				// mark a hard failure
				pDb->portStatus = 0xff;
			}
			else
			{
				// mark active
				pDb->portStatus = FC_PORT_STATUS_ACTIVE;

				// always update: WWN, type and Owner
				memcpy(&pDb->wwName[0], &buffer[20], 8);
				memcpy(&pDb->wwnNodeName[0], &buffer[12], 8);
				
				// Target bit 0, Initiator bit 1
				pDb->portType = (buffer[0x4e] >> 4) & 0x03;
				TRACE_HEX(TRACE_L3, "\n\rLM_Scan_Loops: portType: ", pDb->portType);
				
				// check if ours
				if (LM_Loop_Desc[chip]->IDsInUse && 
						(memchr(&LM_Loop_Desc[chip]->TargetIDs[0], id,
						   LM_Loop_Desc[chip]->IDsInUse)))
					pDb->attribs |= FC_PORT_OWNER_INTERNAL;		// ours
				else
					pDb->attribs &= ~FC_PORT_OWNER_INTERNAL;		// theirs
					
				// Check if this port is usable in a virtual circuit
				// must be on a target port and be an external initiator
				if (((portType == FC_PORT_TYPE_TARGET) || 
						(portType == FC_PORT_TYPE_TARGET_INITIATOR)) &&
							(pDb->portType == FC_PORT_TYPE_INITIATOR))
					pDb->attribs |= FC_PORT_OWNER_VC_USE_OK;		// OK in vc
				else
					pDb->attribs &= ~FC_PORT_OWNER_VC_USE_OK;		// not OK in vc
								
			}
		}
	}
	
	TRACE_HEX(TRACE_L3, "\n\rLM_Scan_Loops: num containers after scan: ", pPDB[chip]->Count());

	// unroll the FCPortDatabase containers, update the PTS
	// with the new port IDs that were found and/or removed
	for (int x = pPDB[chip]->Count() - 1; x >= 0; x--)
	{
		// get each container in sequence
		pPDB[chip]->GetAt((CONTAINER_ELEMENT &)pFCDBState, x);
		
		// check if the device is still active
		if ((pFCDBState->pDBR->portStatus == FC_PORT_STATUS_ACTIVE) && 
					(memchr(&map[1], ID_AL_PA[pFCDBState->pDBR->id], map[0])))
		{
			pFCDBState->pDBR->portStatus = FC_PORT_STATUS_ACTIVE;
		}
		// allow our ports to always show ACTIVE and bad ports to show REMOVED
		else if ((pFCDBState->pDBR->attribs & FC_PORT_OWNER_INTERNAL) == 0)
		{
			// not active anymore, device offline/removed
			pFCDBState->pDBR->portStatus = FC_PORT_STATUS_REMOVED;
		}
		
		// update or add an entry in the FCPortDatabaseRecord Table
		// no Callback, no state, just do it.
		LmDBTableUpdate(pFCDBState, NULL, (pLMCallback_t)NULL);
	}

	// this loop is now up
	LM_Loop_Desc[chip]->ActualLoopState = LoopUp;
	
	// do we have a DriveMonitor assigned to this loop?
	if (LM_Loop_Desc[chip]->vdnDriveMonitor)
	{
		// yes and since the loop is up, send a DM_SCAN message to it.
		LM_Send_DM_SCAN(chip);
	}

UpdateTable:

	// Update the table entry for this loop
	pLmc = new (tSMALL|tUNCACHED) LM_CONTEXT;
	memset(pLmc, 0, sizeof(LM_CONTEXT));
	pLmc->last = 1;
		
	LmLpTableUpdate(NULL, pLmc, FCinstance, (pLMCallback_t) &LM_Scan_Callback);

	// return local resources
	delete map;
	delete buffer;
	
} // LM_Scan_A_Loop
示例#12
0
//void control(int wake_Flag, SerialPort* telitPort, SerialPort* debugPort) {
void control(int wake_Flag){
	
	//conditional set init state due to what causes uC to wake up
	
	if(wake_Flag){
		current_state = ST_WAIT_PIN;
	}	
	else{
		//Starting from Keypad Press
		current_state = ST_AVAILABLE;		
		Engage_Lock();
		//init should read timestamp and fill position struct on data from GPS
		
		
		//init should read in SIM card info for BIKE ID , battery level
		present_state.repair_state = BIKE_WORKING;
		present_state.owner_state = BIKE_AVAILABLE;
		present_state.lock_state = BIKE_LOCKED;
		for(int i  = 0 ; i < BIKE_ID_LEN +1 ; i++){
			present_state.bike_id[i] = 0 ;
		}
		for(int i = 0 ; i < ACCOUNT_LEN + 1 ; i++){
			present_state.account[i] = 0 ;
		}
		for(int i = 0; i < PIN_LEN + 1 ; i++){
			present_state.pin[i] = 0;
		}
		
		
		present_state.timestamp = 0;
		present_state.battery_level = 0;
		present_state.positions_count = 2;
		//present_state.positions = *(struct position present_position); todo later
		pin_fail_flag = 0;
		//start sleep timeout
		sleep_timeout_flag = 1;
		sleep_timeout_counter = 0;
		sleep_timeout_ready = 0;
		//set locked state
		lock_flag = 1;
		
		turnOffLEDS();
	}
		
				
	
	//initialize gsm module
	
/*
	Toggle_PWRKEY();
	
	uart0SendByte('A');
	uart0SendByte('T');
	uart0SendByte('\n');
	while(1){
	uartFlag = uartReceiveByte(0 , &rData );
	uart1SendByte(rData);
		if(!uartFlag)
			break;
	}

*/
	//rprintfInit(DebugPrint);
	///rprintf("Starting");

			
	 while (current_state != ST_SLEEP) {
		 int i = 0;
		 evnt = getNextEvent();
		 //<----telitEventHandler();
		//sockethandler should  go here , and set flag
		 for (i = 0; i < TRANS_COUNT; i++) {
			 if ( (current_state == trans[i].st) ) {
				 if ( (evnt == trans[i].ev) ) {
					 next_state = (trans[i].fn)();
					 break;
				 }
			 }
		 }
		  current_state = next_state;
		
		  delay_ms(100);
	 }	
	 
	
	//setup sleep state and tell uC to loop in main

}
示例#13
0
文件: main.c 项目: LiosonLiu/LoRa
//=====================================
void main()
//=====================================
{
	u16 i,j,k=0,g;
	SysTime 				= 0;
	SystemFlag 			= 0x00;
	mode 						= 0x01;//lora mode
	Freq_Sel 				= 0x00;//433M
	Power_Sel 			= 0x00;//
	Lora_Rate_Sel 	= 0x06;//
	BandWide_Sel 		= 0x07;
	Fsk_Rate_Sel 		= 0x00;
	
	_asm("sim");               //Disable interrupts.
	mcu_init();
	ITC_SPR4 = 0xf3;//time2 interrupt priority 2¡¢level13
	ITC_SPR5 = 0x3c;//UART1_RX ¡¢UART_TX interrupt priority 2
	ITC_SPR6 = 0x00;//UART3_RX ¡¢UART_TX interrupt priority 2
	_asm("rim");              //Enable interrupts.
	
	GREEN_LED_L();
	RED_LED_L();
	delay_ms(500);
	GREEN_LED_H();
	RED_LED_H();
	sx1278_Config();
  sx1278_LoRaEntryRx();
	TIM1_CR1 |= 0x01;			//enable time1
	MasterModeFlag=0;
	while(1)
	{
	if(GetOption())	//Slave
		{
		if(SystemFlag&PreviousOptionBit)
			{
			sx1278_LoRaEntryRx();
			SystemFlag&=(!PreviousOptionBit);
			}
		if(sx1278_LoRaRxPacket())
			{
			GREEN_LED_L();
			delay_ms(100);
			GREEN_LED_H();
			RED_LED_L();
			sx1278_LoRaEntryTx();
			sx1278_LoRaTxPacket();
			RED_LED_H();
			sx1278_LoRaEntryRx();
			}		
		}
	else					//Master
		{
		if((SystemFlag&PreviousOptionBit)==0)
			{
			MasterModeFlag=0;
			SystemFlag|=PreviousOptionBit;
			}			
		switch(MasterModeFlag)
			{
			case 0:
				if(time_flag==1)
				{
				time_flag=0;
				RED_LED_L();
				sx1278_LoRaEntryTx();
				sx1278_LoRaTxPacket();
				RED_LED_H();
				MasterModeFlag++;
				}
				break;
			case 1:
				sx1278_LoRaEntryRx();
				for(i=0;i<30;i++)
					{
					delay_ms(100);
					if(sx1278_LoRaRxPacket())
						{
						i=50;
						GREEN_LED_L();
						delay_ms(100);
						GREEN_LED_H();			
						}
					}
				MasterModeFlag++;
				break;
			case 2:
				if(time_flag==1)
					{
					time_flag=0;
					MasterModeFlag=0;
					}
				break;
			}
		}
	}
}
示例#14
0
static void twl3025_wait_ibic_access(void)
{
    /* Wait 6 * 32kHz clock cycles for first IBIC access (187us + 10% = 210us) */
    delay_ms(1);
}
示例#15
0
文件: lcd.c 项目: peterzjin/vbox
//初始化lcd
//该初始化函数可以初始化各种ILI93XX液晶,但是其他函数是基于ILI9320的!!!
//在其他型号的驱动芯片上没有测试! 
void LCD_Init(void)
{  
     										 
	GPIO_InitTypeDef GPIO_InitStructure;

 	RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO, ENABLE); 
	GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable , ENABLE);
	
	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10|GPIO_Pin_9|GPIO_Pin_8|GPIO_Pin_7|GPIO_Pin_6;	   //GPIO_Pin_10
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;  //推挽输出
	GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOC, &GPIO_InitStructure); //GPIOC	
    //GPIO_WriteBit(GPIOC,GPIO_Pin_10|GPIO_Pin_9|GPIO_Pin_8|GPIO_Pin_7|GPIO_Pin_6,Bit_SET);
	GPIO_SetBits(GPIOC,GPIO_Pin_10|GPIO_Pin_9|GPIO_Pin_8|GPIO_Pin_7|GPIO_Pin_6);


	GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;	//  
	GPIO_Init(GPIOB, &GPIO_InitStructure); //GPIOB
	//GPIO_WriteBit(GPIOC,GPIO_Pin_All,Bit_SET); 
	GPIO_SetBits(GPIOB,GPIO_Pin_All);
 
	delay_ms(50); // delay 50 ms 
	LCD_WriteReg(0x0000,0x0001);
	delay_ms(50); // delay 50 ms 
	DeviceCode = LCD_ReadReg(0x0000);   
	printf(" LCD ID:%x\n",DeviceCode); //打印LCD ID  
	if(DeviceCode==0x9325||DeviceCode==0x9328)//ILI9325
	{
  		LCD_WriteReg(0x00EC,0x108F);// internal timeing  
		LCD_WriteReg(0x00EF,0x1234);// ADD 
		LCD_WriteReg(0x0001,0x0100);     
        LCD_WriteReg(0x0002,0x0700);//电源开启     

		//LCD_WriteReg(0x00e7,0x0010);      
        //LCD_WriteReg(0x0000,0x0001);//开启内部时钟
        LCD_WriteReg(0x0001,0x0100);     
        LCD_WriteReg(0x0002,0x0700);//电源开启                    
		//LCD_WriteReg(0x0003,(1<<3)|(1<<4) ); 	//65K  RGB
		//DRIVE TABLE(寄存器 03H)
		//BIT3=AM BIT4:5=ID0:1
		//AM ID0 ID1   FUNCATION
		// 0  0   0	   R->L D->U
		// 1  0   0	   D->U	R->L
		// 0  1   0	   L->R D->U
		// 1  1   0    D->U	L->R
		// 0  0   1	   R->L U->D
		// 1  0   1    U->D	R->L
		// 0  1   1    L->R U->D 正常就用这个.
		// 1  1   1	   U->D	L->R
        LCD_WriteReg(0x0003,(1<<12)|(3<<4)|(0<<3) );//65K    
        LCD_WriteReg(0x0004,0x0000);                                   
        LCD_WriteReg(0x0008,0x0207);	           
        LCD_WriteReg(0x0009,0x0000);         
        LCD_WriteReg(0x000a,0x0000);//display setting         
        LCD_WriteReg(0x000c,0x0001);//display setting          
        LCD_WriteReg(0x000d,0x0000);//0f3c          
        LCD_WriteReg(0x000f,0x0000);
		//电源配置
        LCD_WriteReg(0x0010,0x0000);   
        LCD_WriteReg(0x0011,0x0007);
        LCD_WriteReg(0x0012,0x0000);                                                                 
        LCD_WriteReg(0x0013,0x0000);                 
        delay_ms(50); 
        LCD_WriteReg(0x0010,0x1590);   
        LCD_WriteReg(0x0011,0x0227);
        delay_ms(50); 
        LCD_WriteReg(0x0012,0x009c);                  
        delay_ms(50); 
        LCD_WriteReg(0x0013,0x1900);   
        LCD_WriteReg(0x0029,0x0023);
        LCD_WriteReg(0x002b,0x000e);
        delay_ms(50); 
        LCD_WriteReg(0x0020,0x0000);                                                            
        LCD_WriteReg(0x0021,0x013f);           
		delay_ms(50); 
		//伽马校正
        LCD_WriteReg(0x0030,0x0007); 
        LCD_WriteReg(0x0031,0x0707);   
        LCD_WriteReg(0x0032,0x0006);
        LCD_WriteReg(0x0035,0x0704);
        LCD_WriteReg(0x0036,0x1f04); 
        LCD_WriteReg(0x0037,0x0004);
        LCD_WriteReg(0x0038,0x0000);        
        LCD_WriteReg(0x0039,0x0706);     
        LCD_WriteReg(0x003c,0x0701);
        LCD_WriteReg(0x003d,0x000f);
        delay_ms(50); 
        LCD_WriteReg(0x0050,0x0000); //水平GRAM起始位置 
        LCD_WriteReg(0x0051,0x00ef); //水平GRAM终止位置                    
        LCD_WriteReg(0x0052,0x0000); //垂直GRAM起始位置                    
        LCD_WriteReg(0x0053,0x013f); //垂直GRAM终止位置  
        
        LCD_WriteReg(0x0060,0xa700);        
        LCD_WriteReg(0x0061,0x0001); 
        LCD_WriteReg(0x006a,0x0000);
        LCD_WriteReg(0x0080,0x0000);
        LCD_WriteReg(0x0081,0x0000);
        LCD_WriteReg(0x0082,0x0000);
        LCD_WriteReg(0x0083,0x0000);
        LCD_WriteReg(0x0084,0x0000);
        LCD_WriteReg(0x0085,0x0000);
      
        LCD_WriteReg(0x0090,0x0010);     
        LCD_WriteReg(0x0092,0x0600);  
        //开启显示设置    
        LCD_WriteReg(0x0007,0x0133);  
	}else if(DeviceCode==0x9320||DeviceCode==0x9300)
	{
		LCD_WriteReg(0x00,0x0000);
		LCD_WriteReg(0x01,0x0100);	//Driver Output Contral.
		LCD_WriteReg(0x02,0x0700);	//LCD Driver Waveform Contral.
		LCD_WriteReg(0x03,0x1030);//Entry Mode Set.
		//LCD_WriteReg(0x03,0x1018);	//Entry Mode Set.
	
		LCD_WriteReg(0x04,0x0000);	//Scalling Contral.
		LCD_WriteReg(0x08,0x0202);	//Display Contral 2.(0x0207)
		LCD_WriteReg(0x09,0x0000);	//Display Contral 3.(0x0000)
		LCD_WriteReg(0x0a,0x0000);	//Frame Cycle Contal.(0x0000)
		LCD_WriteReg(0x0c,(1<<0));	//Extern Display Interface Contral 1.(0x0000)
		LCD_WriteReg(0x0d,0x0000);	//Frame Maker Position.
		LCD_WriteReg(0x0f,0x0000);	//Extern Display Interface Contral 2.	    
		delay_ms(50); 
		LCD_WriteReg(0x07,0x0101);	//Display Contral.
		delay_ms(50); 								  
		LCD_WriteReg(0x10,(1<<12)|(0<<8)|(1<<7)|(1<<6)|(0<<4));	//Power Control 1.(0x16b0)
		LCD_WriteReg(0x11,0x0007);								//Power Control 2.(0x0001)
		LCD_WriteReg(0x12,(1<<8)|(1<<4)|(0<<0));				//Power Control 3.(0x0138)
		LCD_WriteReg(0x13,0x0b00);								//Power Control 4.
		LCD_WriteReg(0x29,0x0000);								//Power Control 7.
	
		LCD_WriteReg(0x2b,(1<<14)|(1<<4));	    
		LCD_WriteReg(0x50,0);	//Set X Star
		//水平GRAM终止位置Set X End.
		LCD_WriteReg(0x51,239);	//Set Y Star
		LCD_WriteReg(0x52,0);	//Set Y End.t.
		LCD_WriteReg(0x53,319);	//
	
		LCD_WriteReg(0x60,0x2700);	//Driver Output Control.
		LCD_WriteReg(0x61,0x0001);	//Driver Output Control.
		LCD_WriteReg(0x6a,0x0000);	//Vertical Srcoll Control.
	
		LCD_WriteReg(0x80,0x0000);	//Display Position? Partial Display 1.
		LCD_WriteReg(0x81,0x0000);	//RAM Address Start? Partial Display 1.
		LCD_WriteReg(0x82,0x0000);	//RAM Address End-Partial Display 1.
		LCD_WriteReg(0x83,0x0000);	//Displsy Position? Partial Display 2.
		LCD_WriteReg(0x84,0x0000);	//RAM Address Start? Partial Display 2.
		LCD_WriteReg(0x85,0x0000);	//RAM Address End? Partial Display 2.
	
		LCD_WriteReg(0x90,(0<<7)|(16<<0));	//Frame Cycle Contral.(0x0013)
		LCD_WriteReg(0x92,0x0000);	//Panel Interface Contral 2.(0x0000)
		LCD_WriteReg(0x93,0x0001);	//Panel Interface Contral 3.
		LCD_WriteReg(0x95,0x0110);	//Frame Cycle Contral.(0x0110)
		LCD_WriteReg(0x97,(0<<8));	//
		LCD_WriteReg(0x98,0x0000);	//Frame Cycle Contral.	   
		LCD_WriteReg(0x07,0x0173);	//(0x0173)
	}else if(DeviceCode==0x5408)
	{
		LCD_WriteReg(0x01,0x0100);								  
		LCD_WriteReg(0x02,0x0700);//LCD Driving Waveform Contral 
		LCD_WriteReg(0x03,0x1030);//Entry Mode设置 	   
		//指针从左至右自上而下的自动增模式
		//Normal Mode(Window Mode disable)
		//RGB格式
		//16位数据2次传输的8总线设置
		LCD_WriteReg(0x04,0x0000); //Scalling Control register     
		LCD_WriteReg(0x08,0x0207); //Display Control 2 
		LCD_WriteReg(0x09,0x0000); //Display Control 3	 
		LCD_WriteReg(0x0A,0x0000); //Frame Cycle Control	 
		LCD_WriteReg(0x0C,0x0000); //External Display Interface Control 1 
		LCD_WriteReg(0x0D,0x0000); //Frame Maker Position		 
		LCD_WriteReg(0x0F,0x0000); //External Display Interface Control 2 
 		delay_ms(20);
		//TFT 液晶彩色图像显示方法14
		LCD_WriteReg(0x10,0x16B0); //0x14B0 //Power Control 1
		LCD_WriteReg(0x11,0x0001); //0x0007 //Power Control 2
		LCD_WriteReg(0x17,0x0001); //0x0000 //Power Control 3
		LCD_WriteReg(0x12,0x0138); //0x013B //Power Control 4
		LCD_WriteReg(0x13,0x0800); //0x0800 //Power Control 5
		LCD_WriteReg(0x29,0x0009); //NVM read data 2
		LCD_WriteReg(0x2a,0x0009); //NVM read data 3
		LCD_WriteReg(0xa4,0x0000);	 
		LCD_WriteReg(0x50,0x0000); //设置操作窗口的X轴开始列
		LCD_WriteReg(0x51,0x00EF); //设置操作窗口的X轴结束列
		LCD_WriteReg(0x52,0x0000); //设置操作窗口的Y轴开始行
		LCD_WriteReg(0x53,0x013F); //设置操作窗口的Y轴结束行
		LCD_WriteReg(0x60,0x2700); //Driver Output Control
		//设置屏幕的点数以及扫描的起始行
		LCD_WriteReg(0x61,0x0001); //Driver Output Control
		LCD_WriteReg(0x6A,0x0000); //Vertical Scroll Control
		LCD_WriteReg(0x80,0x0000); //Display Position – Partial Display 1
		LCD_WriteReg(0x81,0x0000); //RAM Address Start – Partial Display 1
		LCD_WriteReg(0x82,0x0000); //RAM address End - Partial Display 1
		LCD_WriteReg(0x83,0x0000); //Display Position – Partial Display 2
		LCD_WriteReg(0x84,0x0000); //RAM Address Start – Partial Display 2
		LCD_WriteReg(0x85,0x0000); //RAM address End – Partail Display2
		LCD_WriteReg(0x90,0x0013); //Frame Cycle Control
		LCD_WriteReg(0x92,0x0000);  //Panel Interface Control 2
		LCD_WriteReg(0x93,0x0003); //Panel Interface control 3
		LCD_WriteReg(0x95,0x0110);  //Frame Cycle Control
		LCD_WriteReg(0x07,0x0173);		 
		delay_ms(50);
	}	
	else if(DeviceCode==0x1505)
	{
		// second release on 3/5  ,luminance is acceptable,water wave appear during camera preview
        LCD_WriteReg(0x0007,0x0000);
        delay_ms(50); 
        LCD_WriteReg(0x0012,0x011C);//0x011A   why need to set several times?
        LCD_WriteReg(0x00A4,0x0001);//NVM	 
        LCD_WriteReg(0x0008,0x000F);
        LCD_WriteReg(0x000A,0x0008);
        LCD_WriteReg(0x000D,0x0008);	    
  		//伽马校正
        LCD_WriteReg(0x0030,0x0707);
        LCD_WriteReg(0x0031,0x0007); //0x0707
        LCD_WriteReg(0x0032,0x0603); 
        LCD_WriteReg(0x0033,0x0700); 
        LCD_WriteReg(0x0034,0x0202); 
        LCD_WriteReg(0x0035,0x0002); //?0x0606
        LCD_WriteReg(0x0036,0x1F0F);
        LCD_WriteReg(0x0037,0x0707); //0x0f0f  0x0105
        LCD_WriteReg(0x0038,0x0000); 
        LCD_WriteReg(0x0039,0x0000); 
        LCD_WriteReg(0x003A,0x0707); 
        LCD_WriteReg(0x003B,0x0000); //0x0303
        LCD_WriteReg(0x003C,0x0007); //?0x0707
        LCD_WriteReg(0x003D,0x0000); //0x1313//0x1f08
        delay_ms(50); 
        LCD_WriteReg(0x0007,0x0001);
        LCD_WriteReg(0x0017,0x0001);//开启电源
        delay_ms(50); 
  		//电源配置
        LCD_WriteReg(0x0010,0x17A0); 
        LCD_WriteReg(0x0011,0x0217);//reference voltage VC[2:0]   Vciout = 1.00*Vcivl
        LCD_WriteReg(0x0012,0x011E);//0x011c  //Vreg1out = Vcilvl*1.80   is it the same as Vgama1out ?
        LCD_WriteReg(0x0013,0x0F00);//VDV[4:0]-->VCOM Amplitude VcomL = VcomH - Vcom Ampl
        LCD_WriteReg(0x002A,0x0000);  
        LCD_WriteReg(0x0029,0x000A);//0x0001F  Vcomh = VCM1[4:0]*Vreg1out    gate source voltage??
        LCD_WriteReg(0x0012,0x013E);// 0x013C  power supply on
        //Coordinates Control//
        LCD_WriteReg(0x0050,0x0000);//0x0e00
        LCD_WriteReg(0x0051,0x00EF); 
        LCD_WriteReg(0x0052,0x0000); 
        LCD_WriteReg(0x0053,0x013F); 
    	//Pannel Image Control//
        LCD_WriteReg(0x0060,0x2700); 
        LCD_WriteReg(0x0061,0x0001); 
        LCD_WriteReg(0x006A,0x0000); 
        LCD_WriteReg(0x0080,0x0000); 
    	//Partial Image Control//
        LCD_WriteReg(0x0081,0x0000); 
        LCD_WriteReg(0x0082,0x0000); 
        LCD_WriteReg(0x0083,0x0000); 
        LCD_WriteReg(0x0084,0x0000); 
        LCD_WriteReg(0x0085,0x0000); 
  		//Panel Interface Control//
        LCD_WriteReg(0x0090,0x0013);//0x0010 frenqucy
        LCD_WriteReg(0x0092,0x0300); 
        LCD_WriteReg(0x0093,0x0005); 
        LCD_WriteReg(0x0095,0x0000); 
        LCD_WriteReg(0x0097,0x0000); 
        LCD_WriteReg(0x0098,0x0000); 
  
        LCD_WriteReg(0x0001,0x0100); 
        LCD_WriteReg(0x0002,0x0700); 
        LCD_WriteReg(0x0003,0x1030); 
        LCD_WriteReg(0x0004,0x0000); 
        LCD_WriteReg(0x000C,0x0000); 
        LCD_WriteReg(0x000F,0x0000); 
        LCD_WriteReg(0x0020,0x0000); 
        LCD_WriteReg(0x0021,0x0000); 
        LCD_WriteReg(0x0007,0x0021); 
        delay_ms(20);
        LCD_WriteReg(0x0007,0x0061); 
        delay_ms(20);
        LCD_WriteReg(0x0007,0x0173); 
        delay_ms(20);
	}else if(DeviceCode==0xB505)
	{
		LCD_WriteReg(0x0000,0x0000);
		LCD_WriteReg(0x0000,0x0000);
		LCD_WriteReg(0x0000,0x0000);
		LCD_WriteReg(0x0000,0x0000);
		
		LCD_WriteReg(0x00a4,0x0001);
		delay_ms(20);		  
		LCD_WriteReg(0x0060,0x2700);
		LCD_WriteReg(0x0008,0x0202);
		
		LCD_WriteReg(0x0030,0x0214);
		LCD_WriteReg(0x0031,0x3715);
		LCD_WriteReg(0x0032,0x0604);
		LCD_WriteReg(0x0033,0x0e16);
		LCD_WriteReg(0x0034,0x2211);
		LCD_WriteReg(0x0035,0x1500);
		LCD_WriteReg(0x0036,0x8507);
		LCD_WriteReg(0x0037,0x1407);
		LCD_WriteReg(0x0038,0x1403);
		LCD_WriteReg(0x0039,0x0020);
		
		LCD_WriteReg(0x0090,0x001a);
		LCD_WriteReg(0x0010,0x0000);
		LCD_WriteReg(0x0011,0x0007);
		LCD_WriteReg(0x0012,0x0000);
		LCD_WriteReg(0x0013,0x0000);
		delay_ms(20);
		
		LCD_WriteReg(0x0010,0x0730);
		LCD_WriteReg(0x0011,0x0137);
		delay_ms(20);
		
		LCD_WriteReg(0x0012,0x01b8);
		delay_ms(20);
		
		LCD_WriteReg(0x0013,0x0f00);
		LCD_WriteReg(0x002a,0x0080);
		LCD_WriteReg(0x0029,0x0048);
		delay_ms(20);
		
		LCD_WriteReg(0x0001,0x0100);
		LCD_WriteReg(0x0002,0x0700);
		LCD_WriteReg(0x0003,0x1230);
		LCD_WriteReg(0x0008,0x0202);
		LCD_WriteReg(0x000a,0x0000);
		LCD_WriteReg(0x000c,0x0000);
		LCD_WriteReg(0x000d,0x0000);
		LCD_WriteReg(0x000e,0x0030);
		LCD_WriteReg(0x0050,0x0000);
		LCD_WriteReg(0x0051,0x00ef);
		LCD_WriteReg(0x0052,0x0000);
		LCD_WriteReg(0x0053,0x013f);
		LCD_WriteReg(0x0060,0x2700);
		LCD_WriteReg(0x0061,0x0001);
		LCD_WriteReg(0x006a,0x0000);
		//LCD_WriteReg(0x0080,0x0000);
		//LCD_WriteReg(0x0081,0x0000);
		LCD_WriteReg(0x0090,0X0011);
		LCD_WriteReg(0x0092,0x0600);
		LCD_WriteReg(0x0093,0x0402);
		LCD_WriteReg(0x0094,0x0002);
		delay_ms(20);
		
		LCD_WriteReg(0x0007,0x0001);
		delay_ms(20);
		LCD_WriteReg(0x0007,0x0061);
		LCD_WriteReg(0x0007,0x0173);
		
		LCD_WriteReg(0x0020,0x0000);
		LCD_WriteReg(0x0021,0x0000);	  
		LCD_WriteReg(0x00,0x22);  
	}else if(DeviceCode==0x8989)
	{	   
		LCD_WriteReg(0x0000,0x0001);//打开晶振
    	LCD_WriteReg(0x0003,0xA8A4);//0xA8A4
    	LCD_WriteReg(0x000C,0x0000);    
    	LCD_WriteReg(0x000D,0x080C);   
    	LCD_WriteReg(0x000E,0x2B00);    
    	LCD_WriteReg(0x001E,0x00B0);    
    	LCD_WriteReg(0x0001,0x2B3F);//驱动输出控制320*240  0x6B3F
    	LCD_WriteReg(0x0002,0x0600);
    	LCD_WriteReg(0x0010,0x0000);  
    	LCD_WriteReg(0x0011,0x6070); //定义数据格式  16位色 		横屏 0x6058
    	LCD_WriteReg(0x0005,0x0000);  
    	LCD_WriteReg(0x0006,0x0000);  
    	LCD_WriteReg(0x0016,0xEF1C);  
    	LCD_WriteReg(0x0017,0x0003);  
    	LCD_WriteReg(0x0007,0x0233); //0x0233       
    	LCD_WriteReg(0x000B,0x0000);  
    	LCD_WriteReg(0x000F,0x0000); //扫描开始地址
    	LCD_WriteReg(0x0041,0x0000);  
    	LCD_WriteReg(0x0042,0x0000);  
    	LCD_WriteReg(0x0048,0x0000);  
    	LCD_WriteReg(0x0049,0x013F);  
    	LCD_WriteReg(0x004A,0x0000);  
    	LCD_WriteReg(0x004B,0x0000);  
    	LCD_WriteReg(0x0044,0xEF00);  
    	LCD_WriteReg(0x0045,0x0000);  
    	LCD_WriteReg(0x0046,0x013F);  
    	LCD_WriteReg(0x0030,0x0707);  
    	LCD_WriteReg(0x0031,0x0204);  
    	LCD_WriteReg(0x0032,0x0204);  
    	LCD_WriteReg(0x0033,0x0502);  
    	LCD_WriteReg(0x0034,0x0507);  
    	LCD_WriteReg(0x0035,0x0204);  
    	LCD_WriteReg(0x0036,0x0204);  
    	LCD_WriteReg(0x0037,0x0502);  
    	LCD_WriteReg(0x003A,0x0302);  
    	LCD_WriteReg(0x003B,0x0302);  
    	LCD_WriteReg(0x0023,0x0000);  
    	LCD_WriteReg(0x0024,0x0000);  
    	LCD_WriteReg(0x0025,0x8000);  
    	LCD_WriteReg(0x004f,0);        //行首址0
    	LCD_WriteReg(0x004e,0);        //列首址0
	}else if(DeviceCode==0x4531)
	{
		LCD_WriteReg(0X00,0X0001);   
		delay_ms(10);   
		LCD_WriteReg(0X10,0X1628);   
		LCD_WriteReg(0X12,0X000e);//0x0006    
		LCD_WriteReg(0X13,0X0A39);   
		delay_ms(10);   
		LCD_WriteReg(0X11,0X0040);   
		LCD_WriteReg(0X15,0X0050);   
		delay_ms(10);   
		LCD_WriteReg(0X12,0X001e);//16    
		delay_ms(10);   
		LCD_WriteReg(0X10,0X1620);   
		LCD_WriteReg(0X13,0X2A39);   
		delay_ms(10);   
		LCD_WriteReg(0X01,0X0100);   
		LCD_WriteReg(0X02,0X0300);   
		LCD_WriteReg(0X03,0X1030);//改变方向的   
		LCD_WriteReg(0X08,0X0202);   
		LCD_WriteReg(0X0A,0X0008);   
		LCD_WriteReg(0X30,0X0000);   
		LCD_WriteReg(0X31,0X0402);   
		LCD_WriteReg(0X32,0X0106);   
		LCD_WriteReg(0X33,0X0503);   
		LCD_WriteReg(0X34,0X0104);   
		LCD_WriteReg(0X35,0X0301);   
		LCD_WriteReg(0X36,0X0707);   
		LCD_WriteReg(0X37,0X0305);   
		LCD_WriteReg(0X38,0X0208);   
		LCD_WriteReg(0X39,0X0F0B);   
		LCD_WriteReg(0X41,0X0002);   
		LCD_WriteReg(0X60,0X2700);   
		LCD_WriteReg(0X61,0X0001);   
		LCD_WriteReg(0X90,0X0210);   
		LCD_WriteReg(0X92,0X010A);   
		LCD_WriteReg(0X93,0X0004);   
		LCD_WriteReg(0XA0,0X0100);   
		LCD_WriteReg(0X07,0X0001);   
		LCD_WriteReg(0X07,0X0021);   
		LCD_WriteReg(0X07,0X0023);   
		LCD_WriteReg(0X07,0X0033);   
		LCD_WriteReg(0X07,0X0133);   
		LCD_WriteReg(0XA0,0X0000); 
	}else if(DeviceCode==0x4535)
	{			      
		LCD_WriteReg(0X15,0X0030);   
		LCD_WriteReg(0X9A,0X0010);   
 		LCD_WriteReg(0X11,0X0020);   
 		LCD_WriteReg(0X10,0X3428);   
		LCD_WriteReg(0X12,0X0002);//16    
 		LCD_WriteReg(0X13,0X1038);   
		delay_ms(40);   
		LCD_WriteReg(0X12,0X0012);//16    
		delay_ms(40);   
  		LCD_WriteReg(0X10,0X3420);   
 		LCD_WriteReg(0X13,0X3038);   
		delay_ms(70);   
		LCD_WriteReg(0X30,0X0000);   
		LCD_WriteReg(0X31,0X0402);   
		LCD_WriteReg(0X32,0X0307);   
		LCD_WriteReg(0X33,0X0304);   
		LCD_WriteReg(0X34,0X0004);   
		LCD_WriteReg(0X35,0X0401);   
		LCD_WriteReg(0X36,0X0707);   
		LCD_WriteReg(0X37,0X0305);   
		LCD_WriteReg(0X38,0X0610);   
		LCD_WriteReg(0X39,0X0610); 
		  
		LCD_WriteReg(0X01,0X0100);   
		LCD_WriteReg(0X02,0X0300);   
		LCD_WriteReg(0X03,0X1030);//改变方向的   
		LCD_WriteReg(0X08,0X0808);   
		LCD_WriteReg(0X0A,0X0008);   
 		LCD_WriteReg(0X60,0X2700);   
		LCD_WriteReg(0X61,0X0001);   
		LCD_WriteReg(0X90,0X013E);   
		LCD_WriteReg(0X92,0X0100);   
		LCD_WriteReg(0X93,0X0100);   
 		LCD_WriteReg(0XA0,0X3000);   
 		LCD_WriteReg(0XA3,0X0010);   
		LCD_WriteReg(0X07,0X0001);   
		LCD_WriteReg(0X07,0X0021);   
		LCD_WriteReg(0X07,0X0023);   
		LCD_WriteReg(0X07,0X0033);   
		LCD_WriteReg(0X07,0X0133);   
	}				 
	LCD_LED=1;//点亮背光	 
	LCD_Clear(WHITE);
}  		  
示例#16
0
void test()
{
	unsigned char button;

	clear();

	delay(200);
	print("Orangutan");	// print to the top line of the LCD
	delay_ms(400);		// delay 200 ms
	lcd_goto_xy(0, 1);	// go to the start of the second LCD line
	print(" X2");	// print to the bottom line of the LCD

	red_led(1);
	delay_ms(100);
	green_led(1);
	delay_ms(100);
	red_led2(1);
	delay_ms(100);
	green_led2(1);
	delay_ms(100);
	yellow_led(1);
	delay_ms(100);

	red_led(0);
	delay_ms(100);
	green_led(0);
	delay_ms(100);
	red_led2(0);
	delay_ms(100);
	green_led2(0);
	delay_ms(100);
	yellow_led(0);
	delay_ms(100);

	clear();			// clear the LCD, move cursor to start of top line

	print("  VBAT");

	do
	{
		// Perform 10-bit analog-to-digital conversions on ADC channel 6.
		// Average ten readings and return the result, which will be one
		// third of the battery voltage when the "ADC6 = VBAT/3" solder
		// bridge is in place on the bottom of the Orangutan PCB
		int vbat = read_battery_millivolts_x2();
		lcd_goto_xy(0, 1);	// go to the start of the second LCD line
		print_long(vbat);	// display battery voltage in millivolts
		print(" mV ");		// display the units
		delay_ms(50);		// delay for 50 ms
		button = button_is_pressed(ANY_BUTTON);	// check for button press
	}
	while (button == 0);	// loop if no buttons are being pressed


	red_led(1);
	green_led(1);
	red_led2(1);
	green_led2(1);
	yellow_led(1);


	// *** MAIN LOOP ***

	while (1)	// loop forever
	{
		if (button & TOP_BUTTON)			// if the top button is pressed
			button = melodyTest();	// this func. loops until next button press

		else if (button & MIDDLE_BUTTON)	// if the middle button is pressed
			button = IOTest();		// this func. loops until next button press

		else if (button & BOTTOM_BUTTON)	// if the bottom button is pressed
			button = motorTest();	// this func. loops until next button press
	}
}
示例#17
0
int open_ifport (PORTPROP *pc)
{
	OSVERSIONINFO vinfo = { sizeof(OSVERSIONINFO) };
	LARGE_INTEGER val1;
	BYTE cmdspi[6];
	static const WORD PortsCom[] = { COM1ADR, COM2ADR, COM3ADR, COM4ADR };
	static const WORD PortsLpt[] = { LPT1ADR, LPT2ADR, LPT3ADR };
	char sComm[16];
	DCB dcb = { sizeof(DCB),
				9600, TRUE, FALSE, TRUE, FALSE,
				DTR_CONTROL_DISABLE, FALSE,
				TRUE, FALSE, FALSE, FALSE, FALSE,
				RTS_CONTROL_DISABLE, FALSE, 0, 0,
				10, 10,
				8, NOPARITY, ONESTOPBIT, '\x11', '\x13', '\xFF', '\xFF', 0 };
	COMMTIMEOUTS commtimeouts = { 0, 1, 100, 1, 300};


	/* Check if high resolution timer is supported */
	QueryPerformanceFrequency(&val1);
	if (val1.QuadPart == 0) {
		pc->Info1 = "Incompatible envilonment.\n";
		return 1;
	}

	PortDly = pc->Delay;		/* I/O delay for direct I/O control */
	dcb.BaudRate = pc->Baud;	/* Bit rate for SPI bridge */

	/* Open direct I/O driver if needed */
	if(GetVersionEx(&vinfo) == FALSE) {
		pc->Info1 = "Incompatible envilonment.\n";
		return 1;
	}
	if((vinfo.dwPlatformId == VER_PLATFORM_WIN32_NT)
	    && ((pc->PortClass == TY_COMM)||(pc->PortClass == TY_LPT))) {
		if(init_driver()) {
			pc->Info1 = "I/O driver initialization failed.\n";
			return 1;
		}
	}

	/* Use COM port in direct I/O */
	if(pc->PortClass == TY_COMM) {
		if((pc->PortNum < 1)||(pc->PortNum > 4)) {
			pc->Info1 = "Invalid Port#.\n";
			return 1;
		}
		PortBase = PortsCom[pc->PortNum - 1];
		sprintf(str_info, "No COM%u(0x%X) port.\n", pc->PortNum, PortBase);
		pc->Info1 = str_info;
		if(check_comport()) {
			if(vinfo.dwPlatformId != VER_PLATFORM_WIN32_NT) return 1;
			sprintf(sComm, "\\\\.\\COM%u", pc->PortNum);
			hComm = CreateFile(sComm, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
			if(hComm == INVALID_HANDLE_VALUE) return 1;
			if(check_comport()) return 1;
		}

		_outp(COM_IMR, 0x00);		/* Mask interrupts */
		pc->Info1 = NULL;
		PortType = TY_COMM;
		return 0;
	}

	/* Use COM port via API */
	if(pc->PortClass == TY_VCOM) {
		sprintf(sComm, "\\\\.\\COM%u", pc->PortNum);
		hComm = CreateFile(sComm, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
		if(hComm == INVALID_HANDLE_VALUE) {
			sprintf(str_info, "%s could not be opened.\n", sComm);
			pc->Info1 = str_info;
			return 1;
		}
		SetCommState(hComm, &dcb);
		EscapeCommFunction(hComm, CLRRTS);
		EscapeCommFunction(hComm, CLRDTR);
		PortType = TY_VCOM;
		return 0;
	}

	/* Use SPI bridge attached on COM port */
	if(pc->PortClass == TY_BRIDGE) {
		sprintf(sComm, "\\\\.\\COM%u", pc->PortNum);
		hComm = CreateFile(sComm, GENERIC_READ|GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
		if(hComm == INVALID_HANDLE_VALUE) {
			sprintf(str_info, "%s could not be opened.\n", sComm);
			pc->Info1 = str_info;
			return 1;
		}
		dcb.fOutxCtsFlow = TRUE;
		dcb.fRtsControl = RTS_CONTROL_HANDSHAKE;
		SetCommState(hComm, &dcb);
		SetCommTimeouts(hComm, &commtimeouts);
		EscapeCommFunction(hComm, CLRDTR);
		delay_ms(10);
		while(read_bridge(cmdspi, sizeof(cmdspi)));
		cmdspi[0] = FLAG-1;
		cmdspi[1] = FLAG; cmdspi[2] = SPI_ENABLE;	/* Enable Bridge */
		cmdspi[3] = FLAG; cmdspi[4] = SPI_SETDLY; cmdspi[5] = (BYTE)PortDly; /* Set SPI delay */
		send_bridge(cmdspi, 6);		/* Send bridge initialization commands */
		read_bridge(cmdspi, 2);		/* Check if the commands are accepted */
		if((cmdspi[0] != SPI_ENABLE) || (cmdspi[1] != SPI_SETDLY)) {
			sprintf(str_info, "No SPI bridge on the %s.\n", sComm);
			pc->Info1 = str_info;
			return 1;
		}
		PortType = TY_BRIDGE;
		return 0;
	}

	/* Use LPT port in direct I/O */
	if(pc->PortClass == TY_LPT) {
		if((pc->PortNum < 1)||(pc->PortNum > 3)) {
			pc->Info1 = "Invalid Port#.\n";
			return 1;
		}
		PortBase = PortsLpt[pc->PortNum - 1];
		if(check_lptport()) {
			sprintf(str_info, "No LPT%u(0x%X) port.\n", pc->PortNum, PortBase);
			pc->Info1 = str_info;
			return 1;
		}

		_outp(LPT_DAT, 0x20);	/* Check if the adapter is ByteBlasterMV (D5-ACK) */
		if(_inp(LPT_STA) & S_ACK) {
			_outp(LPT_DAT, 0);
			if((_inp(LPT_STA) & S_ACK) == 0) {
				_outp(LPT_CTL, BA_ENA);
				pc->Info1 = "Altera ByteBlasterMV was found.\n";
				PortType = TY_ALTERA;
				if(_inp(LPT_STA) & S_ERR) return 0;	/* Check target power */
				pc->Info2 = "But target power is OFF.\n";
				return 1;
			}
		}
		_outp(LPT_DAT, 0x80);	/* Check if the adapter is AVRSP (D7-PE) */
		if(_inp(LPT_STA) & S_PE) {
			_outp(LPT_DAT, 0);
			if((_inp(LPT_STA) & S_PE) == 0) {
				_outp(LPT_DAT, B_ENA);
				pc->Info1 = "AVRSP adapter was found.\n";
				PortType = TY_AVRSP;
				if(_inp(LPT_STA) & S_ERR) return 0;	/* Check target power */
				pc->Info2 = "But target power is OFF.\n";
				return 1;
			}
		}
		_outp(LPT_DAT, 0x40);	/* Check if the adapter is Xilinx JTAG (D6-BUSY-PE) */
		if((_inp(LPT_STA) & (S_PE | S_BUSY)) == S_PE) {
			_outp(LPT_DAT, 0);
			if((_inp(LPT_STA) & (S_PE | S_BUSY)) == S_BUSY) {
				pc->Info1 = "Xilinx JTAG adapter was found.\n";
				PortType = TY_XILINX;
				if(_inp(LPT_STA) & S_ERR) return 0;	/* Check target power */
				pc->Info2 = "But target power is OFF.\n";
				return 1;
			}
		}
		_outp(LPT_DAT, 0x40);	/* Check if the adapter is Lattice ISP (D6-PE) */
		if(_inp(LPT_STA) & S_PE) {
			_outp(LPT_DAT, 0);
			if((_inp(LPT_STA) & S_PE) == 0) {
				pc->Info1 = "Lattice ISP adapter was found.\n";
				PortType = TY_LATTICE;
				if(_inp(LPT_STA) & S_ERR) return 0;	/* Check target power */
				pc->Info2 = "But target power is OFF.\n";
				return 1;
			}
		}
		_outp(LPT_DAT, 0x01);	/* Check if the adapter is STK200 dongle (D0-PE) */
		if(_inp(LPT_STA) & S_PE) {
			_outp(LPT_DAT, 0);
			if((_inp(LPT_STA) & S_PE) == 0) {
				pc->Info1 = "STK200 ISP dongle was found.\n";
				PortType = TY_STK200;
				if(_inp(LPT_STA) & S_ERR) return 0;	/* Check target power */
				pc->Info2 = "But target power is OFF.\n";
				return 1;
			}
		}
		sprintf(str_info, "No ISP adapter on the LPT%u.\n", pc->PortNum);
		pc->Info1 = str_info;
		return 1;
	}

	pc->Info1 = "Invalid port class.\n";
	return 1;
}
示例#18
0
文件: main.c 项目: blueskycoco/d4
void Delay(int ms)
{
 	 int i=0;
	for(i=0;i<ms;i++)
	  delay_ms(1);
}
示例#19
0
//#define POWER_OFF_EE
void enter_power_down()
{
	int i;
	unsigned v1,v2,v;
	unsigned rtc_ctrl;
	unsigned power_key,key;
	//*******************************************
	//*  power down flow  
	//*******************************************
	f_serial_puts("\n");
	
	wait_uart_empty();

	// disable jtag
	setbits_le32(P_AO_RTI_PIN_MUX_REG, 1<<13);
	clrbits_le32(P_AO_RTI_PIN_MUX_REG, 1<<14);
	
	// turn off mali clock
	clrbits_le32(P_HHI_MALI_CLK_CNTL, 1 << 8);
	// change RTC filter for 32k
    rtc_ctrl = readl(0xC810074c);
//	writel(0x00800000,0xC810074c);
    writel(0x0,0xC810074c);

	writel(readl(0xC8100024)|((1<<2)|(1<<3)|(1<<6)),0xC8100024);
	// disable all memory accesses.
    disable_mmc_req();
   
    //save registers for clk and ddr
    store_restore_plls(1);
    
    //mmc enter sleep
    mmc_sleep();
    delay_ms(20);
    
    // save ddr power
    APB_Wr(MMC_PHY_CTRL, APB_Rd(MMC_PHY_CTRL)|(1<<0)|(1<<8)|(1<<13));
    APB_Wr(PCTL_PHYCR_ADDR, APB_Rd(PCTL_PHYCR_ADDR)|(1<<6));
    APB_Wr(PCTL_DLLCR9_ADDR, APB_Rd(PCTL_DLLCR9_ADDR)|(1<<31));
 	  delay_ms(20);

 	// power down DDR
 	writel(readl(P_HHI_DDR_PLL_CNTL)|(1<<15),P_HHI_DDR_PLL_CNTL);

	// enable retention
	enable_retention();

 	// reset A9
//	setbits_le32(P_A9_CFG2, 7<<16);
	clrbits_le32(P_HHI_SYS_CPU_CLK_CNTL, 1<<4); // disable APB_CLK
	clrbits_le32(P_HHI_SYS_CPU_CLK_CNTL, 1<<5); // disable AT_CLK
	setbits_le32(P_HHI_SYS_CPU_CLK_CNTL,1<<19);
	udelay(10);
	 
	// enable iso ee for A9
	writel(readl(P_AO_RTI_PWR_CNTL_REG0)&(~(1<<4)),P_AO_RTI_PWR_CNTL_REG0);
	udelay(1000);
	
#ifdef POWER_OFF_HDMI_VCC
	reg7_off();
#endif
#ifdef POWER_OFF_AVDD33
	reg5_off();
#endif
//DDR vcc 1520<-->1420
//1.2V AO 1220<-->1050
    vcc_down();

#ifdef POWER_OFF_EE 
	//iso EE from AO
	//comment isolate EE. otherwise cannot detect power key.
	// writel(readl(P_AO_RTI_PWR_CNTL_REG0)&(~(1<<0)),P_AO_RTI_PWR_CNTL_REG0); 
	writel(readl(P_AO_RTI_PWR_CNTL_REG0)&(~(1<<2)),P_AO_RTI_PWR_CNTL_REG0);
	writel(readl(P_AO_RTI_PWR_CNTL_REG0)&(~(1<<3)),P_AO_RTI_PWR_CNTL_REG0);

	//?? Gate off clk81 to EE domain
	writel(readl(P_AO_RTI_GEN_CNTL_REG0)&(~(1<<12)),P_AO_RTI_GEN_CNTL_REG0);
	//-------------------------------
	//turn off EE voltage
	//v = readl(0xC8100024);
	//v &= ~(1<<9);
	//v &= ~(1<<25);
	//writel(v,0xC8100024);
#else
	// ee use 32k
	writel(readl(P_HHI_MPEG_CLK_CNTL)|(1<<9),P_HHI_MPEG_CLK_CNTL);
#endif

	// switch to 32k
    writel(readl(P_AO_RTI_PWR_CNTL_REG0)|(1<<8),P_AO_RTI_PWR_CNTL_REG0);
    i2c_set_clk(0);
    delay_ms(1);
    
#ifdef POWER_OFF_AVDD25
	reg6_off();
#endif

#ifdef POWER_OFF_VDDIO 
	vddio_off(); 
#endif		
    
	// gate off REMOTE, UART
	writel(readl(P_AO_RTI_GEN_CNTL_REG0)&(~(0xF)),P_AO_RTI_GEN_CNTL_REG0);
	// wait key
    power_key = readl(0Xc8100744);
    while (((power_key&4) != 0)&&((power_key&8) == 0))
    {        
     	power_key = readl(0Xc8100744);
    }
    
	// gate on REMOTE, I2C s/m, UART
	writel(readl(P_AO_RTI_GEN_CNTL_REG0)|0xF, P_AO_RTI_GEN_CNTL_REG0); 

#ifdef POWER_OFF_VDDIO 
	vddio_on();
#endif
#ifdef POWER_OFF_AVDD25
	reg6_on();
#endif

   // switch to clk81 
	writel(readl(P_AO_RTI_PWR_CNTL_REG0)&(~(0x1<<8)),P_AO_RTI_PWR_CNTL_REG0);
	
	i2c_set_clk(1);
	// restore RTC filter
	writel(rtc_ctrl,0xC810074c);

	// set AO interrupt mask
	writel(0xFFFF,P_AO_IRQ_STAT_CLR);
	
#ifdef POWER_OFF_EE
	//turn on EE voltage
	//v = readl(0xC8100024);
	//v &= ~(1<<9);
	//v |= (1<<25);
	//writel(v,0xC8100024);
	//delay_ms(200);

	// un-iso AO domain from EE bit0=signals, bit1=reset, bit2=irq, bit3=test_mode
 	writel(readl(P_AO_RTI_PWR_CNTL_REG0)|(0xD<<0),P_AO_RTI_PWR_CNTL_REG0);

	//un isolate the reset in the EE
	writel(readl(P_AO_RTI_PWR_CNTL_REG0)|(0x1<<5),P_AO_RTI_PWR_CNTL_REG0);

	writel(readl(P_AO_RTI_PWR_CNTL_REG0)|(0x1<<5)|(1<<3)|(1<<2)|(1<<1)|(1<<0), \
			   P_AO_RTI_PWR_CNTL_REG0);
#else
    // ee go back to clk81
	writel(readl(P_HHI_MPEG_CLK_CNTL)&(~(0x1<<9)),P_HHI_MPEG_CLK_CNTL);
#endif
	
#ifdef POWER_OFF_AVDD33
	reg5_on();
#endif
#ifdef POWER_OFF_HDMI_VCC
	reg7_on();
#endif    
//DDR vcc 1520<-->1420
//1.2V AO 1220<-->1050
    vcc_up();

    store_restore_plls(0);
     
    init_ddr_pll();
	
    udelay(1000);
    uart_reset();

    reset_mmc();

    // initialize mmc and put it to sleep
    init_pctl();

    mmc_sleep();
    
    // disable retention
    disable_retention();

    // Next, we wake up
    mmc_wakeup();

    // Next, we enable all requests
    enable_mmc_req();

//	f_serial_puts("restart arm...\n");
	
	//0. make sure a9 reset
	setbits_le32(P_A9_CFG2,1<<17); // release APB reset
	udelay(1000);
	setbits_le32(P_A9_CFG2,1<<16); // release AXI reset
	udelay(1000);
	setbits_le32(P_A9_CFG2,1<<18); // release A9DBG reset
	udelay(1000);
	setbits_le32(P_HHI_SYS_CPU_CLK_CNTL,1<<19);
	udelay(1000);	
	//1. write flag
	if (power_key&8)
		writel(0xabcd1234,P_AO_RTI_STATUS_REG2);
	else
		writel(0x1234abcd,P_AO_RTI_STATUS_REG2);
	
	//2. remap AHB SRAM
	writel(3,P_AO_REMAP_REG0);
	writel(2,P_AHB_ARBDEC_REG);
 
	//3. turn off romboot clock
	writel(readl(P_HHI_GCLK_MPEG1)&0x7fffffff,P_HHI_GCLK_MPEG1);
 
	//4. Release ISO for A9 domain.
	setbits_le32(P_AO_RTI_PWR_CNTL_REG0,1<<4);
	udelay(1000);
	
	writel(	(0 << 9)    | // select xtal as clock source
			(0 << 0)	, 
			P_HHI_MALI_CLK_CNTL);
	delay_ms(1);
	setbits_le32(P_HHI_SYS_CPU_CLK_CNTL, (1<<14)|(1<<15)); // soft reset
	udelay(10);
	clrbits_le32(P_HHI_SYS_CPU_CLK_CNTL, (1<<14)|(1<<15)); // soft reset
	udelay(1000);
	
	//reset A9
	writel(0xF,P_RESET4_REGISTER);// -- reset arm.ww
	writel(1<<14,P_RESET2_REGISTER);// -- reset arm.mali
	udelay(1000);
	clrbits_le32(P_A9_CFG2,1<<17); // release APB reset
	udelay(1000);
	clrbits_le32(P_A9_CFG2,1<<16); // release AXI reset
	udelay(1000);
	clrbits_le32(P_A9_CFG2,1<<18); // release A9DBG reset
	udelay(1000);

	setbits_le32(P_HHI_SYS_CPU_CLK_CNTL, 1<<4); // enable APB_CLK
	udelay(10);
	
	clrbits_le32(P_HHI_SYS_CPU_CLK_CNTL,1<<19); // release A9 reset
	udelay(1000);
  
//	delay_1s();
//	delay_1s();
//	delay_1s();
}
示例#20
0
/**
 * \brief Set maXTouch configuration
 *
 * This function writes a set of predefined, optimal maXTouch configuration data
 * to the mXT143E Xplained.
 *
 * \param device Pointer to mxt_device struct
 */
static void mxt_init(struct mxt_device *device)
{
	enum status_code status;
	UNUSED(status);

	/* T8 configuration object data */
	uint8_t t8_object[] = {
		0x10, 0x05, 0x0a, 0x14, 0x64, 0x00, 0x05,
		0x0a, 0x00, 0x00,
	};

	/* T9 configuration object data */
	uint8_t t9_object[] = {
		0x8f, 0x00, 0x00, 0x0d, 0x0b, 0x00, 0x21,
		0x3c, 0x0f, 0x00, 0x32, 0x01, 0x01, 0x00,
		0x08, 0x05, 0x05, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x1c, 0x1c, 0x37, 0x37, 0x8f, 0x50,
		0xcf, 0x6e, 0x00, 0x02, 0x2f, 0x2c, 0x00
	};

	/* T48 configuration object data */
	uint8_t t48_object[] = {
		0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x00, 0x00, 0x00, 0x00
	};

	/* TWI configuration */
	twi_master_options_t twi_opt = {
		.speed = MXT_TWI_SPEED,
		.chip  = MAXTOUCH_TWI_ADDRESS,
	};

	status = twi_master_setup(TWI_INTERFACE, &twi_opt);
	Assert(status == STATUS_OK);

	/* Initialize the maXTouch device */
	status = mxt_init_device(device, TWI_INTERFACE,
			MAXTOUCH_TWI_ADDRESS, MXT143E_XPLAINED_CHG);
	Assert(status == STATUS_OK);

	/* Issue soft reset of maXTouch device by writing a non-zero value to
	 * the reset register */
	mxt_write_config_reg(device, mxt_get_object_address(device,
			MXT_GEN_COMMANDPROCESSOR_T6, 0)
			+ MXT_GEN_COMMANDPROCESSOR_RESET, 0x01);

	/* Wait for the reset of the device to complete */
	delay_ms(MXT_RESET_TIME);

	/* Write data to configuration registers in T7 configuration object */
	mxt_write_config_reg(device, mxt_get_object_address(device,
			MXT_GEN_POWERCONFIG_T7, 0) + 0, 0xff);
	mxt_write_config_reg(device, mxt_get_object_address(device,
			MXT_GEN_POWERCONFIG_T7, 0) + 1, 0xff);
	mxt_write_config_reg(device, mxt_get_object_address(device,
			MXT_GEN_POWERCONFIG_T7, 0) + 2, 0x32);

	/* Write predefined configuration data to configuration objects */
	mxt_write_config_object(device, mxt_get_object_address(device,
			MXT_GEN_ACQUISITIONCONFIG_T8, 0), &t8_object);
	mxt_write_config_object(device, mxt_get_object_address(device,
			MXT_TOUCH_MULTITOUCHSCREEN_T9, 0), &t9_object);
	mxt_write_config_object(device, mxt_get_object_address(device,
			MXT_PROCG_TOUCHSUPPRESSION_T48, 0), &t48_object);

	/* Issue recalibration command to maXTouch device by writing a non-zero
	 * value to the calibrate register */
	mxt_write_config_reg(device, mxt_get_object_address(device,
			MXT_GEN_COMMANDPROCESSOR_T6, 0)
			+ MXT_GEN_COMMANDPROCESSOR_CALIBRATE, 0x01);
}
示例#21
0
/**
  * @brief  Main program.
  * @param  None
  * @retval None
  */
int main(void)
{
  /*!< At this stage the microcontroller clock setting is already configured, 
       this is done through SystemInit() function which is called from startup
       file (startup_stm32f10x_xx.s) before to branch to application main.
       To reconfigure the default setting of SystemInit() function, refer to
       system_stm32f10x.c file
     */  
	SystemInit();
       
  /* System clocks configuration ---------------------------------------------*/
  RCC_Configuration();

  /* GPIO configuration ------------------------------------------------------*/
  GPIO_Configuration();
	
	/* DMA1 channel1 configuration ----------------------------------------------*/
  DMA_DeInit(DMA1_Channel1);
  DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC1->DR;
  DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)ADCConvertedValue;
  DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
  DMA_InitStructure.DMA_BufferSize = 2;
  DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
  DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
  DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
  DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
  DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
  DMA_InitStructure.DMA_Priority = DMA_Priority_High;
  DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
  DMA_Init(DMA1_Channel1, &DMA_InitStructure);
	
	/* Enable DMA1 channel1 */
  DMA_Cmd(DMA1_Channel1, ENABLE);
	
	/* ADC1 configuration ------------------------------------------------------*/
  ADC_InitStructure.ADC_Mode = ADC_Mode_Independent;
  ADC_InitStructure.ADC_ScanConvMode = ENABLE;
  ADC_InitStructure.ADC_ContinuousConvMode = DISABLE;
  ADC_InitStructure.ADC_ExternalTrigConv = ADC_ExternalTrigConv_None;
  ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
  ADC_InitStructure.ADC_NbrOfChannel = 2;
  ADC_Init(ADC1, &ADC_InitStructure);

  /* ADC1 regular channel0 configuration */ 
  ADC_RegularChannelConfig(ADC1, ADC_Channel_2, 1, ADC_SampleTime_55Cycles5);
	ADC_RegularChannelConfig(ADC1, ADC_Channel_3, 2, ADC_SampleTime_55Cycles5);
  /* Enable ADC1 DMA */
  ADC_DMACmd(ADC1, ENABLE);
  
  /* Enable ADC1 */
  ADC_Cmd(ADC1, ENABLE);

  /* Enable ADC1 reset calibration register */   
  ADC_ResetCalibration(ADC1);
  /* Check the end of ADC1 reset calibration register */
  while(ADC_GetResetCalibrationStatus(ADC1));

  /* Start ADC1 calibration */
  ADC_StartCalibration(ADC1);
  /* Check the end of ADC1 calibration */
  while(ADC_GetCalibrationStatus(ADC1));
     
  /* Start ADC1 Software Conversion */ 
  ADC_SoftwareStartConvCmd(ADC1, ENABLE);

  /* To achieve GPIO toggling maximum frequency, the following  sequence is mandatory. 
     You can monitor PD0 or PD2 on the scope to measure the output signal. 
     If you need to fine tune this frequency, you can add more GPIO set/reset 
     cycles to minimize more the infinite loop timing.
     This code needs to be compiled with high speed optimization option.  */
	/*Init LCD*/
	LCD_Init();
  while (1)
  {
		/* Start ADC1 Software Conversion */ 
		ADC_SoftwareStartConvCmd(ADC1, ENABLE);
		sprintf(LCD_Buffer,"ADC1=%d ",ADCConvertedValue[0]);
		LCD_GotoXY(0,0);
		LCD_PutStr(LCD_Buffer);
		sprintf(LCD_Buffer,"ADC2=%d ",ADCConvertedValue[1]);
		LCD_GotoXY(0,1);
		LCD_PutStr(LCD_Buffer);
		delay_ms(1000);
  }
}
示例#22
0
void load_program(void)
{
  int1  do_ACKLOD, done=FALSE;
  int8  checksum, line_type;
  int16 l_addr,h_addr=0;
  int8 to;
  int32 addr;
  int8  dataidx, i, count;
  int8  data[32];
  int  buffidx;
  char buffer[BUFFER_LEN_LOD];
   
  while (!done)  // Loop until the entire program is downloaded
  {
    usb_task();

    if(!usb_cdc_kbhit())
      continue;
         
    buffidx = 0;  // Read into the buffer until 0x0D ('\r') is received or the buffer is full
    to = 250;   //250 milliseconds
    do 
    {
      if(!usb_cdc_kbhit())
      {
	delay_ms(1);
	to--;
	if(!to)
	  break;
      }
      else
	to = 250;
      i = usb_cdc_getc();
      buffer[buffidx++] = i;
    }while((i != 0x0D) && (i != 0x0A) && (buffidx <= BUFFER_LEN_LOD));
            
    if(!to)
      continue;

    usb_cdc_putc(XOFF);  // Suspend sender

    do_ACKLOD = TRUE;

    // Only process data blocks that start with ':'
    if(buffer[0] == ':')
    {
      count = atoi_b16 (&buffer[1]);  // Get the number of bytes from the buffer

      // Get the lower 16 bits of address
      l_addr = make16(atoi_b16(&buffer[3]),atoi_b16(&buffer[5]));

      line_type = atoi_b16 (&buffer[7]);

      addr = make32(h_addr,l_addr);

      // If the line type is 1, then data is done being sent
      if(line_type == 1) 
      {
	done = TRUE;
      }
      else if((addr >= (int32)APPLICATION_START) && (addr < ((int32)0x300000)))
      {
	checksum = 0;  // Sum the bytes to find the check sum value
	for(i=1; i<(buffidx-3); i+=2)
	  checksum += atoi_b16 (&buffer[i]);
	checksum = 0xFF - checksum + 1;

	if(checksum != atoi_b16 (&buffer[buffidx-3]))
	  do_ACKLOD = FALSE;
	else   
	{
	  if(line_type == 0) {
	    // Loops through all of the data and stores it in data
	    // The last 2 bytes are the check sum, hence buffidx-3
	    for(i = 9,dataidx=0; i < buffidx-3; i += 2)
	      data[dataidx++]=atoi_b16(&buffer[i]);
                    
	    rom_w(addr, data, count);
	  }
	  else if(line_type == 4)
	    h_addr = make16(atoi_b16(&buffer[9]), atoi_b16(&buffer[11]));
	}
      }
    }

    if(do_ACKLOD)
      usb_cdc_putc (ACKLOD);

    usb_cdc_putc(XON);
  }

  usb_cdc_putc(ACKLOD);
  usb_cdc_putc(XON);
  delay_ms(2000);   //give time for packet to flush
  reset_cpu();
}
示例#23
0
void delay(){
 delay_ms(500);
}
示例#24
0
void main(void)
{
   //const unsigned char *msg;

   const unsigned char * arr1 = "\r\ntaking in the text \r\n";

   const unsigned char *arr2="\r\nAcknowledged\r\n";

   const unsigned char *arr3= "You have entered:\r\n";

   const unsigned char *arr4= "UART Initialised\r\n";

   const unsigned char *arr5= "Sending TO Led\r\n";

   const unsigned char *arr6= "Tx of 1 byte complete\r\n";

   const unsigned char *arr7= "Tx completed all bytes\r\n";

   unsigned int j;

   unsigned char LED_Output;

  TRISB=0x00;


   OSCCONbits.IRCF = 0x07;  // Configure Internal OSC for 8MHz Clock

    while(!OSCCONbits.HTS);   // Wait Until Internal Osc is Stable

    INTCON=0;   // purpose of disabling the interrupts.

    UART_Init(baud_rate);

    UART_Write_Text(arr4);

    delay_ms(500);

    while(1)
    {


        UART_Write_Text(arr1);

         is=UART_Read_Text();
         
         UART_Write_Text(arr2);
         
         UART_Write_Text(arr3);
         
         UART_Write_Text(is);
         //sending to led
         UART_Write_Text(arr5);

       while(*is)
         {
              for(j=0;j<=7;j++)
              {
                LED_Output= (*is&0x01)==1?1:0;
                RB0=LED_Output;
                delay_ms(125);
                *is=*is>>1;
             }
              is++;
            UART_Write_Text(arr6);
        }
         UART_Write_Text(arr7);
       
     }

         
     
         


 }
示例#25
0
void LCD12864_ClearScreen(void) 
{
  LCD12864_WriteCmd(CLEAR_SCREEN);
  delay_ms(5);
}
示例#26
0
// this is called from main event handler
u8 app_launch(u8 firstrun) {

  print_dbg("\r\n launching app with firstrun: ");
  print_dbg_ulong(firstrun);

  //  net_print();
  
  render_boot("BEES");
  render_boot(versionString);

  while (!sd_mmc_spi_mem_check()) {
    render_boot("waiting for SD card...");
  }

  if(firstrun) {
    render_boot("launching app, first run");
    print_dbg("\r\n first run, writing nonvolatile data...");
    
    ///... write param scaler data
    // this is done at firstrun instead of being linked statically,
    // so that users can tune scaler data offline without recompiling
    render_boot("init param scaling data...");
    flash_init_scaler_data();

    print_dbg("\r\n first run, try and load default DSP");
    render_boot("launching default DSP");

    //// startup using default DSP name
    files_load_dsp_name(DEFAULT_LDR);
    
    render_boot("waiting for DSP init...");
    bfin_wait_ready();

    //    print_dbg("\r\n enable DSP audio...");
    render_boot("enabling audio");
    bfin_enable();
    
  } else {

    app_pause();

    /// blackfin should clear ready pin ASAP on boot.
    /// but give it a moment to accomplish that.
    delay_ms(2);

    /// read the default scene from sd card
    /// this also attempts to load associated .ldr    
    render_boot("reading default scene");
    print_dbg("\r\n loading default scene. current module name from sceneData: ");
    print_dbg(sceneData->desc.moduleName);

    scene_read_default();

    delay_ms(2); 

    app_resume();
    
   }

  // init pages (fill graphics buffers)
  render_boot("initializing gfx");
  print_dbg("\r\n pages_init...");
  pages_init();

  print_dbg("\r\n play_init...");
  play_init();

  // enable timers
  print_dbg("\r\n enable app timers...");
  render_boot("enabling app timers");
  init_app_timers();

  // pull up power control pin, enabling soft-powerdown
  //  gpio_set_gpio_pin(POWER_CTL_PIN);

  // assign app event handlers
  print_dbg("\r\n assigning handlers... ");
  render_boot("assigning UI handlers");
  assign_bees_event_handlers();

  // update page rendering and handlers...
  pages_reselect();

  // start in play mode if not firstrun 
  if(!firstrun) pages_toggle_play();

  return 1;
}
示例#27
0
文件: main.c 项目: Wiznet/W7500P
/**
  * @brief  Main Function
  */
int main()
{
    /* Set Systme init */
    SystemInit();
    
    /* GPIO LED(R) Set */
    GPIO_InitDef.GPIO_Pin = GPIO_Pin_0; // Set to Pin_0 (LED(R))
    GPIO_InitDef.GPIO_Mode = GPIO_Mode_OUT; // Set to Mode Output
    GPIO_Init(GPIOC, &GPIO_InitDef);
    PAD_AFConfig(PAD_PC,GPIO_Pin_0, PAD_AF1); // PAD Config - LED used 2nd Function
	
    /* GPIO LED(G) Set */
    GPIO_InitDef.GPIO_Pin = GPIO_Pin_4; // Set to Pin_4 (LED(G))
    GPIO_InitDef.GPIO_Mode = GPIO_Mode_OUT; // Set to Mode Output
    GPIO_Init(GPIOC, &GPIO_InitDef);
    PAD_AFConfig(PAD_PC,GPIO_Pin_4, PAD_AF1);	// PAD Config - LED used 2nd Function
	  
    /* GPIO LED(B) Set */
    GPIO_InitDef.GPIO_Pin = GPIO_Pin_5; // Set to Pin_5 (LED(B))
    GPIO_InitDef.GPIO_Mode = GPIO_Mode_OUT; // Set to Mode Output
    GPIO_Init(GPIOC, &GPIO_InitDef);
    PAD_AFConfig(PAD_PC,GPIO_Pin_5, PAD_AF1); // PAD Config - LED used 2nd Function
		
    GPIO_SetBits(GPIOC, GPIO_Pin_0); // LED(R) Off
    GPIO_SetBits(GPIOC, GPIO_Pin_4); // LED(G) Off
    GPIO_SetBits(GPIOC, GPIO_Pin_5); // LED(B) Off
	
    while(1)
    {
        // LED(RGB) On/off
        delay_ms(500);
  	    GPIO_ResetBits(GPIOC, GPIO_Pin_0);			
	    GPIO_ResetBits(GPIOC, GPIO_Pin_4);
	    GPIO_ResetBits(GPIOC, GPIO_Pin_5);		  
	    delay_ms(500);
        GPIO_SetBits(GPIOC, GPIO_Pin_0);
        GPIO_SetBits(GPIOC, GPIO_Pin_4);
        GPIO_SetBits(GPIOC, GPIO_Pin_5);

        // LED(RG) On/off			
	    delay_ms(500);
  	    GPIO_ResetBits(GPIOC, GPIO_Pin_0);				
	    GPIO_ResetBits(GPIOC, GPIO_Pin_4);
	    delay_ms(500);
		GPIO_SetBits(GPIOC, GPIO_Pin_0);
        GPIO_SetBits(GPIOC, GPIO_Pin_4);

	    // LED(GB) On/off
		delay_ms(500);
  	    GPIO_ResetBits(GPIOC, GPIO_Pin_4);				
		GPIO_ResetBits(GPIOC, GPIO_Pin_5);			
		delay_ms(500);
  	    GPIO_SetBits(GPIOC, GPIO_Pin_4);				
		GPIO_SetBits(GPIOC, GPIO_Pin_5);
				
        // LED(BR) On/off
		delay_ms(500);
        GPIO_ResetBits(GPIOC, GPIO_Pin_0);				
        GPIO_ResetBits(GPIOC, GPIO_Pin_5);			
        delay_ms(500);
        GPIO_SetBits(GPIOC, GPIO_Pin_0);				
        GPIO_SetBits(GPIOC, GPIO_Pin_5);

        // LED(R) On/off
        delay_ms(500);
        GPIO_ResetBits(GPIOC, GPIO_Pin_0);
        delay_ms(500);
        GPIO_SetBits(GPIOC, GPIO_Pin_0);

        // LED(G) On/off
        delay_ms(500);
        GPIO_ResetBits(GPIOC, GPIO_Pin_4);
        delay_ms(500);
        GPIO_SetBits(GPIOC, GPIO_Pin_4);
        
        // LED(B) On/off
        delay_ms(500);
        GPIO_ResetBits(GPIOC, GPIO_Pin_5);
        delay_ms(500);
        GPIO_SetBits(GPIOC, GPIO_Pin_5);			
    }
}
示例#28
0
void clearLCD(void) {
	commandLCD(0b00000001);
	delay_ms(2);
	setCursorLCD(0,0);
}
示例#29
0
void MPU6000_init16(void)
{
// MPU-6000 maximum SPI clock is specified as 1 MHz for all registers
//    however the datasheet states that the sensor and interrupt registers
//    may be read using an SPI clock of 20 Mhz
//    NOTE!!: the SPI limit on the dsPIC is 9 Mhz

// Primary prescaler options   1:1/4/16/64
// Secondary prescaler options 1:1 to 1:8

// As these register accesses are one time only during initial setup lets be
//    conservative and only run the SPI bus at half the maximum specified speed

#if (MIPS == 70)
	// set prescaler for FCY/112 = 625 kHz at 70MIPS
	initMPUSPI_master16(SEC_PRESCAL_7_1, PRI_PRESCAL_16_1);
#elif (MIPS == 64)
	// set prescaler for FCY/96 = 667 kHz at 64MIPS
	initMPUSPI_master16(SEC_PRESCAL_6_1, PRI_PRESCAL_16_1);
#elif (MIPS == 40)
	// set prescaler for FCY/64 = 625 KHz at 40MIPS
	initMPUSPI_master16(SEC_PRESCAL_4_1, PRI_PRESCAL_16_1);
#elif (MIPS == 32)
	// set prescaler for FCY/48 = 667 kHz at 32 MIPS
	initMPUSPI_master16(SEC_PRESCAL_3_1, PRI_PRESCAL_16_1);
#elif (MIPS == 16)
	// set prescaler for FCY/24 = 667 kHz at 16MIPS
	initMPUSPI_master16(SEC_PRESCAL_6_1, PRI_PRESCAL_4_1);
#else
#error Invalid MIPS Configuration
#endif // MIPS

	// need at least 60 msec delay here
	delay_ms(60);
	writeMPUSPIreg16(MPUREG_PWR_MGMT_1, BIT_H_RESET);

	// 10msec delay seems to be needed for AUAV3 (MW's prototype)
	delay_ms(10);

	// Wake up device and select GyroZ clock (better performance)
	writeMPUSPIreg16(MPUREG_PWR_MGMT_1, MPU_CLK_SEL_PLLGYROZ);

	// Disable I2C bus (recommended on datasheet)
	writeMPUSPIreg16(MPUREG_USER_CTRL, BIT_I2C_IF_DIS);

	// SAMPLE RATE
	writeMPUSPIreg16(MPUREG_SMPLRT_DIV, 4); // Sample rate = 200Hz  Fsample= 1Khz/(N+1) = 200Hz

	// scaling & DLPF
	writeMPUSPIreg16(MPUREG_CONFIG, BITS_DLPF_CFG_42HZ);

//	writeMPUSPIreg16(MPUREG_GYRO_CONFIG, BITS_FS_2000DPS);  // Gyro scale 2000º/s
	writeMPUSPIreg16(MPUREG_GYRO_CONFIG, BITS_FS_500DPS); // Gyro scale 500º/s

#if (ACCEL_RANGE == 2)
	writeMPUSPIreg16(MPUREG_ACCEL_CONFIG, BITS_FS_2G); // Accel scele 2g, g = 8192
#elif (ACCEL_RANGE == 4)
	writeMPUSPIreg16(MPUREG_ACCEL_CONFIG, BITS_FS_4G); // Accel scale g = 4096
#elif (ACCEL_RANGE == 8)
	writeMPUSPIreg16(MPUREG_ACCEL_CONFIG, BITS_FS_8G); // Accel scale g = 2048
#else
#error "Invalid ACCEL_RANGE"
#endif

#if 0
	// Legacy from Mark Whitehorn's testing, we might need it some day.
	// SAMPLE RATE
	writeMPUSPIreg16(MPUREG_SMPLRT_DIV, 7); // Sample rate = 1KHz  Fsample= 8Khz/(N+1)

	// no DLPF, gyro sample rate 8KHz
	writeMPUSPIreg16(MPUREG_CONFIG, BITS_DLPF_CFG_256HZ_NOLPF2);

	writeMPUSPIreg16(MPUREG_GYRO_CONFIG, BITS_FS_500DPS); // Gyro scale 500º/s

//	writeMPUSPIreg16(MPUREG_ACCEL_CONFIG, BITS_FS_2G); // Accel scale 2g, g = 16384
	writeMPUSPIreg16(MPUREG_ACCEL_CONFIG, BITS_FS_4G); // Accel scale g = 8192
//	writeMPUSPIreg16(MPUREG_ACCEL_CONFIG, BITS_FS_8G); // Accel scale g = 4096
#endif

	// INT CFG => Interrupt on Data Ready, totem-pole (push-pull) output
	writeMPUSPIreg16(MPUREG_INT_PIN_CFG, BIT_INT_LEVEL | BIT_INT_RD_CLEAR); // INT: Clear on any read
	writeMPUSPIreg16(MPUREG_INT_ENABLE, BIT_DATA_RDY_EN); // INT: Raw data ready

// Bump the SPI clock up towards 20 MHz for ongoing sensor and interrupt register reads
// 20 MHz is the maximum specified for the MPU-6000
// however 9 MHz is the maximum specified for the dsPIC33EP
// Primary prescaler options   1:1/4/16/64
// Secondary prescaler options 1:1 to 1:8
#if (MIPS == 70)
	// set prescaler for FCY/32 = 2.2 MHz at 70MIPS
	initMPUSPI_master16(SEC_PRESCAL_2_1, PRI_PRESCAL_16_1);
#elif (MIPS == 64)
	// set prescaler for FCY/8 = 8 MHz at 64 MIPS
	initMPUSPI_master16(SEC_PRESCAL_2_1, PRI_PRESCAL_4_1);
#elif (MIPS == 40)
	// UDB5 only
	// set prescaler for FCY/5 = 8 MHz at 40MIPS
	initMPUSPI_master16(SEC_PRESCAL_5_1, PRI_PRESCAL_1_1);
#elif (MIPS == 32)
	// set prescaler for FCY/4 = 8 MHz at 32 MIPS
	initMPUSPI_master16(SEC_PRESCAL_1_1, PRI_PRESCAL_4_1);
#elif (MIPS == 16)
	// set prescaler for FCY/2 = 8 MHz at 16 MIPS
	initMPUSPI_master16(SEC_PRESCAL_2_1, PRI_PRESCAL_1_1);
#else
#error Invalid MIPS Configuration
#endif // MIPS

	_TRISMPUINT = 1; // this is probably already taken care of in mcu.c for most boards

#if (MPU_SPI == 1)
	_INT1EP = 1; // Setup INT1 pin to interrupt on falling edge
	_INT1IP = INT_PRI_INT1;
	_INT1IF = 0; // Reset INT1 interrupt flag
	_INT1IE = 1; // Enable INT1 Interrupt Service Routine 
#elif (MPU_SPI == 2)
	_INT3EP = 1; // Setup INT3 pin to interrupt on falling edge
	_INT3IP = INT_PRI_INT3;
	_INT3IF = 0; // Reset INT3 interrupt flag
	_INT3IE = 1; // Enable INT3 Interrupt Service Routine 
#endif
}
示例#30
0
/**
 * \brief Show SD card status on the OLED screen.
 */
static void display_sd_info(void)
{
	uint8_t card_check;
	uint8_t sd_card_type;
	uint8_t sd_card_version;
	uint32_t sd_card_size;
	uint8_t size[10];

	// Is SD card present?
	if (gpio_pin_is_low(SD_MMC_0_CD_GPIO) == false)
	{
		ssd1306_write_text("Please insert SD card...");
	}
	else
	{
		ssd1306_write_text("SD card information:");

		sd_mmc_init();
		card_check = sd_mmc_check(0);
		while (card_check != SD_MMC_OK)
		{
			card_check = sd_mmc_check(0);
			delay_ms(1);
		}

		if (card_check == SD_MMC_OK)
		{
			sd_card_type = sd_mmc_get_type(0);
			sd_card_version = sd_mmc_get_version(0);
			sd_card_size = sd_mmc_get_capacity(0);

			ssd1306_set_page_address(1);
			ssd1306_set_column_address(0);

			// Card type
			switch(sd_card_type)
			{
				case CARD_TYPE_SD:
				ssd1306_write_text("- Type: Normal SD card");
				break;
				case CARD_TYPE_SDIO:
				ssd1306_write_text("- Type: SDIO card");
				break;
				case CARD_TYPE_HC:
				ssd1306_write_text("- Type: High Capacity card");
				break;
				case CARD_TYPE_SD_COMBO:
				ssd1306_write_text("- Type: SDIO/Memory card");
				break;
				default:
				ssd1306_write_text("- Type: unknown");
			}

			ssd1306_set_page_address(2);
			ssd1306_set_column_address(0);

			// SD card version
			switch(sd_card_version)
			{
				case CARD_VER_SD_1_0:
				ssd1306_write_text("- Version: 1.0x");
				break;
				case CARD_VER_SD_1_10:
				ssd1306_write_text("- Version: 1.10");
				break;
				case CARD_VER_SD_2_0:
				ssd1306_write_text("- Version: 2.00");
				break;
				case CARD_VER_SD_3_0:
				ssd1306_write_text("- Version: 3.0x");
				break;
				default:
				ssd1306_write_text("- Version: unknown");
			}

			ssd1306_set_page_address(3);
			ssd1306_set_column_address(0);

			sprintf(size, "- Total size: %lu KB", sd_card_size);
			ssd1306_write_text(size);
		}
	}
}