void UART_init(void) { FIFO_Init(&tx_fifo, tx_buf_gs, TX_BUFFER_MAX_SIZE); FIFO_Init(&rx_fifo, rx_buf_gs, RX_BUFFER_MAX_SIZE); /** @snippet [Configure UART RX and TX pin] */ nrf_gpio_cfg_output(TX_PIN_NUM); nrf_gpio_cfg_input(RX_PIN_NUM, NRF_GPIO_PIN_NOPULL); NRF_UART0->PSELTXD = TX_PIN_NUM; NRF_UART0->PSELRXD = RX_PIN_NUM; NRF_UART0->BAUDRATE = (UART_BAUDRATE_BAUDRATE_Baud38400 << UART_BAUDRATE_BAUDRATE_Pos); NRF_UART0->EVENTS_RXDRDY = 0; NRF_UART0->EVENTS_TXDRDY = 0; NRF_UART0->TASKS_STARTTX = 1; NRF_UART0->TASKS_STARTRX = 1; NRF_UART0->INTENSET = UART_INTENSET_RXDRDY_Enabled << UART_INTENSET_RXDRDY_Pos; NRF_UART0->INTENSET |= UART_INTENSET_TXDRDY_Enabled << UART_INTENSET_TXDRDY_Pos; // enable interrupt; NVIC_SetPriority(UART0_IRQn, APP_IRQ_PRIORITY_LOW); NVIC_EnableIRQ(UART0_IRQn); NRF_UART0->ENABLE = (UART_ENABLE_ENABLE_Enabled << UART_ENABLE_ENABLE_Pos); }
/**************************************************************************** * DESCRIPTION: Initializes the data and the port * RETURN: none * ALGORITHM: none * NOTES: none *****************************************************************************/ void RS485_Initialize( void) { /* Init the Rs485 buffers */ FIFO_Init(&FIFO_Rx, RS485_Rx_Buffer, sizeof(RS485_Rx_Buffer)); FIFO_Init(&FIFO_Tx, RS485_Tx_Buffer, sizeof(RS485_Tx_Buffer)); /* FIXME: read the stored baud rate */ /* I2C_Read_Block( EEPROM_DEVICE_ADDRESS, (char *)&RS485_Baud_Rate, sizeof(RS485_Baud_Rate), EEPROM_MSTP_BAUD_RATE_ADDR); */ RS485_Initialize_Port(); }
uint8_t module_system_init() { FIFO_Init (&s_at_fifo); //ATE0, set no echo. add_send_at_command("ATE", "ATE0\r\n"); //AT+IFC=0, set no flow control. add_send_at_command("AT+IFC", "AT+IFC=0\r\n"); //AT+CPIN, query ..... add_send_at_command("AT+CPIN", "AT+CPIN?\r\n"); //AT+CSQ add_send_at_command("AT+CSQ", "AT+CSQ\r\n"); //AT+GSN request for the IMEI of the module.; add_send_at_command("AT+GSN", "AT+GSN\r\n"); // AT+CGSOCKCONT add_send_at_command("AT+CGSOCKCONT", "AT+CGSOCKCONT=1,\"IP\",\"CMNET\"\r\n"); //AT+CIPMODE add_send_at_command("AT+CIPMODE", "AT+CIPMODE=0\r\n"); //AT+NETOPEN add_send_at_command("AT+NETOPEN", "AT+NETOPEN\r\n"); s_module_status = MODULE_INIT; return s_module_status; }
int main2(void){ FIFO_Init(); // initializes a FIFO that holds 6 elements for(;;){ Status[0] = FIFO_Get(&GetData[0]); // should fail, empty Status[1] = FIFO_Put(1); // should succeed, 1 Status[2] = FIFO_Put(2); // should succeed, 1 2 Status[3] = FIFO_Put(3); // should succeed, 1 2 3 Status[4] = FIFO_Put(4); // should succeed, 1 2 3 4 Status[5] = FIFO_Put(5); // should succeed, 1 2 3 4 5 Status[6] = FIFO_Put(6); // should succeed, 1 2 3 4 5 6 Status[7] = FIFO_Put(7); // should fail, 1 2 3 4 5 6 Status[8] = FIFO_Get(&GetData[1]); // should succeed, 2 3 4 5 6 Status[9] = FIFO_Get(&GetData[2]); // should succeed, 3 4 5 6 Status[10] = FIFO_Put(7); // should succeed, 3 4 5 6 7 Status[11] = FIFO_Put(8); // should succeed, 3 4 5 6 7 8 Status[12] = FIFO_Put(9); // should fail, 3 4 5 6 7 8 Status[13] = FIFO_Get(&GetData[3]); // should succeed, 4 5 6 7 8 Status[14] = FIFO_Get(&GetData[4]); // should succeed, 5 6 7 8 Status[15] = FIFO_Get(&GetData[5]); // should succeed, 6 7 8 Status[16] = FIFO_Get(&GetData[6]); // should succeed, 7 8 Status[17] = FIFO_Get(&GetData[7]); // should succeed, 8 Status[18] = FIFO_Get(&GetData[8]); // should succeed, empty Status[19] = FIFO_Get(&GetData[9]); // should fail, empty } }
static void TestCase_StaticMemory(void) { FIFO_t MyFifo; int ret = 0; T MyT_A, MyT_B, MyT_C; T MyT; MyT.sex = 0; MyT.addr = 0; MyT.tel = 0; MyT_A.sex = 1; MyT_A.addr = 1; MyT_A.tel = 1; MyT_B.sex = 2; MyT_B.addr = 2; MyT_B.tel = 2; MyT_C.sex = 3; MyT_C.addr = 3; MyT_C.tel = 3; FIFO_Init(&MyFifo, FIFO_Pool, sizeof(T), ELE_CNT); ret = FIFO_IsEmpty(&MyFifo); ret = FIFO_IsFull(&MyFifo); ret = FIFO_CountFree(&MyFifo); ret = FIFO_CountUsed(&MyFifo); FIFO_Put(&MyFifo, &MyT_A); FIFO_Put(&MyFifo, &MyT_B); FIFO_Put(&MyFifo, &MyT_C); ret = FIFO_IsEmpty(&MyFifo); ret = FIFO_IsFull(&MyFifo); ret = FIFO_CountFree(&MyFifo); ret = FIFO_CountUsed(&MyFifo); FIFO_Get(&MyFifo, &MyT); FIFO_Get(&MyFifo, &MyT); FIFO_Get(&MyFifo, &MyT); ret = FIFO_IsEmpty(&MyFifo); ret = FIFO_IsFull(&MyFifo); ret = FIFO_CountFree(&MyFifo); ret = FIFO_CountUsed(&MyFifo); FIFO_Put(&MyFifo, &MyT_A); FIFO_Put(&MyFifo, &MyT_B); FIFO_Put(&MyFifo, &MyT_C); ret = FIFO_Flush(&MyFifo); ret = FIFO_IsEmpty(&MyFifo); ret = FIFO_IsFull(&MyFifo); ret = FIFO_CountFree(&MyFifo); ret = FIFO_CountUsed(&MyFifo); }
VOID ITaskQ_Init (ITaskQ *pThis, String pSigName, String pSemName, UINT16 nNumQNodes) { Signal_Init(&pThis->oWrite, pSigName); Mutex_Init(&pThis->oLock, pSemName, 1); FIFO_Init(&pThis->oQ, nNumQNodes); pThis->pRead = &pThis->oWrite; }
void rs485_init( void) { FIFO_Init(&Receive_Buffer, &Receive_Buffer_Data[0], (unsigned) sizeof(Receive_Buffer_Data)); rs485_rts_init(); rs485_usart_init(); rs485_init_nvdata(); rs485_receiver_enable(); rs485_rts_enable(false); }
/************************************************************************* * Description: Initialize the room network USART * Returns: nothing * Notes: none **************************************************************************/ void rs485_init( void) { GPIO_InitTypeDef GPIO_InitStructure; NVIC_InitTypeDef NVIC_InitStructure; GPIO_StructInit(&GPIO_InitStructure); /* Configure USARTx Rx as input floating */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING; GPIO_Init(GPIOA, &GPIO_InitStructure); /* Configure USARTx Tx as alternate function push-pull */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; GPIO_Init(GPIOA, &GPIO_InitStructure); /* Configure the Request To Send (RTS) aka Transmit Enable pin */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; GPIO_Init(GPIOA, &GPIO_InitStructure); /* Enable USARTx Clock */ RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); /*RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);*/ /* Enable GPIO Clock */ RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE); /* Enable the USART Pins Software Remapping for this pair of pins and peripheral functions: USART3 Full remap (TX/PD8, RX/PD9, CK/PD10, CTS/PD11, RTS/PD12) */ /*GPIO_PinRemapConfig(GPIO_FullRemap_USART3, ENABLE);*/ /* Configure the NVIC Preemption Priority Bits */ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0); /* Enable the USARTx Interrupt */ NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* enable the USART to generate interrupts */ USART_ITConfig(USART2, USART_IT_RXNE, ENABLE); rs485_baud_rate_set(Baud_Rate); USART_Cmd(USART2, ENABLE); FIFO_Init(&Receive_Buffer, &Receive_Buffer_Data[0], (unsigned) sizeof(Receive_Buffer_Data)); timer_elapsed_start(&Silence_Timer); }
// Initialization function void IV_Init(void) { // Initializes point delay in ms iv_tracer.point_delay_ms = IV_DEFAULT_POINT_DELAY; // Initializes FIFO FIFO_Init(&iv_tracer.events.super, &iv_tracer.events.list , IV_EVENT_LIST_SIZE, sizeof(IV_EVENT_T)); // FSM Constructor FSM_Ctor(&iv_tracer.super,IV_HAND_INITIAL); // FSM Init FSM_Init(&iv_tracer.super); }
// Idle, waiting timeout to get the next IV Curve FSM_State IV_HAND_IDLE(IV_TRACER_T *me, FSM_Event *e) { switch (e->signal) { case FSM_ENTRY_SIGNAL: return FSM_HANDLED(); case IV_START_NEW_CURVE: return FSM_TRAN(me,IV_HAND_OPER); case FSM_EXIT_SIGNAL: // Inits Curve FIFO FIFO_Init(&me->curve.super, &me->curve.points, IV_CURVE_SIZE, sizeof(IV_POINT_T)); return FSM_HANDLED(); } // Default: Handled return FSM_HANDLED(); }
void UART_Init(void){ // int i; // SYSCTL_RCGC1_R |= SYSCTL_RCGC1_UART1; // activate UART1 // i=i; // SYSCTL_RCGC2_R |= SYSCTL_RCGC2_GPIOD; // activate port D // i = i; // UART1_CTL_R &= ~0x1; // disable UART // i=i; // UART1_IBRD_R = 31; // IBRD = int(50,000,000 / (16 * 100000)) = int(31.25) // UART1_FBRD_R = 16; // FBRD = int(0.1267 * 64 + 0.5) = 16.5 // // 8 bit word length (no parity bits, one stop bit, FIFOs) // //UART1_CTL_R &= UART_CTL_UARTEN; // I put this in. Reenable UART? // UART1_LCRH_R = (UART_LCRH_WLEN_8|UART_LCRH_FEN); // UART1_CTL_R |= UART_CTL_UARTEN; // enable UART // i=i; // UART1_LCRH_R |= 0x0070; // UART1_CTL_R |= 0x0301; // enables RXE, TXE, and UART // GPIO_PORTD_AFSEL_R |= 0x03; // enable alt funct on PD1-0 // GPIO_PORTD_DEN_R |= 0x03; // enable digital I/O on PD1-0 int i; SYSCTL_RCGC1_R |= 0x2; //activate UART1 i=0; i=1; SYSCTL_RCGC2_R |= 0x08; //activate PortD i=0; i=1; UART1_CTL_R &= ~0x01; //disable UART UART1_IBRD_R = 31; //15.625 31 UART1_FBRD_R = 6; //0.625*64 = 40 16 UART1_LCRH_R = 0x0070; UART1_CTL_R = 0x0301; // enables RXE, TXE, and UART UART1_IM_R |= 0x10; // something from slides I'm not sure the effect of NVIC_EN0_R |= 0x40; // enable "interrupt 6" UART1_IFLS_R = (UART1_IFLS_R & ~0x38)|0x12; // enables interrupts for 1/2 full, etc? GPIO_PORTD_AFSEL_R |= 0x0C; //enable alt function on PD2,3 GPIO_PORTD_DEN_R |= 0x0C; //enable digital I/O on PD2,3 FIFO_Init(); errorcount =0; }
int main(){ FIFO_Init(&fifo); configureDBGU((unsigned int) DGBU_INT_handler); DBGU_sendString((char*)"Welcome to DBGU have fun and good luck!\r\n"); sendStringUsingFIFO((char*)"Hello world\r\n"); sendStringUsingFIFO((char*)"Hello world once again\r\n"); sendStringUsingFIFO((char*)"Goodbye world\r\n"); sendStringUsingFIFO((char*)"Hello world\r\n"); sendStringUsingFIFO((char*)"Hello world once again\r\n"); sendStringUsingFIFO((char*)"Goodbye world\r\n"); sendStringUsingFIFO((char*)"Hello world\r\n"); sendStringUsingFIFO((char*)"Hello world once again\r\n"); sendStringUsingFIFO((char*)"Goodbye world\r\n"); while(1){ } }
/*! * This function takes care of everyting required to display and operate * a dialog box, represented as a prepared form object. If registers its own * joystick event handler and handles the dialog box until the DIALOG_OnClickInModal * callback is called by an element. E.g. a static text widget having this function * registered as its OnClick callback. * * This function restores the joystick event handler when it exits, but leaves the * form graphics untouched in the LCD. * * \param form The form to show and operate as a modal dialog box. * * \return The custom ID provided by the element that called the OnClickInModal callback. */ WIDGETS_id_t DIALOG_RunModal( FORMS_form_t * form ) { // Save old state without being disturbed by interrupts. uint8_t savedSREG = SREG; CAL_disable_interrupt(); JOYSTICK_EventHandler_t oldJoystickHandler = JOYSTICK_GetEventHandler(); // Set new state and draw form. DIALOG_currentModalForm = form; FORMS_Draw( form ); FIFO_Init( &DIALOG_eventFifo, DIALOG_eventFifoBuf, DIALOG_EVENTFIFOSIZE * sizeof(DIALOG_event_t) ); JOYSTICK_SetEventHandler( DIALOG_JoystickHandler ); // Enable interrupts and wait for modal form to exit. CAL_enable_interrupt(); DIALOG_modalClicked = false; do { while (FIFO_HasData( &DIALOG_eventFifo, JOYSTICK_event_t ) == false) { POWER_EnterIdleSleepMode(); } JOYSTICK_event_t event; FIFO_GetData( &DIALOG_eventFifo, &event ); FORMS_OnJoystick( DIALOG_currentModalForm, &event ); } while (DIALOG_modalClicked == false); // Wait for all joystick buttons to be released. do {} while (JOYSTICK_GetState() != 0x00); // Normalize LCD hardware scrolling before releasing control to other parts. FORMS_NormalizeLCDScroll( form ); // Restore old state without being disturbed by interrupts. CAL_disable_interrupt(); JOYSTICK_SetEventHandler( oldJoystickHandler ); SREG = savedSREG; // Then we can return the userId from one of the form elements. return DIALOG_modalId; }
int main(void){ TExaS_Init(); ADC_Init(); // turn on ADC, set channel to 1 ST7735_InitR(INITR_REDTAB); PortF_Init(); SysTick_Init(); // This makes things work UART1_Init(); FIFO_Init(); unsigned char data; while(1){ while(data != 0x02){ FIFO_Get(&data); // Look for new data byte } ST7735_SetCursor(0,0); for(int i = 0; i<5; i++){ // Print next 5 elements FIFO_Get(&data); ST7735_OutChar(data); } ST7735_OutString(" cm"); // Print units } }
/**************************************************************************** * DESCRIPTION: Initializes the RS485 hardware and variables, and starts in * receive mode. * RETURN: none * ALGORITHM: none * NOTES: none *****************************************************************************/ void Recievebuf_Initialize() { FIFO_Init(&Receive_Buffer0, &USART_RX_BUF[0], sizeof(USART_RX_BUF)); }
void Slideshow( void ) { LCD_SetScreen( 0x00 ); FIFO_data_t * fifoBuffer = MEM_ALLOC_ARRAY( Slideshow_event_t, SLIDESHOW_MAXEVENTS ); if (fifoBuffer == NULL) { POPUP_MsgBox( 10, 2, 6, "Not enough\r\nmemory!", NULL ); } else { TIMING_event_t timerEvent; FIFO_handle_t fifo; // Init FIFO. Slideshow_eventFifo = &fifo; FIFO_Init( &fifo, fifoBuffer, SLIDESHOW_MAXEVENTS ); // Init slideshow data and state. static uint8_t const CAL_PGM_DEF(* const pictures[SLIDESHOW_MAXPICS]) = { FLASHPICS_ECARS_DEMO_0, FLASHPICS_ECARS_DEMO_1, FLASHPICS_ECARS_DEMO_2, FLASHPICS_ECARS_DEMO_3, FLASHPICS_ECARS_DEMO_4, FLASHPICS_ECARS_DEMO_5, FLASHPICS_ECARS_DEMO_6, FLASHPICS_ECARS_DEMO_7, FLASHPICS_ECARS_DEMO_8, FLASHPICS_ECARS_DEMO_9 }; int8_t picIdx = 0; int8_t direction = 1; // Install joystick handler. CAL_disable_interrupt(); JOYSTICK_EventHandler_t oldHandler = JOYSTICK_GetEventHandler(); JOYSTICK_SetEventHandler( Slideshow_JoystickCallback ); CAL_enable_interrupt(); // Run main slideshow loop. bool exit = false; do { // Show current picture. PICTURE_CopyFullscreenFlashToLcd( CAL_pgm_read_puint8(&pictures[picIdx]) ); // Register timer event. TIMING_RemoveEvent( &timerEvent ); TIMING_AddCallbackEventAfter( RTC_TICKS_PER_SECOND * SLIDESHOW_DELAYSECONDS, Slideshow_TimerCallback, &timerEvent ); // Wait for event from timer or joystick. Slideshow_event_t event; while (FIFO_HasData( &fifo, Slideshow_event_t ) == false) { POWER_EnterIdleSleepMode(); } FIFO_GetData( &fifo, &event ); // Process event. switch (event) { case SLIDESHOW_EXIT : exit = true; break; case SLIDESHOW_TIMER : Slideshow_UpdateIndex( &picIdx, direction ); break; case SLIDESHOW_NEXT : direction = 1; Slideshow_UpdateIndex( &picIdx, direction ); break; case SLIDESHOW_PREV : direction = -1; Slideshow_UpdateIndex( &picIdx, direction ); break; default : break; } } while (exit == false); // Clean up. CAL_disable_interrupt(); TIMING_RemoveEvent( &timerEvent ); JOYSTICK_SetEventHandler( oldHandler ); CAL_enable_interrupt(); MEM_FREE( fifoBuffer ); } }
/*---------------------------------------------------------------------------- ** Define public functions */ void SOCKETFIFO_Init (FIFO_t *fifo, void *elements, uint32_t maxcount) { // Initialize global data socketfifo = fifo; socketfifo->pvElements = elements; FIFO_Init (socketfifo, maxcount, socketfifo_Push, socketfifo_Pop); }