void main(void)
{
char Buf[_Buffer_Size];
SSPInit();
Delay_Init();
LED_DIR_OUT;
Led_Blink();
char Address[_Address_Width] = { 0x11, 0x22, 0x33, 0x44, 0x55 };
NRF24L01_Init(_RX_MODE, _CH, _1Mbps, Address, _Address_Width, _Buffer_Size);
while (1) {
NRF24L01_Receive(Buf);
if (Buf[0] == 0x48) {
LED_ON;
Delay_us(1000);
LED_OFF;
}
}
}
int main(void) {
Delay_Init(NULL);
// Enable PORTB peripheral
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA,ENABLE);
// Beeper pin (PA6 -> TIM3_CH1)
PORT.GPIO_Mode = GPIO_Mode_AF;
PORT.GPIO_Speed = GPIO_Speed_40MHz;
PORT.GPIO_OType = GPIO_OType_PP;
PORT.GPIO_PuPd = GPIO_PuPd_UP;
PORT.GPIO_Pin = GPIO_Pin_6;
GPIO_Init(GPIOA,&PORT);
GPIO_PinAFConfig(GPIOA,GPIO_PinSource6,GPIO_AF_TIM3); // Alternative function of PA6 -> TIM3_CH1
// Configure TIM3 (PWM output on CH1)
RCC->APB1ENR |= RCC_APB1Periph_TIM3; // Enable the TIM3 peripheral
TIM3->CR1 |= TIM_CR1_ARPE; // Auto-preload enable
TIM3->CCMR1 |= TIM_CCMR1_OC1PE; // Output compare 1 preload enable
TIM3->CCMR1 |= TIM_CCMR1_OC1M_2 | TIM_CCMR1_OC1M_1; // PWM mode 1
TIM3->PSC = 0; // TIM3CLK = 32MHz
TIM3->ARR = 0xFF; // PWM frequency = 125kHz
TIM3->CCR1 = 0x7F; // 50% duty cycle
TIM3->CCER |= TIM_CCER_CC1NP; // Output polarity
TIM3->CCER |= TIM_CCER_CC1E; // BEEPER TIM3_CH1 output compare enable
TIM3->EGR = TIM_EGR_UG; // Generate an update event to reload the prescaler value immediately
// Configure TIM2 (OCMode_Timing)
RCC->APB1ENR |= RCC_APB1Periph_TIM2; // Enable the TIM2 peripheral
TIM2->CR1 |= TIM_CR1_ARPE; // Auto-preload enable
TIM2->PSC = 0; // TIM2CLK = 32MHz
TIM2->ARR = SystemCoreClock / 44100; // 44.100 kHz
TIM2->CCER |= TIM_CCER_CC1P;
TIM2->CCR1 = 0;
TIM2->EGR = TIM_EGR_UG; // Generate an update event to reload the prescaler value immediately
TIM2->DIER |= TIM_DIER_UIE; // TIMx update interrupt enable
// TIM2 IRQ
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
NVICInit.NVIC_IRQChannel = TIM2_IRQn;
NVICInit.NVIC_IRQChannelCmd = ENABLE;
NVICInit.NVIC_IRQChannelPreemptionPriority = 0x02;
NVICInit.NVIC_IRQChannelSubPriority = 0x00;
NVIC_Init(&NVICInit);
TIM3->CR1 |= TIM_CR1_CEN; // Enable TIM3
TIM2->CR1 |= TIM_CR1_CEN; // Enable TIM2
// Configure USB peripheral
USB_HWConfig();
// Initialize USB device
USB_Init();
while(1);
}
void Init_Fun(void)
{
UART_SEND;
Flash_IO_Init();
Delay_Init();
Uart_Init();
ADC_Init_Fun();
EEPROM_IO_Init();
Key_IO_Init();
Cartridge_Type_Check();
UART_RECEIVE;
Flash_Times = Read_Num_From_EEPROM();
if(Flash_Times >= Flash_Times_Level8)
{
Flash_Times_Level = Flash_Times_Level_9;
Low_Lamp = 1;
}else{
Low_Lamp = 0;
if(Flash_Times >= Flash_Times_Level7)
{
Flash_Times_Level = Flash_Times_Level_8;
}else{
if(Flash_Times >= Flash_Times_Level6)
{
Flash_Times_Level = Flash_Times_Level_7;
}else{
if(Flash_Times >= Flash_Times_Level5)
{
Flash_Times_Level = Flash_Times_Level_6;
}else{
if(Flash_Times >= Flash_Times_Level4)
{
Flash_Times_Level = Flash_Times_Level_5;
}else{
if(Flash_Times >= Flash_Times_Level3)
{
Flash_Times_Level = Flash_Times_Level_4;
}else{
if(Flash_Times >= Flash_Times_Level2)
{
Flash_Times_Level = Flash_Times_Level_3;
}else{
if(Flash_Times >= Flash_Times_Level1)
{
Flash_Times_Level = Flash_Times_Level_2;
}else{
Flash_Times_Level = Flash_Times_Level_1;
}
}
}
}
}
}
}
}
}
int main( void )
{
setupBSP();
Delay_Init();
setupMEM();
setupFPGA();
setupINT();
setupCMU();
setupPRS();
setupDAC();
setupDMA();
setupADC();
setupTIMER();
Delay_Init();
BSP_LedsInit();
BSP_LedsSet(0);
while(1) {
//test_and_display();
BSP_LedToggle(0);
Delay(1000);
BSP_LedsSet(0);
Delay(500);
}
}
int main(void)
{
float tempf;
InitRCC();
InitGPIO();
InitADC();
I2CInit();
InitIT();
Delay_Init(24);
// reset pot value
PotWrite(0x00);
while(1) {
if (mode == MODE_CAL) {
LED_GREEN_ON();
LED_RED_OFF();
uint16_t av = ADC_GetConversionValue(AN_ADCx);
if (av > trig_level) {
trig_level = av;
tempf = GetADCVolt(trig_level)*VOLT_DIV; // get voltage from piezo
tempf = GetTargetK(tempf); // get target amp coefficient
tempf = GetTargetR(tempf); // get R2 for opamp feedback
tempf = GetPotR(tempf); // get target resistance for pot as part of R2
PotWrite(GetWStep(tempf)); // write step to pot
}
} else {
// turn on red for working mode indication, turn green if mcu gets opamp output high
LED_RED_ON();
if (GPIO_ReadInputDataBit(OP_PORT, OP_PIN) == SET) {
LED_GREEN_ON();
delay_ms(500);
} else {
LED_GREEN_OFF();
}
}
}
}
int main(void)
{
Delay_Init();
RCC_Configuration();
LED_GPIO();
usart_config();
/*while(1)
{
printf("pr is ok!\n");
delay_ms(800);
}*/
OSInit();//初始化UCOS操作系统
OSTaskCreate(start_task,//指向任务代码的指针
(void *)0,//任务开始执行时，传递给任务参数的指针
(OS_STK *)&START_TASK_STK[START_STK_SIZE-1],//分配给任务堆栈的栈顶指针
START_TASK_PRIO);//分配给任务的优先级
OSStart();//启动ucos操作系统
}
void Hal_Init(void)
{
RGB_LED_Init();
printf("RGB LED Init OK\r\n");
LED_GPIO_Init();
printf("LED Init OK\r\n");
TIM3_Int_Init(7199,9); //1ms SystemTimeCount + 1
printf("SystemTime Init OK\r\n");
KEY_GPIO_Init();
printf("KEY Init OK\r\n");
Motor_Init();
printf("Motor Init OK\r\n");
Delay_Init(72);
DHT11_Init();
printf("DHT11 Init OK\r\n");
IR_Init();
printf("IR Init OK\r\n");
OLED_Init();
OLED_ShowString(40, 0, "GoKit");
OLED_ShowString(0, 32, "www.gizwits.com");
}
int main()
{
RCC_ClocksTypeDef RCC_Clocks;
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
int rf_len = 0;
int rs485_len = 0;
#if DEBUG
// int usart_len = 0;
// char buff_usart[BUFFER_SIZE];
#endif
char buff_rf[BUFFER_SIZE];
char buff_rs485[BUFFER_SIZE];
unsigned int sensors_time_poll = 0;
// int temp_time_poll = 0;
// int sms_test_time = 0;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_WriteBit(GPIOB, GPIO_Pin_9, Bit_SET); // off
Delay_Init();
Enrf24_init(CE_PIN, CSN_PIN, IRQ_PIN);
Enrf24_begin(1000000, 0); // Defaults 1Mbps, channel 0, max TX power
Enrf24_setTXaddress((void*)enrf24_addr);
Enrf24_setRXaddress((void*)enrf24_addr);
Enrf24_enableRX(); // Start listening
#if DEBUG
USART1_Init(115200);
#endif
DS1307_Init();
Sensors_Init();
RS485_Init(115200);
sim_hal_init(115200);
OutputInit();
if (ThesisInit() == THESIS_FLASH_ERROR)
{
#if DEBUG
USART1_SendStr("\nFlash write error.\n");
#endif
TurnBuzzerOn();
Delay(1000);
}
#if DEBUG
RCC_GetClocksFreq(&RCC_Clocks);
USART1_SendStr("System Clock: ");
USART1_SendNum(RCC_Clocks.SYSCLK_Frequency);
USART1_SendStr("\r\n");
USART1_SendStr("Device ID: ");
USART1_SendByte(__flash_data.id, HEX);
USART1_SendStr("\r\n");
USART1_SendStr("Device Unique Number: ");
USART1_SendByte(__flash_data.unique_number[0], HEX);
USART1_SendByte(__flash_data.unique_number[1], HEX);
USART1_SendByte(__flash_data.unique_number[2], HEX);
USART1_SendByte(__flash_data.unique_number[3], HEX);
USART1_SendStr("\r\n");
#endif
OneWire_Init();
for EVER
{
if (millis() - sensors_time_poll > 100)
{
led_toggle();
Sensors_Poll();
sensors_time_poll = millis();
// buzzer_toggle();
// output_toggle();
if (millis() > 10000)
{
if (sensors.Gas >= GAS_LIMIT)
{
#if DEBUG
USART1_SendStr("Gas detected.\r\n");
USART1_SendStr("Current Gas: ");
USART1_SendFloat(sensors.Gas);
USART1_SendStr("Limited Gas: ");
USART1_SendFloat(GAS_LIMIT);
USART1_SendStr("\r\n");
#endif
TurnBuzzerOn();
TurnSpeakerOn();
TurnRelayOn();
}
else if (sensors.Lighting >= LIGHT_LIMIT)
{
#if DEBUG
USART1_SendStr("Light detected.\r\n");
USART1_SendStr("Current Light: ");
USART1_SendFloat(sensors.Lighting);
USART1_SendStr("Limited Light: ");
USART1_SendFloat(LIGHT_LIMIT);
USART1_SendStr("\r\n");
#endif
TurnBuzzerOn();
TurnSpeakerOn();
TurnRelayOn();
}
else if (sensors.TempC >= TEMPC_LIMIT)
{
#if DEBUG
USART1_SendStr("Tempc detected.\r\n");
USART1_SendStr("Current Tempc: ");
USART1_SendFloat(sensors.TempC);
USART1_SendStr("Limited Tempc: ");
USART1_SendFloat(TEMPC_LIMIT);
USART1_SendStr("\r\n");
#endif
TurnBuzzerOn();
TurnSpeakerOn();
TurnRelayOn();
}
else
{
TurnBuzzerOff();
TurnSpeakerOff();
TurnRelayOff();
}
}
// Sim900_Process();
}
// if (millis() - sms_test_time > 10000)
// {
// Sim900_SendSMS("Hi kieu", "01677880531");
// sms_test_time = millis();
// }
// usart_len = USART1_Available();
//
// // usart: for test
// if (usart_len > 4)
// {
// int i;
// USART1_SendStr("\nUSART1 received packet: \n");
// USART1_GetData(buff_usart, usart_len);
// for (i = 0; i < usart_len; i++)
// USART1_SendByte(buff_usart[i], HEX);
// USART1_SendChar('\n');
// if (ThesisProcess(buff_usart, usart_len) == THESIS_OK)
// {
// memset(buff_usart, 0, usart_len);
// USART1_Flush();
// if (thesis_need_to_send)
// {
// int i;
// USART1_SendStr("\nNeed to send packet: ");
// for (i = 0; i < thesis_msg_len; i++)
// {
// USART1_SendByte(thesis_sent_msg[i], HEX);
// }
// USART1_SendStr("\nNeed to send packet length: ");
// USART1_SendNum(thesis_msg_len);
// USART1_SendStr("\n");
// thesis_msg_len = 0;
// thesis_need_to_send = 0;
// }
// USART1_SendStr("\nPacket processed.\n");
// }
// else if (thesis_errn == THESIS_FLASH_ERROR)
// {
// USART1_SendStr("\n");
// USART1_SendStr(thesis_err_msg);
// USART1_SendStr("\n");
// led_toggle();
// for(;;);
// }
// else if (thesis_errn != THESIS_PACKET_NOT_ENOUGH_LENGTH)
// {
// memset(buff_usart, 0, usart_len);
// USART1_Flush();
// USART1_SendStr("Packet processing fail.\n");
// }
//
// USART1_SendStr("\n");
// USART1_SendStr(thesis_err_msg);
// USART1_SendStr("\n");
// }
// rf
if (Enrf24_available(1))
{
int i;
rf_len = Enrf24_read(buff_rf + rf_len, BUFFER_SIZE - 1 - rf_len);
#if DEBUG
USART1_SendStr("\nRF received packet.\n");
for (i = 0; i < rf_len; i++)
USART1_SendByte(buff_rf[i], HEX);
USART1_SendChar('\n');
#endif
if (ThesisProcess(buff_rf, rf_len) == THESIS_OK)
{
memset(buff_rf, 0, rf_len);
rf_len = 0;
if (thesis_need_to_send)
{
int i;
#if DEBUG
USART1_SendStr("\nNeed to send packet: ");
for (i = 0; i < thesis_msg_len; i++)
{
// Enrf24_write(thesis_sent_msg[i]);
USART1_SendByte(thesis_sent_msg[i], HEX);
}
#endif
Enrf24_write_buff(thesis_sent_msg, thesis_msg_len);
Enrf24_flush();
#if DEBUG
USART1_SendStr("\nNeed to send packet length: ");
USART1_SendNum(thesis_msg_len);
USART1_SendStr("\n");
#endif
thesis_msg_len = 0;
thesis_need_to_send = 0;
}
#if DEBUG
USART1_SendStr("\nPacket processed.\n");
#endif
}
else if (thesis_errn == THESIS_FLASH_ERROR)
{
#if DEBUG
USART1_SendStr("\n");
USART1_SendStr(thesis_err_msg);
USART1_SendStr("\n");
#endif
led_toggle();
for(;;);
}
else if (thesis_errn != THESIS_PACKET_NOT_ENOUGH_LENGTH)
{
memset(buff_rf, 0, rf_len);
// RF_Flush();
rf_len = 0;
#if DEBUG
USART1_SendStr("Packet processing fail.\n");
#endif
}
#if DEBUG
USART1_SendStr("\n");
USART1_SendStr(thesis_err_msg);
USART1_SendStr("\n");
#endif
}
// rs485
rs485_len = RS485_Available();
if (rs485_len > 4)
{
int i;
RS485_GetData(buff_rs485, rs485_len);
#if DEBUG
USART1_SendStr("\nUSART1 received packet: \n");
for (i = 0; i < rs485_len; i++)
USART1_SendByte(buff_rs485[i], HEX);
USART1_SendChar('\n');
#endif
if (ThesisProcess(buff_rs485, rs485_len) == THESIS_OK)
{
memset(buff_rs485, 0, rs485_len);
RS485_Flush();
if (thesis_need_to_send)
{
int i;
#if DEBUG
USART1_SendStr("\nNeed to send packet: ");
#endif
RS485_DIR_Output();
for (i = 0; i < thesis_msg_len; i++)
{
RS485_SendChar(thesis_sent_msg[i]);
#if DEBUG
USART1_SendByte(thesis_sent_msg[i], HEX);
#endif
}
RS485_DIR_Input();
#if DEBUG
USART1_SendStr("\nNeed to send packet length: ");
USART1_SendNum(thesis_msg_len);
USART1_SendStr("\n");
#endif
thesis_msg_len = 0;
thesis_need_to_send = 0;
}
#if DEBUG
USART1_SendStr("\nPacket processed.\n");
#endif
}
else if (thesis_errn == THESIS_FLASH_ERROR)
{
#if DEBUG
USART1_SendStr("\n");
USART1_SendStr(thesis_err_msg);
USART1_SendStr("\n");
#endif
led_toggle();
for(;;);
}
else if (thesis_errn != THESIS_PACKET_NOT_ENOUGH_LENGTH)
{
memset(buff_rs485, 0, rs485_len);
RS485_Flush();
#if DEBUG
USART1_SendStr("Packet processing fail.\n");
#endif
}
#if DEBUG
USART1_SendStr("\n");
USART1_SendStr(thesis_err_msg);
USART1_SendStr("\n");
#endif
}
}
}
void Redbull_Init()
{
char buff[128] = { 0 };
USART_STDIO_Init();
Delay_Init();
Button_GPIO_Config();
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_FSMC, ENABLE);
STM3210E_LCD_Init();
LCD_SetFont(&Font8x12);
LCD_SetColors(LCD_COLOR_WHITE, LCD_COLOR_BLACK);
LCD_WriteRAM_Prepare();
for (int i = 0; i < (320 * 240); i++)
{
LCD_WriteRAM(LCD_COLOR_WHITE);
}
for (int i = 0; i < (320 * 240); i++)
{
LCD_WriteRAM(LCD_COLOR_BLACK);
}
LCD_DisplayStringLine(LINE(0), (uint8_t*) " initializing REDBULL");
LCD_DisplayStringLine(LINE(1), (uint8_t*) " CPU ...............................");
sprintf(buff, "ARM Cortex-M3 @ %dMHz", (int) SystemCoreClock / 1000000);
printRight(1, buff);
LCD_DisplayStringLine(LINE(2), (uint8_t*) " LCD ............................320x240");
LCD_DisplayStringLine(LINE(3), (uint8_t*) " LED ..................................");
LED_Init();
toggleLED(LED1_PIN, 0);
toggleLED(LED2_PIN, LED1_PIN);
toggleLED(LED3_PIN, LED2_PIN);
toggleLED(LED4_PIN, LED3_PIN);
toggleLED(LED5_PIN, LED4_PIN);
toggleLED(LED4_PIN, LED5_PIN);
toggleLED(LED3_PIN, LED4_PIN);
toggleLED(LED2_PIN, LED3_PIN);
toggleLED(LED1_PIN, LED2_PIN);
toggleLED(0, LED1_PIN);
printRight(3, "5");
LCD_DisplayStringLine(LINE(4), (uint8_t*) " RTC ................");
RTC_Init();
RTC_t rtc = { .year = 2011, .month = 12, .mday = 19, .hour = 21, .min = 00 };
//RTC_SetTime(&rtc);
RTC_GetTime(&rtc);
sprintf(buff, "%04d/%02d/%02d %02d:%02d:%02d", rtc.year, rtc.month, rtc.mday, rtc.hour, rtc.min, rtc.sec);
printRight(4, buff);
LCD_DisplayStringLine(LINE(5), (uint8_t*) " USB .................................");
Set_USBClock();
Set_System();
USB_Interrupts_Config();
USB_Init();
printRight(5, "ok");
//IS61LV25616 (512KB)
LCD_DisplayStringLine(LINE(6), (uint8_t*) " SRAM ................................");
SRAM_Init();
uint32_t* RAM = (uint32_t*) Bank1_SRAM3_ADDR;
uint8_t TESTOK = 1;
for (uint32_t i = 0; i < (512 * 1024) / 4; i++)
{
RAM[i] = i;
}
for (uint32_t i = 0; i < (512 * 1024) / 4; i++)
{
if (RAM[i] != i)
{
TESTOK = 0;
}
RAM[i] = 0;
}
if (TESTOK)
{
printRight(6, "IS61LV25616 512KB");
}
else
{
printRight(6, "fail");
}
//M29W128F (2MB)
LCD_DisplayStringLine(LINE(7), (uint8_t*) " NOR .................................");
NOR_Init();
NOR_IDTypeDef norid;
NOR_ReadID(&norid);
printRight(7, "MX29LV160D 2MB");
//HY27UF081G2A (128MB)
LCD_DisplayStringLine(LINE(8), (uint8_t*) " NAND ................................");
NAND_Init();
NAND_IDTypeDef nandid;
NAND_ReadID(&nandid);
printRight(8, "HY27UF081G2A 128MB");
LCD_DisplayStringLine(LINE(9), (uint8_t*) " SDIO ................................");
SD_Init();
SD_CardInfo cardinfo;
SD_GetCardInfo(&cardinfo);
printRight(9, "ok");
}
int main(void) {
Delay_Init((void *)0);
UARTx_Init(USART2,1382400);
UART_SendStr(USART2,"--------------------------------------\n");
if (I2Cx_Init(BMC050_I2C_PORT,400000) != I2C_SUCCESS) {
UART_SendStr(USART2,"I2C2 init fail\n");
while(1);
}
UART_SendStr(USART2,"I2C2 init at 400kHz\n");
// Enable PORTA peripheral
RCC->AHBENR |= RCC_AHBENR_GPIOAEN;
// Configure PA6 as external interrupt
GPIOA->MODER &= ~GPIO_MODER_MODER6; // Input mode (reset state)
GPIOA->PUPDR &= ~GPIO_PUPDR_PUPDR6; // No pull-up, pull-down
GPIOA->PUPDR |= GPIO_PUPDR_PUPDR6_1; // Pull-down
// Configure priority group: 4 bits for preemption priority, 0 bits for subpriority.
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
// Enable the SYSCFG module clock
RCC->APB2ENR |= RCC_APB2ENR_SYSCFGEN;
// PA6 -> EXTI line 6 (INT1 from BMC050)
EXTI->PR = INT1_EXTI_LINE; // Clear IT pending bit for EXTI line
EXTI->IMR |= INT1_EXTI_LINE; // Enable interrupt request from EXTI line
EXTI->EMR &= ~INT1_EXTI_LINE; // Disable event on EXTI line
EXTI->RTSR |= INT1_EXTI_LINE; // Trigger rising edge enabled
EXTI->FTSR &= ~INT1_EXTI_LINE; // Trigger falling edge disabled
// Enable the USB interrupt
NVICInit.NVIC_IRQChannel = EXTI9_5_IRQn;
NVICInit.NVIC_IRQChannelPreemptionPriority = 2;
NVICInit.NVIC_IRQChannelSubPriority = 0;
NVICInit.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVICInit);
///*
uint8_t buf[2];
uint8_t reg;
uint8_t val;
uint32_t i;
//*/
///*
reg = 0x00;
val = 0;
UART_SendStr(USART2,"\nAccelerometer\n");
for (reg = 0; reg <= 0x3f; reg++) {
I2Cx_Write(BMC050_I2C_PORT,®,1,0x18 << 1,I2C_NOSTOP);
I2Cx_Read(BMC050_I2C_PORT,&val,1,0x18 << 1);
UART_SendStr(USART2,"R");
UART_SendHex8(USART2,reg);
UART_SendStr(USART2," = ");
UART_SendHex8(USART2,val);
UART_SendStr(USART2,"\t\t");
}
UART_SendChar(USART2,'\n');
//*/
/*
UART_SendStr(USART2,"\nMagnetometer\n");
// Magnetometer power enable
buf[0] = 0x4b;
buf[1] = 0x01; // Set power control bit
I2Cx_Write(BMC050_I2C_PORT,&buf[0],2,0x10 << 1,I2C_STOP);
for (reg = 0x40; reg <= 0x52; reg++) {
I2Cx_Write(BMC050_I2C_PORT,®,1,0x10 << 1,I2C_NOSTOP);
I2Cx_Read(BMC050_I2C_PORT,&val,1,0x10 << 1);
UART_SendStr(USART2,"R");
UART_SendHex8(USART2,reg);
UART_SendStr(USART2," = ");
UART_SendHex8(USART2,val);
UART_SendStr(USART2,"\t\t");
}
UART_SendStr(USART2,"\n========================================\n");
*/
BMC050_ACC_SoftReset();
Delay_ms(5); // must wait for start-up time of accelerometer (2ms)
BMC050_Init();
// Enable I2C watchdog timer with 50ms
BMC050_ACC_InterfaceConfig(ACC_IF_WDT_50ms);
UART_SendStr(USART2,"BMC050 ACC device ID: ");
UART_SendHex8(USART2,BMC050_ACC_GetDeviceID());
UART_SendChar(USART2,'\n');
UART_SendStr(USART2,"BMC050 MAG device ID: ");
UART_SendHex8(USART2,BMC050_MAG_GetDeviceID());
UART_SendChar(USART2,'\n');
UART_SendStr(USART2,"BMC050 temperature: ");
temp = BMC050_ReadTemp();
UART_SendInt(USART2,temp / 10);
UART_SendChar(USART2,'.');
UART_SendInt(USART2,temp % 10);
UART_SendStr(USART2,"C\n");
BMC050_ACC_SetBandwidth(ACC_BW8); // Accelerometer readings filtering (lower or higher better?)
BMC050_ACC_SetIRQMode(ACC_IM_NOLATCH); // No IRQ latching
BMC050_ACC_ConfigSlopeIRQ(0,16); // Motion detection sensitivity
BMC050_ACC_IntPinMap(ACC_IM1_SLOPE); // Map slope interrupt to INT1 pin
BMC050_ACC_SetIRQ(ACC_IE_SLOPEX | ACC_IE_SLOPEY | ACC_IE_SLOPEZ); // Detect motion by all axes
BMC050_ACC_LowPower(ACC_SLEEP_100); // Low power with sleep duration 0.1s
// BMC050_ACC_Suspend();
while(1);
/*
while(1) {
while (!BMC050_ACC_GetIRQStatus()); // Wait for new data from accelerometer
i8 = BMC050_ACC_GetTSIRQ();
BMC050_ACC_GetXYZ(&X,&Y,&Z);
UART_SendStr(USART2,"Slope=");
UART_SendHex8(USART2,i8);
UART_SendChar(USART2,' ');
if (i8 & ACC_TS_SLOPEZ) UART_SendStr(USART2,"SLOPEZ ");
if (i8 & ACC_TS_SLOPEY) UART_SendStr(USART2,"SLOPEY ");
if (i8 & ACC_TS_SLOPEX) UART_SendStr(USART2,"SLOPEX ");
UART_SendStr(USART2," X=");
UART_SendInt(USART2,X);
UART_SendStr(USART2," Y=");
UART_SendInt(USART2,Y);
UART_SendStr(USART2," Z=");
UART_SendInt(USART2,Z);
UART_SendChar(USART2,'\n');
BMC050_ACC_SetIRQMode(ACC_IM_RESET);
Delay_ms(100);
}
*/
}
int main(void) {
// Initialize the MCU clock system
SetSysClock();
SystemCoreClockUpdate();
// Prefetch is useful if at least one wait state is needed to access the Flash memory
if (RCC_GetLatency() != FLASH_ACR_LATENCY_0WS) {
// Enable prefetch buffer (a.k.a ART)
RCC_PrefetchEnable();
}
// Initialize debug output port (USART2)
// clock source: SYSCLK
// mode: transmit only
USART2_HandleInit();
RCC_SetClockUSART(RCC_USART2_CLK_SRC, RCC_PERIPH_CLK_SYSCLK);
USART_Init(&hUSART2, USART_MODE_TX);
// Configure USART:
// oversampling by 16
// 115200, 8-N-1
// no hardware flow control
USART_SetOversampling(&hUSART2, USART_OVERS16);
USART_SetBaudRate(&hUSART2, 115200);
USART_SetDataMode(&hUSART2, USART_DATAWIDTH_8B, USART_PARITY_NONE, USART_STOPBITS_1);
USART_SetHWFlow(&hUSART2, USART_HWCTL_NONE);
USART_Enable(&hUSART2);
USART_CheckIdleState(&hUSART2, 0xC5C10); // Timeout of about 100ms at 80MHz CPU
// Say "hello world" into the USART port
RCC_ClocksTypeDef Clocks;
RCC_GetClocksFreq(&Clocks);
printf("---STM32L476RG---\r\n");
printf("STM32L476 Template (%s @ %s)\r\n", __DATE__, __TIME__);
printf("CPU: %.3uMHz\r\n", SystemCoreClock / 1000);
printf("SYSCLK: %.3uMHz, HCLK: %.3uMHz\r\n", Clocks.SYSCLK_Frequency / 1000, Clocks.HCLK_Frequency / 1000);
printf("APB1: %.3uMHz, APB2: %.3uMHz\r\n", Clocks.PCLK1_Frequency / 1000, Clocks.PCLK2_Frequency / 1000);
printf("System clock: %s\r\n", _sysclk_src_str[RCC_GetSysClockSource()]);
#if 0
// DEV: 0x461 = STM32L496xx/4A6xx
// 0x415 = STM32L475xx/476xx/486xx devices
// REV: 0x1000: Rev 1 for STM32L475xx/476xx/486xx devices
// Rev A for STM32L496xx/4A6xx devices
// 0x1001: Rev 2 for STM32L475xx/476xx/486xx devices
// Rev B for STM32L496xx/4A6xx devices
// 0x1003: Rev 3 for STM32L475xx/476xx/486xx devices
// 0x1007: Rev 4 for STM32L475xx/476xx/486xx devices
printf("MCU: DEV=%03X REV=%04X FLASH=%uKB ID=%08X%08X%08X\r\n",
DBGMCU->IDCODE & 0xFFFU, // DEV_ID
DBGMCU->IDCODE >> 16, // REV_ID
(uint16_t)(*(volatile uint32_t*)(FLASHSIZE_BASE)), // Flash size in kilobytes
*(volatile uint32_t*)(UID_BASE), // Unique ID 96 bits
*(volatile uint32_t*)(UID_BASE + 4U),
*(volatile uint32_t*)(UID_BASE + 8U)
);
#endif // MCU model
// Initialize delay functions
Delay_Init();
// Initialize the PA5 pin (LED on the Nucleo board)
// Enable the GPIOA peripheral
RCC->AHB2ENR |= RCC_AHB2ENR_GPIOAEN;
// Configure PA5 as push-pull output without pull-up, at lowest speed
GPIO_set_mode(GPIOA, GPIO_Mode_OUT, GPIO_PUPD_NONE, GPIO_PIN_5);
GPIO_out_cfg(GPIOA, GPIO_OT_PP, GPIO_SPD_LOW, GPIO_PIN_5);
// The main loop
while (1) {
// Invert the PA5 pin state every half of second
Delay_ms(500);
GPIO_PIN_INVERT(GPIOA, GPIO_PIN_5);
}
}
void main(void)
{
CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV1);
Delay_Init();
RS485_Init(115200);
#if DEBUG
// UART_Init(115200);
#endif
SRF05_Init();
SRF05_AutoPoolEnable();
//flash_read_buffer((char *)&my_data, sizeof (struct flash_data));
my_data.id = 0x21;
// UART_SendByte(0x21, HEX);
// RS485_SendStr("Hello world.\n");
// LED run
GPIO_Init(LED_RUN_PORT, LED_RUN_PIN, GPIO_MODE_OUT_PP_HIGH_FAST);
GPIO_WriteHigh(LED_RUN_PORT, LED_RUN_PIN);
while (1)
{
if (Millis() - tmp_time > 500)
{
LED_RUN_TOGGLE;
tmp_time = Millis();
#if DEBUG
RS485_DIR_OUTPUT;
RS485_SendStr("\n");
RS485_SendFloat(SRF05_GetDistance());
RS485_DIR_INPUT;
#endif
}
if (GPIO_ReadInputPin(RS485_SEL_PORT, RS485_SEL_PIN) == RESET)
{
if (RS485_Available() >= 8)
{
// memset(packet_buff, 0, PACKET_BUFFER_SIZE);
packet_len = RS485_GetData(packet_buff);
packet = (struct Packet *)packet_buff;
if (packet_len < 4 + getTypeLength(packet->data_type))
{
// not enough length
}
else
{
switch (packet->cmd)
{
case CMD_QUERY:
if (packet->id == my_data.id)
{
LED_RUN_TOGGLE;
tmp_distance = SRF05_GetDistance();
packet->data_type = TYPE_FLOAT | BIG_ENDIAN_BYTE_ORDER;
memcpy(packet->data, &tmp_distance, getTypeLength(packet->data_type));
packet->data[getTypeLength(packet->data_type)] = checksum((char *)packet);
RS485_DIR_OUTPUT;
RS485_SendData(packet_buff, 4 + getTypeLength(packet->data_type));
RS485_DIR_INPUT;
}
else if (IS_BROADCAST_ID(packet->id))
{
// if (GPIO_ReadInputPin(RS485_SEL_PORT, RS485_SEL_PIN) == RESET)
// {
LED_RUN_TOGGLE;
packet->id = my_data.id;
tmp_distance = SRF05_GetDistance();
packet->data_type = TYPE_FLOAT | BIG_ENDIAN_BYTE_ORDER;
memcpy(packet->data, &tmp_distance, getTypeLength(packet->data_type));
packet->data[getTypeLength(packet->data_type)] = checksum((char *)packet);
RS485_DIR_OUTPUT;
RS485_SendData(packet_buff, 4 + getTypeLength(packet->data_type));
RS485_DIR_INPUT;
// }
}
else
{
// not own id
}
break;
case CMD_CONTROL:
// by default, this mode used only for setting id
// the id stored on the first bytes of data bytes
if (IS_BROADCAST_ID(packet->id))
{
LED_RUN_TOGGLE;
if (IS_SENSOR_ULTRA_SONIC(packet->data[0]))
{
my_data.id = packet->data[0];
}
}
break;
default:
break;
}
RS485_Flush();
}
}
}
else
{
RS485_Flush();
}
SRF05_ProcessTrigger();
}
}
