void ledFlash() {
uint8_t i;
for (i = 0; i < 4; i++) {
ledToggle(0);
ledToggle(1);
ledToggle(2);
if (i != 3) {
_delay_ms(333);
}
}
}
//---------------------------------------------------------------------------
// main()
//---------------------------------------------------------------------------
void main(void)
{
char i=1,l=2;
hardware_init(); // init hardware via Xware
while(1) // forever loop
{
if((GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_4)==0))
{
if(i<4)
i=i<<1;
else
i=1;
}
while((GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_4)==0));
if((GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_0)==0))
{
if(l<8)
l=l<<1;
else
l=2;
}
while((GPIOPinRead(GPIO_PORTF_BASE, GPIO_PIN_0)==0));
ledToggle(l);
delay(i);
}
}
static void appTaskConnect(void *pdata) {
while (true) {
OSTimeDlyHMSM(0,0,0,500);
ledToggle(USB_CONNECT_LED);
}
}
void mainTimerTick()
{
if (s_started)
{
if (s_timerCounter++ >= 244)
{
s_timerCounter = 0;
ledToggle();
}
if (buttonIsPressed())
{
if (!s_buttonLock)
{
s_buttonPressed = 1;
s_buttonLock = 1;
}
}
else
{
s_buttonPressed = 0;
s_buttonLock = 0;
}
}
}
/*
===========================================================================================================================================================================
ERROR FUNCTION(That function is executed when error occurs)
===========================================================================================================================================================================
*/
void error_function(void){
while(1){
ledToggle();
HAL_Delay(100);
}
}
/*
* appTaskEmergencyStop - Emergency stop task
* This task handles the emergency stop and stop tasks in
* the robot 2 subsystem.
*/
static void appTaskEmergencyStop(void *pdata)
{
/* Start the OS ticker
* (must be done in the highest priority task)
*/
osStartTick();
canRxInterrupt(canHandler);
while(true)
{
if(emergencyStop)
{
ledToggle(USB_LINK_LED);
} else if (stopped) {
ledToggle(USB_CONNECT_LED);
} else {
OSTimeDlyHMSM(0,0,0,500);
}
}
}
static bool appDataInd(NWK_DataInd_t *ind)
{
AppMessage_t *msg = (AppMessage_t *)ind->data;
ledToggle(LED_DATA);
msg->lqi = ind->lqi;
msg->rssi = ind->rssi;
appSendMessage(ind->data, ind->size);
return true;
}
static void appTaskLink(void *pdata) {
/* Start the OS ticker
* Must be done in the highest priority task
*/
osStartTick();
/* Task main loop */
while (true) {
ledToggle(USB_LINK_LED);
OSTimeDlyHMSM(0,0,0,500);
}
}
/* Emergency Stop Task
* This task handles the pause, stop and emergency stop functions
* in the system.
*/
static void appTaskEmergencyStop(void *pdata)
{
// Start the OS ticker
osStartTick();
canRxInterrupt(canHandler);
while(true)
{
if(emergencyStop)
{
ledToggle(USB_LINK_LED);
conveyorSetState(CONVEYOR_OFF);
} else if(paused){
pausedState = conveyorGetState();
conveyorSetState(CONVEYOR_OFF);
} else if (stopped){
ledToggle(USB_CONNECT_LED);
}
else{
OSTimeDlyHMSM(0,0,0,500);
}
}
}
void appMain(void)
{
uint16_t i;
for (i = 0; ; i++) {
i %= 64;
PRINTF("calibrate potentiometer to %u\n", i);
if (!ad5258Write(i)) {
PRINTF("write failed!\n");
}
mdelay(PERIOD);
PRINTF("read adc: %u\n", adcRead(0));
ledToggle();
}
}
//-------------------------------------------
// Entry point for the application
//-------------------------------------------
void appMain(void)
{
// Set packet reception handler (callback function)
serialSetPacketReceiveHandle(PRINTF_SERIAL_ID, serialPacketReceived, buf, BUF_SIZE);
ledOff();
// Send Ping every second
static uint_t counter = 1;
while (1) {
PRINTF("Ping #%i\n", counter++);
ledToggle();
mdelay(1000);
}
}
//------------------------------------------------------------------------------
int main(void)
{
ledConfig(LED_GREEN);
SysTick_Config(BOARD_MCK / 1000);
ledOn(LED_GREEN);
while(1)
{
Wait(500);
ledToggle(LED_GREEN);
}
return 0;
}
__interrupt void timerA0ISR( void )
{
timerCount = ( timerCount + 1 ) % 16;
if ( timerCount == 0 ) {
if( getFreeMessage( &mainMessage ) == queue_ok ){
mainMessage->source = main_user;
mainMessage->destination = led_user;
mainMessage->id = MSG_ID_LED_GREEN;
mainMessage->event = toggle_event;
putMessage( mainMessage );
} else {
ledToggle( MSG_ID_LED_RED );
}
}
scheduler();
}
/**
* Application entry point.
*/
int simpleTx(void)
{
/* Reset and initialise DW1000.
* For initialisation, DW1000 clocks must be temporarily set to crystal speed. After initialisation SPI rate can be increased for optimum
* performance. */
reset_DW1000(); /* Target specific drive of RSTn line into DW1000 low for a period. */
//spi_set_rate_low();
dwt_initialise(DWT_LOADNONE);
//spi_set_rate_high();
/* Configure DW1000. See NOTE 2 below. */
dwt_configure(&config);
/* Loop forever sending frames periodically. */
while(1)
{
/* Write frame data to DW1000 and prepare transmission. See NOTE 3 below.*/
dwt_writetxdata(sizeof(tx_msg), tx_msg, 0);
dwt_writetxfctrl(sizeof(tx_msg), 0);
/* Start transmission. */
dwt_starttx(DWT_START_TX_IMMEDIATE);
/* Poll DW1000 until TX frame sent event set. See NOTE 4 below.
* STATUS register is 5 bytes long but, as the event we are looking at is in the first byte of the register, we can use this simplest API
* function to access it.*/
while (!(status_reg = dwt_read32bitreg(SYS_STATUS_ID) & SYS_STATUS_TXFRS))
{ };
printf("Status reg now 0x%x\r\n",status_reg);
/* Clear TX frame sent event. */
dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_TXFRS);
/* Execute a delay between transmissions. */
deca_sleep(TX_DELAY_MS);
// toggle led
ledToggle();
/* Increment the blink frame sequence number (modulo 256). */
tx_msg[BLINK_FRAME_SN_IDX]++;
}
}
static void testMode() {
// In case disabled by boot-loader
__enable_irq();
initPorts();
initTimers();
bdm_interfaceOff();
initUSB();
ledEnable();
testEnable();
bootInputEnable();
for(;;) {
WAIT_MS(100);
ledToggle();
testToggle();
if (bootInputActive() == 0) {
reboot();
}
}
}
void appMain(void)
{
// initialize the alarm
alarmInit(&alarm, alarmCallback, NULL);
// schedule the alarm after specific interval
alarmSchedule(&alarm, ALARM_INTERVAL);
for (;;) {
ledToggle();
// lock the mutex in user context
uint32_t start, end;
start = getJiffies();
mutexLock(&testMutex);
end = getJiffies();
PRINTF("in user main, mutex lock time=%lu\n", end - start);
mdelay(1000);
mutexUnlock(&testMutex);
}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
uint32_t currentTime;
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f3xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f4xx.c file
*/
systemReady = false;
systemInit();
systemReady = true;
//evrPush(EVR_StartingMain, 0);
/* Setup SysTick Timer for 1 msec interrupts.
------------------------------------------
1. The SysTick_Config() function is a CMSIS function which configure:
- The SysTick Reload register with value passed as function parameter.
- Configure the SysTick IRQ priority to the lowest value (0x0F).
- Reset the SysTick Counter register.
- Configure the SysTick Counter clock source to be Core Clock Source (HCLK).
- Enable the SysTick Interrupt.
- Start the SysTick Counter.
2. You can change the SysTick Clock source to be HCLK_Div8 by calling the
SysTick_CLKSourceConfig(SysTick_CLKSource_HCLK_Div8) just after the
SysTick_Config() function call. The SysTick_CLKSourceConfig() is defined
inside the misc.c file.
3. You can change the SysTick IRQ priority by calling the
NVIC_SetPriority(SysTick_IRQn,...) just after the SysTick_Config() function
call. The NVIC_SetPriority() is defined inside the core_cm4.h file.
4. To adjust the SysTick time base, use the following formula:
Reload Value = SysTick Counter Clock (Hz) x Desired Time base (s)
- Reload Value is the parameter to be passed for SysTick_Config() function
- Reload Value should not exceed 0xFFFFFF
*/
#if 1
if (APRS_SLOT >= 0)
{
do
{
/*
while (!uartAvailable())
sleep();
*/
} while (!gpsDecode((char)uartRead()));
next_aprs = millis() + 1000 * (APRS_PERIOD - (gps_seconds + APRS_PERIOD - APRS_SLOT) % APRS_PERIOD);
}
else
{
next_aprs = millis();
}
#endif
while (1)
{
//evrCheck();
// Wait for sampling clock to overflow
if (TIM_GetFlagStatus(TIM2, TIM_FLAG_Update) != RESET)
{
;
}
#if 1
if ((int32_t)(millis() - next_aprs) >= 0)
{
getPos();
aprsSend();
next_aprs += APRS_PERIOD * 1000L;
while(afskBusy())
;
//sleep();
#if DEBUG_MODEM
afskDebug();
#endif
}
//sleep();
#else
///////////////////////////////
if (frame_500Hz)
{
frame_500Hz = false;
currentTime = micros();
deltaTime500Hz = currentTime - previous500HzTime;
previous500HzTime = currentTime;
executionTime500Hz = micros() - currentTime;
}
///////////////////////////////
if (frame_100Hz)
{
frame_100Hz = false;
currentTime = micros();
deltaTime100Hz = currentTime - previous100HzTime;
previous100HzTime = currentTime;
executionTime100Hz = micros() - currentTime;
}
///////////////////////////////
if (frame_50Hz)
{
frame_50Hz = false;
currentTime = micros();
deltaTime50Hz = currentTime - previous50HzTime;
previous50HzTime = currentTime;
#if 1
while (uartAvailable())
{
gpsDecode((char)uartRead());
}
#endif
executionTime50Hz = micros() - currentTime;
}
///////////////////////////////
if (frame_10Hz)
{
frame_10Hz = false;
currentTime = micros();
deltaTime10Hz = currentTime - previous10HzTime;
previous10HzTime = currentTime;
cliCom();
executionTime10Hz = micros() - currentTime;
}
///////////////////////////////
if (frame_5Hz)
{
frame_5Hz = false;
currentTime = micros();
deltaTime5Hz = currentTime - previous5HzTime;
previous5HzTime = currentTime;
executionTime5Hz = micros() - currentTime;
}
///////////////////////////////
if (frame_1Hz)
{
frame_1Hz = false;
currentTime = micros();
deltaTime1Hz = currentTime - previous1HzTime;
previous1HzTime = currentTime;
if (execUp == true) {
ledToggle(LED0);
#ifdef DEBUG_MODEM
afskDebug();
#endif
}
if (execUp == false)
execUpCount++;
if ((execUpCount == 5) && (execUp == false))
{
execUp = true;
ledOFF(LED0);
}
executionTime1Hz = micros() - currentTime;
}
#endif
}
}
//-------------------------------------------
// Entry point for the application
//-------------------------------------------
void appMain(void)
{
#if 0 // no effect
UCTL0 = SWRST;
ME1 &= ~(URXE0 | UTXE0 | USPIE0);
UCTL0 &= ~SWRST;
UCTL1 = SWRST;
ME2 &= ~(URXE1 | UTXE1 | USPIE1);
UCTL1 &= ~SWRST;
#endif
#if 1
ADC12IE = 0;
ADC12IFG = 0;
ADC12CTL0 &= ~ENC;
ADC12CTL0 &= ~REFON;
ADC12CTL0 &= ~ADC12ON;
DMA0CTL = 0;
DMA1CTL = 0;
#endif
#if 0
pinAsData(1, 0);
pinAsData(1, 1);
pinAsData(1, 2);
pinAsData(1, 3);
pinAsData(1, 4);
pinAsData(1, 5);
pinAsData(1, 6);
pinAsData(1, 7); // radio data indicate
pinAsData(2, 0); // ADS interrupts (unused)
pinAsData(2, 1);
pinAsData(2, 2);
pinAsData(2, 3); // SHT SDA + I2C soft SDA
pinAsData(2, 4); // SHT SCL + I2C soft SCL
pinAsData(2, 5); // sensors enable
pinAsData(2, 6);
pinAsData(2, 7); // uart0 rx
pinAsData(3, 0); // SD card CS
pinAsData(3, 1);
pinAsData(3, 2);
pinAsData(3, 3);
pinAsData(3, 4); // uart0 hw tx
pinAsData(3, 5); // uart0 hw rx
pinAsData(3, 6); // uart1 hw tx
pinAsData(3, 7); // uart1 hw tx
pinAsData(4, 0); // radio data request
pinAsData(4, 1); // radio rts
pinAsData(4, 2); // radio config
pinAsData(4, 3); // radio trx disable
pinAsData(4, 4); // radio reset
pinAsData(4, 5); // radio sleep
// pinAsData(4, 6); // uart0 tx
// pinAsData(4, 7);
pinAsData(5, 0);
pinAsData(5, 1);
pinAsData(5, 2);
pinAsData(5, 3);
pinAsData(5, 4); // red LED
pinAsData(5, 5); // green LED
pinAsData(5, 6); // blue LED
pinAsData(5, 7);
pinAsData(6, 0);
pinAsData(6, 1);
pinAsData(6, 2);
pinAsData(6, 3);
pinAsData(6, 4);
pinAsData(6, 5);
pinAsData(6, 6);
pinAsData(6, 7);
#endif
pinAsInput(1, 0);
pinAsInput(1, 1);
pinAsInput(1, 2);
pinAsInput(1, 3);
pinAsInput(1, 4);
pinAsInput(1, 5);
pinAsInput(1, 6);
pinAsInput(1, 7); // radio data indicate
pinAsInput(2, 0); // ADS interrupts (unused)
pinAsInput(2, 1);
pinAsInput(2, 2);
pinAsInput(2, 3); // SHT SDA + I2C soft SDA
// pinAsInput(2, 4); // SHT SCL + I2C soft SCL
// pinAsInput(2, 5); // sensors enable
pinAsInput(2, 6);
pinAsInput(2, 7); // uart0 rx
pinAsInput(3, 0); // SD card CS
pinAsInput(3, 1);
pinAsInput(3, 2);
pinAsInput(3, 3);
pinAsInput(3, 4); // uart0 hw tx
pinAsInput(3, 5); // uart0 hw rx
pinAsInput(3, 6); // uart1 hw tx
pinAsInput(3, 7); // uart1 hw tx
pinAsInput(4, 0); // radio data request
pinAsInput(4, 1); // radio rts
pinAsInput(4, 2); // radio config
// pinAsInput(4, 3); // radio trx disable
pinAsInput(4, 4); // radio reset
// pinAsInput(4, 5); // radio sleep
pinAsInput(4, 6); // uart0 tx
pinAsInput(4, 7);
pinAsInput(5, 0);
pinAsInput(5, 1);
pinAsInput(5, 2);
pinAsInput(5, 3);
// pinAsInput(5, 4); // red LED
pinAsInput(5, 5); // green LED
pinAsInput(5, 6); // blue LED
pinAsInput(5, 7);
pinAsInput(6, 0);
pinAsInput(6, 1);
pinAsInput(6, 2);
pinAsInput(6, 3);
pinAsInput(6, 4);
pinAsInput(6, 5);
pinAsInput(6, 6);
pinAsInput(6, 7);
// -- required for better efficiency
// make sure I2C clock is high
I2C_SCL_HI();
// make sure sensors are disabled
pinClear(SM3_SENSORS_ENABLE_PORT, SM3_SENSORS_ENABLE_PIN);
// --
while (1) {
msleep(PAUSE); // sleep PAUSE seconds
// PRINTF("%lu: hello world\n", (uint32_t) getJiffies());
ledToggle();
}
}
// ------------------- flashes LED
void HIDbase::ledFlash( uint8_t nLED ) {
ledToggle( nLED );
delay( 5 );
ledToggle( nLED );
}
void toggle_led1() {ledToggle(1);}
void toggle_led2() {ledToggle(2);}
void HAL_UartBytesReceived(uint16_t bytes)
{
for (uint16_t i = 0; i < bytes; i++)
HAL_UartReadByte();
ledToggle(2);
}
/*! ------------------------------------------------------------------------------------------------------------------
* @fn main()
*
* @brief Application entry point.
*
* @param none
*
* @return none
*/
int ssTwrInit(void)
{
/* Reset and initialise DW1000.
* For initialisation, DW1000 clocks must be temporarily set to crystal speed. After initialisation SPI rate can be increased for optimum
* performance. */
int status;
reset_DW1000(); /* Target specific drive of RSTn line into DW1000 low for a period. */
//spi_set_rate_low();
status = dwt_initialise(DWT_LOADUCODE);
if (DWT_SUCCESS != status) printf("API error line %d\r\n",__LINE__);
//spi_set_rate_high();
/* Configure DW1000. See NOTE 6 below. */
status = dwt_configure(&config);
if (DWT_SUCCESS != status) printf("API error line %d\r\n",__LINE__);
// read otp
uint32_t otpVal[0x20];
dwt_otpread(0,otpVal,0x20);
printf("OTP 6: 0x%x\r\n",otpVal[6]);
printf("OTP 7: 0x%x\r\n",otpVal[7]);
printf("OTP x16: 0x%x\r\n",otpVal[0x16]);
printf("OTP x17: 0x%x\r\n",otpVal[0x17]);
/* Apply default antenna delay value. See NOTE 2 below. */
printf("antenna delays: default TX: %d, default RX: %d, evk 16m: %d, evk 64m: %d\r\n",TX_ANT_DLY,RX_ANT_DLY,DWT_RF_DELAY_16M,DWT_RF_DELAY_64M);
tx_delay = TX_ANT_DLY;
rx_delay = RX_ANT_DLY;
dwt_setrxantennadelay(rx_delay);
dwt_settxantennadelay(tx_delay);
/* Set expected response's delay and timeout. See NOTE 1 and 5 below.
* As this example only handles one incoming frame with always the same delay and timeout, those values can be set here once for all. */
dwt_setrxaftertxdelay(POLL_TX_TO_RESP_RX_DLY_UUS);
dwt_setrxtimeout(RESP_RX_TIMEOUT_UUS);
btn = buttons();
printf("%s entering main loop\r\n",__FUNCTION__);
/* Loop forever initiating ranging exchanges. */
while (1)
{
/* Write frame data to DW1000 and prepare transmission. See NOTE 7 below. */
tx_poll_msg[ALL_MSG_SN_IDX] = frame_seq_nb;
status = dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_TXFRS);
if (DWT_SUCCESS != status) printf("API error line %d\r\n",__LINE__);
status = dwt_writetxdata(sizeof(tx_poll_msg), tx_poll_msg, 0);
if (DWT_SUCCESS != status) printf("API error line %d\r\n",__LINE__);
status = dwt_writetxfctrl(sizeof(tx_poll_msg), 0);
if (DWT_SUCCESS != status) printf("API error line %d\r\n",__LINE__);
/* Start transmission, indicating that a response is expected so that reception is enabled automatically after the frame is sent and the delay
* set by dwt_setrxaftertxdelay() has elapsed. */
status = dwt_starttx(DWT_START_TX_IMMEDIATE | DWT_RESPONSE_EXPECTED);
if (DWT_SUCCESS != status) printf("API error line %d\r\n",__LINE__);
/* We assume that the transmission is achieved correctly, poll for reception of a frame or error/timeout. See NOTE 8 below. */
while (!((status_reg = dwt_read32bitreg(SYS_STATUS_ID)) & (SYS_STATUS_RXFCG | SYS_STATUS_ALL_RX_ERR)))
{ } ; // printf("Waiting. status reg 0x%x\r\n",status_reg); };
//printf("Status reg now 0x%x\r\n",status_reg);
if (SYS_STATUS_RXRFTO & status_reg)
printf("RX timeout\r\n");
/* Increment frame sequence number after transmission of the poll message (modulo 256). */
frame_seq_nb++;
if (status_reg & SYS_STATUS_RXFCG)
{
uint32 frame_len;
//printf("Check RX\r\n");
/* Clear good RX frame event in the DW1000 status register. */
dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_RXFCG);
/* A frame has been received, read it into the local buffer. */
frame_len = dwt_read32bitreg(RX_FINFO_ID) & RX_FINFO_RXFLEN_MASK;
if (frame_len <= RX_BUF_LEN)
{
dwt_readrxdata(rx_buffer, frame_len, 0);
}
/* Check that the frame is the expected response from the companion "SS TWR responder" example.
* As the sequence number field of the frame is not relevant, it is cleared to simplify the validation of the frame. */
rx_buffer[ALL_MSG_SN_IDX] = 0;
if (memcmp(rx_buffer, rx_resp_msg, ALL_MSG_COMMON_LEN) == 0)
{
uint32 poll_tx_ts, resp_rx_ts, poll_rx_ts, resp_tx_ts;
int32 rtd_init, rtd_resp;
/* Retrieve poll transmission and response reception timestamps. See NOTE 9 below. */
poll_tx_ts = dwt_readtxtimestamplo32();
resp_rx_ts = dwt_readrxtimestamplo32();
/* Get timestamps embedded in response message. */
resp_msg_get_ts(&rx_buffer[RESP_MSG_POLL_RX_TS_IDX], &poll_rx_ts);
resp_msg_get_ts(&rx_buffer[RESP_MSG_RESP_TX_TS_IDX], &resp_tx_ts);
/* Compute time of flight and distance. */
rtd_init = resp_rx_ts - poll_tx_ts;
rtd_resp = resp_tx_ts - poll_rx_ts;
tof = ((rtd_init - rtd_resp) / 2.0) * DWT_TIME_UNITS;
distance = tof * SPEED_OF_LIGHT;
/* Display computed distance on LCD. */
//sprintf(dist_str, "DIST: %3.2f m", distance);
sprintf(dist_str, "%3.2f", distance);
printf("%s\r\n",dist_str);
//lcd_display_str(dist_str);
}
}
else
{
/* Clear RX error events in the DW1000 status register. */
printf("Errors occured. Clearing up\r\n");
dwt_write32bitreg(SYS_STATUS_ID, SYS_STATUS_ALL_RX_ERR);
}
/* Execute a delay between ranging exchanges. */
//printf("Delay %dms\r\n",RNG_DELAY_MS);
deca_sleep(RNG_DELAY_MS);
// toggle led
ledToggle();
// update antenna
if (buttons() & 1) {
tx_delay -= 10; // >>= 1;
rx_delay -= 10; //>>= 1;
dwt_setrxantennadelay(rx_delay);
dwt_settxantennadelay(tx_delay);
printf("Decreased antenna delay to 0x%x\r\n",tx_delay);
}
if (buttons() & 2) {
tx_delay += 10;
rx_delay += 10;
dwt_setrxantennadelay(rx_delay);
dwt_settxantennadelay(tx_delay);
printf("Increased antenna delay to 0x%x\r\n",tx_delay);
}
}
}
// led timer expire kicks in about ~100ms and perform the led operation according to the ledState and
// restart the timer according to ledState
static void ledTimerExpire(void)
{
int i;
PLED_CTRL pCurLed;
unsigned long flags;
BCM_ASSERT_NOT_HAS_SPINLOCK_V(&brcm_ledlock);
for (i = 0, pCurLed = gLedCtrl; i < kLedEnd; i++, pCurLed++)
{
#if defined(DEBUG_LED)
printk("led[%d]: Mask=0x%04x, State = %d, blcd=%d\n", i, pCurLed->ledGreenGpio, pCurLed->ledState, pCurLed->blinkCountDown);
#endif
spin_lock_irqsave(&brcm_ledlock, flags); // LEDs can be changed from ISR
switch (pCurLed->ledState)
{
case kLedStateOn:
case kLedStateOff:
case kLedStateFail:
pCurLed->blinkCountDown = 0; // reset the blink count down
spin_unlock_irqrestore(&brcm_ledlock, flags);
break;
case kLedStateSlowBlinkContinues:
if (pCurLed->blinkCountDown-- == 0)
{
pCurLed->blinkCountDown = kSlowBlinkCount;
ledToggle(pCurLed);
}
gTimerOnRequests++;
spin_unlock_irqrestore(&brcm_ledlock, flags);
break;
case kLedStateFastBlinkContinues:
if (pCurLed->blinkCountDown-- == 0)
{
pCurLed->blinkCountDown = kFastBlinkCount;
ledToggle(pCurLed);
}
gTimerOnRequests++;
spin_unlock_irqrestore(&brcm_ledlock, flags);
break;
case kLedStateUserWpsInProgress: /* 200ms on, 100ms off */
if (pCurLed->blinkCountDown-- == 0)
{
pCurLed->blinkCountDown = (((gLedRunningCounter++)&1)? kFastBlinkCount: kSlowBlinkCount);
ledToggle(pCurLed);
}
gTimerOnRequests++;
spin_unlock_irqrestore(&brcm_ledlock, flags);
break;
case kLedStateUserWpsError: /* 100ms on, 100ms off */
if (pCurLed->blinkCountDown-- == 0)
{
pCurLed->blinkCountDown = kFastBlinkCount;
ledToggle(pCurLed);
}
gTimerOnRequests++;
spin_unlock_irqrestore(&brcm_ledlock, flags);
break;
case kLedStateUserWpsSessionOverLap: /* 100ms on, 100ms off, 5 times, off for 500ms */
if (pCurLed->blinkCountDown-- == 0)
{
if(((++gLedRunningCounter)%10) == 0) {
pCurLed->blinkCountDown = 4;
setLed(pCurLed, kLedOff, kLedGreen);
pCurLed->ledState = kLedStateUserWpsSessionOverLap;
}
else
{
pCurLed->blinkCountDown = kFastBlinkCount;
ledToggle(pCurLed);
}
}
gTimerOnRequests++;
spin_unlock_irqrestore(&brcm_ledlock, flags);
break;
default:
spin_unlock_irqrestore(&brcm_ledlock, flags);
printk("Invalid state = %d\n", pCurLed->ledState);
}
}
// Restart the timer if any of our previous LED operations required
// us to restart the timer, or if any other threads requested a timer
// restart. Note that throughout this function, gTimerOn == TRUE, so
// any other thread which want to restart the timer would only
// increment the gTimerOnRequests and not call ledTimerStart.
spin_lock_irqsave(&brcm_ledlock, flags);
if (gTimerOnRequests > 0)
{
ledTimerStart();
gTimerOnRequests = 0;
}
else
{
gTimerOn = FALSE;
}
spin_unlock_irqrestore(&brcm_ledlock, flags);
}
int main(void)
{
int ch;
int8_t res;
systemInit();
gpioInit();
uart1Init(UART_BAUD(BAUD), UART_8N1, UART_FIFO_8); // setup the UART
uart1Puts("\r\nMMC/SD Card Filesystem Test (P:LPC2138 L:EFSL)\r\n");
uart1Puts("efsl LPC2000-port and this Demo-Application\r\n");
uart1Puts("done by Martin Thomas, Kaiserslautern, Germany\r\n");
/* init efsl debug-output */
lpc2000_debug_devopen(uart1Putch);
ledToggle();
rprintf("CARD init...");
if ( ( res = efs_init( &efs, 0 ) ) != 0 ) {
rprintf("failed with %i\n",res);
}
else {
rprintf("ok\n");
rprintf("Directory of 'root':\n");
ls_openDir( &list, &(efs.myFs) , "/");
while ( ls_getNext( &list ) == 0 ) {
list.currentEntry.FileName[LIST_MAXLENFILENAME-1] = '\0';
rprintf( "%s ( %li bytes )\n" ,
list.currentEntry.FileName,
list.currentEntry.FileSize ) ;
}
if ( file_fopen( &filer, &efs.myFs , LogFileName , 'r' ) == 0 ) {
rprintf("File %s open. Content:\n", LogFileName);
while ( ( e = file_read( &filer, 512, buf ) ) != 0 ) {
buf[e]='\0';
uart1Puts((char*)buf);
}
rprintf("\n");
file_fclose( &filer );
}
if ( file_fopen( &filew, &efs.myFs , LogFileName , 'a' ) == 0 ) {
rprintf("File %s open for append. Appending...", LogFileName);
strcpy((char*)buf, "Martin hat's angehaengt\r\n");
if ( file_write( &filew, strlen((char*)buf), buf ) == strlen((char*)buf) ) {
rprintf("ok\n");
}
else {
rprintf("fail\n");
}
file_fclose( &filew );
}
if ( file_fopen( &filer, &efs.myFs , LogFileName , 'r' ) == 0 ) {
rprintf("File %s open. Content:\n", LogFileName);
while ( ( e = file_read( &filer, 512, buf ) ) != 0 ) {
buf[e]='\0';
uart1Puts((char*)buf);
}
rprintf("\n");
file_fclose( &filer );
}
fs_umount( &efs.myFs ) ;
}
while(1) {
if ((ch = uart1Getch()) >= 0) {
uart1Puts("You pressed : ");
uart1Putch(ch);
uart1Puts("\r\n");
if ( ch == 'M' ) {
rprintf("Creating FS\n");
mkfs_makevfat(&efs.myPart);
}
ledToggle();
}
}
return 0; /* never reached */
}
static void appNetworkStatusTimerHandler(SYS_Timer_t *timer)
{
ledToggle(LED_NETWORK);
(void)timer;
}
// led timer expire kicks in about ~100ms and perform the led operation according to the ledState and
// restart the timer according to ledState
static void ledTimerExpire(void)
{
int i;
PLED_CTRL pCurLed;
unsigned long flags;
gTimerOn = FALSE;
for (i = 0, pCurLed = gLedCtrl; i < kLedEnd; i++, pCurLed++)
{
#if defined(DEBUG_LED)
printk("led[%d]: Mask=0x%04x, State = %d, blcd=%d\n", i, pCurLed->ledGreenGpio, pCurLed->ledState, pCurLed->blinkCountDown);
#endif
spin_lock_irqsave(&brcm_ledlock, flags); // LEDs can be changed from ISR
switch (pCurLed->ledState)
{
case kLedStateOn:
case kLedStateOff:
case kLedStateFail:
pCurLed->blinkCountDown = 0; // reset the blink count down
spin_unlock_irqrestore(&brcm_ledlock, flags);
break;
case kLedStateSlowBlinkContinues:
if (pCurLed->blinkCountDown-- == 0)
{
pCurLed->blinkCountDown = kSlowBlinkCount;
ledToggle(pCurLed);
}
spin_unlock_irqrestore(&brcm_ledlock, flags);
ledTimerStart();
break;
case kLedStateFastBlinkContinues:
if (pCurLed->blinkCountDown-- == 0)
{
pCurLed->blinkCountDown = kFastBlinkCount;
ledToggle(pCurLed);
}
spin_unlock_irqrestore(&brcm_ledlock, flags);
ledTimerStart();
break;
case kLedStateUserWpsInProgress: /* 200ms on, 100ms off */
if (pCurLed->blinkCountDown-- == 0)
{
pCurLed->blinkCountDown = (((gLedRunningCounter++)&1)? kFastBlinkCount: kSlowBlinkCount);
ledToggle(pCurLed);
}
spin_unlock_irqrestore(&brcm_ledlock, flags);
ledTimerStart();
break;
case kLedStateUserWpsError: /* 100ms on, 100ms off */
if (pCurLed->blinkCountDown-- == 0)
{
pCurLed->blinkCountDown = kFastBlinkCount;
ledToggle(pCurLed);
}
spin_unlock_irqrestore(&brcm_ledlock, flags);
ledTimerStart();
break;
case kLedStateUserWpsSessionOverLap: /* 100ms on, 100ms off, 5 times, off for 500ms */
if (pCurLed->blinkCountDown-- == 0)
{
if(((++gLedRunningCounter)%10) == 0) {
pCurLed->blinkCountDown = 4;
setLed(pCurLed, kLedOff, kLedGreen);
pCurLed->ledState = kLedStateUserWpsSessionOverLap;
}
else
{
pCurLed->blinkCountDown = kFastBlinkCount;
ledToggle(pCurLed);
}
}
spin_unlock_irqrestore(&brcm_ledlock, flags);
ledTimerStart();
break;
default:
spin_unlock_irqrestore(&brcm_ledlock, flags);
printk("Invalid state = %d\n", pCurLed->ledState);
}
}
}
