void led_toggle(void){
PIN_setOutputValue(ledPinHandle, Board_LED1, !PIN_getOutputValue(Board_LED1));
PIN_setOutputValue(ledPinHandle, Board_LED2, !PIN_getOutputValue(Board_LED2));
}
/**
* @fn SBL_openTarget
*
* @brief Forces target device into SBL
*
* @param None.
*
* @return uint8_t - SBL_SUCCESS, SBL_FAILURE
*/
uint8_t SBL_openTarget(void)
{
// Set BL PIN low and then set Reset PIN low to enter SBL
PIN_setOutputValue(hsblPins, blPIN, 0);
PIN_setOutputValue(hsblPins, rstPIN, 0);
SBL_utilDelay(15);
// Release Reset PIN while keeping BL pin low
PIN_setOutputValue(hsblPins, rstPIN, 1);
// Delay to be tuned
SBL_utilDelay(150);
// Release BL Pin now that target should be in SBL mode
PIN_setOutputValue(hsblPins, blPIN, 1);
// Send initial packet so target can detect baud rate
if (SBL_TL_uartAutoBaud() == SBL_DEV_ACK)
{
return SBL_SUCCESS;
}
return SBL_FAILURE;
}
// -----------------------------------------------------------------------------
//! \brief This callback is invoked on the completion of one transmission
//! to/from the host MCU. Any bytes receives will be [0,Rxlen) in
//! npiRxBuf.
//! If bytes were receives or transmitted, this function notifies
//! the NPI task via registered call backs
//!
//! \param[in] Rxlen - length of the data received
//! \param[in] Txlen - length of the data transferred
//!
//! \return void
// -----------------------------------------------------------------------------
static void NPITL_transmissionCallBack(uint16_t Rxlen, uint16_t Txlen)
{
npiRxBufHead = 0;
npiRxBufTail = Rxlen;
npiTxActive = FALSE;
//Since the largest valid NPI packet size is 4096
//valid RxLen fields should only be up to 0x0FFF
//a larger RxLen value tells the TL that a Rx is in progress
//and the UART cannot be closed yet
//in the above case, a CB will be triggered for the Tx, but Rx will wait
//until ReadCB completes at NPITLUART layer
if(!(Rxlen & 0x1000))
{
//Since we have rx/tx'd a complete packet, it is time to close out the TL
//and ready the processor for sleep
#ifdef SWHS_DEBUG
//Set Pin if in debug mode
PIN_setOutputValue(hNpiProfilingPin, Board_LED2, 1);
#endif //SWHS_DEBUG
transportClose();
// Open the Pins for ISR
hNpiUartRxPin = PIN_open(&npiUartRxPin, npiUartRxPinCfg);
PIN_registerIntCb(hNpiUartRxPin, NPITL_rxPinHwiFxn);
PIN_setConfig(hNpiUartRxPin,
PIN_BM_IRQ,
Board_UART_RX | PIN_IRQ_BOTHEDGES);
// Enable wakeup
PIN_setConfig(hNpiUartRxPin,
PINCC26XX_BM_WAKEUP,
Board_UART_RX | PINCC26XX_WAKEUP_NEGEDGE);
#ifdef SWHS_DEBUG
//Set Pin if in debug mode
PIN_setOutputValue(hNpiProfilingPin, Board_LED2, 0);
#endif //SWHS_DEBUG
//It is also valid to clear all flags at this point
trasnportLayerState = TL_closed;
// If Task is registered, invoke transaction complete callback
if (taskCBs.transCompleteCB)
{
taskCBs.transCompleteCB(Rxlen, Txlen);
}
NPITL_relPM();
}
else
{
//be sure to indicate TL is still busy
trasnportLayerState = TL_busy;
// If Task is registered, invoke transaction complete callback
//note that RxLen is zero because the read is incomplete
if (taskCBs.transCompleteCB)
{
taskCBs.transCompleteCB(0, Txlen);
}
}
}
/*******************************************************************************
* @fn devpkLcdSelect
*
* @brief Select/deselect the DevPack on the SensorTag
* (this function is called from GrLib only)
*
* @param select - true to select, false to deselect
*
* @return none
*/
void devpkLcdSelect(bool select)
{
if (select)
{
PIN_setOutputValue(hLcdPin,Board_SPI_DEVPK_CS,Board_DEVPK_CS_ON);
}
else
{
PIN_setOutputValue(hLcdPin,Board_SPI_DEVPK_CS,Board_DEVPK_CS_OFF);
}
}
void led_init(void){
/* Open LED pins */
ledPinHandle = PIN_open(&ledPinState, ledPinTable);
if(!ledPinHandle) {
System_abort("Error initializing board LED pins\n");
}
PIN_setOutputValue(ledPinHandle, Board_LED1, 0);
PIN_setOutputValue(ledPinHandle, Board_LED2, 1);
}
/**
* @fn SBL_resetTarget
*
* @brief Forces target device to boot from flash image instead of SBL. This
* function can be called before SBL_open() or after SBL_open()
*
* @param rstPinID - Board Pin ID of reset PIN
* @param blPinID - Board Pin ID of boot loader PIN
*
* @return uint8_t - SBL_SUCCESS, SBL_FAILURE
*/
uint8_t SBL_resetTarget(uint32_t rstPinID, uint32_t blPinID)
{
uint8_t openedPins = 0;
if (hsblPins == NULL)
{
// Must open pins if SBL_open() has not yet been called
openedPins = 1;
// Assign PIN IDs to reset and bl
rstPIN = (rstPinID & IOC_IOID_MASK);
blPIN = (blPinID & IOC_IOID_MASK);
// Add PIN IDs to PIN Configuration
sblPinsCfg[RST_PIN_IDX] |= rstPIN;
sblPinsCfg[BL_PIN_IDX] |= blPIN;
// Initialize SBL Pins
hsblPins = PIN_open(&sblPins, sblPinsCfg);
if (hsblPins == NULL)
{
return SBL_FAILURE;
}
}
// Guarantee that Boot Loader Pin is high during reset toggle
PIN_setOutputValue(hsblPins, blPIN, 1);
// Set reset PIN low
PIN_setOutputValue(hsblPins, rstPIN, 0);
SBL_utilDelay(15);
// Release Reset PIN
PIN_setOutputValue(hsblPins, rstPIN, 1);
// Must close Pins if opened in function
if (openedPins)
{
// Clear SBL PIN IDs
rstPIN = (IOID_UNUSED & IOC_IOID_MASK); // Set to 0x000000FF
blPIN = (IOID_UNUSED & IOC_IOID_MASK); // Set to 0x000000FF
// Clear PIN IDs from PIN Configuration
sblPinsCfg[RST_PIN_IDX] &= ~rstPIN;
sblPinsCfg[BL_PIN_IDX] &= ~blPIN;
// Close PIN Handle
PIN_close(hsblPins);
hsblPins = NULL;
}
return SBL_SUCCESS;
}
/*******************************************************************************
* @fn SensorTag_blinkLed
*
* @brief Blinks a led 'n' times, duty-cycle 50-50
* @param led - led identifier
* @param nBlinks - number of blinks
*
* @return none
*/
void SensorTag_blinkLed(uint8_t led, uint8_t nBlinks)
{
uint8_t i;
for (i=0; i<nBlinks; i++)
{
PIN_setOutputValue(hGpioPin, led, Board_LED_ON);
delay_ms(BLINK_DURATION);
PIN_setOutputValue(hGpioPin, led, Board_LED_OFF);
delay_ms(BLINK_DURATION);
}
}
/*********************************************************************
* @fn SensorTagIO_reset
*
* @brief Reset characteristics
*
* @param none
*
* @return none
*/
void SensorTagIO_reset(void)
{
ioValue = SensorTag_testResult();
Io_setParameter(SENSOR_DATA, 1, &ioValue);
ioMode = IO_MODE_LOCAL;
Io_setParameter(SENSOR_CONF, 1, &ioMode);
// Normal mode; make sure LEDs and buzzer are off
PIN_setOutputValue(hGpioPin, IOID_RED_LED, Board_LED_OFF);
PIN_setOutputValue(hGpioPin, IOID_GREEN_LED, Board_LED_OFF);
PIN_setOutputValue(hGpioPin, IOID_BLUE_LED, Board_LED_OFF);
}
/*********************************************************************
* @fn SensorTagIO_reset
*
* @brief Reset characteristics
*
* @param none
*
* @return none
*/
void SensorTagIO_reset(void)
{
ioValue = sensorTestResult();
Io_setParameter( SENSOR_DATA, 1, &ioValue);
ioMode = IO_MODE_LOCAL;
Io_setParameter( SENSOR_CONF, 1, &ioMode);
// Normal mode; make sure LEDs and buzzer are off
PIN_setOutputValue(hGpioPin, Board_LED1, Board_LED_OFF);
PIN_setOutputValue(hGpioPin, Board_LED2, Board_LED_OFF);
Clock_stop(buzzClockHandle);
PIN_setOutputValue(hGpioPin, Board_BUZZER, Board_BUZZER_OFF);
}
static void LCDTask_turnOnLCD(void) {
// Turn on LCD
PIN_setOutputValue(hGpioPin, Board_LCD_PWR, Board_LCD_PWR_ON);
delay_ms(250);
// Initialize LCD
//bspSpiOpen();
ILI9341_setup();
ILI9341_fillScreen(ILI9341_BLACK);
Adafruit_GFX_setTextColorBg(ILI9341_WHITE,ILI9341_BLACK);
Adafruit_GFX_setTextSize(4);
Adafruit_GFX_setCursor(45*1+5*4*0, 38*1+8*4*0);
Adafruit_GFX_print("1");
Adafruit_GFX_setCursor(45*2+5*4*1, 38*1+8*4*0);
Adafruit_GFX_print("2");
Adafruit_GFX_setCursor(45*3+5*4*2, 38*1+8*4*0);
Adafruit_GFX_print("3");
Adafruit_GFX_setCursor(45*1+5*4*0, 38*2+8*4*1);
Adafruit_GFX_print("4");
Adafruit_GFX_setCursor(45*2+5*4*1, 38*2+8*4*1);
Adafruit_GFX_print("5");
Adafruit_GFX_setCursor(45*3+5*4*2, 38*2+8*4*1);
Adafruit_GFX_print("6");
Adafruit_GFX_setCursor(45*1+5*4*0, 38*3+8*4*2);
Adafruit_GFX_print("7");
Adafruit_GFX_setCursor(45*2+5*4*1, 38*3+8*4*2);
Adafruit_GFX_print("8");
Adafruit_GFX_setCursor(45*3+5*4*2, 38*3+8*4*2);
Adafruit_GFX_print("9");
Adafruit_GFX_setCursor(45*2+5*4*1, 38*4+8*4*3);
Adafruit_GFX_print("0");
Adafruit_FT6206_setup(FT6206_DEFAULT_THRESSHOLD);
}
/*********************************************************************
* @fn timerIsr
*
* @brief Interrupt service routine for buzzer.
*
* @param none
*
* @return none
*/
static void timerIsr(UArg arg0)
{
uint32_t v;
v = PIN_getOutputValue(Board_BUZZER);
PIN_setOutputValue(hGpioPin, Board_BUZZER, !v);
}
/*
* ======== main ========
*/
int main(void)
{
PIN_Handle ledPinHandle;
/* Call board init functions */
Board_initGeneral();
Board_initUART();
/* Open LED pins */
ledPinHandle = PIN_open(&ledPinState, ledPinTable);
if(!ledPinHandle) {
System_abort("Error initializing board LED pins\n");
}
PIN_setOutputValue(ledPinHandle, Board_LED1, 1);
/* This example has logging and many other debug capabilities enabled */
System_printf("This example does not attempt to minimize code or data "
"footprint\n");
System_flush();
System_printf("Starting the UART Echo example\nSystem provider is set to "
"SysMin. Halt the target to view any SysMin contents in "
"ROV.\n");
/* SysMin will only print to the console when you call flush or exit */
System_flush();
/* Start BIOS */
BIOS_start();
return (0);
}
/*********************************************************************
* @fn SensorTagIO_reset
*
* @brief Reset characteristics
*
* @param none
*
* @return none
*/
void SensorTagIO_reset(void)
{
ioValue = sensorTestResult();
Io_setParameter( SENSOR_DATA, 1, &ioValue);
ioMode = IO_MODE_LOCAL;
Io_setParameter( SENSOR_CONF, 1, &ioMode);
// Normal mode; make sure LEDs and buzzer are off
PIN_setOutputValue(hGpioPin, Board_LED1, Board_LED_OFF);
PIN_setOutputValue(hGpioPin, Board_LED2, Board_LED_OFF);
if (buzzerOn) {
buzzerClose();
buzzerOn = false;
}
}
/*******************************************************************************
* @fn rFSwitchNotifyCb
*
* @brief Power driver callback to toggle RF switch on Power state
* transitions.
*
* input parameters
*
* @param eventType - The state change.
* @param eventArg - Not used.
* @param clientArg - Not used.
*
* @return Power_NOTIFYDONE to indicate success.
*/
static uint8_t rFSwitchNotifyCb(uint8_t eventType, uint32_t *eventArg,
uint32_t *clientArg)
{
if (eventType == PowerCC26XX_ENTERING_STANDBY)
{
// Power down RF Switch
PIN_setOutputValue(radCtrlHandle, Board_DIO30_SWPWR, 0);
}
else if (eventType == PowerCC26XX_AWAKE_STANDBY)
{
// Power up RF Switch
PIN_setOutputValue(radCtrlHandle, Board_DIO30_SWPWR, 1);
}
// Notification handled successfully
return Power_NOTIFYDONE;
}
// -----------------------------------------------------------------------------
//! \brief This callback is invoked on the completion of one transmission
//! to/from the host MCU. Any bytes receives will be [0,Rxlen) in
//! npiRxBuf.
//! If bytes were receives or transmitted, this function notifies
//! the NPI task via registered call backs
//!
//! \param[in] Rxlen - length of the data received
//! \param[in] Txlen - length of the data transferred
//!
//! \return void
// -----------------------------------------------------------------------------
static void NPITL_transmissionCallBack(uint16_t Rxlen, uint16_t Txlen)
{
npiRxBufHead = 0;
npiRxBufTail = Rxlen;
npiTxActive = FALSE;
// If Task is registered, invoke transaction complete callback
if (taskCBs.transCompleteCB)
{
taskCBs.transCompleteCB(Rxlen, Txlen);
}
#ifdef NPI_SW_HANDSHAKING_DEBUG
//Set the profiling pin high
PIN_setOutputValue(hNpiProfilingDebugPin, profilingDebugPin, 1);
#endif //NPI_SW_HANDSHAKING_DEBUG
// Close the UART
transportClose();
// Open the Pins for ISR
hNpiHandshakePins = PIN_open(&npiHandshakePins, npiHandshakePinsCfg);
//replace remRdyPIN with Board_UART_RX
PIN_registerIntCb(hNpiHandshakePins, NPITL_remRdyPINHwiFxn);
PIN_setConfig(hNpiHandshakePins,
PIN_BM_IRQ,
Board_UART_RX | PIN_IRQ_BOTHEDGES);
// Enable wakeup
PIN_setConfig(hNpiHandshakePins,
PINCC26XX_BM_WAKEUP,
Board_UART_RX | PINCC26XX_WAKEUP_NEGEDGE);
#ifdef NPI_SW_HANDSHAKING_DEBUG
//Indicate that we are now asleep in the GPIO state
PIN_setOutputValue(hNpiProfilingDebugPin, profilingDebugPin, 0);
#endif //NPI_SW_HANDSHAKING_DEBUG
//It is also valid to clear all flags at this point
_npiCSKey_t key;
key = NPIUtil_EnterCS();
handshakingState = HS_GPIO_STATE;
NPIUtil_ExitCS(key);
#ifdef POWER_SAVING
NPITL_relPM();
#endif //POWER_SAVING
}
/*******************************************************************************
* @fn SensorTagFactoryReset_extFlashErase
*
* @brief Erase the external flash
*
* @return none
*/
void SensorTagFactoryReset_extFlashErase(void)
{
SensorTagDisplay_suspend();
if (ExtFlash_open())
{
uint32_t address;
// Erase entire external flash
for (address= 0; address<EFL_FLASH_SIZE; address+=EFL_PAGE_SIZE)
{
bool ledToggle;
// Toggle both LEDs for each second page
ledToggle = (address % (EFL_PAGE_SIZE * 2)) == 0;
// LED on
if (ledToggle)
{
PIN_setOutputValue(hGpioPin, IOID_GREEN_LED, Board_LED_ON);
PIN_setOutputValue(hGpioPin, IOID_RED_LED, Board_LED_OFF);
}
// Erase the page
ExtFlash_erase(address,EFL_PAGE_SIZE);
// LED off
if (ledToggle)
{
PIN_setOutputValue(hGpioPin, IOID_RED_LED, Board_LED_ON);
PIN_setOutputValue(hGpioPin, IOID_GREEN_LED, Board_LED_OFF);
}
}
PIN_setOutputValue(hGpioPin, IOID_RED_LED, Board_LED_OFF);
ExtFlash_close();
}
SensorTagDisplay_resume();
}
/*******************************************************************************
* @fn devpkLcdClose
*
* @brief Turns of the display and releases the LCD control pins
*
* @return true if success
*/
void devpkLcdClose(void)
{
if (hLcdPin != NULL)
{
// Turn off the display
PIN_setOutputValue(hLcdPin,Board_DEVPK_LCD_DISP,0);
PIN_close(hLcdPin);
hLcdPin = NULL;
bspSpiClose();
}
}
/*******************************************************************************
* @fn SensorTagFactoryReset_applyFactoryImage
*
* @brief Load the factory image from external flash and reboot
*
* @return none
*/
void SensorTagFactoryReset_applyFactoryImage(void)
{
SensorTagDisplay_suspend();
if (SensorTagFactoryReset_hasImage())
{
// Indicate that factory image is launched
PIN_setOutputValue(hGpioPin, IOID_GREEN_LED, Board_LED_ON);
// Load and launch factory image; page 0 and 31 must be omitted
((void (*)(uint32_t, uint32_t, uint32_t))BL_OFFSET)
(EFL_ADDR_RECOVERY + APP_START, // Location in external flash
EFL_SIZE_RECOVERY - 0x2000, // Length
APP_START); // Location in internal flash
}
else
{
// Indicate that factory image launch failed
PIN_setOutputValue(hGpioPin, IOID_RED_LED, Board_LED_ON);
}
SensorTagDisplay_resume();
}
/*******************************************************************************
* @fn devpkLcdPower
*
* @brief Enables/disables the display
*
* @return true if success
*/
bool devpkLcdPower(uint8_t state)
{
bool ret;
if (hLcdPin != NULL &&
(state == DEVPK_LCD_POWER_OFF | state == DEVPK_LCD_POWER_ON))
{
PIN_setOutputValue(hLcdPin, Board_DEVPK_LCD_DISP, state);
ret = true;
}
else
{
ret = false;
}
return ret;
}
/*******************************************************************************
* @fn devpkLcdOpen
*
* @brief Initialize the LCD
*
* @descr Initializes the pins used by the LCD, creates resource access
* protection semaphore, turns on the LCD device, initializes the
* frame buffer, initializes to white background/dark foreground,
* and finally clears the display.
*
* @return true if success
*/
bool devpkLcdOpen(void)
{
hLcdPin = PIN_open(&pinState, BoardDevpackLCDPinTable);
if (hLcdPin != 0)
{
display.bg = ClrBlack;
display.fg = ClrWhite;
// Open the SPI driver
bspSpiOpen();
// Exclusive access
Semaphore_Params_init(&semParamsLCD);
semParamsLCD.mode = Semaphore_Mode_BINARY;
Semaphore_construct(&semLCD, 1, &semParamsLCD);
hSemLCD = Semaphore_handle(&semLCD);
// Turn on the display
PIN_setOutputValue(hLcdPin,Board_DEVPK_LCD_DISP,1);
// Graphics library init
GrContextInit(&g_sContext, &g_sharp96x96LCD);
// Graphics properties
GrContextForegroundSet(&g_sContext, display.fg);
GrContextBackgroundSet(&g_sContext, display.bg);
GrContextFontSet(&g_sContext, &g_sFontFixed6x8);
// Clear display
GrClearDisplay(&g_sContext);
GrFlush(&g_sContext);
}
return hLcdPin != 0;
}
static void LCDTask_turnOffLCD(void) {
// Turn off LCD
PIN_setOutputValue(hGpioPin, Board_LCD_PWR, Board_LCD_PWR_OFF);
}
/*********************************************************************
* @fn SensorTagIO_processCharChangeEvt
*
* @brief Process a change in the IO characteristics
*
* @return none
*/
void SensorTagIO_processCharChangeEvt(uint8_t paramID)
{
if( paramID == SENSOR_CONF )
{
Io_getParameter(SENSOR_CONF, &ioMode);
if (ioMode == IO_MODE_SELFTEST)
{
ioValue = sensorTestResult();
Io_setParameter(SENSOR_DATA, 1, &ioValue);
}
else
{
// Mode change: make sure LEDs and buzzer are off
Io_setParameter(SENSOR_DATA, 1, &ioValue);
PIN_setOutputValue(hGpioPin, Board_LED1, Board_LED_OFF);
PIN_setOutputValue(hGpioPin, Board_LED2, Board_LED_OFF);
Clock_stop(buzzClockHandle);
PIN_setOutputValue(hGpioPin, Board_BUZZER, Board_BUZZER_OFF);
}
}
else if (paramID == SENSOR_DATA)
{
Io_getParameter(SENSOR_DATA, &ioValue);
}
if (ioMode == IO_MODE_REMOTE)
{
// Control by remote client:
// - possible to operate the LEDs and buzzer
// - right key functionality overridden (will not terminate connection)
if (!!(ioValue & IO_DATA_LED1))
{
PIN_setOutputValue(hGpioPin, Board_LED1, Board_LED_ON);
}
else
{
PIN_setOutputValue(hGpioPin, Board_LED1, Board_LED_OFF);
}
if (!!(ioValue & IO_DATA_LED2))
{
PIN_setOutputValue(hGpioPin, Board_LED2, Board_LED_ON);
}
else
{
PIN_setOutputValue(hGpioPin, Board_LED2, Board_LED_OFF);
}
if (!!((ioValue & IO_DATA_BUZZER)))
{
Clock_start(buzzClockHandle);
}
else
{
Clock_stop(buzzClockHandle);
PIN_setOutputValue(hGpioPin, Board_BUZZER, Board_BUZZER_OFF);
}
}
}
/*******************************************************************************
* @fn SensorTag_processStateChangeEvt
*
* @brief Process a pending GAP Role state change event.
*
* @param newState - new state
*
* @return none
*/
static void SensorTag_processStateChangeEvt(gaprole_States_t newState)
{
#ifdef PLUS_BROADCASTER
static bool firstConnFlag = false;
#endif // PLUS_BROADCASTER
switch (newState)
{
case GAPROLE_STARTED:
{
uint8_t ownAddress[B_ADDR_LEN];
uint8_t systemId[DEVINFO_SYSTEM_ID_LEN];
SensorTag_blinkLed(Board_LED2, 5);
GAPRole_GetParameter(GAPROLE_BD_ADDR, ownAddress);
// use 6 bytes of device address for 8 bytes of system ID value
systemId[0] = ownAddress[0];
systemId[1] = ownAddress[1];
systemId[2] = ownAddress[2];
// set middle bytes to zero
systemId[4] = 0x00;
systemId[3] = 0x00;
// shift three bytes up
systemId[7] = ownAddress[5];
systemId[6] = ownAddress[4];
systemId[5] = ownAddress[3];
DevInfo_SetParameter(DEVINFO_SYSTEM_ID, DEVINFO_SYSTEM_ID_LEN, systemId);
LCD_WRITES_STATUS("Initialized");
}
break;
case GAPROLE_ADVERTISING:
// Start the clock
if (!Util_isActive(&periodicClock))
{
Util_startClock(&periodicClock);
}
// Make sure key presses are not stuck
sensorTag_updateAdvertisingData(0);
LCD_WRITES_STATUS("Advertising");
break;
case GAPROLE_CONNECTED:
{
// Start the clock
if (!Util_isActive(&periodicClock))
{
Util_startClock(&periodicClock);
}
// Turn of LEDs and buzzer
PIN_setOutputValue(hGpioPin, Board_LED1, Board_LED_OFF);
PIN_setOutputValue(hGpioPin, Board_LED2, Board_LED_OFF);
PIN_setOutputValue(hGpioPin, Board_BUZZER, Board_BUZZER_OFF);
#ifdef FEATURE_OAD
SensorTagConnectionControl_update();
#endif
#ifdef PLUS_BROADCASTER
// Only turn advertising on for this state when we first connect
// otherwise, when we go from connected_advertising back to this state
// we will be turning advertising back on.
if (firstConnFlag == false)
{
uint8_t advertEnabled = TRUE; // Turn on Advertising
GAPRole_SetParameter(GAPROLE_ADVERT_ENABLED, sizeof(uint8_t),
&advertEnabled);
firstConnFlag = true;
}
#endif // PLUS_BROADCASTER
}
LCD_WRITES_STATUS("Connected");
break;
case GAPROLE_CONNECTED_ADV:
break;
case GAPROLE_WAITING:
case GAPROLE_WAITING_AFTER_TIMEOUT:
SensorTag_resetAllSensors();
LCD_WRITES_STATUS("Waiting...");
break;
case GAPROLE_ERROR:
SensorTag_resetAllSensors();
PIN_setOutputValue(hGpioPin,Board_LED1, Board_LED_ON);
LCD_WRITES_STATUS("Error");
break;
default:
break;
}
gapProfileState = newState;
}
/*******************************************************************************
* @fn SensorTagFactoryReset_storeCurrentImage
*
* @brief Save the current image to external flash as a factory image
*
* @return none
*/
bool SensorTagFactoryReset_storeCurrentImage(void)
{
bool success;
success = ExtFlash_open();
if (success)
{
uint32_t address;
uint16_t imageCRC = 0;
// Install factory image
for (address=0; address<EFL_SIZE_RECOVERY && success; address+=EFL_PAGE_SIZE)
{
size_t offset;
bool ledToggle;
ledToggle = (address % (EFL_PAGE_SIZE * 2)) == 0;
// LED on
if (ledToggle)
{
PIN_setOutputValue(hGpioPin, IOID_GREEN_LED, Board_LED_ON);
PIN_setOutputValue(hGpioPin, IOID_RED_LED, Board_LED_OFF);
}
// Erase the page
ExtFlash_erase(address,EFL_PAGE_SIZE);
for (offset=0; offset<EFL_PAGE_SIZE && success; offset+=sizeof(buf))
{
const uint8_t *pIntFlash;
int i;
// Copy from internal to external flash
pIntFlash = (const uint8_t*)address + offset;
memcpy(buf,pIntFlash,sizeof(buf));
success = ExtFlash_write(EFL_ADDR_RECOVERY+address+offset,
sizeof(buf), buf);
if (success)
{
// Add CRC
for (i = 0; i < sizeof(buf); i++)
{
imageCRC = crc16(imageCRC, buf[i]);
}
}
}
// LED off
if (ledToggle)
{
PIN_setOutputValue(hGpioPin, IOID_GREEN_LED, Board_LED_OFF);
PIN_setOutputValue(hGpioPin, IOID_RED_LED, Board_LED_ON);
}
}
if (success)
{
PIN_setOutputValue(hGpioPin, IOID_RED_LED, Board_LED_OFF);
imageCRC = crc16(imageCRC, 0);
imageCRC = crc16(imageCRC, 0);
// Erase mata-data page
ExtFlash_erase(EFL_IMAGE_INFO_ADDR_FACTORY, EFL_PAGE_SIZE);
// Populate meta-data
imgInfo.crc[0] = imageCRC;
imgInfo.crc[1]= 0xFFFF;
imgInfo.addr = 0x0000;
imgInfo.ver = 0;
imgInfo.len = EFL_SIZE_RECOVERY / EFL_OAD_ADDR_RESOLUTION;
imgInfo.imgType = EFL_OAD_IMG_TYPE_FACTORY;
imgInfo.uid[0]= 'F';
imgInfo.uid[1]= 'F';
imgInfo.uid[2]= 'F';
imgInfo.uid[3]= 'F';
imgInfo.status = 0xFF;
// Store CRC in the meta-data region for factory image
ExtFlash_write(EFL_IMAGE_INFO_ADDR_FACTORY, sizeof(ExtImageInfo_t),
(uint8_t*)&imgInfo);
}
else
{
// Erase the meta-data to invalidate factory image
ExtFlash_erase(EFL_IMAGE_INFO_ADDR_FACTORY, EFL_PAGE_SIZE);
}
ExtFlash_close();
}
return success;
}
/*********************************************************************
* @fn SensorTagIO_processCharChangeEvt
*
* @brief Process a change in the IO characteristics
*
* @param none
*
* @return none
*/
void SensorTagIO_processCharChangeEvt(uint8_t paramID)
{
if (paramID == SENSOR_CONF)
{
Io_getParameter(SENSOR_CONF, &ioMode);
if (ioMode == IO_MODE_SELFTEST)
{
ioValue = SensorTag_testResult();
Io_setParameter(SENSOR_DATA, 1, &ioValue);
}
else
{
// Mode change: make sure LEDs are off
Io_setParameter(SENSOR_DATA, 1, &ioValue);
PIN_setOutputValue(hGpioPin, IOID_RED_LED, Board_LED_OFF);
PIN_setOutputValue(hGpioPin, IOID_GREEN_LED, Board_LED_OFF);
PIN_setOutputValue(hGpioPin, IOID_BLUE_LED, Board_LED_OFF);
}
}
else if (paramID == SENSOR_DATA)
{
Io_getParameter(SENSOR_DATA, &ioValue);
}
if (ioMode == IO_MODE_REMOTE)
{
// Control by remote client:
// - possible to operate the LEDs and buzzer
// - right key functionality overridden (will not terminate connection)
if (!!(ioValue & IO_DATA_LED_R))
{
PIN_setOutputValue(hGpioPin, IOID_RED_LED, Board_LED_ON);
}
else
{
PIN_setOutputValue(hGpioPin, IOID_RED_LED, Board_LED_OFF);
}
if (!!(ioValue & IO_DATA_LED_G))
{
PIN_setOutputValue(hGpioPin, IOID_GREEN_LED, Board_LED_ON);
}
else
{
PIN_setOutputValue(hGpioPin, IOID_GREEN_LED, Board_LED_OFF);
}
if (!!(ioValue & IO_DATA_LED_B))
{
PIN_setOutputValue(hGpioPin, IOID_BLUE_LED, Board_LED_ON);
}
else
{
PIN_setOutputValue(hGpioPin, IOID_BLUE_LED, Board_LED_OFF);
}
if (!!((ioValue & IO_DATA_EXT_FLASH_ERASE)))
{
SensorTagFactoryReset_extFlashErase();
}
}
}
