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

static rt_size_t rt_led_write(rt_device_t dev, rt_off_t pos,                              const void *buffer, rt_size_t size){    rt_ubase_t index = 0;    rt_ubase_t nw = size;    const rt_uint8_t *value = buffer;    RT_ASSERT(dev == &led.parent);    RT_ASSERT((pos + size) <= LED_NUM);    for (index = 0; index < nw; index++)    {			if (*value > 0)			{				 //LPC_GPIO->CLR[led.ctrl[pos + index].port] |= (1 << led.ctrl[pos + index].num);				 //LPC_GPIO->CLR[0] |= (1 << led.ctrl[pos + index].num);				Chip_GPIO_SetPinState(LPC_GPIO, led.ctrl[pos + index].port, led.ctrl[pos + index].num, 0UL);			}			else			{				//LPC_GPIO->SET[led.ctrl[pos + index].port] |= (1 << led.ctrl[pos + index].num);				//LPC_GPIO->SET[0] |= (1 << led.ctrl[pos + index].num);				Chip_GPIO_SetPinState(LPC_GPIO, led.ctrl[pos + index].port, led.ctrl[pos + index].num, 1UL);			}		}    		return index;}

/** /brief Main function * * This is the main entry point of the software. * * /returns 0 * * /remarks This function never returns. Return value is only to avoid compiler *          warnings or errors. */int main(void){   /* perform the needed initialization here */      boardInit();   while(1) {            /* add your code here */            /* Read TEC1 */      if( !(Chip_GPIO_ReadPortBit( LPC_GPIO_PORT, TEC1_GPIO, TEC1_PIN )) ){         /* Write LED with 1 */         Chip_GPIO_SetPinState( LPC_GPIO_PORT, gpioLed1.gpioNumber, gpioLed1.gpioPin, 1);            Chip_GPIO_SetPinState( LPC_GPIO_PORT, gpioLed2.gpioNumber, gpioLed2.gpioPin, 0);          } else{         /* Write LED with 0 */         Chip_GPIO_SetPinState( LPC_GPIO_PORT, gpioLed1.gpioNumber, gpioLed1.gpioPin, 0);            Chip_GPIO_SetPinState( LPC_GPIO_PORT, gpioLed2.gpioNumber, gpioLed2.gpioPin, 1);         }   }      return 0;}

static rt_err_t rt_led_init(rt_device_t dev){	/*led2 Blue:P0.31 ,led1 Green:P0.30 ,led0 Red:P0_29  P38,P32*/	Chip_IOCON_PinMuxSet(LPC_IOCON, 0, 29, (IOCON_FUNC0 | IOCON_MODE_PULLUP | IOCON_DIGITAL_EN));	Chip_IOCON_PinMuxSet(LPC_IOCON, 1, 10, (IOCON_FUNC0 | IOCON_MODE_PULLUP | IOCON_DIGITAL_EN));	Chip_IOCON_PinMuxSet(LPC_IOCON, 1,  9, (IOCON_FUNC0 | IOCON_MODE_PULLUP | IOCON_DIGITAL_EN));	  Chip_GPIO_SetPinDIROutput(LPC_GPIO, 0, 29);  Chip_GPIO_SetPinState(LPC_GPIO, 0, 29, false);	  Chip_GPIO_SetPinDIROutput(LPC_GPIO, 1, 10);  Chip_GPIO_SetPinState(LPC_GPIO, 1, 10, true);  Chip_GPIO_SetPinDIROutput(LPC_GPIO, 1, 9);  Chip_GPIO_SetPinState(LPC_GPIO, 1, 9, true);		led.ctrl[0].num = 29;	led.ctrl[0].port = 0;		led.ctrl[1].num = 10;	led.ctrl[1].port = 1;		led.ctrl[2].num =  9;	led.ctrl[2].port = 1;	return RT_EOK;	}

void W5500_Init(){	uint8_t memsize[2][8] = { { 2, 2, 2, 2, 2, 2, 2, 2 }, { 2, 2, 2, 2, 2, 2, 2, 2 } };	Chip_GPIO_SetPinState(LPC_GPIO, 0, 2, true);	// SSEL(CS)	Chip_GPIO_SetPinState(LPC_GPIO, 0, 22, false);	// N_RESET	delay_cnt(1000);	Chip_GPIO_SetPinState(LPC_GPIO, 0, 22, true);	// N_RESET	reg_wizchip_cs_cbfunc(wizchip_select, wizchip_deselect);	reg_wizchip_spi_cbfunc(wizchip_read, wizchip_write);	reg_wizchip_spiburst_cbfunc(wizchip_readburst, wizchip_writeburst);	/* wizchip initialize*/	if (ctlwizchip(CW_INIT_WIZCHIP, (void*) memsize) == -1) {		//printf("WIZCHIP Initialized fail./r/n");		while (1);	}	/* For Delay */	delay_cnt(10000);	setRCR(3);}

uint8_t get_ipmb_addr( void ){    uint8_t ga0, ga1, ga2;    uint8_t index;    /* Set the test pin and read all GA pins */    Chip_GPIO_SetPinState(LPC_GPIO, GA_TEST_PORT, GA_TEST_PIN, 1);    /* when using NAMC-EXT-RTM at least 11 instruction cycles required     *  to have correct GA value after GA_TEST_PIN changes */    {		uint8_t i;		for (i = 0; i < GPIO_GA_DELAY; i++)			asm volatile ("nop");	}    ga0 = Chip_GPIO_GetPinState(LPC_GPIO, GA0_PORT, GA0_PIN);    ga1 = Chip_GPIO_GetPinState(LPC_GPIO, GA1_PORT, GA1_PIN);    ga2 = Chip_GPIO_GetPinState(LPC_GPIO, GA2_PORT, GA2_PIN);    /* Clear the test pin and see if any GA pin has changed is value,     * meaning that it is unconnected */    Chip_GPIO_SetPinState(LPC_GPIO, GA_TEST_PORT, GA_TEST_PIN, 0);    /* when using NAMC-EXT-RTM at least 11 instruction cycles required     *  to have correct GA value after GA_TEST_PIN changes */    {		uint8_t i;		for (i = 0; i < GPIO_GA_DELAY; i++)			asm volatile ("nop");	}    if ( ga0 != Chip_GPIO_GetPinState(LPC_GPIO, GA0_PORT, GA0_PIN) )    {        ga0 = UNCONNECTED;    }    if ( ga1 != Chip_GPIO_GetPinState(LPC_GPIO, GA1_PORT, GA1_PIN) )    {        ga1 = UNCONNECTED;    }    if ( ga2 != Chip_GPIO_GetPinState(LPC_GPIO, GA2_PORT, GA2_PIN) )    {        ga2 = UNCONNECTED;    }    /* Transform the 3-based code in a decimal number */    index = (9 * ga2) + (3 * ga1) + (1 * ga0);    if ( index >= IPMBL_TABLE_SIZE )    {        return 0;    }    return IPMBL_TABLE[index];}

static void task_pwm() {	while (1) {		Chip_GPIO_SetPinState(LPC_GPIO, 2, 0, true);		vTaskDelay(counter);		Chip_GPIO_SetPinState(LPC_GPIO, 2, 0, false);		vTaskDelay(20 - counter);	}}

static void vBootSystem(void* pvParameters) {	int result;	LOG_INFO("Wait for voltage stabilization");	vTaskDelay(1000);	{		int sdcard_retry_limit = SDCARD_START_RETRY_LIMIT;		while (sdcard_retry_limit > 0) {			LOG_INFO("Attempting to mount FAT on SDCARD");			result = f_mount(&root_fs, "0:", 1);			if (result == FR_OK) {				break;			}			Chip_GPIO_SetPinState(LPC_GPIO, 0, 20, !Chip_GPIO_GetPinState(LPC_GPIO, 0, 20));			vTaskDelay(200);			sdcard_retry_limit --;		}		if (sdcard_retry_limit == 0) {			LOG_ERROR("SDCard Mount failed");			exit_error(ERROR_CODE_SDCARD_MOUNT_FAILED);		}		Chip_GPIO_SetPinState(LPC_GPIO, 0, 20, false);	}	result = logging_init_persistent();	if (result != 0) {		exit_error(ERROR_CODE_SDCARD_LOGGING_INIT_FAILED);	}	LOG_INFO("Starting real tasks");	xTaskCreate(vFlushLogs, (signed char *) "vFlushLogs",				256, NULL, (tskIDLE_PRIORITY + 2), NULL);	xTaskCreate(vLEDTask1, (signed char *) "vTaskLed1",				256, NULL, (tskIDLE_PRIORITY + 1UL),				(xTaskHandle *) NULL);	/* LED2 toggle thread */	xTaskCreate(vLEDTask2, (signed char *) "vTaskLed2",				256, NULL, (tskIDLE_PRIORITY + 1UL),				(xTaskHandle *) NULL);	/* LED0 toggle thread */	xTaskCreate(vLEDTask0, (signed char *) "vTaskLed0",				configMINIMAL_STACK_SIZE, NULL, (tskIDLE_PRIORITY + 1UL),				(xTaskHandle *) NULL);	mutex_i2c = xSemaphoreCreateMutex();	xTaskCreate(vBaro, (signed char*) "Baro", 256, NULL, (tskIDLE_PRIORITY + 1UL), NULL);//	xTaskCreate(xRadio, (signed char*) "Radio", 256, NULL, (taskIDLE_PRIORITY + 1UL), NULL);	LOG_INFO("Initialization Complete. Clock speed is %d", SystemCoreClock);	vTaskSuspend(boot_handle);}

void Board_LED_Set(uint8_t LEDNumber, bool On){	if (LEDNumber == 0) {		Chip_GPIO_SetPinState(LPC_GPIO_PORT, LED1_GPIO_PORT_NUM, LED1_GPIO_BIT_NUM, (bool) !On);	}	else if (LEDNumber == 1) {		Chip_GPIO_SetPinState(LPC_GPIO_PORT, LED2_GPIO_PORT_NUM, LED2_GPIO_BIT_NUM, (bool) !On);	}}

void AVALON_LED_Rgb(unsigned int rgb, bool on){	/* LED Level reversal ,and LEDs mutex light */	switch (rgb) {	case AVALON_LED_RED:		Chip_GPIO_SetPinState(LPC_GPIO, 0, 8, (on ^ true));		if (on) {			Chip_GPIO_SetPinState(LPC_GPIO, 0, 9, on);			Chip_GPIO_SetPinState(LPC_GPIO, 0, 11, on);		}		break;	case AVALON_LED_GREEN:		Chip_GPIO_SetPinState(LPC_GPIO, 0, 9, (on ^ true));		if (on) {			Chip_GPIO_SetPinState(LPC_GPIO, 0, 8, on);			Chip_GPIO_SetPinState(LPC_GPIO, 0, 11, on);		}		break;	case AVALON_LED_BLUE:		Chip_GPIO_SetPinState(LPC_GPIO, 0, 11, (on ^ true));		if (on) {			Chip_GPIO_SetPinState(LPC_GPIO, 0, 8, on);			Chip_GPIO_SetPinState(LPC_GPIO, 0, 9, on);		}		break;	default:		break;	}}

void AVALON_LED_Init(void){	/* Set LED's GPIO High */	Chip_GPIO_SetPinState(LPC_GPIO, 0, 8, true);	Chip_GPIO_SetPinState(LPC_GPIO, 0, 9, true);	Chip_GPIO_SetPinState(LPC_GPIO, 0, 11, true);	Chip_GPIO_SetPinDIROutput(LPC_GPIO, 0, 8);	Chip_GPIO_SetPinDIROutput(LPC_GPIO, 0, 9);	Chip_GPIO_SetPinDIROutput(LPC_GPIO, 0, 11);}

static void Board_LED_Init(){	/* Set LEDs as output */    Chip_SCU_PinMuxSet(LED1_PIN_PORT_NUM, LED1_PIN_BIT_NUM, (SCU_PINIO_FAST | LED1_MODE_FUNC));    Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, LED1_GPIO_PORT_NUM, LED1_GPIO_BIT_NUM);    Chip_SCU_PinMuxSet(LED2_PIN_PORT_NUM, LED2_PIN_BIT_NUM, (SCU_PINIO_FAST | LED2_MODE_FUNC));    Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, LED2_GPIO_PORT_NUM, LED2_GPIO_BIT_NUM);    /* Set initial states to off (true to disable) */    Chip_GPIO_SetPinState(LPC_GPIO_PORT, LED1_GPIO_PORT_NUM, LED1_GPIO_BIT_NUM, (bool) true);    Chip_GPIO_SetPinState(LPC_GPIO_PORT, LED2_GPIO_PORT_NUM, LED2_GPIO_BIT_NUM, (bool) true);}

/** * @brief GPIO initialization. */void gpioInit(void) {    //Chip_GPIO_Init(LPC_GPIO_PORT);	Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, LCD_BACKLIGHT);	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, LCD_BACKLIGHT, 1);	Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, RANGE_POWER_PIN);	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, RANGE_POWER_PIN, 0);	Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, MoonLander_LED);	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, MoonLander_LED, 0);	Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, SW_LEFT);	Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, SW_RIGHT);}

/* Sets the state of a board LED to on or off */void Board_LED_Set(uint8_t LEDNumber, bool On){    /* Must connect JP3 to see LED0 and JP4 to see LED1 */    if (LEDNumber == 0) {        Chip_GPIO_SetPinState(LPC_GPIO_PORT, LED0_PORT, LED0_PIN, On);    }}

/* Set up and initialize all required blocks and functions related to the   board hardware */void Board_Init(void){	/* Sets up DEBUG UART */	DEBUGINIT();	/* Updates SystemCoreClock global var with current clock speed */	SystemCoreClockUpdate();	/* Initializes GPIO */	Chip_GPIO_Init(LPC_GPIO_PORT);	/* Setup GPIOs for USB demos */	Chip_SCU_PinMuxSet(0x2, 6, (SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_FUNC4));			/* P2_6 USB1_PWR_EN, USB1 VBus function */	Chip_SCU_PinMuxSet(0x2, 5, (SCU_MODE_INACT | SCU_MODE_INBUFF_EN | SCU_MODE_ZIF_DIS | SCU_MODE_FUNC2));	/* P2_5 USB1_VBUS, MUST CONFIGURE THIS SIGNAL FOR USB1 NORMAL OPERATION */	Chip_SCU_PinMuxSet(0x1, 7, (SCU_MODE_PULLUP | SCU_MODE_INBUFF_EN | SCU_MODE_FUNC4));			/* P1_7 USB0_PWR_EN, USB0 VBus function Xplorer */	Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 5, 6);							/* GPIO5[6] = USB1_PWR_EN */	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 5, 6, true);							/* GPIO5[6] output high */	/* Initialize LEDs */	Board_LED_Init();#if defined(USE_RMII)	Chip_ENET_RMIIEnable(LPC_ETHERNET);#else	Chip_ENET_MIIEnable(LPC_ETHERNET);#endif}

int SDCardSendCommand(uint8_t command, uint32_t param, uint8_t crc, void* buffer, size_t recvSize) {	Chip_GPIO_SetPinState(LPC_GPIO, 0, 2, !Chip_GPIO_GetPinState(LPC_GPIO, 0, 2));	if (xTaskGetSchedulerState() == taskSCHEDULER_RUNNING)		xSemaphoreTake(xMutexSDCard, portMAX_DELAY);	int result = SDCARD_ERROR_GENERIC;	int wait = SDCARD_SPI_MAX_WAIT;	int i;	uint8_t read = 0;	uint8_t* data = (uint8_t*) buffer;	command += 0x40;	SDCardSetSS();	for (i = 0; i < SDCARD_IDLE_PRE_WAIT_ATTEMPTS; i++) {		if (spi_transceive_byte(SDCARD_SPI_DEVICE, 0xff) == 0xff) break;	}	result = SDCARD_ERROR_TRANSMIT_INTERRUPTED;	CommandBuffer[0] = command;	CommandBuffer[1] = param >> 24;	CommandBuffer[2] = param >> 16;	CommandBuffer[3] = param >> 8;	CommandBuffer[4] = param;	CommandBuffer[5] = (crc_crc7(CommandBuffer, 5) << 1) | 1;	spi_transceive(SDCARD_SPI_DEVICE, CommandBuffer, 6);	for (i = 0; i < 6; i++) {		if (CommandBuffer[i] != 0xff) {//			MSS_GPIO_set_output(MSS_GPIO_27, 0);			__asm volatile ("nop");//			MSS_GPIO_set_output(MSS_GPIO_27, 1);			goto fail;		}	}

voidmain (void){  volatile int i;  SystemInit ();  debug_init ();#ifdef DEBUG_LEVEL  debug_set_level (DEBUG_LEVEL);#endif  /* configure LED output */  Chip_IOCON_PinMuxSet (LPC_IOCON, LED_STATUS_PIO, IOCON_MODE_INACT | IOCON_FUNC0);  Chip_GPIO_SetPinDIROutput (LPC_GPIO, LED_STATUS_PORT, LED_STATUS_PIN);  Chip_GPIO_SetPinState (LPC_GPIO, LED_STATUS_PORT, LED_STATUS_PIN, false);  DBG_NEWLINE (DBG_LEVEL_INFO);  DBG (DBG_LEVEL_INFO, "Debug test firmware (" __GIT_SHA1__ ")");  DBG (DBG_LEVEL_INFO, "Compiled " __DATE__ " at " __TIME__ " on " __BUILD_HOSTNAME__ " using GCC " __VERSION__ " (%d.%d-%d)", __CS_SOURCERYGXX_MAJ__, __CS_SOURCERYGXX_MIN__, __CS_SOURCERYGXX_REV__);  DBG (DBG_LEVEL_INFO, "MCU running at %d MHz", SystemCoreClock / 1000000);  for (i = 0; i < 0x800000; i++);  while (1) {    /* toggle LED */    Chip_GPIO_SetPinToggle (LPC_GPIO, LED_STATUS_PORT, LED_STATUS_PIN);    DBG (DBG_LEVEL_INFO, "Hello world !!!");    for (i = 0; i < 0x400000; i++);  }}

/* Sets the state of a board LED to on or off */void Board_LED_Set(uint8_t LEDNumber, bool On){	if (LEDNumber < MAXLEDS) {		/* Toggle state, low is on, high is off */		Chip_GPIO_SetPinState(LPC_GPIO, ledports[LEDNumber], ledpins[LEDNumber], !On);	}}

uint32_t ciaaWriteOutput(uint32_t outputNumber, uint32_t value){	Chip_GPIO_SetPinState(LPC_GPIO_PORT,			outputs[outputNumber].port,			outputs[outputNumber].bit,			value);	return 0;}

/* NXP_Quick_Jack io initilize detect the mic&gnd */void QUICKJACK_IO_Init(void){	uint32_t MgAcmpOutVal;	uint32_t i = 0;	Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, MnGSWENAPINNUM);	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, MnGSWENAPINNUM, 1);	Chip_IOCON_PinSetMode(LPC_IOCON, IOCON_PIO14, PIN_MODE_INACTIVE);	Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, 14);		Chip_IOCON_PinSetMode(LPC_IOCON, MnGACMPOUTPIN, PIN_MODE_INACTIVE);	Chip_GPIO_SetPinDIRInput(LPC_GPIO_PORT, 0, MnGACMPOUTPINNUM);		MgAcmpOutVal = Chip_GPIO_ReadPortBit(LPC_GPIO_PORT, 0, 6);		for(i=0; i<5; i++) {																									/* waiting a while */		__NOP();	}		while(MgAcmpOutVal!= Chip_GPIO_ReadPortBit(LPC_GPIO_PORT, 0, 6)) {		for(i=0; i<5; i++) {																									/* waiting a while */			__NOP();		}		MgAcmpOutVal = Chip_GPIO_ReadPortBit(LPC_GPIO_PORT, 0, 6);		for(i=0; i<5; i++) {																									/* waiting a while */			__NOP();		}	}		/* configured analog switch selectable pin */	Chip_IOCON_PinSetMode(LPC_IOCON, MnGSWSELPIN, PIN_MODE_INACTIVE);	Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, MnGSWSELPINNUM);	if(MgAcmpOutVal==0) {		Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, MnGSWSELPINNUM, 1);	}	else {		Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, MnGSWSELPINNUM, 0);	}	/* enabled analog switch enabled pin */	Chip_IOCON_PinSetMode(LPC_IOCON, MnGSWENAPIN, PIN_MODE_INACTIVE);	Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, MnGSWENAPINNUM);	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, MnGSWENAPINNUM, 0);}

