/**************************************************************************************************
* @fn halLcdInvert_Line
*
* @brief Invert pixels in a line. e.g. from white to black.
*
* @param uint8 line - the line to invert
*
* @return none
**************************************************************************************************/
void HalLcdInvert_Line(uint8 line)
{
#if (HAL_LCD == TRUE)
// Invert a line in the buffer
lcdBufferInvertPage( BSP_DEFAULT_BUFFER, 0, (LCD_COLS - 1), (tLcdPage) (line - 1));
// Rewrite buffer to LCD.
lcdSendBuffer(BSP_DEFAULT_BUFFER);
#endif
}
/**************************************************************************************************
* @fn halLcdClear_Line
*
* @brief clear a line from the LCD
*
* @param uint8 line - the line to clear
*
* @return none
**************************************************************************************************/
void HalLcdClear_Line(uint8 line)
{
#if (HAL_LCD == TRUE)
// Clear a line in the buffer
lcdBufferClearPage( BSP_DEFAULT_BUFFER, (tLcdPage) (line - 1));
// Rewrite buffer to LCD.
lcdSendBuffer(BSP_DEFAULT_BUFFER);
#endif
}
/**************************************************************************************************
* @fn halLcdInvert
*
* @brief Invert pixels on LCD. e.g. from white to black.
*
* @param none
*
* @return none
**************************************************************************************************/
void HalLcdInvert(void)
{
#if (HAL_LCD == TRUE)
// Invert the buffer
lcdBufferInvert( BSP_DEFAULT_BUFFER, 0, 0, (LCD_COLS - 1), (LCD_ROWS - 1));
// Rewrite buffer to LCD.
lcdSendBuffer(BSP_DEFAULT_BUFFER);
#endif
}
/*******************************************************************************
* @fn printWelcomeMessage
*
* @brief Function displaying a welkome message at start-up
*
*
* @param none
*
* @return none
*/
static void printWelcomeMessage(void) {
lcdBufferClear(0);
lcdBufferPrintString(0, "Inf. Pkt. Length Mode", 0, eLcdPage0);
lcdBufferSetHLine(0, 0, LCD_COLS - 1, eLcdPage7);
lcdBufferPrintString(0, "Waiting to receive", 0, eLcdPage2);
lcdBufferPrintString(0, "packets", 0, eLcdPage3);
lcdBufferPrintString(0, "Packet RX", 0, eLcdPage7);
lcdBufferSetHLine(0, 0, LCD_COLS - 1, 55);
lcdBufferInvertPage(0, 0, LCD_COLS, eLcdPage7);
lcdSendBuffer(0);
}
/**************************************************************************************************
* @fn HalLcdWriteStringAligned
*
* @brief Write a string to the LCD with the specified alignment
*
* @param str - pointer to the string that will be displayed
* alignment - the alignment to give to the string. Use the enumerated values:
* \li \b eLcdAlignLeft
* \li \b eLcdAlignCenter
* \li \b LCD_ALIGN_RIGHT
* line - line number to display
*
* @return None
**************************************************************************************************/
void HalLcdWriteStringAligned( char *str, uint8 alignment, uint8 line)
{
#if (HAL_LCD == TRUE)
if ( line <= HAL_LCD_LINE_8)
{
// Write aligned string to buffer.
lcdBufferPrintStringAligned( BSP_DEFAULT_BUFFER, str, (tLcdAlign) alignment, (tLcdPage) (line - 1));
// Write to LCD.
lcdSendBuffer(BSP_DEFAULT_BUFFER);
}
#endif // (HAL_LCD == TRUE)
}
/*******************************************************************************
* @fn updateLcd
*
* @brief updates LCD buffer and sends buffer to LCD module
*
* @param none
*
* @return none
*/
static void updateLcd(void) {
// Update LDC buffer and send to screen.
lcdBufferClear(0);
lcdBufferPrintString(0, "EasyLink Test", 0, eLcdPage0);
lcdBufferSetHLine(0, 0, LCD_COLS-1, 7);
lcdBufferPrintString(0, "Received ok:", 0, eLcdPage3);
lcdBufferPrintInt(0, packetCounter, 70, eLcdPage4);
lcdBufferPrintString(0, "Packet RX ", 0, eLcdPage7);
lcdBufferSetHLine(0, 0, LCD_COLS-1, 55);
lcdBufferInvertPage(0, 0, LCD_COLS, eLcdPage7);
lcdSendBuffer(0);
}
/*****************************************************************************
* @fn menuDisplay
*
* @brief Displays the menu provided by pMenu
*
* input parameters
*
* @param pMenu - The menu to be shown on the display
*/
void menuDisplay(const menu_t *pMenu){
#ifdef MENU_ANIMATED
static menu_t *pPrevMenu = 0; /* previously displayed menu */
tLcdMotion motion;
char buff[LCD_BYTES];
if(pMenu->pParentMenu==pPrevMenu)
{ /* user went into a submenu: slide left */
motion = eLcdSlideLeft;
}
else if(pPrevMenu->pParentMenu==pMenu)
{ /* user went back to parent menu: slide right */
motion = eLcdSlideRight;
}
else
{ /* none of the above */
motion = eLcdNoMotion;
}
if(motion)
{
lcdBufferCopy(0, buff);
//lcdGetBuffer(buff);
}
#endif /* MENU_ANIMATED */
menuWriteBuffer(pMenu);
#ifdef MENU_ANIMATED
if(motion)
{
lcdSendBufferAnimated(0,buff,motion);
}
/* will be remembered to next function call due to static */
pPrevMenu = (menu_t*)pMenu;
#endif // MENU_ANIMATED
#ifndef MENU_DMA
/* Not implemeted*/
lcdSendBuffer(0);
#endif /* not defined MENU_DMA */
}
/**************************************************************************************************
* @fn halLcdWriteLine
*
* @brief Write one line on display. It is required to place a
* NULL terminator \0 at the end of the string
*
* @param uint8 line - display line
* char *pText - text buffer to write
*
* @return none
**************************************************************************************************/
void HalLcd_HW_WriteLine(char str[], uint8 line)
{
/* Initialize with spaces to clear the line on the LCD. */
uint8 buf[] = " ";
uint32 len = ((strlen(str) > HAL_LCD_MAX_CHARS) ? HAL_LCD_MAX_CHARS : strlen(str));
/* Copy string characters but not the NULL to keep spaces */
(void)memcpy(buf, str, len);
/* Copy into the default buffer */
lcdBufferPrintString((char *)HAL_LCD_DEF_BUF, (char const *)buf, 0, (tLcdPage)line);
/* Flush the default buffer to the LCD */
lcdSendBuffer(HAL_LCD_DEF_BUF);
}
/**************************************************************************************************
* @fn halLcdWriteLine
*
* @brief Write one line on display. It is required to place a
* NULL terminator \0 at the end of the string
*
* @param uint8 line - display line
* char *pText - text buffer to write
*
* @return none
**************************************************************************************************/
void HalLcd_HW_WriteLine(char str[], uint8 line)
{
// Initialize with spaces to clear the line on the LCD.
uint8 buf[] = " ";
uint32 len = ((strlen(str) > HAL_LCD_MAX_CHARS) ? HAL_LCD_MAX_CHARS : strlen(str));
//Copy string characters but not the NULL to keep spaces
(void)memcpy(buf, str, len);
// Copy into the default buffer
lcdBufferPrintString(BSP_DEFAULT_BUFFER, (char const *)buf, 1, (tLcdPage)line);
// Flush the default buffer to the LCD
lcdSendBuffer(BSP_DEFAULT_BUFFER);
}
/*******************************************************************************
* @fn updateLcd
*
* @brief Updates the LCS every time a packet has been received
* with CRC OK
*
* @param none
*
* @return none
*/
static void updateLcd(void) {
lcdBufferClear(0);
lcdBufferPrintString(0, "Inf. Pkt. Length Mode", 0, eLcdPage0);
lcdBufferSetHLine(0, 0, LCD_COLS - 1, eLcdPage7);
lcdBufferPrintString(0, "Received packets:", 0, eLcdPage3);
lcdBufferPrintInt(0, (int32)(++packetCounter), 102, eLcdPage3);
lcdBufferPrintString(0, "RSSI:", 0, eLcdPage5);
lcdBufferPrintInt(0, rssi, 40, eLcdPage5);
lcdBufferPrintString(0, "Packet RX", 0, eLcdPage7);
lcdBufferSetHLine(0, 0, LCD_COLS - 1, 55);
lcdBufferInvertPage(0, 0, LCD_COLS, eLcdPage7);
lcdSendBuffer(0);
}
/***************************************************************************//**
* @brief Loads initial LCD buffer and sends buffer to LCD module
*******************************************************************************/
static void
welcomeLCD(void)
{
// Clear LCD buffer
lcdBufferClear(0);
// TI logo
lcdSendBuffer(pLcdTiLogo);
// Project Text
lcdBufferPrintString(0, "TI/Sigfox", 63, eLcdPage2);
lcdBufferPrintString(0, "Demo", 63, eLcdPage3);
lcdBufferPrintString(0, "SDK", 63, eLcdPage5);
lcdSendBufferPart(0, 63, 127, eLcdPage2, eLcdPage6);
}
void createMenu( Menu *menu ) {
int i;
currentMenu = menu;
lcdState.menuHover = 0;
lcdState.page = eLcdPage0;
lcdBufferClear( 0 );
lcdBufferPrintString( 0, currentMenu->header, 0, lcdState.page++ );
for( i = 0; i < currentMenu->menuCount; ++i ) {
lcdBufferPrintString( 0, currentMenu->menu[i], 0, lcdState.page++ );
}
lcdBufferInvertPage( 0, 0, 127, eLcdPage1 );
lcdSendBuffer( 0 );
}
/******************************************************************************
* @fn main
*
* @brief Main handles all applications attached to the menu system
*
* input parameters
*
* output parameters
*
*@return
*/
void main( void )
{
// Init clocks and I/O
bspInit(BSP_SYS_CLK_16MHZ);
// Init leds
bspLedInit();
// Init Buttons
bspKeyInit(BSP_KEY_MODE_POLL);
// Initialize SPI interface to LCD (shared with SPI flash)
bspIoSpiInit(BSP_FLASH_LCD_SPI, BSP_FLASH_LCD_SPI_SPD);
/* Init Buttons */
bspKeyInit(BSP_KEY_MODE_ISR);
bspKeyIntEnable(BSP_KEY_ALL);
/* Init LCD and issue a welcome */
lcdInit();
lcdClear();
// Instantiate tranceiver RF spi interface to SCLK ~ 4 MHz */
//input clockDivider - SMCLK/clockDivider gives SCLK frequency
trxRfSpiInterfaceInit(0x10);
/* Welcome Screen Part */
lcdSendBuffer(trxebWelcomeScreen);
lcdBufferPrintString(lcdDefaultBuffer,"TEXAS",60,eLcdPage6);
lcdBufferPrintString(lcdDefaultBuffer,"INSTRUMENTS",60,eLcdPage7);
lcdSendBufferPart(lcdDefaultBuffer, 60,127,eLcdPage6, eLcdPage7);
/* MCU will stay in sleep until button is pressed */
__low_power_mode_3();
bspKeyPushed(BSP_KEY_ALL);
//Clear screen
lcdBufferClear(0);
/* Menu Driver */
menu_t *pCurrentMenu = &mainMenu;
uint8 menuButtonsPressed;
menuDisplay(pCurrentMenu);
__low_power_mode_3();
while(1)
{
menuButtonsPressed = bspKeyPushed(BSP_KEY_ALL);
switch(menuButtonsPressed)
{
case BSP_KEY_LEFT:
pCurrentMenu = menuBack(pCurrentMenu);
break;
case BSP_KEY_RIGHT:
pCurrentMenu = menuEnter(pCurrentMenu);
break;
case BSP_KEY_DOWN:
menuDown(pCurrentMenu);
break;
case BSP_KEY_UP:
menuUp(pCurrentMenu);
break;
default:
break;
}
menuDisplay(pCurrentMenu);
/* Enter low power mode while menu driver waits on user input */
__low_power_mode_3();
}
}
void invertScreen( void ) {
lcdBufferInvert( 0, 0, 0, 127, 63 );
lcdSendBuffer( 0 );
}
/***************************************************************************//**
* @brief Updates LCD buffer and sends buffer to LCD module
*
* +-----------------------------------------+
* |_____________ SIGFOX DEMO_______________|
* | UL: XX XX XX XX XX XX |
* | XX XX XX XX XX XX |
* | |
* | DL: XX XX XX XX XX XX |
* | XX XX |
* |_________________________________________|
* | (c) Texas Instruments |
* +-----------------------------------------+
*
*******************************************************************************/
static void
updateLCD(void)
{
char ulmsg[36] = {0};
char dlmsg[24] = {0};
char ulmsg1[18] = {0};
char ulmsg2[18] = {0};
char dlmsg1[18] = {0};
char dlmsg2[6] = {0};
dataToString((unsigned char*) message, ulmsg, 24);
dataToString((unsigned char*) ReceivedPayload, dlmsg, 16);
// Format the converted string to display on LCD
unsigned char n;
unsigned char m = 0;
for(n=0;n<12;n++)
{
if(m % 3 == 0)
{
ulmsg1[m] = ' ';
ulmsg2[m] = ' ';
dlmsg1[m] = ' ';
if(n<4)
{
dlmsg2[m] = ' ';
}
m++;
}
ulmsg1[m] = ulmsg[n];
ulmsg2[m] = ulmsg[12+n];
dlmsg1[m] = dlmsg[n];
if(n<4)
{
dlmsg2[m] = dlmsg[12+n];
}
m++;
}
// Clear LCD
lcdBufferClear(0);
lcdSendBuffer(0);
// Load status buffer
lcdBufferPrintStringAligned(0, "Sigfox Demo", eLcdAlignCenter, eLcdPage0);
lcdBufferSetHLine(0, 0, LCD_COLS-1, 7);
lcdBufferInvertPage(0, 0, LCD_COLS, eLcdPage0);
lcdSendBufferPart(0, 0, 127, eLcdPage0,eLcdPage0);
lcdBufferClearPart(0, 0, 127, eLcdPage1, eLcdPage6);
lcdBufferPrintString(0, "UL:", 0, eLcdPage1);
lcdBufferPrintString(0, ulmsg1, 20, eLcdPage1);
lcdSendBufferPart(0, 0, 127, eLcdPage1,eLcdPage1);
lcdBufferPrintString(0, ulmsg2, 20, eLcdPage2);
lcdSendBufferPart(0, 20, 127, eLcdPage2,eLcdPage2);
lcdBufferClearPart(0, 0, 127, eLcdPage3, eLcdPage6);
lcdBufferPrintString(0, "DL:", 0, eLcdPage4);
lcdBufferPrintString(0, dlmsg1, 20, eLcdPage4);
lcdSendBufferPart(0, 0, 127, eLcdPage4,eLcdPage4);
lcdBufferPrintString(0, dlmsg2, 20, eLcdPage5);
lcdSendBufferPart(0, 20, 55, eLcdPage5,eLcdPage5);
lcdBufferPrintString(0, "(c) Texas Instruments" , 0, eLcdPage7);
lcdBufferSetHLine(0, 0, LCD_COLS-1, 55);
lcdBufferInvertPage(0, 0, LCD_COLS, eLcdPage7);
// Send the buffer to the LCD screen
lcdSendBufferPart(0, 0, 127, eLcdPage7, eLcdPage7);
}
/**************************************************************************//**
* @brief Main function of example.
******************************************************************************/
void main(void)
{
uint8_t ui8KeyBm = 0;
uint_fast16_t ui16Cnt = 0;
uint8_t ui8Byte = APP_TX_BYTE;
//
// Initialize clocks and board I/O
//
bspInit(BSP_SYS_CLK_SPD);
//
// Set LED1 to indicate life
//
bspLedSet(BSP_LED_1);
//
// Initialize key driver
//
bspKeyInit(BSP_KEY_MODE_ISR);
bspKeyIntEnable(BSP_KEY_SELECT|BSP_KEY_UP);
//
// Initialize UART to USB MCU
//
bspUartBufInit(pui8TxBuf, sizeof(pui8TxBuf), pui8RxBuf, sizeof(pui8RxBuf));
//
// Application must register the UART interrupt handler
//
UARTIntRegister(BSP_UART_BASE, &appUartIsr);
//
// Open UART connection
//
if(bspUartOpen(eBaudRate115200) != BSP_UART_SUCCESS)
{
//
// Failed to initialize UART handler
//
bspAssert();
}
//
// Initialize SPI interface to LCD, configure LCD, and display information.
//
bspSpiInit(BSP_SPI_CLK_SPD);
lcdInit();
lcdBufferPrintStringAligned(0, "UART example", eLcdAlignCenter, eLcdPage0);
lcdBufferInvertPage(0, 0,127, eLcdPage0);
lcdBufferPrintString(0, "Baud rate :", 6, eLcdPage2);
lcdBufferPrintIntAligned(0, bspUartBaudRateGet(), eLcdAlignRight, eLcdPage2);
lcdBufferPrintString(0, "Format :", 6, eLcdPage3);
lcdBufferPrintStringAligned(0, "8-N-1", eLcdAlignRight, eLcdPage3);
lcdBufferPrintString(0, "Flow control:", 6, eLcdPage4);
lcdBufferPrintStringAligned(0, "No", eLcdAlignRight, eLcdPage4);
lcdBufferPrintStringAligned(0, "Transmit: UP key", eLcdAlignRight, eLcdPage6);
lcdBufferPrintStringAligned(0, "SELECT to toggle mode", eLcdAlignCenter, eLcdPage7);
lcdBufferInvertPage(0, 0,127, eLcdPage7);
lcdSendBuffer(0);
//
// Enable global interrupts
//
IntMasterEnable();
while(1)
{
ui8KeyBm = bspKeyPushed(BSP_KEY_ALL);
if(BSP_KEY_SELECT & ui8KeyBm)
{
//
// Change mode
//
bRepeaterMode ^= 1;
bspLedToggle(BSP_LED_3);
//
// Update LCD for the new mode
//
lcdBufferClearPart(0, 0,127, eLcdPage6, eLcdPage6);
if(bRepeaterMode)
{
lcdBufferPrintStringAligned(0, "Repeater mode",
eLcdAlignCenter, eLcdPage6);
}
else
{
lcdBufferPrintStringAligned(0, "Transmit: UP key",
eLcdAlignCenter, eLcdPage6);
}
lcdSendBufferPart(0, 0,127, eLcdPage6, eLcdPage6);
}
//
// Read data from UART RX buffer to application buffer
//
ui16Cnt = bspUartDataGet(pui8AppBuf, bspUartRxCharsAvail());
if(bRepeaterMode)
{
//
// Repeater mode
//
if(ui16Cnt)
{
//
// Send data from application buffer to UART TX buffer
//
bspUartDataPut(pui8AppBuf, ui16Cnt);
}
}
else
{
//
// Transmit mode
//
if(BSP_KEY_UP & ui8KeyBm)
{
//
// Transmit a single character
//
bspUartDataPut(&ui8Byte, 1);
}
}
}
}
/******************************************************************************
* @fn cc120x_masterStartApp
*
* @brief
*
* input parameters
*
* @param pDummy - pointer to pointer to void. Not used
*
* output parameters
*
* @return SNIFF_RETURN_SUCCESS
*/
uint8 cc120x_masterStartApp(void)
{
static uint8 marcState;
// Set first packet number
pkt = 1;
// Set up GPIO pins. For debug
cc112xSpiWriteReg(CC120X_IOCFG3,&cc120x_gpioConfigMaster[0],4);
//Display while configuring radios*
lcdBufferClear(0);
lcdBufferPrintString(0," RX Sniff Test ",0,eLcdPage0);
lcdBufferSetHLine(0,0,LCD_COLS-1,eLcdPage7);
lcdBufferPrintString(0," Radio in TX ",0,eLcdPage2);
lcdBufferPrintString(0," ",0,eLcdPage3);
lcdBufferPrintString(0," Press right button ",0,eLcdPage4);
lcdBufferPrintString(0," to send packet ",0,eLcdPage5);
lcdBufferPrintString(0," 1 Abort Master Mode ",0,eLcdPage7);
lcdBufferSetHLine(0,0,LCD_COLS-1,55);
lcdBufferInvertPage(0,0,LCD_COLS,eLcdPage7);
lcdSendBuffer(0);
// Calibrate radio
trxSpiCmdStrobe(CC120X_SCAL);
// Wait for calibration to be done (radio back in IDLE state)
do {
cc120xSpiReadReg(CC120X_MARCSTATE, &marcState, 1);
} while (marcState != 0x41);
// Put MCU to sleep
__low_power_mode_3();
while(1)
{
if(buttonPressed = bspKeyPushed(BSP_KEY_ALL))
{
if(buttonPressed == BSP_KEY_LEFT)
{
// Left button pressed. Abort function
// Put radio in powerdown to save power
trxSpiCmdStrobe(CC120X_SPWD);
//Insert Carrier Sense threshold warning in Sniff Test Menu
drawInfo();
return SNIFF_RETURN_FAILURE;
}
else if (buttonPressed == BSP_KEY_RIGHT)
{
//Right button pressed, send packet
lcdBufferClear(0);
// build packet
comArray[0] = PKTLEN; // length field
comArray[1] = 0x00; // address field
comArray[2] = pkt>>24; // payload
comArray[3] = pkt>>16;
comArray[4] = pkt>>8;
comArray[5] = pkt;
// Update LCD
lcdBufferPrintString(0," RX Sniff Test ",0,eLcdPage0);
lcdBufferSetHLine(0,0,LCD_COLS-1,eLcdPage7);
lcdBufferPrintString(0,"Sent Pkt number:",0,eLcdPage3);
lcdBufferPrintInt(0,pkt,70,eLcdPage4);
lcdBufferPrintString(0," 1 Abort Master Mode ",0,eLcdPage7);
lcdBufferSetHLine(0,0,LCD_COLS-1,55);
lcdBufferInvertPage(0,0,LCD_COLS,eLcdPage7);
lcdSendBuffer(0);
// Update packet counter
pkt++;
// Strobe IDLE and fill TX FIFO
trxSpiCmdStrobe(CC120X_SIDLE);
// wait for radio to enter IDLE state
while((trxSpiCmdStrobe(CC112X_SNOP)& 0xF0) != 0x00);
cc112xSpiWriteTxFifo(comArray,PKTLEN+1);
// Send packet
trxSpiCmdStrobe(CC120X_STX);
// Wait for radio to finish sending packet
while((trxSpiCmdStrobe(CC120X_SNOP)& 0xF0) != 0x00);
// Put radio in powerdown to save power
trxSpiCmdStrobe(CC120X_SPWD);
//Put MCU to sleep
__low_power_mode_3();
}
}
}
