自学教程：C++ xSemaphoreCreateBinary函数代码示例

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 );}