Ejemplo n.º 1
0
void refreshScreen( void ) {
    RetVal retVal;
    
    TimerIntClear( GPTIMER0_BASE, GPTIMER_TIMA_TIMEOUT );
    
    if( !currentMenu ) {
        return;
    }
    
    if( currentMenu->menuCount > 0 ) {
        lcdBufferClearPage( 0, lcdState.page );
        
        ( *currentMenu->hoverFunction[lcdState.menuHover] )( &retVal );
        switch( retVal.retType ) {
        case RET_TYPE_INT: 
            lcdBufferPrintInt( 0, retVal.intRet, 0, lcdState.page );
            break;
        case RET_TYPE_FLOAT:
            lcdBufferPrintFloat( 0, retVal.floatRet, 2, 0, lcdState.page );
            break;
        }
    }
    
    lcdSendBufferPart( 0, 0, 127, lcdState.page, lcdState.page );
}
Ejemplo n.º 2
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);
}
Ejemplo n.º 3
0
/**************************************************************************//**
* @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);
            }
        }
    }
}
Ejemplo n.º 4
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();
  }
}
Ejemplo n.º 5
0
void invertHovered( void ) {
    tLcdPage menuHover = eLcdPage1 + lcdState.menuHover;
    lcdBufferInvertPage( 0, 0, 127, menuHover );
    lcdSendBufferPart( 0, 0, 127, menuHover, menuHover );
}
Ejemplo n.º 6
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);
}