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;
}
}
void
main (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);
}
void
tx_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;
}
}
