int main(void) { ///////// Initial Portion ///////////////////////// init_USART1(9600); // initialize USART1 @ 9600 baud SystemCoreClockUpdate(); /* Get Core Clock Frequency */ if (SysTick_Config(SystemCoreClock / 1000)) { /* SysTick 1 msec interrupts */ while (1); /* Capture error */ } USART_puts(USART1, "Init 1 complete! Hello World!rn"); // just send a message to indicate that it works //Init GPIO for Leds on board and button input init_GPIO(); /////////////////- Loop - //////////////////////////////////// while (1){ // You can do whatever you want in here USART_puts(USART1, "Init 2 complete! Hello World! \r \n"); // just send a message to indicate that it works //GPIO_ToggleBits(GPIOD, GPIO_Pin_15 | GPIO_Pin_14 | GPIO_Pin_13| GPIO_Pin_12 ); GPIO_ToggleBits(GPIOD, GPIO_Pin_12 ); //Test Leds on board Delay(200); GPIO_ToggleBits(GPIOD, GPIO_Pin_13 ); //Test Leds on board Delay(200); GPIO_ToggleBits(GPIOD, GPIO_Pin_14 ); //Test Leds on board Delay(1000); } ////////////////////////////////////////////////////////// }
int main(void) { initButton(); initLEDs(); init_USART1(54000); // initialize USART1 @ 9600 baud //USART_puts(USART1, "Init complete! Hello World!&"); // just send a message to indicate that it works byte bull[5]; //Set lowest power parameter bull[0]=0x43; bull[1]=0x78; bull[2]=0x1E; bull[3]=0x09; bull[4]=7; USART_puts(USART1, bull); //Set 50000bps bull[0]=0x43; bull[1]=0x78; bull[2]=0x1E; bull[3]=0x08; bull[4]=50; USART_puts(USART1, bull); while (1){ char buff[4]="*&*"; USART_puts(USART1, buff); } }
void abrir(char *id, uint8_t print) { uint32_t num_id = (uint32_t) strtoul(id, NULL, 0); // USART_puts(USART2, "Abrir: Comando ainda nao implementado. ID: "); // USART_puts(USART2, id); // USART_puts(USART2, "\n"); if (consultaID(num_id)) { if (print) USART_puts(USART2, "Usuario Cadastrado!\n"); openRequestTimer = 10000; // USART_puts(USART2, "Abrindo o Portao!\n"); } else { uint8_t i; if (print) USART_puts(USART2, "Usuario Nao Cadastrado!\n"); for( i = 1 ; i <= bufferNaoCadastrados[0] ; ++i ){ if( bufferNaoCadastrados[i] == num_id ){ return; } } if (bufferNaoCadastrados[0] < 9) { bufferNaoCadastrados[0]++; bufferNaoCadastrados[bufferNaoCadastrados[0]] = num_id; } } }
// cpu <-> gpu serial void usart1_isr ( void ) { // check if the USART1 receive interrupt flag was set if ( USART_GetITStatus ( USART1, USART_IT_RXNE ) ) { static uint8_t cnt = 0; // this counter is used to determine the string length char t = USART1->DR; // the character from the USART1 data register is saved in t /* check if the received character is not the LF character (used to determine end of string) * or the if the maximum string length has been been reached */ if( (t != '\n') && (cnt < MAX_STRLEN) ){ received_string[cnt] = t; cnt++; } else { // otherwise reset the character counter and print the received string cnt = 0; //USART_puts(USART1, received_string); USART_puts ( USART2, "avr: " ); USART_puts ( USART2, received_string ); USART_puts ( USART2, "\r\n" ); } } // if USART received } // func
/** * @brief Configures all needed resources (I2C, DCMI and DMA) to interface with * the OV9655 camera module * @param None * @retval 0x00 Camera module configured correctly * 0xFF Camera module configuration failed */ uint8_t DCMI_OV9655Config(void) { uint8_t readvalue; char str[8]; uint8_t opmask=MODE|LEN|OEN_TRI_SEL_MASK; /* I2C1 will be used for camera configuration */ I2C1_Config(); // - Read ID and check readvalue=DCMI_SingleRandomRead(OV9655_DEVICE_READ_ADDRESS,ID); sprintf(str,"ID=%x,",readvalue); USART_puts(USART2,str); //- Write opform register //Mode=0, Len=0, rest default tw9910_mask_set(OV9655_DEVICE_WRITE_ADDRESS, OPFORM, opmask, 0x00|OEN_TRI_SEL_ALL_ON); //- set resolution(vscale,hscale or vactive,hactive and vdelay hdelay) /* OV9655 Camera size setup */ DCMI_OV9655_QVGASizeSetup(); //- write the hsync vsync pin configuration(output control 0x05) DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OUTCTR1, 0x02);//**0x11,0x01,0x10? //- write clock DCMI_SingleRandomWrite(OV9655_DEVICE_WRITE_ADDRESS, OUTCTR2, 0x00); //- write vbi control register for invalid bit settings and Hactive enable tw9910_mask_set(OV9655_DEVICE_WRITE_ADDRESS,VBICNTL,0x18, 0x18);//Enable HA_EN**0,1? and cntl656 //- read and print status registers(Nicely! - normal status, detected format etc.) readvalue=DCMI_SingleRandomRead(OV9655_DEVICE_READ_ADDRESS,STATUS1); sprintf(str,"St1=%x,",readvalue); USART_puts(USART2,str); while((DCMI_SingleRandomRead(OV9655_DEVICE_READ_ADDRESS,STATUS1)&~0x10)!=0x68){ Delay(10); } readvalue=DCMI_SingleRandomRead(OV9655_DEVICE_READ_ADDRESS,STATUS1); sprintf(str,"St1=%x,",readvalue); // USART_puts(USART2,str); readvalue=DCMI_SingleRandomRead(OV9655_DEVICE_READ_ADDRESS,STATUS2); sprintf(str,"St2=%x,",readvalue); USART_puts(USART2,str); readvalue=DCMI_SingleRandomRead(OV9655_DEVICE_READ_ADDRESS,SDT); sprintf(str,"Sdt=%x\n",readvalue); USART_puts(USART2,str); /* Configure the DCMI to interface with the OV9655 camera module */ DCMI_Config(); return (0x00); }
//-------------- //main loop int main(void) { int i=0; for(i=0;i<100000ul;i++); rcc_config(); nvic_config(); gpio_config(); usart_config(); USART_puts(USART1, "USART BT initialization complete!\r\n"); // just send a message to indicate that it works MPU6050_I2C_Init(); MPU6050_Initialize(); if( MPU6050_TestConnection() == 1){ // connection success USART_puts(USART1, "I2C IMU connection initialization complete!\r\n"); }else{ // connection failed USART_puts(USART1, "I2C initialization failed!\r\n"); } //sysTick_Config_Mod(SysTick_CLKSource_HCLK_Div8, 10500000ul); // interruption every 1/2sec from systick sysTick_Config_Mod(SysTick_CLKSource_HCLK_Div8, 840000ul); // interruption every 0.04sec from systick while(1) { } }
void TIM4_Init(void) { TIM4->PSC = 1999; TIM4->ARR = 41999; TIM4->CR1 |= TIM_CR1_CEN; USART_puts(USART1, "TIM4 init ok"); USART_puts(USART1, "\n\r"); }
void backward(){ SpeedValue_left = 105; SpeedValue_right = 105; mMove(SpeedValue_left, SpeedValue_right); USART_puts(USART3, "left:"); USART_putd(USART3, SpeedValue_left); USART_puts(USART3, " right:"); USART_putd(USART3, SpeedValue_right); USART_puts(USART3, "\r\n"); }
void forward(){ SpeedValue_left = 140; SpeedValue_right = 140; mMove(SpeedValue_left,SpeedValue_right); USART_puts(USART3, "left:"); USART_putd(USART3, SpeedValue_left); USART_puts(USART3, " right:"); USART_putd(USART3, SpeedValue_right); USART_puts(USART3, "\r\n"); }
void stop(){ SpeedValue_left = 120; SpeedValue_right = 120; mMove(SpeedValue_left, SpeedValue_right); USART_puts(USART3, "left"); USART_putd(USART3, SpeedValue_left); USART_puts(USART3, " right"); USART_putd(USART3, SpeedValue_right); USART_puts(USART3, "\r\n"); }
void right(){ SpeedValue_left = 140; SpeedValue_right = 105; mMove(SpeedValue_left, SpeedValue_right); USART_puts(USART3, "left"); USART_putd(USART3, SpeedValue_left); USART_puts(USART3, " right"); USART_putd(USART3, SpeedValue_right); USART_puts(USART3, "\r\n"); }
uint8_t handleTopPacket(void) { if(USART_GetFlagStatus(USART2, USART_FLAG_RXNE)) { uint8_t received = USART_ReceiveData(USART2); if(START_BYTE == received) { uint8_t timer = 0; //Timer used to stop the function from waiting for data if there is an error GPIO_SetBits(GPIOD, GREED_LED); //Turns on the green led uint8_t counter = 1; //Counter used to count how many bytes we have read in from the top borad while(counter < PACKET_SIZE && timer < 0xFFFF) //Waits until all 16 bytes are read in. If no data comes then the function will break //out after a short period of time { if(USART_GetFlagStatus(USART2, USART_FLAG_RXNE)) //if data is received store it in the array storage { received = USART_ReceiveData(USART2); if(received != START_BYTE) { storage[counter] = received; //Reads in the data from the buffer into an array counter++; //Increments the counter } else { return(0); } } GPIO_SetBits(GPIOD, ORANGE_LED); timer++; } if(1 || (checksum(storage, PACKET_SIZE - 3) == storage[PACKET_SIZE - 2]) && (storage[PACKET_SIZE - 1] == END_BYTE)) //Checks the check sum and the end byte { GPIO_ResetBits(GPIOD, ORANGE_LED); convertTBtoBB(storage); //Converts the data from the top board into motor controller commands that we can use sendPackets(); //Sends the motor controller commands produced by the convert function return(1); //Reading the packet was successful! } else { USART_puts(USART1, (checksum(storage, PACKET_SIZE - 3))); USART_puts(USART1,storage[PACKET_SIZE - 2]); return(0); //Returns 0 if the check sum or end byte were incorrect } } else return(0); //Makes the function recursive until we get a response from the top board } else return(0); }
void listar(void) { int i = 0; uint32_t contadorRegistros; USART_puts(USART2, "Usuarios Cadastrados: \n"); contadorRegistros = buffer[0]; sprintf(string_buffer, "Quantidade: %d\n", (int) contadorRegistros); USART_puts(USART2, string_buffer); if (contadorRegistros != 0) USART_puts(USART2, "\tCodigo\n"); for (i = 1; i <= contadorRegistros; i++) { sprintf(string_buffer, "%d.\t%d\n", i, (int) buffer[i]); USART_puts(USART2, string_buffer); } USART_puts(USART2, "Usuarios Nao Cadastrados (Recentes): \n"); contadorRegistros = bufferNaoCadastrados[0]; sprintf(string_buffer, "Quantidade: %d\n", (int) contadorRegistros); USART_puts(USART2, string_buffer); if (contadorRegistros != 0) USART_puts(USART2, "\tCodigo\n"); for (i = 1; i <= contadorRegistros; i++) { sprintf(string_buffer, "%d.\t%d\n", i, (int) bufferNaoCadastrados[i]); USART_puts(USART2, string_buffer); } bufferNaoCadastrados[0] = 0; }
void convert_int(int x) { if(x<0) { x = x*(-1); USART_puts(USART2,'-'); } if(x>=10) convert_int(x/10); x = x%10; USART_puts(USART2,x+'0'); }
// this is the interrupt request handler (IRQ) for ALL USART3 interrupts void USART3_IRQHandler(void){ // check if the USART3 receive interrupt flag was set if( USART_GetITStatus(USART3, USART_IT_RXNE) ){ /*check the uart RX have accept the char*/ GPIO_ToggleBits(GPIOD,GPIO_Pin_14); static uint8_t cnt = 0; // this counter is used to determine the uart receive string length //Receive_data = USART3->DR; // the character from the USART3 data register is saved in t Receive_data = USART_ReceiveData(USART3);; /* check if the received character is not the LF character (used to determine end of string) * or the if the maximum string length has been been reached */ if( cnt < MAX_STRLEN){ received_string[cnt] = Receive_data; if(Receive_data=='0') GPIO_ToggleBits(GPIOD,GPIO_Pin_15); /*start determine the period of command.*/ if(received_string[cnt]=='\r'){ Receive_String_Ready = 1; /*Ready to parse the command */ cnt=0; /*restart to accept next stream message.*/ } else{ cnt++; } } else{ // over the max string length, cnt return to zero. Receive_String_Ready=1; cnt = 0; } if(Receive_String_Ready){ //print the content of the received string USART_puts(USART3, received_string); USART_puts(USART3,"\r\n"); //receive_task(); /*clear the received string and the flag*/ Receive_String_Ready = 0; int i; for( i = 0 ; i< MAX_STRLEN ; i++){ received_string[i]= 0; } } } }
void TIM2_Init(void) { TIM2->CR1 &= ~TIM_CR1_CEN; prescaler = SystemCoreClock/2; prescaler /=Timer_Frequency; prescaler -=1; TIM2 -> PSC = (Timer_Frequency-1); TIM2 -> ARR = prescaler; NVIC_EnableIRQ(TIM2_IRQn); NVIC_SetPriority(TIM2_IRQn, 0x01); TIM2->DIER |= TIM_DIER_UIE; TIM2->CR1 |= TIM_CR1_CEN; USART_puts(USART1, "TIM2 init ok"); USART_puts(USART1, "\n\r"); }
FRESULT ff_read(void) { char line[20]; printf("ff_read begin\n\r"); res = f_mount(&fatfs, "", 0); if(res != FR_OK) printf("mount failed: %d\n\r", res); res = f_open(&file, "test.txt", FA_READ); res = f_open(&file2, "var.txt", FA_READ); if(res != FR_OK) printf("open failed: %d\n\r", res); speed[0] = 1; speed[1] = 0; while(1) { f_gets(line, sizeof(line), &file); if(line[0] == 0) break; USART_puts(USART3, line); int i; for(i = 0; i < 20; i++) line[i] = 0; } res = f_read(&file2, speed, sizeof(speed), &br); printf("speed:%d, %d\n\r",speed[0], speed[1]); res = f_close(&file); res = f_close(&file2); if(res != FR_OK) printf("close failed: %d\n\r", res); res = f_mount(NULL, "", 0); if(res != FR_OK) printf("umnout failed: %d\n\r", res); }
void printf2(const char *format, ...) { if ( Utils::inISR() ) { Event *e = EventPool::instance().newEvent(DEBUG_EVENT); if ( e == NULL ) return; va_list list; va_start(list, format); vsnprintf(e->debugMessage.buffer, 128, format, list); va_end(list); EventQueue::instance().push(e); } else { va_list list; va_start(list, format); vsnprintf(__buffer, 128, format, list); va_end(list); #ifdef MULTIPLEXED_OUTPUT DataTerminal::instance().write("DEBUG", __buffer); #else USART_puts(USART2, __buffer); #endif } }
void test_motors(int max_torgue) { cnt = 0; while(cnt < max_torgue) { sprintf(send, "hhh: %d\n",cnt); USART_puts(USART2, send); if(cnt < max_torgue-1) { STM_EVAL_LEDOn(LED3); cnt = cnt + 5; ESC_SetPower(1,cnt); ESC_SetPower(2,cnt); ESC_SetPower(3,cnt); ESC_SetPower(4,cnt); Delay(10); }else { STM_EVAL_LEDOff(LED3); ESC_SetPower(1,0); ESC_SetPower(2,0); ESC_SetPower(3,0); ESC_SetPower(4,0); Delay(3000); } if(UserButtonPressed == 1) { break; } } }
void usartTaskMain(void* dummy) { USART_puts("usartTaskMain"); while (1) { vTaskDelay(usartTask_delay); // yield } return; }
void USART2_INIT(void) { GPIOA -> MODER |= GPIO_MODER_MODER3_1; // RX PD6 to alternate function output push-pull at 50 MHz 0x10 GPIOA -> MODER |= GPIO_MODER_MODER2_1; // TX PD5 to alternate function output push-pull at 50 MHz 0x10 GPIOA -> OSPEEDR |= GPIO_OSPEEDER_OSPEEDR3_0 | GPIO_OSPEEDER_OSPEEDR3_1; //50Mhz fast speed GPIOA -> OSPEEDR |= GPIO_OSPEEDER_OSPEEDR2_0 | GPIO_OSPEEDER_OSPEEDR2_1; GPIOA -> PUPDR |= GPIO_PUPDR_PUPDR2_0; GPIOA -> AFR[0] |= (7<<8); GPIOA -> AFR[0] |= (7<<12); BRR = (SystemCoreClock/4) / (BaudRate*16); USART2 -> BRR = (68 << 4 ) + 0x06; //38400br USART2 -> CR1 |= USART_CR1_UE | USART_CR1_RE | USART_CR1_TE; USART2 -> CR3 |= USART_CR3_DMAR; USART_puts(USART1, "USART2 init ok"); USART_puts(USART1, "\n\r"); }
void serial::write(uint8_t* packet, uint8_t size) { for(int i = 0; i < size; i++) { USART_puts(thisUsart, packet[i]); } }
void USART_putd(USART_TypeDef* USARTx, uint32_t number) //uint32_t = unsigned int { static uint32_t temp; //uint32_t static uint8_t cnt = 0; //uint8_t = unsigned char volatile uint8_t tmp_num[10]; //uint8_t volatile uint8_t num[10]; //uint8_t if(number == 0){ tmp_num[cnt++] = '0'; } while(number != 0){ temp = number % 10; number -= temp; number /= 10; tmp_num[cnt] = temp+'0'; cnt++; } int j = 0; while(cnt){ num[j++] = tmp_num[--cnt]; } num[j] = '\0'; USART_puts(USART3, num); cnt = 0; int i; for( i = 0 ; i< 10 ; i++){ tmp_num[i]= 0; num[i]= 0; } }
int main (void) { SystemCoreClockUpdate(); USART_init(&usart, PIO0_18, PIO0_19); USART_begin(&usart, 9600); USART_puts(&usart, "Hello.\n"); VCOM_Init(); // VCOM Initialization USB_Init(); // USB Initialization USB_Connect(TRUE); // USB Connect while (!USB_Configuration) ; // wait until USB is configured while (1) { // Loop forever VCOM_Serial2Usb(); // read serial port and initiate USB event VCOM_CheckSerialState(); VCOM_Usb2Serial(); } // end while SPI_init(&SPI0, PIO0_1, PIO0_1, PIO0_1, PIO0_2); while ( 1 ); }
void USART1_IRQHandler(void) { if( USART_GetITStatus(USART1, USART_IT_RXNE) ) { char t = USART1->DR; USART_puts(USART1, (t+10)%256); } }
void DMA2_Init(void) { DMA2_Stream0 -> CR &= ~DMA_SxCR_EN; // disable Stream0 DMA2_Stream0 -> PAR = (uint32_t)&ADC1->DR; // from periph port register DMA2_Stream0 -> M0AR = (uint32_t) &adc_buffer; // write to memory DMA2_Stream0 -> NDTR = ARRAYSIZE; // number of data items DMA2_Stream0 -> CR |= DMA_SxCR_MINC; // memory increment DMA2_Stream0 -> CR &= ~(DMA_SxCR_CHSEL); // select chanel0 DMA2_Stream0 -> CR |= DMA_SxCR_MSIZE_0; // half-word (16bit) memory data size DMA2_Stream0 -> CR |= DMA_SxCR_PSIZE_0; // half-word (16bit) peripherial data size DMA2_Stream0 -> CR |= DMA_SxCR_TCIE; // transaction complete interrupt DMA2_Stream0 -> CR |= DMA_SxCR_CIRC; // non enable continous mode DMA2_Stream0 -> CR |= DMA_SxCR_EN; // enable Stream0 NVIC_EnableIRQ(DMA2_Stream0_IRQn); // enable IRQ USART_puts(USART1, "DMA2 init ok"); USART_puts(USART1, "\n\r"); }
void cnc_joystick_interrupt(){ if(cnc_joystick_button_status(BUTTON_UP))USART_puts(USART1, "Button UP pressed\n\r"); if(cnc_joystick_button_status(BUTTON_DOWN))USART_puts(USART1, "Button DOWN pressed\n\r"); if(cnc_joystick_button_status(BUTTON_FORWARD))USART_puts(USART1, "Button FORWARD pressed\n\r"); if(cnc_joystick_button_status(BUTTON_BACK))USART_puts(USART1, "Button BACK pressed\n\r"); if(cnc_joystick_button_status(BUTTON_LEFT))USART_puts(USART1, "Button LEFT pressed\n\r"); if(cnc_joystick_button_status(BUTTON_RIGHT))USART_puts(USART1, "Button RIGHT pressed\n\r"); if(cnc_joystick_button_status(BUTTON_OK))USART_puts(USART1, "Button OK pressed\n\r"); if(cnc_joystick_button_status(BUTTON_CANCEL))USART_puts(USART1, "Button CANCEL pressed\n\r"); }
/* test use for printing the status and counter value through usart */ void getEncoder(void){ detachEXTI(EXTI_Line0 | EXTI_Line1 | EXTI_Line2 | EXTI_Line3); USART_puts(USART3, "L_state:"); USART_putd(USART3, ENCODER_L.rotate); USART_puts(USART3, " R_state:"); USART_putd(USART3, ENCODER_R.rotate); getEncoderState(&ENCODER_L); getEncoderState(&ENCODER_R); USART_puts(USART3, " L_state2:"); USART_putd(USART3, ENCODER_L.rotate); USART_puts(USART3, " R_state2:"); USART_putd(USART3, ENCODER_R.rotate); USART_puts(USART3, " le_en:"); USART_putd(USART3, ENCODER_L.count); USART_puts(USART3, " ri_en:"); USART_putd(USART3, ENCODER_R.count); USART_puts(USART3, "\r\n"); /* clear encoder counter*/ ENCODER_L.count = 0; ENCODER_R.count = 0; attachEXTI(EXTI_Line0 | EXTI_Line1 | EXTI_Line2 | EXTI_Line3); }
void ADC_Init(void) { ADC1-> CR1 |=ADC_CR1_SCAN; // Enable channel scan ADC1-> CR2 |=ADC_CR2_CONT; //continous ADC1-> SQR1 |=(1<<20); // 0001: 2 conversion ADC1-> SQR3 |=(16<<0); // Channel 16 first sequence ADC1-> SQR3 |=(18<<5); // Channel 18 second sequence ADC1-> CR2 |=ADC_CR2_ADON; // Enable ADC1 ADC1->CR2 &=~ADC_CR2_DMA; ADC1->CR2 |=ADC_CR2_DMA; ADC1->SMPR1 |= ADC_SMPR1_SMP16_1 | ADC_SMPR1_SMP16_2; // sampling time 144 cycles ADC1->SMPR1 |= ADC_SMPR1_SMP18_1 | ADC_SMPR1_SMP18_2; // sampling time 144 cycles ADC -> CCR |=ADC_CCR_TSVREFE; // Enable TSVREFE ADC -> CCR |=ADC_CCR_VBATE; // Enable VBATE ADC1 -> DR = 0; USART_puts(USART1, "ADC init ok"); USART_puts(USART1, "\n\r"); }
void USART1_INIT(uint32_t baudrate) { GPIOB -> MODER |= GPIO_MODER_MODER6_1; // RX PD6 to alternate function output push-pull at 50 MHz 0x10 GPIOB -> MODER |= GPIO_MODER_MODER7_1; // TX PD5 to alternate function output push-pull at 50 MHz 0x10 GPIOB -> OSPEEDR |= GPIO_OSPEEDER_OSPEEDR6_0 | GPIO_OSPEEDER_OSPEEDR6_1; //50Mhz fast speed GPIOB -> OSPEEDR |= GPIO_OSPEEDER_OSPEEDR7_0 | GPIO_OSPEEDER_OSPEEDR7_1; GPIOB -> PUPDR |= GPIO_PUPDR_PUPDR6_0; GPIOB -> AFR[0] |= (7<<24); GPIOB -> AFR[0] |= (7<<28); USART1 -> BRR = (136 << 4 ) + 0x0C; //38400br USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); // enable the USART1 receive interrupt NVIC_SetPriority(USART1_IRQn, 2); NVIC_EnableIRQ(USART1_IRQn); USART1 -> CR1 |= USART_CR1_UE | USART_CR1_RE | USART_CR1_TE; USART_puts(USART1, "USART1 init ok"); USART_puts(USART1, "\n\r"); }