static void sensorsInterruptInit(void) { GPIO_InitTypeDef GPIO_InitStructure; EXTI_InitTypeDef EXTI_InitStructure; sensorsDataReady = xSemaphoreCreateBinary(); dataReady = xSemaphoreCreateBinary(); // FSYNC "shall not be floating, must be set high or low by the MCU" GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz; GPIO_Init(GPIOC, &GPIO_InitStructure); GPIO_ResetBits(GPIOC, GPIO_Pin_14); // Enable the MPU6500 interrupt on PC13 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN; GPIO_Init(GPIOC, &GPIO_InitStructure); SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource13); EXTI_InitStructure.EXTI_Line = EXTI_Line13; EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising; EXTI_InitStructure.EXTI_LineCmd = ENABLE; portDISABLE_INTERRUPTS(); EXTI_Init(&EXTI_InitStructure); EXTI_ClearITPendingBit(EXTI_Line13); portENABLE_INTERRUPTS(); }
int main(void) { gpio_setup(); interrupts_setup(); motor_pwm_setup(); empty_sem = xSemaphoreCreateBinary(); configASSERT( empty_sem ); full_sem = xSemaphoreCreateBinary(); configASSERT( full_sem ); xTaskCreate(led_blink, "led_bliker", configMINIMAL_STACK_SIZE, NULL, 1, &blink_handler); configASSERT( blink_handler ); vTaskSuspend(blink_handler); xTaskCreate(start_filling, "start_filling", configMINIMAL_STACK_SIZE, NULL, 2, &start_filling_hanlder); configASSERT( start_filling_hanlder ); xTaskCreate(stop_filling, "stop_filling", configMINIMAL_STACK_SIZE, NULL, 3, &stop_filling_handler); configASSERT( stop_filling_handler ); recue_tim_handler = xTimerCreate("recue_timer", (1000/portTICK_PERIOD_MS), pdFALSE, (void *) 0, recue_tim_func ); configASSERT(recue_tim_handler); vTaskStartScheduler(); return 1; }
static void sensorsInterruptInit(void) { GPIO_InitTypeDef GPIO_InitStructure; EXTI_InitTypeDef EXTI_InitStructure; sensorsDataReady = xSemaphoreCreateBinary(); dataReady = xSemaphoreCreateBinary(); // Enable the interrupt on PC14 GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; //GPIO_PuPd_DOWN; GPIO_Init(GPIOC, &GPIO_InitStructure); SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource14); EXTI_InitStructure.EXTI_Line = EXTI_Line14; EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising; EXTI_InitStructure.EXTI_LineCmd = ENABLE; portDISABLE_INTERRUPTS(); EXTI_Init(&EXTI_InitStructure); EXTI_ClearITPendingBit(EXTI_Line14); portENABLE_INTERRUPTS(); }
bool example_alarm::init(void) { mAlarmSec = xSemaphoreCreateBinary(); mAlarmMin = xSemaphoreCreateBinary(); return (mAlarmSec != NULL && mAlarmMin != NULL); }
void vStartSemaphoreTasks( UBaseType_t uxPriority ) { xSemaphoreParameters *pxFirstSemaphoreParameters, *pxSecondSemaphoreParameters; const TickType_t xBlockTime = ( TickType_t ) 100; /* Create the structure used to pass parameters to the first two tasks. */ pxFirstSemaphoreParameters = ( xSemaphoreParameters * ) pvPortMalloc( sizeof( xSemaphoreParameters ) ); if( pxFirstSemaphoreParameters != NULL ) { /* Create the semaphore used by the first two tasks. */ pxFirstSemaphoreParameters->xSemaphore = xSemaphoreCreateBinary(); xSemaphoreGive( pxFirstSemaphoreParameters->xSemaphore ); if( pxFirstSemaphoreParameters->xSemaphore != NULL ) { /* Create the variable which is to be shared by the first two tasks. */ pxFirstSemaphoreParameters->pulSharedVariable = ( uint32_t * ) pvPortMalloc( sizeof( uint32_t ) ); /* Initialise the share variable to the value the tasks expect. */ *( pxFirstSemaphoreParameters->pulSharedVariable ) = semtstNON_BLOCKING_EXPECTED_VALUE; /* The first two tasks do not block on semaphore calls. */ pxFirstSemaphoreParameters->xBlockTime = ( TickType_t ) 0; /* Spawn the first two tasks. As they poll they operate at the idle priority. */ xTaskCreate( prvSemaphoreTest, "PolSEM1", semtstSTACK_SIZE, ( void * ) pxFirstSemaphoreParameters, tskIDLE_PRIORITY, ( TaskHandle_t * ) NULL ); xTaskCreate( prvSemaphoreTest, "PolSEM2", semtstSTACK_SIZE, ( void * ) pxFirstSemaphoreParameters, tskIDLE_PRIORITY, ( TaskHandle_t * ) NULL ); } } /* Do exactly the same to create the second set of tasks, only this time provide a block time for the semaphore calls. */ pxSecondSemaphoreParameters = ( xSemaphoreParameters * ) pvPortMalloc( sizeof( xSemaphoreParameters ) ); if( pxSecondSemaphoreParameters != NULL ) { pxSecondSemaphoreParameters->xSemaphore = xSemaphoreCreateBinary(); xSemaphoreGive( pxSecondSemaphoreParameters->xSemaphore ); if( pxSecondSemaphoreParameters->xSemaphore != NULL ) { pxSecondSemaphoreParameters->pulSharedVariable = ( uint32_t * ) pvPortMalloc( sizeof( uint32_t ) ); *( pxSecondSemaphoreParameters->pulSharedVariable ) = semtstBLOCKING_EXPECTED_VALUE; pxSecondSemaphoreParameters->xBlockTime = xBlockTime / portTICK_PERIOD_MS; xTaskCreate( prvSemaphoreTest, "BlkSEM1", semtstSTACK_SIZE, ( void * ) pxSecondSemaphoreParameters, uxPriority, ( TaskHandle_t * ) NULL ); xTaskCreate( prvSemaphoreTest, "BlkSEM2", semtstSTACK_SIZE, ( void * ) pxSecondSemaphoreParameters, uxPriority, ( TaskHandle_t * ) NULL ); } } /* vQueueAddToRegistry() adds the semaphore to the registry, if one is in use. The registry is provided as a means for kernel aware debuggers to locate semaphores and has no purpose if a kernel aware debugger is not being used. The call to vQueueAddToRegistry() will be removed by the pre-processor if configQUEUE_REGISTRY_SIZE is not defined or is defined to be less than 1. */ vQueueAddToRegistry( ( QueueHandle_t ) pxFirstSemaphoreParameters->xSemaphore, "Counting_Sem_1" ); vQueueAddToRegistry( ( QueueHandle_t ) pxSecondSemaphoreParameters->xSemaphore, "Counting_Sem_2" ); }
/* * Variables globales * */ void vInicializar_globales(){ xSem_OK = xSemaphoreCreateBinary(); xSem_Fin_mov = xSemaphoreCreateBinary(); xCola_mov = FRTOS1_xQueueCreate(MAX_MOVIMIENTOS, sizeof(uint8)); xCola_US = FRTOS1_xQueueCreate(1, sizeof(portCHAR)); sensar = FALSE; distancia_objeto = 999; }
/** * Queueset example shows how to use FreeRTOS to block on MULTIPLE semaphores or queues. * The idea is that we want to call our run() when EITHER of mSec, or mMin semaphore is ready. * This example also shows how to log information to "log" file on flash memory. */ example_logger_qset::example_logger_qset() : scheduler_task("ex_log_qset", 4 * 512, PRIORITY_LOW), mSec(NULL), mMin(NULL) { mSec = xSemaphoreCreateBinary(); mMin = xSemaphoreCreateBinary(); }
void initComms(void) { /* Setup the queues to use */ commsSendQueue = xQueueCreate(COMMS_QUEUE_SIZE,1); commsReceiveQueue = xQueueCreate(COMMS_QUEUE_SIZE,1); commsSendSemaphore = xSemaphoreCreateBinary(); xSemaphoreGive(commsSendSemaphore); commsEmptySemaphore = xSemaphoreCreateBinary(); xSemaphoreGive(commsEmptySemaphore); }
void esp_ipc_init() { s_ipc_mutex = xSemaphoreCreateMutex(); s_ipc_ack = xSemaphoreCreateBinary(); const char* task_names[2] = {"ipc0", "ipc1"}; for (int i = 0; i < portNUM_PROCESSORS; ++i) { s_ipc_sem[i] = xSemaphoreCreateBinary(); portBASE_TYPE res = xTaskCreatePinnedToCore(ipc_task, task_names[i], CONFIG_IPC_TASK_STACK_SIZE, (void*) i, configMAX_PRIORITIES - 1, &s_ipc_tasks[i], i); assert(res == pdTRUE); } }
void APP_Init(void) { //DbgConsole_Printf("hello world.\r\n"); #if PL_CONFIG_HAS_SHELL_QUEUE SQUEUE_Init(); #endif semSW2 = xSemaphoreCreateBinary(); if (semSW2==NULL) { /* semaphore creation failed */ for(;;){} /* error */ } vQueueAddToRegistry(semSW2, "Sem_SW2"); semSW3 = xSemaphoreCreateBinary(); if (semSW3==NULL) { /* semaphore creation failed */ for(;;){} /* error */ } vQueueAddToRegistry(semSW3, "Sem_SW3"); semLED = xSemaphoreCreateBinary(); if (semLED==NULL) { /* semaphore creation failed */ for(;;){} /* error */ } vQueueAddToRegistry(semLED, "Sem_LED"); semMouse = xSemaphoreCreateBinary(); if (semMouse==NULL) { /* semaphore creation failed */ for(;;){} /* error */ } vQueueAddToRegistry(semMouse, "Sem_Mouse"); semKbd = xSemaphoreCreateBinary(); if (semKbd==NULL) { /* semaphore creation failed */ for(;;){} /* error */ } vQueueAddToRegistry(semKbd, "Sem_Kbd"); #if 0 /*! \todo 1 Increase stack size by 50 */ if (xTaskCreate(ButtonTask, "Buttons", configMINIMAL_STACK_SIZE+50, NULL, tskIDLE_PRIORITY+2, NULL) != pdPASS) { /*! \todo 1 Increase stack size by 50 */ #else if (xTaskCreate(ButtonTask, "Buttons", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+2, NULL) != pdPASS) { #endif for(;;){} /* error */ } if (xTaskCreate(AppTask, "App", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+1, NULL) != pdPASS) { for(;;){} /* error */ } #if configUSE_TRACE_HOOKS vTraceSetISRProperties("ISR_USB", TRACE_PRIO_ISR_USB); #endif }
void vStartSystemLEDTask( UBaseType_t uxPriority){ if(xStatusSemaphore==NULL) { xStatusSemaphore = xSemaphoreCreateBinary(); } xTaskCreate(vSystemLEDTask, "Status LED", systemledSTACK_SIZE, NULL, uxPriority, (TaskHandle_t *) NULL ); }
void vStartButtonTask( UBaseType_t uxPriority){ if(xButtonSemaphore==NULL) { xButtonSemaphore = xSemaphoreCreateBinary(); } xTaskCreate(vButtonTask, "Button", buttonSTACK_SIZE, NULL, uxPriority, (TaskHandle_t *) NULL ); }
I2C_Base::I2C_Base(LPC_I2C_TypeDef* pI2CBaseAddr) : mpI2CRegs(pI2CBaseAddr), mDisableOperation(false) { mI2CMutex = xSemaphoreCreateMutex(); mTransferCompleteSignal = xSemaphoreCreateBinary(); /// Binary semaphore needs to be taken after creating it xSemaphoreTake(mTransferCompleteSignal, 0); if((unsigned int)mpI2CRegs == LPC_I2C0_BASE) { mIRQ = I2C0_IRQn; } else if((unsigned int)mpI2CRegs == LPC_I2C1_BASE) { mIRQ = I2C1_IRQn; } else if((unsigned int)mpI2CRegs == LPC_I2C2_BASE) { mIRQ = I2C2_IRQn; } else { mIRQ = (IRQn_Type)99; // Using invalid IRQ on purpose } }
static void leuartInit(void) { LEUART_Init_TypeDef leuart0Init; leuart0Init.enable = leuartEnable; /* Activate data reception on LEUn_TX pin. */ leuart0Init.refFreq = 0; /* Inherit the clock frequenzy from the LEUART clock source */ leuart0Init.baudrate = LEUART0_BAUDRATE; /* Baudrate = 9600 bps */ leuart0Init.databits = leuartDatabits8; /* Each LEUART frame containes 8 databits */ leuart0Init.parity = leuartNoParity; /* No parity bits in use */ leuart0Init.stopbits = leuartStopbits2; /* Setting the number of stop bits in a frame to 2 bitperiods */ CMU_ClockEnable(cmuClock_CORELE, true); CMU_ClockEnable(cmuClock_LEUART0, true); LEUART_Reset(LEUART0); LEUART_Init(LEUART0, &leuart0Init); LEUART0->SIGFRAME = '\n'; /* Enable LEUART Signal Frame Interrupt */ LEUART_IntEnable(LEUART0, LEUART_IEN_SIGF); /* Enable LEUART0 interrupt vector */ NVIC_SetPriority(LEUART0_IRQn, LEUART0_INT_PRIORITY); LEUART0->ROUTE = LEUART_ROUTE_RXPEN | LEUART_ROUTE_TXPEN | LEUART0_LOCATION; GPIO_PinModeSet(LEUART0_PORT, LEUART0_TX, gpioModePushPull, 1); GPIO_PinModeSet(LEUART0_PORT, LEUART0_RX, gpioModeInputPull, 1); lineEndReceived = xSemaphoreCreateBinary(); DMADRV_AllocateChannel(&dmaChannel, NULL); }
esp_err_t esp_bt_controller_init(esp_bt_controller_config_t *cfg) { BaseType_t ret; if (btdm_controller_status != ESP_BT_CONTROLLER_STATUS_IDLE) { return ESP_ERR_INVALID_STATE; } if (cfg == NULL) { return ESP_ERR_INVALID_ARG; } btdm_init_sem = xSemaphoreCreateBinary(); if (btdm_init_sem == NULL) { return ESP_ERR_NO_MEM; } memcpy(&btdm_cfg_opts, cfg, sizeof(esp_bt_controller_config_t)); ret = xTaskCreatePinnedToCore(bt_controller_task, "btController", ESP_TASK_BT_CONTROLLER_STACK, NULL, ESP_TASK_BT_CONTROLLER_PRIO, &btControllerTaskHandle, CONFIG_BTDM_CONTROLLER_RUN_CPU); if (ret != pdPASS) { memset(&btdm_cfg_opts, 0x0, sizeof(esp_bt_controller_config_t)); vSemaphoreDelete(btdm_init_sem); return ESP_ERR_NO_MEM; } xSemaphoreTake(btdm_init_sem, BTDM_INIT_PERIOD/portTICK_PERIOD_MS); vSemaphoreDelete(btdm_init_sem); return ESP_OK; }
void ws2812_setColors(uint16_t length, rgbVal *array) { uint16_t i; ws2812_len = (length * 3) * sizeof(uint8_t); ws2812_buffer = malloc(ws2812_len); for (i = 0; i < length; i++) { ws2812_buffer[0 + i * 3] = array[i].g; ws2812_buffer[1 + i * 3] = array[i].r; ws2812_buffer[2 + i * 3] = array[i].b; } ws2812_pos = 0; ws2812_half = 0; ws2812_copy(); if (ws2812_pos < ws2812_len) ws2812_copy(); ws2812_sem = xSemaphoreCreateBinary(); RMT.conf_ch[RMTCHANNEL].conf1.mem_rd_rst = 1; RMT.conf_ch[RMTCHANNEL].conf1.tx_start = 1; xSemaphoreTake(ws2812_sem, portMAX_DELAY); vSemaphoreDelete(ws2812_sem); ws2812_sem = NULL; free(ws2812_buffer); return; }
void mac_init(void) { #ifdef NODE_TYPE_DETECTOR lora_init(UART_4, 9600); #endif #ifdef NODE_TYPE_GATEWAY lora_init(UART_1, 9600); #endif portBASE_TYPE res = pdTRUE; res = xTaskCreate(mac_task, //*< task body "MacTask", //*< task name 200, //*< task heap NULL, //*< tasK handle param configMAX_PRIORITIES - 2, //*< task prio NULL); //*< task pointer if (res != pdTRUE) { DBG_LOG(DBG_LEVEL_ERROR, "mac task init failed\r\n"); } mac_queue = xQueueCreate(10, sizeof(osel_event_t)); if (mac_queue == NULL) { DBG_LOG(DBG_LEVEL_ERROR, "mac_queue init failed\r\n"); } mac_sent = xSemaphoreCreateBinary(); if (mac_sent == NULL) { DBG_LOG(DBG_LEVEL_ERROR, "mac_set init failed\r\n"); } }
int main() { //unsigned int delay_1 = 5000, delay_2 = 4000; bsp_init(); xSemaphore = xSemaphoreCreateBinary(); /* Create the tasks defined within this file. */ //xTaskCreate(CDecoder, "CDecoder", configMINIMAL_STACK_SIZE, NULL, 4, NULL ); //xTaskCreate(loop_test_01, "loop_test_01", configMINIMAL_STACK_SIZE, (void*)&delay_1, 6, NULL ); //xTaskCreate(loop_test_02, "loop_test_02", configMINIMAL_STACK_SIZE, (void*)&delay_2, 3, NULL ); xTaskCreate(led_update, "led_update", configMINIMAL_STACK_SIZE, NULL, 3, &xHandle[led_task] ); xTaskCreate(key_scan, "key_scan", configMINIMAL_STACK_SIZE, NULL, 5, &xHandle[key_task] ); xTaskCreate(audio_play, "audio_play", configMINIMAL_STACK_SIZE, NULL, 4, &xHandle[audio_task] ); /* In this port, to use preemptive scheduler define configUSE_PREEMPTION as 1 in portmacro.h. To use the cooperative scheduler define configUSE_PREEMPTION as 0. */ vTaskStartScheduler(); // RunSchedular fail!! while(1) { reset_watchdog(); } return 0; }
/**@brief Function for application main entry. */ int main(void) { // Do not start any interrupt that uses system functions before system initialisation. // The best solution is to start the OS before any other initalisation. // Init a semaphore for the BLE thread. m_ble_event_ready = xSemaphoreCreateBinary(); if(NULL == m_ble_event_ready) { APP_ERROR_HANDLER(NRF_ERROR_NO_MEM); } // Start execution. if(pdPASS != xTaskCreate(ble_stack_thread, "BLE", 256, NULL, 1, &m_ble_stack_thread)) { APP_ERROR_HANDLER(NRF_ERROR_NO_MEM); } /* Activate deep sleep mode */ SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk; // Start FreeRTOS scheduler. vTaskStartScheduler(); while (true) { APP_ERROR_HANDLER(NRF_ERROR_FORBIDDEN); } }
/**************************************************************************** Call this function to set up the TWI master to its initial standby state. Remember to enable interrupts from the main application after initialising the TWI. ****************************************************************************/ void I2C_Master_Initialise( uint8_t I2C_ownAddress ) { // The Semaphore has to be created to allow the I2C bus to be shared. // Assuming the I2C bus will be shared. // Use this semaphore (take, give) when calling I2C functions, and it can ensure single access. if( xI2CSemaphore == NULL ) // Check to see if the semaphore has not been created. { xI2CSemaphore = xSemaphoreCreateBinary(); // binary semaphore for I2C bus if( ( xI2CSemaphore ) != NULL ) xSemaphoreGive( ( xI2CSemaphore ) ); // make the I2C bus available } I2C_PORT_DIR &= ~(I2C_BIT_SCL | I2C_BIT_SDA); // set the I2C SDA & SCL inputs. // Pull up resistors I2C_PORT |= (I2C_BIT_SCL | I2C_BIT_SDA); // only need these set at one place, usually Master. // Initialise TWI clock TWSR = 0; // no prescaler TWBR = ((F_CPU/SCL_CLOCK)-16)/2; // must be > 10 for stable operation TWAR = I2C_ownAddress; // Set own TWI slave address, in case it is called. // Accept TWI General Calls if ODD address. TWDR = 0xff; // Default content = SDA released. TWCR = (1<<TWEN)| // Enable TWI-interface and release TWI pins. (0<<TWIE)|(0<<TWINT)| // Disable Interrupt. (0<<TWEA)|(0<<TWSTA)|(0<<TWSTO)| // No Signal requests. (0<<TWWC); }
static void rsa_isr_initialise() { if (op_complete_sem == NULL) { op_complete_sem = xSemaphoreCreateBinary(); esp_intr_alloc(ETS_RSA_INTR_SOURCE, 0, rsa_complete_isr, NULL, NULL); } }
void TASK_SPI( void *pvParameters ) { UNUSED( pvParameters ); spi_configureLED(); /* Create a semaphore */ rxSemaphoreLED = xSemaphoreCreateBinary(); /* Ensure that semaphore is valid */ Assert( rxSemaphoreLED ); /* Start DMA reception */ dma_start_transfer_job( &zDMA_LEDResourceRx ); for(;;) { /* Block task until DMA read complete */ xSemaphoreTake( rxSemaphoreLED, portMAX_DELAY ); /* Do something */ /* Respond..? */ dma_start_transfer_job( &zDMA_LEDResourceTx ); /* Yield to oncoming traffic */ taskYIELD(); } }
void vStartUART_NAVITask(unsigned portBASE_TYPE uxPriority) { /* Creating semaphore related to this task */ xSemaphoreUART_NAVIRX = NULL; xSemaphoreUART_NAVIRX = xSemaphoreCreateBinary(); xSemaphoreUART_NAVITX = NULL; xSemaphoreUART_NAVITX = xSemaphoreCreateMutex(); /* Creating queue which is responsible for handling IMU_t typedef data */ xQueueUART_1xIMU_t = xQueueCreate(1, sizeof(IMU_t) ); /* Creating queue which is responsible for handling SENSOR_t typedef data */ xQueueUART_1xSENSOR_t = xQueueCreate(1, sizeof(SENSOR_t) ); /* Creating task [sending IMU data frames] 25 Hz task */ xTaskHandle xHandleTaskUART_NAVIimu; xTaskCreate( vTaskUART_NAVIimu, "UART_NAVI_TXimu", configMINIMAL_STACK_SIZE, NULL, uxPriority, &xHandleTaskUART_NAVIimu ); /* Creating task [sending SENSOR data frames] 10 Hz task*/ xTaskHandle xHandleTaskUART_NAVIsns; xTaskCreate( vTaskUART_NAVIsns, "UART_NAVI_TXsns", configMINIMAL_STACK_SIZE, NULL, uxPriority, &xHandleTaskUART_NAVIsns ); }
void lwip_network_init(uint8_t opmode) { lwip_tcpip_config_t tcpip_config = {{0}, {0}, {0}, {0}, {0}, {0}}; ip4addr_aton(STA_IPADDR, &(tcpip_config.sta_addr)); ip4addr_aton(STA_NETMASK, &tcpip_config.sta_mask); ip4addr_aton(STA_GATEWAY, &tcpip_config.sta_gateway); ip4addr_aton(AP_IPADDR, &(tcpip_config.ap_addr)); ip4addr_aton(AP_NETMASK, &tcpip_config.ap_mask); ip4addr_aton(AP_GATEWAY, &tcpip_config.ap_gateway); wifi_connected = xSemaphoreCreateBinary(); #if USE_DHCP ip_ready = xSemaphoreCreateBinary(); #endif lwip_tcpip_init(&tcpip_config, opmode); }
int main(void) { // turn on the serial port for setting or querying the time . xSerialPort = xSerialPortInitMinimal( USART0, 115200, portSERIAL_BUFFER_TX, portSERIAL_BUFFER_RX); // serial port: WantedBaud, TxQueueLength, RxQueueLength (8n1) // Memory shortages mean that we have to minimise the number of // threads, hence there are no longer multiple threads using a resource. // Still, semaphores are useful to stop a thread proceeding, where it should be stopped because it is using a resource. if( xADCSemaphore == NULL ) // Check to see if the ADC semaphore has not been created. { xADCSemaphore = xSemaphoreCreateBinary(); // binary semaphore for ADC - Don't sample temperature when hands are moving (voltage droop). if( ( xADCSemaphore ) != NULL ) xSemaphoreGive( ( xADCSemaphore ) ); // make the ADC available } // initialise I2C master interface, need to do this once only. // If there are two I2C processes, then do it during the system initiation. I2C_Master_Initialise((ARDUINO<<I2C_ADR_BITS) | (pdTRUE<<I2C_GEN_BIT)); avrSerialxPrint_P(&xSerialPort, PSTR("\r\nHello World!\r\n")); // Ok, so we're alive... xTaskCreate( TaskWriteLCD , (const portCHAR *)"WriteLCD" , 192 , NULL , 2 , NULL ); // */ xTaskCreate( TaskWriteRTCRetrograde , (const portCHAR *)"WriteRTCRetrograde" , 120 , NULL , 1 , &xTaskWriteRTCRetrograde ); // */ xTaskCreate( TaskMonitor , (const portCHAR *)"SerialMonitor" , 256 , NULL , 3 , NULL ); // */ avrSerialPrintf_P(PSTR("\r\nFree Heap Size: %u\r\n"), xPortGetFreeHeapSize() ); // needs heap_1, heap_2 or heap_4 for this function to succeed. vTaskStartScheduler(); avrSerialPrint_P(PSTR("\r\n\nGoodbye... no space for idle task!\r\n")); // Doh, so we're dead... #if defined (portHD44780_LCD) lcd_Locate (0, 1); lcd_Print_P(PSTR("DEAD BEEF!")); #endif }
void ProgramManager::startManager(){ if(xManagerHandle == NULL) xTaskCreate(runManagerTask, "Manager", MANAGER_TASK_STACK_SIZE, NULL, MANAGER_TASK_PRIORITY, &xManagerHandle); #if defined AUDIO_TASK_SEMAPHORE if(xSemaphore == NULL) xSemaphore = xSemaphoreCreateBinary(); #endif // AUDIO_TASK_SEMAPHORE }
void watchdog_init( void ) { wdt_init(); wdt_config(); wdt_set_timeout(((WATCHDOG_TIMEOUT/1000)*WATCHDOG_CLK_FREQ)); watchdog_smphr = xSemaphoreCreateBinary(); xTaskCreate( WatchdogTask, (const char *) "Watchdog Task", 60, (void * ) NULL, tskWATCHDOG_PRIORITY, ( TaskHandle_t * ) NULL); }
periodicSchedulerTask::periodicSchedulerTask(void) : scheduler_task("dispatcher", 512 * 3, PRIORITY_CRITICAL + PRIORITY_CRITICAL + 5) { setRunDuration(1); setStatUpdateRate(0); // Create the semaphores first before creating the actual periodic tasks sems[prd_1Hz] = xSemaphoreCreateBinary(); sems[prd_10Hz] = xSemaphoreCreateBinary(); sems[prd_100Hz] = xSemaphoreCreateBinary(); sems[prd_1000Hz] = xSemaphoreCreateBinary(); // Create the FreeRTOS tasks, these will only run once we start giving their semaphores xTaskCreate(period_task_1Hz, "1Hz", PERIOD_TASKS_STACK_SIZE_BYTES/4, NULL, PRIORITY_CRITICAL + 1, NULL); xTaskCreate(period_task_10Hz, "10Hz", PERIOD_TASKS_STACK_SIZE_BYTES/4, NULL, PRIORITY_CRITICAL + 2, NULL); xTaskCreate(period_task_100Hz, "100Hz", PERIOD_TASKS_STACK_SIZE_BYTES/4, NULL, PRIORITY_CRITICAL + 3, NULL); xTaskCreate(period_task_1000Hz, "1000Hz", PERIOD_TASKS_STACK_SIZE_BYTES/4, NULL, PRIORITY_CRITICAL + 4, NULL); }
void ivory_freertos_binary_semaphore_create(struct binary_semaphore* bs_handle) { bs_handle->v = xSemaphoreCreateBinary(); if ( bs_handle->v == NULL ) { /* Die: semaphore not created successfully */ ASSERTS(0); } }
static void prvTestAbortingSemaphoreTake( void ) { TickType_t xTimeAtStart; BaseType_t xReturn; SemaphoreHandle_t xSemaphore; #if( configSUPPORT_STATIC_ALLOCATION == 1 ) { static StaticSemaphore_t xSemaphoreBuffer; /* Create the semaphore. Statically allocated memory is used so the creation cannot fail. */ xSemaphore = xSemaphoreCreateBinaryStatic( &xSemaphoreBuffer ); } #else { xSemaphore = xSemaphoreCreateBinary(); } #endif /* Note the time before the delay so the length of the delay is known. */ xTimeAtStart = xTaskGetTickCount(); /* This first delay should just time out. */ xReturn = xSemaphoreTake( xSemaphore, xMaxBlockTime ); if( xReturn != pdFALSE ) { xErrorOccurred = pdTRUE; } prvCheckExpectedTimeIsWithinAnAcceptableMargin( xTimeAtStart, xMaxBlockTime ); /* Note the time before the delay so the length of the delay is known. */ xTimeAtStart = xTaskGetTickCount(); /* This second delay should be aborted by the primary task half way through. */ xReturn = xSemaphoreTake( xSemaphore, xMaxBlockTime ); if( xReturn != pdFALSE ) { xErrorOccurred = pdTRUE; } prvCheckExpectedTimeIsWithinAnAcceptableMargin( xTimeAtStart, xHalfMaxBlockTime ); /* Note the time before the delay so the length of the delay is known. */ xTimeAtStart = xTaskGetTickCount(); /* This third delay should just time out again. */ xReturn = xSemaphoreTake( xSemaphore, xMaxBlockTime ); if( xReturn != pdFALSE ) { xErrorOccurred = pdTRUE; } prvCheckExpectedTimeIsWithinAnAcceptableMargin( xTimeAtStart, xMaxBlockTime ); /* Not really necessary in this case, but for completeness. */ vSemaphoreDelete( xSemaphore ); }