/* Initialize Audio Codec */static Status Board_Audio_CodecInit(int micIn){	/* Reset UDA1380 on board NGX Xplorer */	Chip_SCU_PinMuxSet(0x2, 10, (SCU_MODE_PULLUP | SCU_MODE_FUNC0));	Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, 14);	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, 14, true);	// delay 1us	delay(100000);	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, 14, false);	delay(100000);	if (!UDA1380_Init(UDA1380_MIC_IN_LR & - (micIn != 0))) {		return ERROR;	}	return SUCCESS;}

/** * @brief Enters sleep state until pinint signal received. */void goToSleep(void) {	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, LCD_BACKLIGHT, 1);	Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, RANGE_POWER_PIN, 0);	// Give plenty of time to release switch:	delayms(750);	// Disable systick timer:	SysTick->CTRL  &= ~SysTick_CTRL_ENABLE_Msk;	// Only allow enabled IRQ's to wake us up:	NVIC_DisableIRQ(ADC_SEQA_IRQn);	g_go_to_sleep = 0;	Chip_SYSCTL_EnablePINTWakeup(SW_LEFT_PININT);	Chip_SYSCTL_EnablePINTWakeup(SW_RIGHT_PININT);	SCB->SCR &= ~(SCB_SCR_SEVONPEND_Msk);	Chip_PMU_SleepState(LPC_PMU);}

