void uifLcdPrintJoystickInfo(void) {
halLcdPrintLine("L: Mouse left ", 4, OVERWRITE_TEXT );
halLcdPrintLine("R: Mouse right ", 5, OVERWRITE_TEXT );
halLcdPrintLine("U: Mouse up ", 6, OVERWRITE_TEXT );
halLcdPrintLine("D: Mouse down ", 7, OVERWRITE_TEXT );
halLcdPrintLine("C: Mouse L-button", 8, OVERWRITE_TEXT );
} // uifLcdPrintJoystickInfo
void main(void)
{
WDTCTL = WDTPW+WDTHOLD; // Paramos el watchdog timer
init_botons(); // Iniciamos los botones y Leds.
_enable_interrupt(); // Activamos las interrupciones a nivel global del chip
init_LCD(); // Inicializamos la pantalla
init_UCS(); //Inicialitzem UCS
init_UART(); //Inicialitzem UART
halLcdPrintLine( saludo,linea,textstyle);
linea++;
sprintf(cadena,"bID = %d",bID);
halLcdPrintLine( cadena,linea,textstyle);
Encendre_LED();
TxPacket(0xFE, 2, 0x19);
do
{
P1OUT ^= 0x03;
i = 25000;
do {
i--;
}
while (i != 0);
}
while(1);
}
void uifLcdPrintJoystickInfo(void) {
halLcdPrintLine("L: Skip previous ", 4, OVERWRITE_TEXT );
halLcdPrintLine("R: Skip next ", 5, OVERWRITE_TEXT );
halLcdPrintLine("U: Volume up ", 6, OVERWRITE_TEXT );
halLcdPrintLine("D: Volume down ", 7, OVERWRITE_TEXT );
halLcdPrintLine("C: Play - Pause ", 8, OVERWRITE_TEXT );
} // uifLcdPrintJoystickInfo
void main()
{
WDTCTL = WDTPW | WDTHOLD; // Stop watchdog timer (good dog)
_disable_interrupt();
cron.seconds = 0;
cron.minutes = 0;
cron.hours = 0;
alarm.seconds = 30;
alarm.minutes = 2;
alarm.hours = 0;
initialize_leds();
initialize_lcd();
initialize_buttons();
initialize_timer_b();
initialize_timer_a1();
_enable_interrupt();
halLcdPrintLine(lcd_line, 0, OVERWRITE_TEXT);
write_time_base();
write_cron();
while ( 1 );
}
void doLCD(void){
//Initialize LCD and backlight
// 138 x 110, 4-level grayscale pixels.
halLcdInit();
// halLcdBackLightInit();
// halLcdSetBackLight(0); // 8 for normal
halLcdSetContrast(100);
halLcdClearScreen();
halLcdImage(TI_TINY_BUG, 4, 32, 104, 12 );
halLcdPrintLine("BTstack on ", 0, 0);
halLcdPrintLine("TI MSP430", 1, 0);
halLcdPrintLine("Keyboard", 2, 0);
halLcdPrintLine("Init...", 3, 0);
row = 4;
}
static void prvSetupHardware( void )
{
taskDISABLE_INTERRUPTS();
/* Disable the watchdog. */
WDTCTL = WDTPW + WDTHOLD;
halBoardInit();
LFXT_Start( XT1DRIVE_0 );
hal430SetSystemClock( configCPU_CLOCK_HZ, configLFXT_CLOCK_HZ );
hal430SetSubSystemMasterClock( );
halButtonsInit( BUTTON_ALL );
halButtonsInterruptEnable( BUTTON_SELECT );
/* Initialise the LCD, but note that the backlight is not used as the
library function uses timer A0 to modulate the backlight, and this file
defines vApplicationSetupTimerInterrupt() to also use timer A0 to generate
the tick interrupt. If the backlight is required, then change either the
halLCD library or vApplicationSetupTimerInterrupt() to use a different
timer. Timer A1 is used for the run time stats time base6. */
halLcdInit();
halLcdSetContrast( 100 );
halLcdClearScreen();
halLcdPrintLine( " www.FreeRTOS.org", 0, OVERWRITE_TEXT );
}
/**********************************************************************//**
* @brief Disables the recording peripherals and the microphone.
*
* @param none
*
* @return none
*************************************************************************/
static void shutdownRecord(void)
{
halLcdSetBackLight(lcdBackLightLevelSettingLOCAL);
TBCTL &= ~MC0;
ADC12CTL0 &= ~( ADC12ENC + ADC12ON );
FCTL1 = FWKEY; // Disable Flash write
FCTL3 = FWKEY + LOCK; // Lock Flash memory
// Power-down MSP430 modules
ADC12CTL1 &= ~ADC12CONSEQ_2; // Stop conversion immediately
ADC12CTL0 &= ~ADC12ENC; // Disable ADC12 conversion
ADC12CTL0 = 0; // Switch off ADC12 & ref voltage
TBCTL = 0; // Disable Timer_B
LED_PORT_OUT &= ~LED_1; // Turn off LED
AUDIO_PORT_OUT &= ~MIC_POWER_PIN; // Turn of MIC
AUDIO_PORT_SEL &= ~MIC_INPUT_PIN;
saveSettings(); // Store lastAudioByte to Flash
halLcdPrintLine(" DONE ", 6, INVERT_TEXT | OVERWRITE_TEXT);
halLcdPrintLineCol("Record", 8, 1, OVERWRITE_TEXT);
halLcdPrintLineCol("Play", 8, 12, OVERWRITE_TEXT);
buttonsPressed = 0;
halButtonsInterruptEnable( BUTTON_S1);
}
static void prvSetupHardware( void )
{
/* Convert a Hz value to a KHz value, as required by the Init_FLL_Settle()
function. */
unsigned long ulCPU_Clock_KHz = ( configCPU_CLOCK_HZ / 1000UL );
halBoardInit();
LFXT_Start( XT1DRIVE_0 );
Init_FLL_Settle( ( unsigned short ) ulCPU_Clock_KHz, 488 );
halButtonsInit( BUTTON_ALL );
halButtonsInterruptEnable( BUTTON_SELECT );
/* Initialise the LCD, but note that the backlight is not used as the
library function uses timer A0 to modulate the backlight, and this file
defines vApplicationSetupTimerInterrupt() to also use timer A0 to generate
the tick interrupt. If the backlight is required, then change either the
halLCD library or vApplicationSetupTimerInterrupt() to use a different
timer. Timer A1 is used for the run time stats time base6. */
halLcdInit();
halLcdSetContrast( 100 );
halLcdClearScreen();
halLcdPrintLine( " www.FreeRTOS.org", 0, OVERWRITE_TEXT );
}
/**********************************************************************//**
* @brief Plays back the audio data stored in Flash memory using
* the integrated DMA controller and the DAC12 module.
*
* @param mode The mode of audio record
*
* - AUDIO_TEST_MODE ...for production test
* - AUDIO_DEMO_MODE ...called for user sample code
*
* @return none
*************************************************************************/
void audioPlayBack(unsigned char mode)
{
// Power-up external hardware
AUDIO_PORT_DIR |= AUDIO_OUT_PWR_PIN;
AUDIO_PORT_OUT &= ~AUDIO_OUT_PWR_PIN;
AUDIO_OUT_SEL |= AUDIO_OUT_PIN; // P4.4 = TB4
LED_PORT_OUT |= LED_1; // Turn on LED
if (mode == AUDIO_TEST_MODE)
PlaybackPtr = (unsigned long)(MemstartTest);
else
PlaybackPtr = (unsigned long)(Memstart);
PlaybackPtr ++;
/* Setup Timer0_A for playback */
// Use SMCLK as Timer0_A source, enable overflow interrupt
TBCTL = TBSSEL_2 + TBIE;
// Set output resolution (8 bit. Add 10 counts of headroom for loading TBCCR1
TBCCR0 = 255 ;
TBCCR4 = 255 >> 1; // Default output ~Vcc/2
// Reset OUT1 on EQU1, set on EQU0. Load TBCCR1 when TBR counts to 0.
TBCCTL4 = OUTMOD_7 + CLLD_1;
// Start Timer_B in UP mode (counts up to TBCCR0)
TBCTL |= MC0;
halLcdPrintLine(" Playing ", 6, INVERT_TEXT | OVERWRITE_TEXT);
halLcdPrintLineCol(" Stop ", 8, 1, OVERWRITE_TEXT);
halButtonsInterruptDisable( BUTTON_S2 );
// Activate LPM during DMA playback, wake-up when finished
__bis_SR_register(LPM0_bits + GIE); // Enable interrupts, enter LPM0
__no_operation();
halLcdPrintLine(" DONE ", 6, INVERT_TEXT | OVERWRITE_TEXT);
halButtonsInterruptEnable( BUTTON_S2 );
halLcdPrintLineCol("Record", 8, 1, OVERWRITE_TEXT);
halLcdPrintLineCol("Play", 8, 12, OVERWRITE_TEXT);
// Power-down MSP430 modules
TBCTL = 0; // Disable Timer_B PWM generation
AUDIO_OUT_SEL &= ~AUDIO_OUT_PIN; // P4.4 = TB4
LED_PORT_OUT &= ~LED_1; // Turn off LED
buttonsPressed = 0;
}
/**********************************************************************//**
* @brief Global API call to record audio on the mike.
*
* - Initializes the record using setupRecord()
* - Erases the memory reserved for audio recording
* - Records until the memory is full using record()
* - Shuts down the record using shutdownRecord()
*
* @param mode The mode of audio record
*
* - AUDIO_TEST_MODE ...for production test
* - AUDIO_DEMO_MODE ...called for user sample code
*
* @return none
*************************************************************************/
void audioRecord(unsigned char mode)
{
unsigned char i;
setupRecord();
halLcdPrintLine(" Erasing ", 6, INVERT_TEXT | OVERWRITE_TEXT);
halLcdPrintLineCol("----", 8, 12, OVERWRITE_TEXT);
// Not used in User Experience sample code
if (mode == AUDIO_TEST_MODE)
{
flashErase(MemstartTest, Memend);
__data16_write_addr((unsigned short)&DMA0DA, MemstartTest);
DMA0SZ = (long) (Memend - MemstartTest);
record();
if (DMA0SZ != ( long) (Memend - MemstartTest))
lastAudioByte = Memend - DMA0SZ;
else
lastAudioByte = Memend;
}
// Always used in User Experience sample code
else
{
flashEraseBank(AUDIO_MEM_START[0]);
flashEraseBank(AUDIO_MEM_START[1]);
flashEraseBank(AUDIO_MEM_START[2]);
flashErase(AUDIO_MEM_START[3], AUDIO_MEM_START[4]);
for (i=0;i<3;i++)
{
__data16_write_addr((unsigned short)&DMA0DA, AUDIO_MEM_START[i]);
DMA0SZ = AUDIO_MEM_START[i+1] - AUDIO_MEM_START[i] - 1;
record();
if (DMA0SZ != AUDIO_MEM_START[i+1] - AUDIO_MEM_START[i] - 1)
{
lastAudioByte = AUDIO_MEM_START[i+1] - DMA0SZ;
break;
}
else lastAudioByte = AUDIO_MEM_START[i+1]-1;
}
}
shutdownRecord();
}
__interrupt void Port2_ISR(void)
{
//Inicializamos los leds para que parpadeen en fase (S1) o alternando (S2):
P2IE &= 0xC0; //interrupciones botones S1 y S2 (P2.6 y P2.7) desactivadas
P2IE &= 0x3E; //interrupciones joystick (2.1-2.5) desactivadas
switch (P2IFG) {
case 0x40: //Boton S1
txchar=chartest;
P1OUT |= 0x03; //Leds parpadean a la vez
estado_botones=1;
break;
case 0x80: //Boton S2
txchar=~chartest;
P1OUT |= 0x01; //Leds parpadean en alternancia
estado_botones=2;
break;
case 0x02: // joystick left
if (bID > 0x00) bID--;
else bID = 0xFE;
break;
case 0x04: // joystick right
if (bID < 0xFE) bID++;
else bID = 0;
break;
case 0x08: // joystick center
P1OUT |= 0x01;P1OUT &= 0xFD;//Leds parpadean alternando
break;
case 0x10: // joystick up
if (bID < 0xF0) bID+=0x0F;
else bID = 0;
break;
case 0x20: // joystick down
if (bID > 0x0F) bID-=0x0F;
else bID = 0xFE;
break;
default: break;
}
sprintf(cadena,"bID = %d",bID);
halLcdPrintLine( cadena,linea,OVERWRITE_TEXT );
P2IFG = 0; //limpiamos todas las interrupciones
P2IE |= 0xC0; //interrupciones botones S1 y S2 (P2.6 y P2.7) reactivadas
P2IE |= 0x3E; //interrupciones joystick (2.1-2.5) reactivadas
return;
}
__interrupt void update_cron()
{
halTimer_a1_disableInterruptCCR0();
// Update the chronometer
{
if ( !stop_cron )
{
cron.seconds++;
if ( cron.seconds == 60 )
{
cron.seconds = 0;
cron.minutes++;
}
if ( cron.minutes == 60 )
{
cron.minutes = 0;
cron.hours++;
}
if ( cron.hours == 24 )
cron.hours = 0;
write_cron();
}
}
// Update alarm! ACHTUNG!
{
if ( !disabled_alarm && cron.seconds == alarm.seconds
&& cron.minutes == alarm.minutes && cron.hours == alarm.hours )
{
halLcdPrintLine("ALARM ALARM ALARM", LINE_ALARM, OVERWRITE_TEXT);
disabled_alarm = TRUE;
}
}
halTimer_a1_enableInterruptCCR0();
}
/**********************************************************************//**
* @brief Executes the record.
*
* - Unlocks the Flash and initialize to long-word write mode
* - Initializes the Timer to trigger ADC12 samples
* - When the operation is done, locks the flash, disables the DMA, and stops
* the timer
*
* @param none
*
* @return none
*************************************************************************/
static void record(void)
{
halLcdPrintLine(" Recording ", 6, INVERT_TEXT | OVERWRITE_TEXT);
halLcdPrintLineCol("Stop", 8, 12, OVERWRITE_TEXT);
FCTL3 = FWKEY; // Unlock the flash for write
FCTL1 = FWKEY + BLKWRT;
DMA0CTL = DMADSTINCR_3 + DMAEN + DMADSTBYTE + DMASRCBYTE + DMAIE;
// Enable Long-Word write, all 32 bits will be written once
// 4 bytes are loaded
TBCCTL1 &= ~CCIFG;
TBCTL |= MC0;
__bis_SR_register(LPM0_bits + GIE); // Enable interrupts, enter LPM0
__no_operation();
TBCTL &= ~MC0;
DMA0CTL &= ~( DMAEN + DMAIE);
FCTL3 = FWKEY + LOCK; // Lock the flash from write
}
static void onProgramStart()
{
halAccelerometerInit();
halTimer_b_enableInterruptCCR0();
halLcdPrintLine("ACCEL. VECTOR", 0, INVERT_TEXT);
/* 012345
* 0 ACCEL.VECTOR
* 1
* 2 X: 0000
* 3 Y: 0000
* 4 Z: 0000
* */
halLcdPrintLineCol("X:", 2, 2, OVERWRITE_TEXT);
halLcdPrintLineCol("Y:", 3, 2, OVERWRITE_TEXT);
halLcdPrintLineCol("Z:", 4, 2, OVERWRITE_TEXT);
__test_accel_killProgram = FALSE;
__test_accel_updateVector = FALSE;
TB0CCR0 = 32 * 25; // Each 25 milliseconds it will update the window state
}
/**********************************************************************//**
* @brief Executes the "PMM-MCLK" menu option in the User Experience
* example code. This menu option allows one to change the frequency
* of operation for the MSP430 and the VCore setting.
*
* @param none
*
* @return none
*************************************************************************/
void menuPMMMCLK( void )
{
unsigned char menuLeftPos = 2, menuRightPos = 0, menuRightMaxAllowed = 5;
unsigned char ledOn, quit = 0;
volatile unsigned int i;
halButtonsInterruptDisable( BUTTON_ALL );
halButtonsInterruptEnable( BUTTON_SELECT + BUTTON_S1 + \
BUTTON_S2 + BUTTON_RIGHT );
halAccelerometerShutDown();
halLcdClearScreen();
halBoardOutputSystemClock();
halLcdPrintLineCol(&VcoreText[0], 0, 1, OVERWRITE_TEXT );
for (i=0;i < MCLK_MENU_MAX+1; i++)
halLcdPrintLineCol(&MCLKText[i*6], i, 12, OVERWRITE_TEXT );
halLcdPrintLineCol(&VcoreText[menuLeftPos*6 + 6], \
menuLeftPos+1, 1, INVERT_TEXT | OVERWRITE_TEXT);
halLcdPrintLineCol(&MCLKText[menuRightPos*6 + 6], \
menuRightPos+1, 12, INVERT_TEXT | OVERWRITE_TEXT);
buttonsPressed = 0;
for (i = menuRightMaxAllowed; i < MCLK_MENU_MAX; i++)
{
halLcdLine(96, 12*(i+1)+6, 136, 12*(i+1)+6, PIXEL_ON);
halLcdLine(96, 12*(i+1)+7, 136, 12*(i+1)+7, PIXEL_ON);
}
ledOn = 0;
halLcdPrintLine(" LED", 6, 0);
halLcdPrintLine(" OFF", 7, 0);
halLcdImage(IMG_RIGHT_FILLED, 4, 32, 10, 75);
halBoardSetVCore(menuLeftPos);
halBoardSetSystemClock(menuRightPos);
while (!quit)
{
// The LED can be enabled to show the relative difference between
// frequencies of operation.
while (!buttonsPressed)
if (ledOn)
{
LED_PORT_OUT ^= LED_1;
for (i=0; i < 0xFFFF; i++)
if (buttonsPressed)
break;
}
else
{
// To emulate a real application instead of continuous jumps, use nops
__no_operation();
__no_operation();
__no_operation();
__no_operation();
__no_operation();
__no_operation();
__no_operation();
__no_operation();
__no_operation();
}
if (buttonsPressed & BUTTON_S1)
{
/*
* Disabled for MSP430F5438 RTM Silicon
halLcdPrintLineCol(&VcoreText[menuLeftPos*6 + 6], menuLeftPos+1, \
1, OVERWRITE_TEXT);
if (++ menuLeftPos >= VCORE_MENU_MAX)
{
menuLeftPos = 0;
menuRightMaxAllowed = MAX_MCLK_ALLOWED[ menuLeftPos ];
if (menuRightPos >= menuRightMaxAllowed)
{
halLcdPrintLineCol(&MCLKText[menuRightPos*6 + 6], menuRightPos+1, \
12, OVERWRITE_TEXT);
menuRightPos = menuRightMaxAllowed - 1;
halLcdPrintLineCol(&MCLKText[menuRightPos*6 + 6], menuRightPos+1, \
12, INVERT_TEXT | OVERWRITE_TEXT);
}
for (i = menuRightMaxAllowed; i < MCLK_MENU_MAX; i++)
{
halLcdLine(96, 12*(i+1)+6, 136, 12*(i+1)+6, PIXEL_ON);
halLcdLine(96, 12*(i+1)+7, 136, 12*(i+1)+7, PIXEL_ON);
}
}
else
{
for (i=menuRightMaxAllowed+1; i< MAX_MCLK_ALLOWED[menuLeftPos]+1; i ++)
halLcdPrintLineCol(&MCLKText[i*6], i, 12, OVERWRITE_TEXT );
menuRightMaxAllowed = MAX_MCLK_ALLOWED[menuLeftPos];
}
halLcdPrintLineCol(&VcoreText[menuLeftPos*6 + 6], menuLeftPos+1, \
1, INVERT_TEXT | OVERWRITE_TEXT);
*/
}
if ( buttonsPressed & BUTTON_S2 )
{
halLcdPrintLineCol(&MCLKText[menuRightPos*6 + 6], \
menuRightPos+1, 12, OVERWRITE_TEXT);
if ( ++menuRightPos >= menuRightMaxAllowed )
menuRightPos = 0;
halLcdPrintLineCol(&MCLKText[menuRightPos*6 + 6], \
menuRightPos+1, 12, INVERT_TEXT| OVERWRITE_TEXT);
}
if ( buttonsPressed & BUTTON_RIGHT )
{
ledOn = 1 - ledOn;
if ( ledOn )
halLcdPrintLineCol("ON ", 7, 6, OVERWRITE_TEXT);
else
{
halLcdPrintLineCol("OFF", 7, 6, OVERWRITE_TEXT);
LED_PORT_OUT &= ~LED_1;
}
}
if ( buttonsPressed & (BUTTON_S1 | BUTTON_S2) )
{
halBoardSetVCore(menuLeftPos);
halBoardSetSystemClock(menuRightPos);
//halBoardDisableSVS();
}
if ( buttonsPressed & BUTTON_SELECT )
quit = 1;
buttonsPressed = 0;
}
halBoardSetSystemClock( SYSCLK_16MHZ );
halBoardStopOutputSystemClock();
LED_PORT_OUT &= ~LED_1;
}
static void prvLCDTask( void *pvParameters )
{
xQueueMessage xReceivedMessage;
/* Buffer into which strings are formatted and placed ready for display on the
LCD. Note this is a static variable to prevent it being allocated on the task
stack, which is too small to hold such a variable. The stack size is configured
when the task is created. */
static char cBuffer[ 512 ];
unsigned char ucLine = 1;
/* This function is the only function that uses printf(). If printf() is
used from any other function then some sort of mutual exclusion on stdout
will be necessary.
This is also the only function that is permitted to access the LCD.
First print out the number of bytes that remain in the FreeRTOS heap. This
can be viewed in the terminal IO window within the IAR Embedded Workbench. */
printf( "%d bytes of heap space remain unallocated\n", ( int ) xPortGetFreeHeapSize() );
/* Just as a test of the port, and for no functional reason, check the task
parameter contains its expected value. */
if( pvParameters != mainTASK_PARAMETER_CHECK_VALUE )
{
halLcdPrintLine( "Invalid parameter", ucLine, OVERWRITE_TEXT );
ucLine++;
}
for( ;; )
{
/* Wait for a message to be received. Using portMAX_DELAY as the block
time will result in an indefinite wait provided INCLUDE_vTaskSuspend is
set to 1 in FreeRTOSConfig.h, therefore there is no need to check the
function return value and the function will only return when a value
has been received. */
xQueueReceive( xLCDQueue, &xReceivedMessage, portMAX_DELAY );
/* Clear the LCD if no room remains for any more text output. */
if( ucLine > mainMAX_LCD_LINES )
{
halLcdClearScreen();
ucLine = 0;
}
/* What is this message? What does it contain? */
switch( xReceivedMessage.cMessageID )
{
case mainMESSAGE_BUTTON_UP : /* The button poll task has just
informed this task that the up
button on the joystick input has
been pressed or released. */
sprintf( cBuffer, "Button up = %d", ( int ) xReceivedMessage.ulMessageValue );
break;
case mainMESSAGE_BUTTON_SEL : /* The select button interrupt
just informed this task that the
select button was pressed.
Generate a table of task run time
statistics and output this to
the terminal IO window in the IAR
embedded workbench. */
printf( "\nTask\t Abs Time\t %%Time\n*****************************************" );
vTaskGetRunTimeStats( ( signed char * ) cBuffer );
printf( cBuffer );
/* Also print out a message to
the LCD - in this case the
pointer to the string to print
is sent directly in the
ulMessageValue member of the
message. This just demonstrates
a different communication
technique. */
sprintf( cBuffer, "%s", ( char * ) xReceivedMessage.ulMessageValue );
break;
case mainMESSAGE_STATUS : /* The tick interrupt hook
function has just informed this
task of the system status.
Generate a string in accordance
with the status value. */
prvGenerateStatusMessage( cBuffer, xReceivedMessage.ulMessageValue );
break;
default :
sprintf( cBuffer, "Unknown message" );
break;
}
/* Output the message that was placed into the cBuffer array within the
switch statement above, then move onto the next line ready for the next
message to arrive on the queue. */
halLcdPrintLine( cBuffer, ucLine, OVERWRITE_TEXT );
ucLine++;
}
}
/**************************************************************************
* ESCRIBIR LINEA
*
* Datos de entrada: Linea, indica la linea a escribir
* String, cadena de caracteres que vamos a introducir
*
* Sin datos de salida
*
**************************************************************************/
void write(char string[], unsigned char line)
{
halLcdPrintLine(string, line, OVERWRITE_TEXT); //superponemos la nueva palabra introducida, haya o no algo.
}
int main(void) {
uint8_t currState;
uint8_t targetState;
uint16_t readbcLength;
uint32_t nwkId;
uint8_t errorCheckInterval = 100;
// Stop watchdog timer to prevent time out reset
WDTCTL = WDTPW + WDTHOLD;
// Initialize the MCU and board peripherals
halBoardInit();
halBoardStartXT1();
halBoardSetSystemClock(SYSCLK_16MHZ);
halButtonsInit(BUTTON_ALL);
halLcdInit();
halLcdBackLightInit();
halLcdSetContrast(90);
halLcdSetBackLight(10);
halLcdClearScreen();
halLcdPrintLine(" CC85XX SLAVE ", 0, OVERWRITE_TEXT );
halLcdPrintLine(" ", 1, OVERWRITE_TEXT );
halLcdPrintLine("S1: Power toggle ", 2, OVERWRITE_TEXT );
halLcdPrintLine("S2: Pairing start", 3, OVERWRITE_TEXT );
uifLcdPrintJoystickInfo();
// Wipe remote control information
memset(&ehifRcSetDataParam, 0x00, sizeof(ehifRcSetDataParam));
// Initialize EHIF IO
ehifIoInit();
// Reset into the application
ehifSysResetPin(true);
currState = CC85XX_STATE_ALONE;
targetState = CC85XX_STATE_ACTIVE;
// Get the last used network ID from CC85XX non-volatile storage
initParam();
ehifCmdParam.nvsGetData.index = 0;
ehifCmdExecWithRead(EHIF_EXEC_ALL, EHIF_CMD_NVS_GET_DATA,
sizeof(EHIF_CMD_NVS_GET_DATA_PARAM_T), &ehifCmdParam,
sizeof(EHIF_CMD_NVS_GET_DATA_DATA_T), &ehifCmdData);
nwkId = ehifCmdData.nvsGetData.data;
// Handle illegal default network IDs that may occur first time after programming
if ((nwkId == 0x00000000) || (nwkId == 0xFFFFFFFF)) {
nwkId = 0xFFFFFFFE;
}
// Main loop
while (1) {
// Wait 10 ms
EHIF_DELAY_MS(10);
// Perform action according to edge-triggered button events (debouncing with 100 ms delay)
switch (pollButtons()) {
// POWER TOGGLE
case BUTTON_S1:
if (currState == CC85XX_STATE_OFF) {
targetState = CC85XX_STATE_ACTIVE;
} else {
targetState = CC85XX_STATE_OFF;
}
break;
// PAIRING TRIGGER
case BUTTON_S2:
if (currState != CC85XX_STATE_OFF) {
targetState = CC85XX_STATE_PAIRING;
}
break;
}
// Run the state machine
if (currState != targetState) {
if (currState == CC85XX_STATE_OFF) {
// HANDLE POWER ON
// Ensure known state (power state 5)
ehifSysResetPin(true);
currState = CC85XX_STATE_ALONE;
} else if (targetState == CC85XX_STATE_OFF) {
// HANDLE POWER OFF
// Ensure known state (power state 5)
ehifSysResetPin(true);
currState = CC85XX_STATE_ALONE;
// Set power state 0
ehifCmdParam.pmSetState.state = 0;
ehifCmdExec(EHIF_CMD_PM_SET_STATE, sizeof(EHIF_CMD_PM_SET_STATE_PARAM_T), &ehifCmdParam);
currState = CC85XX_STATE_OFF;
} else if (targetState == CC85XX_STATE_PAIRING) {
// HANDLE PAIRING
// Let the last executed EHIF command complete, with 5 second timeout
ehifWaitReadyMs(5000);
// Disconnect if currently connected
if (ehifGetStatus() & BV_EHIF_STAT_CONNECTED) {
initParam();
// All parameters should be zero
ehifCmdExec(EHIF_CMD_NWM_DO_JOIN, sizeof(EHIF_CMD_NWM_DO_JOIN_PARAM_T), &ehifCmdParam);
}
// Search for one protocol master with pairing signal enabled for 10 seconds
initParam();
ehifCmdParam.nwmDoScan.scanTo = 1000;
ehifCmdParam.nwmDoScan.scanMax = 1;
ehifCmdParam.nwmDoScan.reqPairingSignal = 1;
ehifCmdParam.nwmDoScan.reqRssi = -128;
ehifCmdExecWithReadbc(EHIF_EXEC_CMD, EHIF_CMD_NWM_DO_SCAN,
sizeof(EHIF_CMD_NWM_DO_SCAN_PARAM_T), &ehifCmdParam,
NULL, NULL);
// Fetch network information once ready
ehifWaitReadyMs(12000);
readbcLength = sizeof(ehifNwmDoScanData);
ehifCmdExecWithReadbc(EHIF_EXEC_DATA, EHIF_CMD_NWM_DO_SCAN,
0, NULL,
&readbcLength, &ehifNwmDoScanData);
// If found ...
if (readbcLength == sizeof(EHIF_CMD_NWM_DO_SCAN_DATA_T)) {
// Update the network ID to be used next
nwkId = ehifNwmDoScanData.deviceId;
// Place the new network ID in CC85XX non-volatile storage
initParam();
ehifCmdParam.nvsSetData.index = 0;
ehifCmdParam.nvsSetData.data = ehifNwmDoScanData.deviceId;
ehifCmdExec(EHIF_CMD_NVS_SET_DATA, sizeof(EHIF_CMD_NVS_SET_DATA_PARAM_T), &ehifCmdParam);
}
// Done
currState = CC85XX_STATE_ALONE;
targetState = CC85XX_STATE_ACTIVE;
} else if (targetState == CC85XX_STATE_ACTIVE) {
// We're disconnected. Proceed only if EHIF is ready, so that power toggle and pairing
// buttons can still be operated
uint16_t status = ehifGetStatus();
if (status & BV_EHIF_STAT_CMD_REQ_RDY) {
// Perform join operation first and then activate audio channels. We're using remote
// volume control
if (!(status & BV_EHIF_STAT_CONNECTED)) {
// Enable disconnection notification to avoid unnecessary EHIF activity while active
initParam();
ehifCmdParam.ehcEvtClr.clearedEvents = BV_EHIF_EVT_NWK_CHG;
ehifCmdExec(EHIF_CMD_EHC_EVT_CLR, sizeof(EHIF_CMD_EHC_EVT_CLR_PARAM_T), &ehifCmdParam);
initParam();
ehifCmdParam.ehcEvtMask.irqGioLevel = 0;
ehifCmdParam.ehcEvtMask.eventFilter = BV_EHIF_EVT_NWK_CHG;
ehifCmdExec(EHIF_CMD_EHC_EVT_MASK, sizeof(EHIF_CMD_EHC_EVT_MASK_PARAM_T), &ehifCmdParam);
// Not connected: Start JOIN operation
initParam();
ehifCmdParam.nwmDoJoin.joinTo = 100;
ehifCmdParam.nwmDoJoin.deviceId = nwkId;
ehifCmdExec(EHIF_CMD_NWM_DO_JOIN, sizeof(EHIF_CMD_NWM_DO_JOIN_PARAM_T), &ehifCmdParam);
} else {
// Connected: Subscribe to audio channels (0xFF = unused)
memset(&ehifCmdParam, 0xFF, sizeof(EHIF_CMD_NWM_ACH_SET_USAGE_PARAM_T));
ehifCmdParam.nwmAchSetUsage.pAchUsage[0] = 0; // Front left -> I2S LEFT
ehifCmdParam.nwmAchSetUsage.pAchUsage[1] = 1; // Front right -> I2S RIGHT
ehifCmdExec(EHIF_CMD_NWM_ACH_SET_USAGE, sizeof(EHIF_CMD_NWM_ACH_SET_USAGE_PARAM_T), &ehifCmdParam);
currState = CC85XX_STATE_ACTIVE;
}
}
}
} else {
// Only OFF and ACTIVE are permanent target states. SCAN is only a temporary target state.
// In the OFF state we do nothing, so only need to handle the ACTIVE state.
if (currState == CC85XX_STATE_ACTIVE) {
// Detect network disconnection without generating noise on the SPI interface
if (EHIF_INTERRUPT_IS_ACTIVE()) {
currState = CC85XX_STATE_ALONE;
}
// Perform error checking at 10 ms * 100 = 1 second intervals:
// - No timeouts or SPI errors shall have occurred
// - We should be connected unless disconnection has been signalized
if (--errorCheckInterval == 0) {
errorCheckInterval = 100;
uint16_t status = ehifGetStatus();
if (ehifGetWaitReadyError() || (status & BV_EHIF_EVT_SPI_ERROR) ||
(!(status & BV_EHIF_STAT_CONNECTED) && !(status & BV_EHIF_EVT_NWK_CHG))) {
// The device is in an unknown state -> restart everything
ehifSysResetPin(true);
currState = CC85XX_STATE_ALONE;
}
}
// If the network connection is up and running...
if (currState == CC85XX_STATE_ACTIVE) {
// Send remote control commands (mouse or play control, depending on which uif file
// is included in the build)
if (uifPollFunc(&ehifRcSetDataParam)) {
ehifCmdExec(EHIF_CMD_RC_SET_DATA, sizeof(EHIF_CMD_RC_SET_DATA_PARAM_T), &ehifRcSetDataParam);
}
}
}
}
}
} // main
__interrupt void on_button_interruption(void)
{
halButtons_setInterruptions(BUTTON_ALL, OFF);
halJoystick_setInterruptions(JOYSTICK_ALL, OFF);
switch ( P2IFG )
{
case JOYSTICK_RIGHT:
edit_mode++;
if ( edit_mode > EDIT_SECONDS )
edit_mode = OFF;
break;
case JOYSTICK_LEFT:
edit_mode--;
if ( edit_mode < 0 )
edit_mode = EDIT_SECONDS;
break;
case JOYSTICK_UP:
if ( time_base < 10000 )
time_base *= 10;
break;
case JOYSTICK_DOWN:
if ( time_base > 1 )
time_base /= 10;
break;
case JOYSTICK_CENTER:
stop_cron = ~stop_cron;
break;
case BUTTON_S1:
increase_cron_unit();
halLcdPrintLine(lcd_clear, LINE_CRON, OVERWRITE_TEXT);
write_cron();
break;
case BUTTON_S2:
decrease_cron_unit();
halLcdPrintLine(lcd_clear, LINE_CRON, OVERWRITE_TEXT);
write_cron();
break;
}
write_time_base();
halLcdPrintLine(lcd_clear, LINE_TIME_UNIT_SEL, OVERWRITE_TEXT);
if ( edit_mode != OFF )
{
switch ( edit_mode )
{
case EDIT_HOURS:
halLcdPrintLineCol("HH", LINE_TIME_UNIT_SEL, 1, OVERWRITE_TEXT);
break;
case EDIT_MINUTES:
halLcdPrintLineCol("MM", LINE_TIME_UNIT_SEL, 4, OVERWRITE_TEXT);
break;
case EDIT_SECONDS:
halLcdPrintLineCol("SS", LINE_TIME_UNIT_SEL, 7, OVERWRITE_TEXT);
break;
}
}
halTimer_b_setCCRTimedInterruption(TIMER_CCR0, time_multiplier * time_base);
P2IFG = 0;
halButtons_setInterruptions(BUTTON_ALL, ON);
halJoystick_setInterruptions(JOYSTICK_ALL, ON);
}
/**************************************************************************
* BORRAR LINEA
*
* Datos de entrada: Linea, indica la linea a borrar
*
* Sin datos de salida
*
**************************************************************************/
void clearLine(unsigned char line)
{
halLcdPrintLine(borrado, line, OVERWRITE_TEXT); //incluimos una linea en blanco
}
static void prvLCDTask( void *pvParameters )
{
xQueueMessage xReceivedMessage;
/* Buffer into which strings are formatted and placed ready for display on the
LCD. Note this is a static variable to prevent it being allocated on the task
stack, which is too small to hold such a variable. The stack size is configured
when the task is created. */
static char cBuffer[ 50 ];
unsigned char ucLine = 1;
/* Now the scheduler has been started (it must have been for this task to
be running), start the check timer too. The call to xTimerStart() will
block until the command has been accepted. */
if( xCheckTimer != NULL )
{
xTimerStart( xCheckTimer, portMAX_DELAY );
}
/* This is the only function that is permitted to access the LCD.
First print out the number of bytes that remain in the FreeRTOS heap. This
is done after a short delay to ensure all the demo tasks have created all
the objects they are going to use. */
vTaskDelay( mainTIMER_TEST_PERIOD * 10 );
sprintf( cBuffer, "%d heap free", ( int ) xPortGetFreeHeapSize() );
halLcdPrintLine( cBuffer, ucLine, OVERWRITE_TEXT );
ucLine++;
/* Just as a test of the port, and for no functional reason, check the task
parameter contains its expected value. */
if( pvParameters != mainTASK_PARAMETER_CHECK_VALUE )
{
halLcdPrintLine( "Invalid parameter", ucLine, OVERWRITE_TEXT );
ucLine++;
}
for( ;; )
{
/* Wait for a message to be received. Using portMAX_DELAY as the block
time will result in an indefinite wait provided INCLUDE_vTaskSuspend is
set to 1 in FreeRTOSConfig.h, therefore there is no need to check the
function return value and the function will only return when a value
has been received. */
xQueueReceive( xLCDQueue, &xReceivedMessage, portMAX_DELAY );
/* Clear the LCD if no room remains for any more text output. */
if( ucLine > mainMAX_LCD_LINES )
{
halLcdClearScreen();
ucLine = 0;
}
/* What is this message? What does it contain? */
switch( xReceivedMessage.cMessageID )
{
case mainMESSAGE_BUTTON_UP : /* The button poll task has just
informed this task that the up
button on the joystick input has
been pressed or released. */
sprintf( cBuffer, "Button up = %d", ( int ) xReceivedMessage.ulMessageValue );
break;
case mainMESSAGE_BUTTON_SEL : /* The select button interrupt
just informed this task that the
select button has been pressed.
In this case the pointer to the
string to print is sent directly
in the ulMessageValue member of
the message. This just
demonstrates a different
communication technique. */
sprintf( cBuffer, "%s", ( char * ) xReceivedMessage.ulMessageValue );
break;
case mainMESSAGE_STATUS : /* The tick interrupt hook
function has just informed this
task of the system status.
Generate a string in accordance
with the status value. */
prvGenerateStatusMessage( cBuffer, xReceivedMessage.ulMessageValue );
break;
default : sprintf( cBuffer, "Unknown message" );
break;
}
/* Output the message that was placed into the cBuffer array within the
switch statement above, then move onto the next line ready for the next
message to arrive on the queue. */
halLcdPrintLine( cBuffer, ucLine, OVERWRITE_TEXT );
ucLine++;
}
}
void write_time_base()
{
sprintf(lcd_line, " SEC: %07u", time_multiplier * time_base);
halLcdPrintLine(lcd_line, LINE_TIMER_SECONDS, OVERWRITE_TEXT);
}
// put 'lineBuffer' on screen
void showLine(void){
clearLine(row);
halLcdPrintLine(lineBuffer, row, 0);
printf("LCD: %s\n\r", lineBuffer);
}
void printLine(char *text){
printf("LCD: %s\n\r", text);
halLcdPrintLine(text, row++, 0);
}
void write_cron()
{
sprintf(lcd_line, " %02d:%02d:%02d", cron.hours, cron.minutes, cron.seconds);
halLcdPrintLine(lcd_line, LINE_CRON, OVERWRITE_TEXT);
}