voidtx_init (void){  tx_usage = 0;  Chip_IOCON_PinMuxSet (LPC_IOCON, TXE_PIO, TXE_CONFIG);  Chip_GPIO_SetPinDIROutput (LPC_GPIO, TXE_PORT, TXE_PIN);  Chip_GPIO_SetPinState (LPC_GPIO, TXE_PORT, TXE_PIN, false);}

/* Initialize the LEDs on the NXP LPC824 LPCXpresso Board */static void Board_LED_Init(void){	int i;	for (i = 0; i < LEDSAVAIL; i++) {		Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, 0, ledBits[i]);		Chip_GPIO_SetPinState(LPC_GPIO_PORT, 0, ledBits[i], true);	}}

/* Initializes board LED(s) */static void Board_LED_Init(void){	int idx;	for (idx = 0; idx < MAXLEDS; idx++) {		/* Set the GPIO as output with initial state off (high) */		Chip_GPIO_SetPinDIROutput(LPC_GPIO, ledports[idx], ledpins[idx]);		Chip_GPIO_SetPinState(LPC_GPIO, ledports[idx], ledpins[idx], true);	}}

static void Board_LED_Init(){	uint32_t idx;	for (idx = 0; idx < (sizeof(gpioLEDBits) / sizeof(io_port_t)); ++idx) {		/* Set pin direction and init to off */		Chip_GPIO_SetPinDIROutput(LPC_GPIO_PORT, gpioLEDBits[idx].port, gpioLEDBits[idx].pin);		Chip_GPIO_SetPinState(LPC_GPIO_PORT, gpioLEDBits[idx].port, gpioLEDBits[idx].pin, (bool) true);	}}

void Board_Outputs_set(uint32_t lightNum, uint32_t value){	uint32_t v=1;	if(value==OUTPUT_OFF)		v=0;	switch(lightNum)	{		case OUTPUT_SIREN:			Chip_GPIO_SetPinState( LPC_GPIO_PORT, gpioLed2.gpioNumber, gpioLed2.gpioPin, v);			break;		case OUTPUT_LED_ARMED:			Chip_GPIO_SetPinState( LPC_GPIO_PORT, gpioLed1.gpioNumber, gpioLed1.gpioPin, v);			break;		case OUTPUT_LED_DISARMED:			Chip_GPIO_SetPinState( LPC_GPIO_PORT, gpioLed3.gpioNumber, gpioLed3.gpioPin, v);			break;	}}

/** /brief write managed output *  /param[in] outputNumber number of output to set (0 to ciaaDriverDio_OutputCount) *  /param[in] value new state for output (true or false) */static void ciaa_lpc4337_writeOutput(uint32_t outputNumber, uint32_t value){   if (outputNumber < ciaaDriverDio_OutputCount)   {      Chip_GPIO_SetPinState(LPC_GPIO_PORT,         ciaaDriverDio_Outputs[outputNumber].port,         ciaaDriverDio_Outputs[outputNumber].pin,         value != 0 ? 1 : 0);   }}

/* LED1 toggle thread */static void vLEDTask1(void *pvParameters) {	bool LedState = false;	while (1) {		Board_LED_Set(1, LedState);		LedState = (bool) !LedState;		Chip_GPIO_SetPinState(LPC_GPIO, 0, 2, !Chip_GPIO_GetPinState(LPC_GPIO, 0, 2));		LOG_INFO("Test float %.4f/r/n", 1.2424125);		vTaskDelay(configTICK_RATE_HZ * 2);	}}

/* Initialize the LEDs on the NXP LPC54000 LPCXpresso Board */static void Board_LED_Init(void){	int i;	/* Pin muxing setup as part of board_sysinit */	for (i = 0; i < sizeof(ledBits); i++) {		Chip_GPIO_SetPinDIROutput(LPC_GPIO, 0, ledBits[i]);		Chip_GPIO_SetPinState(LPC_GPIO, 0, ledBits[i], true);	}}

void Led_Control(rt_uint32_t Set_led, rt_uint32_t value){		/* set led status */		switch (value)		{		case 0:				/* Light off */				//PC_GPIO->B[0][led.ctrl[Set_led].num] = 1UL;				Chip_GPIO_SetPinState(LPC_GPIO, led.ctrl[Set_led].port, led.ctrl[Set_led].num, 1UL);				break;		case 1:				/* Lights on */				//LPC_GPIO->B[0][led.ctrl[Set_led].num] = 0UL;				Chip_GPIO_SetPinState(LPC_GPIO, led.ctrl[Set_led].port, led.ctrl[Set_led].num, 0UL);				break;		default:				break;		}}