/***************************************************EEPROM*****************************************
Writes and Reads a character to and from EEPROM
*****************************************************TEST*****************************************/
void eeprom_test()
{
unsigned char eeprom_address=0x00, write_char = 'X', read_char;
UART_Printf("Connections SCL->P0.6 SDA->P0.7");
UART_Printf("Make connections and hit 'k' to test! ");
while(UART_RxChar()!='k');
UART_TxString("\n\rEeprom Write: "); //Print the message on UART
UART_TxChar(write_char); //Print the char to be written
EEPROM_WriteByte(eeprom_address,write_char); // Write the data at memoryLocation 0x00
UART_TxString(" Eeprom Read: "); //Print the message on UART
read_char = EEPROM_ReadByte(eeprom_address); // Read the data from memoryLocation 0x00
UART_TxChar(read_char);
}
void UART_TxNumber(unsigned int num)
{
UART_TxChar((num/10000)+0x30);
num=num%10000;
UART_TxChar((num/1000)+0x30);
num=num%1000;
UART_TxChar((num/100)+0x30);
num=num%100;
UART_TxChar((num/10)+0x30);
UART_TxChar((num%10)+0x30);
}
int main(void)
{
uint16_t adc_result;
int i;
char value[10];
sbi(DDRB, 4);
sbi(DDRC, 5);
cbi(PORTB,4);
sbi(PORTC,5);
UART_init(250000);
InitADC();
sei();
while(1)
{
adc_result=ReadADC(2); // Read Analog value from channel-2
// Voltage = adc_result*5/1024
// Temperature = (V - 1035 mV)/(-5.5 (mV/oC))
itoa(adc_result,value,10);
for(i=0;i<=2;i++){
UART_TxChar(value[i]);}
UART_TxStr("\n\r\0");
PORTB ^= (1<<PB4);
_delay_ms(100);
}
}
/*
ShowProducts routine
This routine shows the products found in each bay.
*/
void ShowProducts(void)
{
Uint8 Pos;
UART_TxStr("Inputs are:");
for (Pos = 0; Pos <= RightTablet; Pos++) {
UART_TxChar(' ');
UART_TxNum(InputPresent[Pos], 1);
}
UART_TxStr("\r\nOutputs are:");
for (Pos = LeftBay; Pos <= RightBay; Pos++) {
UART_TxChar(' ');
UART_TxNum(BayProduct[Pos], 1);
}
UART_TxNewLine();
}
int main()
{
UART_Init(9600); // Initialize UARt at 9600 baud rate
while(1)
{
UART_TxChar('e');
}
return (0);
}
/* Compute the 16-bit crc of the loaded application.
* Syntax: crc
* Response: uint16_t
*/
static void CalcAppCRC_CMD(const char *cmdbuf, uint8_t len)
{
union
{
uint16_t val;
uint8_t by[2];
} crc;
crc.val = CalculateAppCRC();
UART_TxHexByte(crc.by[1]);
UART_TxHexByte(crc.by[0]);
UART_TxChar('\r');
}
void UART_TxDecimalNumber(uint32_t var_decNumber_u32, uint8_t var_numOfDigitsToTransmit_u8)
{
uint8_t i=0,a[10];
if(var_decNumber_u32==0)
{
/* If the number is zero then update the array with the same for transmitting */
for(i=0;((i<var_numOfDigitsToTransmit_u8) && (i<C_MaxDigitsToTransmit_U8)) ;i++)
a[i] = 0x00;
}
else
{
for(i=0;i<var_numOfDigitsToTransmit_u8;i++)
{
/* Continue extracting the digits from right side
till the Specified var_numOfDigitsToTransmit_u8 */
if(var_decNumber_u32!=0)
{
/* Extract the digits from the number till it becomes zero.
First get the remainder and divide the number by 10 each time.
If var_number_u32 = 123 then extracted remainder will be 3 and number will be 12.
The process continues till it becomes zero or max digits reached*/
a[i]=util_GetMod32(var_decNumber_u32,10);
var_decNumber_u32=var_decNumber_u32/10;
}
else if( (var_numOfDigitsToTransmit_u8 == C_DefaultDigitsToTransmit_U8) ||
(var_numOfDigitsToTransmit_u8 > C_MaxDigitsToTransmit_U8))
{
/* Stop the iteration if the Max number of digits are reached or
the user expects exact(Default) digits in the number to be transmitted */
break;
}
else
{
/*In case user expects more digits to be transmitted than the actual digits in number,
then update the remaining digits with zero.
Ex: var_number_u32 is 123 and user wants five digits then 00123 has to be transmitted */
a[i]=0;
}
}
}
while(i)
{
/* Finally get the ascii values of the digits and transmit*/
UART_TxChar(util_Dec2Ascii(a[i-1]));
i--;
}
}
/* start the main program */
void main()
{
char ch;
/* Initilize the UART before Transmitting/Receiving any data */
UART_Init();
while(1)
{
/*Receive and Transmit a char indefinitely at 9600 baud rate */
ch=UART_RxChar(); // Receive a char and store it in "ch"
UART_TxChar(ch); //Transmit the received char
}
}
void UART_RxString(uint8_t var_uartChannel_u8, char *ptr_stringPointer_u8)
{
char ch;
while(1)
{
ch=UART_RxChar(var_uartChannel_u8); //Receive a char
UART_TxChar(var_uartChannel_u8,ch); //Echo back the received char
if((ch=='\r') || (ch=='\n')) //read till enter key is pressed
{ //once enter key is pressed null terminate the string
*ptr_stringPointer_u8=0; //and break the loop
break;
}
*ptr_stringPointer_u8=ch; //copy the char into string and increment the pointer
ptr_stringPointer_u8++;
}
}
/*---------------------------------------------------------------------------------
void UART_RxString(char *string_ptr)
----------------------------------------------------------------------------------
* I/P Arguments: *string_ptr
Address of the string where the received data needs to be stored
* Return value : none
* description :
1.This function is used to receive a ASCII string through UART
till the carriage_return/New_line
2.The string_ptr points to the begining of the string and each
time UART_RxChar() function is called to receive a char and copy
it into the buffer(STRING) and incrment string_ptr.
3.Once the carriage_return/New_line is encountered the loop
is breaked and the String is NULL terminated.
*****NOTE*******:
1.The received char is ECHOED back,
if not required then comment UART_TxChar(ch) in the code.
2.BackSlash is not taken care.
___________________________________________________________________________________*/
void UART_RxString(char *string_ptr)
{
char ch;
while(1)
{
ch=UART_RxChar(); //Reaceive a char
UART_TxChar(ch); //Echo back the received char
if((ch=='\r') || (ch=='\n')) //read till enter key is pressed
{ //once enter key is pressed
*string_ptr=0; //null terminate the string
break; //and break the loop
}
*string_ptr=ch; //copy the char into string.
string_ptr++; //and increment the pointer
}
}
void UART_TxFloatNumber(uint8_t var_uartChannel_u8, float var_floatNumber_f32)
{
uint32_t var_tempNumber_u32;
/* Dirty hack to support the floating point by extracting the integer and fractional part.
1.Type cast the number to int to get the integer part.
2.transmit the extracted integer part followed by a decimal point(.).
3.Later the integer part is made zero by subtracting with the extracted integer value.
4.Finally the fractional part is multiplied by 100000 to support 6-digit precision */
var_tempNumber_u32 = (uint32_t) var_floatNumber_f32;
UART_TxNumber(var_uartChannel_u8,C_DECIMAL_U8,var_tempNumber_u32,C_DefaultDigitsToTransmit_U8);
UART_TxChar(var_uartChannel_u8,'.');
var_floatNumber_f32 = var_floatNumber_f32 - var_tempNumber_u32;
var_tempNumber_u32 = var_floatNumber_f32 * 1000000;
UART_TxNumber(var_uartChannel_u8,C_DECIMAL_U8,var_tempNumber_u32,C_DefaultDigitsToTransmit_U8);
}
/*
SetBassTreble routine
This routine writes the setting values to the MP3 bass/treble settings
and displays them.
*/
void SetBassTreble(void)
{
Uint16 Treble;
// Write current settings to MP3 chip
vs_set_bass(Settings.TrebleLevel, Settings.BassLevel,
Settings.TrebleFreq, Settings.BassFreq);
// Show them to the user
UART_TxStr("Bass ");
if (Settings.BassLevel) {
UART_TxChar('+');
UART_TxNum(Settings.BassLevel, 1);
UART_TxStr("dB at ");
UART_TxNum(Settings.BassFreq, 1);
UART_TxStr("0Hz");
} else {
UART_TxStr("off");
}
UART_TxStr("\r\nTreble ");
if (Settings.TrebleLevel == 0) {
UART_TxStr("off\r\n");
} else {
if (!(Settings.TrebleLevel & 0b10000000)) {
Treble = Settings.TrebleLevel;
UART_TxStr("+");
} else {
Treble = 256 - Settings.TrebleLevel;
UART_TxStr("-");
}
Treble = Treble * 3 / 2;
UART_TxNum(Treble, 1);
if (Settings.TrebleLevel & 0b1)
UART_TxStr(".5");
UART_TxStr("dB at ");
UART_TxNum(Settings.TrebleFreq, 1);
UART_TxStr("kHz\r\n");
}
}
/* start the main program */
void main()
{
char ch;
/* Initilize the UART before Transmitting/Receiving any data */
UART_Init();
/* Initilize the lcd before displaying any thing on the lcd */
LCD_Init();
while(1)
{
/*Receive and Transmit a char indefinitely at 9600 baud rate */
ch=UART_RxChar(); // Receive a char and store it in "ch"
UART_TxChar(ch); //Transmit the received char
LCD_DataWrite(ch); //Display the received char on LCD
}
}
void UART_Printf(uint8_t var_uartChannel_u8, const char *argList, ...)
{
const char *ptr;
double var_floatNum_f32;
va_list argp;
sint16_t var_num_s16;
sint32_t var_num_s32;
uint16_t var_num_u16;
uint32_t var_num_u32;
char *str;
char ch;
uint8_t var_numOfDigitsToTransmit_u8;
va_start(argp, argList);
/* Loop through the list to extract all the input arguments */
for(ptr = argList; *ptr != '\0'; ptr++)
{
ch= *ptr;
if(ch == '%') /*Check for '%' as there will be format specifier after it */
{
ptr++;
ch = *ptr;
if((ch>=0x30) && (ch<=0x39))
{
var_numOfDigitsToTransmit_u8 = 0;
while((ch>=0x30) && (ch<=0x39))
{
var_numOfDigitsToTransmit_u8 = (var_numOfDigitsToTransmit_u8 * 10) + (ch-0x30);
ptr++;
ch = *ptr;
}
}
else
{
var_numOfDigitsToTransmit_u8 = C_MaxDigitsToTransmitUsingPrintf_U8;
}
switch(ch) /* Decode the type of the argument */
{
case 'C':
case 'c': /* Argument type is of char, hence read char data from the argp */
ch = va_arg(argp, int);
UART_TxChar(var_uartChannel_u8,ch);
break;
case 'd': /* Argument type is of signed integer, hence read 16bit data from the argp */
var_num_s16 = va_arg(argp, int);
#if (Enable_UART_TxNumber == 1)
if(var_num_s16<0)
{ /* If the number is -ve then display the 2's complement along with '-' sign */
var_num_s16 = -var_num_s16;
UART_TxChar(var_uartChannel_u8,'-');
}
UART_TxNumber(var_uartChannel_u8,C_DECIMAL_U8,var_num_s16,var_numOfDigitsToTransmit_u8);
#endif
break;
case 'D': /* Argument type is of integer, hence read 16bit data from the argp */
var_num_s32 = va_arg(argp, sint32_t);
#if (Enable_UART_TxNumber == 1)
if(var_num_s32<0)
{ /* If the number is -ve then display the 2's complement along with '-' sign */
var_num_s32 = -var_num_s32;
UART_TxChar(var_uartChannel_u8,'-');
}
UART_TxNumber(var_uartChannel_u8,C_DECIMAL_U8,var_num_s32,var_numOfDigitsToTransmit_u8);
#endif
break;
case 'u': /* Argument type is of unsigned integer, hence read 16bit unsigned data */
var_num_u16 = va_arg(argp, int);
#if (Enable_UART_TxNumber == 1)
UART_TxNumber(var_uartChannel_u8,C_DECIMAL_U8,var_num_u16,var_numOfDigitsToTransmit_u8);
#endif
break;
case 'U': /* Argument type is of integer, hence read 32bit unsigend data */
var_num_u32 = va_arg(argp, uint32_t);
#if (Enable_UART_TxNumber == 1)
UART_TxNumber(var_uartChannel_u8,C_DECIMAL_U8,var_num_u32,var_numOfDigitsToTransmit_u8);
#endif
break;
case 'x': /* Argument type is of hex, hence hexadecimal data from the argp */
var_num_u16 = va_arg(argp, int);
#if (Enable_UART_TxNumber == 1)
UART_TxNumber(var_uartChannel_u8,C_HEX_U8, var_num_u16,var_numOfDigitsToTransmit_u8);
#endif
break;
case 'X': /* Argument type is of hex, hence hexadecimal data from the argp */
var_num_u32 = va_arg(argp, uint32_t);
#if (Enable_UART_TxNumber == 1)
UART_TxNumber(var_uartChannel_u8,C_HEX_U8, var_num_u32,var_numOfDigitsToTransmit_u8);
#endif
break;
case 'b': /* Argument type is of binary,Read int and convert to binary */
var_num_u16 = va_arg(argp, int);
#if (Enable_UART_TxNumber == 1)
if(var_numOfDigitsToTransmit_u8 == C_MaxDigitsToTransmitUsingPrintf_U8)
{
var_numOfDigitsToTransmit_u8 = 16;
}
UART_TxNumber(var_uartChannel_u8,C_BINARY_U8, var_num_u16,var_numOfDigitsToTransmit_u8);
#endif
break;
case 'B': /* Argument type is of binary,Read int and convert to binary */
var_num_u32 = va_arg(argp, uint32_t);
#if (Enable_UART_TxNumber == 1)
if(var_numOfDigitsToTransmit_u8 == C_MaxDigitsToTransmitUsingPrintf_U8)
var_numOfDigitsToTransmit_u8 = 16;
UART_TxNumber(var_uartChannel_u8,C_BINARY_U8, var_num_u32,var_numOfDigitsToTransmit_u8);
#endif
break;
case 'F':
case 'f': /* Argument type is of float, hence read double data from the argp */
var_floatNum_f32 = va_arg(argp, double);
#if (Enable_UART_TxFloatNumber == 1)
UART_TxFloatNumber(var_uartChannel_u8,var_floatNum_f32);
#endif
break;
case 'S':
case 's': /* Argument type is of string, hence get the pointer to sting passed */
str = va_arg(argp, char *);
UART_TxString(var_uartChannel_u8,str);
break;
case '%':
UART_TxChar(var_uartChannel_u8,'%');
break;
}
}
else
{
//int main(void) __attribute__((noreturn)); // Main never returns so don't waste stack space on it.
int main(void)
{
Uint16 TempInt;
// Set up the I/O lines
DDRA = PortDirA;
DDRB = PortDirB;
SD_PowerOn();
DDRC = PortDirC;
DDRD = PortDirD;
PINA = PortPullUpA;
PINB = PortPullUpB;
PINC = PortPullUpC;
PIND = PortPullUpD;
//set the channel is the keyboard.
//mp3 init finish ,after reset the slave board have volume;
SetBit(SelAPort, Sel0A);
SetBit(SelAPort, Sel1A);
SetBit(SelBPort, Sel0B);
SetBit(SelBPort, Sel1B);
SetBit(SelCPort, Sel0C);
SetBit(SelCPort, Sel1C);
LastError = 0; // Indicate no errors yet
// Init the peripherals
Timer_Init(); // Set up timers
UART_Init();
InitKey();
BCMessageInit(BCAMP3Contoller);
wdt_enable(WDTO_8S);//wdt 8s
// Set up key vars
UART_Rx(CmdRxBuf, 1);
Track = 1;
IdleTime = 0;
FlashPhase = 0;
Volume = 0;
PreMuteVolume = 0;
Ramp = NoRamp;
LastKey = 0;
for(Bay = LeftBay; Bay <= NoBay; Bay++) {
BayProduct[Bay] = UnknownProduct;
BaySource[Bay] = 0xff;
}
Bay = LeftBay;
SlaveMode = false;
SlaveModePara = 0;
sei(); // Enable global interrupts
// Print product build banner
wdt_reset();
UART_TxStr("\r\n======================================\r\n031-517-202 ");
UART_TxChar('0' + SWVerMajor);
UART_TxChar('.');
UART_TxChar('0' + SWVerMinor);
UART_TxChar('.');
UART_TxChar('0' + SWVerFix);
UART_TxChar(' ');
UART_TxStr(__TIME__);
UART_TxChar(' ');
UART_TxStr(__DATE__);
UART_TxStr("\r\n======================================\r\n");
// For reset the slave board maybe volume very high so have noise
// so first set volume is 0
wdt_reset();
BCMessageReceive(RxBuf); // Finished with it so get ready for next msg
ExchangeBoardMsg(BCALeftBay, BCTVolume, 0, 0, BCTAck);
BCMessageReceive(RxBuf); // Finished with it so get ready for next msg
ExchangeBoardMsg(BCACenterBay, BCTVolume, 0, 0, BCTAck);
BCMessageReceive(RxBuf); // Finished with it so get ready for next msg
ExchangeBoardMsg(BCARightBay, BCTVolume, 0, 0, BCTAck);
BCMessageReceive(RxBuf); // Finished with it so get ready for next msg
// Test the LEDs while bays boot up
DelayMS(100); // Allow some time for keypad to boot up
UART_TxStr("Testing LEDs\r\n");
for (TempInt = 1; TempInt <= 2; TempInt++){
for (Key = 1; Key <= MaxKey; Key++) {
if(!SetLamp(Key)){
SlaveMode = true;
break;
}
DelayMS(250);
wdt_reset();//feed the watchdog
}
if(SlaveMode)
break;
}
// Show version number
if(!SlaveMode){
SetLamps(0);
DelayMS(1000);
SetLamps(LeftLEDs | SWVerMajor);
DelayMS(2000);
wdt_reset();
SetLamps(RightLEDs | SWVerMinor);
DelayMS(2000);
wdt_reset();
SetLamps(LeftLEDs | RightLEDs | SWVerFix);
DelayMS(2000);
wdt_reset();
}
// Load EEPROM settings
SetLamp(1);
LoadEEPROMSetting();
UART_TxStr("Settings:\r\n");
PrintSettings();
//wait for tablet ready wait 60 seconds
if(SlaveMode)
{
UART_TxStr("Wait for tablet ready\r\n");
for(TempInt = 0; TempInt < 6000; TempInt++)
{
DelayMS(10);
CheckForBoardMsg();
wdt_reset();
}
}
// Prepare MP3 decoder for work
wdt_reset(); // Feed the watchdog
DelayMS(500);
SetLamp(4);
Timer_Clear();
for (TempInt = 1; TempInt <= 5; TempInt++) {
if (MP3_Init())
break; // If init ok exit loop
wdt_reset(); // Feed the watchdog
DelayMS(250); // Wait before trying again
}
MP3_Volume(250);
UART_TxStr("MP3 init time = ");
UART_TxNum(Timer_Read(), 1);
UART_TxStr("mS\r\n");
// Find the last track on the card
wdt_reset();
SetLamp(3);
for (Tracks = 1; Tracks <= 99; Tracks++) {
if (!MP3_OpenFile(Tracks))
break;
}
Tracks--;
SetBassTreble(); // Set the audio curve
// Determine what is connected
wdt_reset();
SetLamp(2);
SearchDevices();
if(!SlaveMode)
{
ConfigDevices(); // Configure connected devices
SetIdleState();
MP3_Track(1);
if (!InputPresent[MP3In]) // If no MP3 player display error
ShowError(ErrorNoMP3, false);
}
UART_TxStr("Start up complete\r\n");
//
// Enter the main loop
//
Timer_Clear();
SlaveModeTimerClear();
for( ; ; ) { // Run forever
if (SlaveMode) { // In slave mode only handle slave mode messages
CheckForBoardMsg();
if(SlaveModeTimerRead() > 5000)
{
UART_TxNum(SlaveModeTimerRead(),5);
UART_TxStr("\r\nMore than 5 seconds change to normal mode\r\n");
SlaveMode = false;//return to Normal mode
SearchDevices();
Volume = 99; //if Volume == IdleVolume the not need send the volume so need give the diffent IdleVolume value
Bay = RightBay;
SetIdleState();
SetMux(Input,LeftBay);
SetMux(Input,CenterBay);
SetMux(Input,RightBay);
}
wdt_reset(); // Update the watchdog
} else { // Not in slave mode so feed the MP3 engine
if (MP3Ready && !MP3_Process())
MainLoop(0); // Tell the main loop we have stopped playback
// Call the main loop if it is due
if (Timer_Read() >= LoopPeriod) { // Run the main loop at 10Hz
Timer_Clear();
MainLoop(1); // Tell the main loop we are still playing a track
}
}
}
return 0;
}
void UART_TxNumber(uint8_t var_uartChannel_u8, uint8_t var_numericSystem_u8, uint32_t var_number_u32, uint8_t var_numOfDigitsToTransmit_u8)
{
uint8_t i=0,a[10];
if(C_BINARY_U8 == var_numericSystem_u8)
{
while(var_numOfDigitsToTransmit_u8!=0)
{
/* Start Extracting the bits from the specified bit positions.
Get the Acsii values of the bits and transmit */
i = util_GetBitStatus(var_number_u32,(var_numOfDigitsToTransmit_u8-1));
UART_TxChar(var_uartChannel_u8,util_Dec2Ascii(i));
var_numOfDigitsToTransmit_u8--;
}
}
else if(var_number_u32==0)
{
/* If the number is zero then update the array with the same for transmitting */
for(i=0;((i<var_numOfDigitsToTransmit_u8) && (i<C_MaxDigitsToTransmit_U8)) ;i++)
UART_TxChar(var_uartChannel_u8,'0');
}
else
{
for(i=0;i<var_numOfDigitsToTransmit_u8;i++)
{
/* Continue extracting the digits from right side
till the Specified var_numOfDigitsToTransmit_u8 */
if(var_number_u32!=0)
{
/* Extract the digits from the number till it becomes zero.
First get the remainder and divide the number by 10 each time.
example for Decimal number:
If var_number_u32 = 123 then extracted remainder will be 3 and number will be 12.
The process continues till it becomes zero or max digits reached*/
a[i]=util_GetMod32(var_number_u32,var_numericSystem_u8);
var_number_u32=var_number_u32/var_numericSystem_u8;
}
else if( (var_numOfDigitsToTransmit_u8 == C_DefaultDigitsToTransmit_U8) ||
(var_numOfDigitsToTransmit_u8 > C_MaxDigitsToTransmit_U8))
{
/* Stop the iteration if the Max number of digits are reached or
the user expects exact(Default) digits in the number to be transmitted */
break;
}
else
{
/*In case user expects more digits to be transmitted than the actual digits in number,
then update the remaining digits with zero.
Ex: var_number_u32 is 123 and user wants five digits then 00123 has to be transmitted */
a[i]=0;
}
}
while(i)
{
/* Finally get the ascii values of the digits and transmit*/
UART_TxChar(var_uartChannel_u8,util_Hex2Ascii(a[i-1]));
i--;
}
}
}
void UART_TxStr(const char *str)
{
int a=0;
while(str[a]!='\0')
UART_TxChar(str[a++]);
}
//int main(void) __attribute__((noreturn)); // Main never returns so don't waste stack space on it.
int main(void)
{
Uint16 TempInt;
// Set up the I/O lines
DDRA = PortDirA;
DDRB = PortDirB;
DDRC = PortDirC;
DDRD = PortDirD;
PINA = PortPullUpA;
PINB = PortPullUpB;
PINC = PortPullUpC;
PIND = PortPullUpD;
//set the channel is the keyboard.
//mp3 init finish ,after reset the slave board have volume;
SetBit(SelAPort, Sel0A);
SetBit(SelAPort, Sel1A);
SetBit(SelBPort, Sel0B);
SetBit(SelBPort, Sel1B);
SetBit(SelCPort, Sel0C);
SetBit(SelCPort, Sel1C);
// Init the peripherals
Timer_Init(); // Set up timers
UART_Init();
BCMessageInit(BCAMP3Contoller);
// Set up key vars
UART_Rx(CmdRxBuf, 1);
Track = 1;
IdleTime = 0;
FlashPhase = 0;
Volume = 0;
PreMuteVolume = 0;
Ramp = NoRamp;
LastKey = 0;
for(Bay = LeftBay; Bay <= NoBay; Bay++) {
BayProduct[Bay] = UnknownProduct;
BaySource[Bay] = 0xff;
}
Bay = LeftBay;
SlaveMode = false;
sei(); // Enable global interrupts
// Print product build banner
UART_TxStr("\r\n================================\r\n031-517-202 ");
UART_TxStr(__TIME__);
UART_TxChar(' ');
UART_TxStr(__DATE__);
UART_TxStr("\r\n================================\r\n");
// For reset the slave board maybe volume very high so have noise
// so first set volume is 0
/*BCMessageReceive(RxBuf); // Finished with it so get ready for next msg
ExchangeBoardMsg(BCALeftBay, BCTVolume, 0, 0, BCTAck);
BCMessageReceive(RxBuf); // Finished with it so get ready for next msg
ExchangeBoardMsg(BCACenterBay, BCTVolume, 0, 0, BCTAck);
BCMessageReceive(RxBuf); // Finished with it so get ready for next msg
ExchangeBoardMsg(BCARightBay, BCTVolume, 0, 0, BCTAck);
BCMessageReceive(RxBuf); // Finished with it so get ready for next msg
// Test the LEDs while bays boot up
DelayMS(500); // Allow some time for keypad to boot up
UART_TxStr("Testing LEDs\r\n");
for (TempInt = 1; TempInt <= 2; TempInt++)
for (Key = 1; Key <= MaxKey; Key++) {
SetLamp(Key);
DelayMS(250);
}
// Keyboard test
Count = 0xff;
SetLamps(Count);
for(;;){
if (BCRXAvail) { // See if we have a new frame
ProcessBoardMsg();
BCMessageReceive(RxBuf); // Get the next message
}
if (GetKey() != TempInt) {
TempInt = GetKey();
if (TempInt) {
Count ^= 1 << (TempInt - 1);
SetLamps(Count);
}
}
}
*/
// Load EEPROM settings
/* SetLamp(1);
LoadEEPROMSetting();
UART_TxStr("Settings:\r\n");
PrintSettings();
// Prepare MP3 decoder for work
SetLamp(4);
Timer_Clear();
MP3_Init();
MP3_Volume(250);
UART_TxStr("MP3 init time = ");
UART_TxNum(Timer_Read(), 1);
UART_TxStr("mS\r\n");
// Find the last track on the card
SetLamp(3);
for (Tracks = 1; Tracks <= 99; Tracks++) {
if (!MP3_OpenFile(Tracks))
break;
}
Tracks--;
SetBassTreble(); // Set the audio curve
// Determine what is connected
SetLamp(2);
UART_TxStr("Searching for devices\r\n");
// Look for input devices
InputPresent[MP3In] = true;
InputFormat[MP3In] = I2S32Bit;
InputPresent[LCDIn] = ExchangeBoardMsg(BDCLCD, BCTInquire, 0, 0, BCTInquireAnswer);
InputFormat[LCDIn] = RxBuf[BCPParam2];
BCMessageReceive(RxBuf);
InputPresent[LeftTablet] = ExchangeBoardMsg(BCATabletLeft, BCTInquire, 0, 0, BCTInquireAnswer);
InputFormat[LeftTablet] = RxBuf[BCPParam2];
BCMessageReceive(RxBuf);
InputPresent[RightTablet]= ExchangeBoardMsg(BCATabletRight, BCTInquire, 0, 0, BCTInquireAnswer);
InputFormat[RightTablet] = RxBuf[BCPParam2];
BCMessageReceive(RxBuf);
*/
// Look for output devices
/*HeadphoneBay = NoBay;
BayCount = 0;
for(Bay = LeftBay; Bay <= RightBay; Bay++) {
if (ExchangeBoardMsg(BCAOutput + Bay, BCTInquire, 0, 0, BCTInquireAnswer)) {
BayCount++;
UART_TxStr("Found bay ");
UART_TxNum(Bay, 1);
UART_TxStr(" = ");
BayProduct[Bay] = RxBuf[BCPParam1];
if (BayProduct[Bay] == FiveHeadphones)
HeadphoneBay = Bay;
UART_TxNum(BayProduct[Bay], 1);
UART_TxNewLine();
}
}
Bay = LeftBay;
BCMessageReceive(RxBuf); // Finished with it so get ready for next msg
// Allow E2 overwrite of detected defaults
if (Settings.LeftProduct != UnknownProduct) {
UART_TxStr("E2 replaced left product ");
UART_TxNum(BayProduct[LeftBay], 1);
UART_TxStr(" with ");
UART_TxNum(Settings.LeftProduct, 1);
UART_TxNewLine();
BayProduct[LeftBay] = Settings.LeftProduct;
}
if (Settings.CenterProduct != UnknownProduct) {
UART_TxStr("E2 replaced center product ");
UART_TxNum(BayProduct[CenterBay], 1);
UART_TxStr(" with ");
UART_TxNum(Settings.CenterProduct, 1);
UART_TxNewLine();
BayProduct[CenterBay] = Settings.CenterProduct;
}
if (Settings.RightProduct != UnknownProduct) {
UART_TxStr("E2 replaced right product ");
UART_TxNum(BayProduct[RightBay], 1);
UART_TxStr(" with ");
UART_TxNum(Settings.RightProduct, 1);
UART_TxNewLine();
BayProduct[RightBay] = Settings.RightProduct;
}
ShowProducts();
// Determine operational mode
// TODO: Check for override in E2 config
Config = TwoBaysTwoSources; // Default mode
if (!InputPresent[LCDIn]) {
Config = TwoBaysOneSource;
} else if (BayCount < 2) {
Config = OneBayTwoSources;
} else {
Config = TwoBaysTwoSources;
}
UART_TxStr("Mode: ");
switch (Config) {
case TwoBaysOneSource: UART_TxStr("Two bays, one source\r\n"); break;
case OneBayTwoSources: UART_TxStr("One bay, two sources\r\n"); break;
case TwoBaysTwoSources: UART_TxStr("Two bays, two sources\r\n"); break;
}
// TODO: Check for override in E2 config
if (InputPresent[LeftTablet] && InputPresent[RightTablet]) // If two tablets
BayNotSourceButtons = false; // Assume input selection buttons
else if (BayCount < 2) // Only one bay
BayNotSourceButtons = false; // Assume input selection buttons
else // We have two, or more, products and one controller
BayNotSourceButtons = true;
ConfigDevices(); // Configure connected devices
SetIdleState();
MP3_Track(1);
UART_TxStr("Start up complete\r\n");
//
// Enter the main loop
//
*/
Timer_Clear();
for( ; ; ) { // Run forever
if (SlaveMode) { // In slave mode only handle slave mode messages
CheckForBoardMsg();
} else { // Not in slave mode so feed the MP3 engine
//if (!MP3_Process())
// MainLoop(0); // Tell the main loop we have stopped playback
// Call the main loop if it is due
//if (Timer_Read() >= LoopPeriod) { // Run the main loop at 10Hz
// Timer_Clear();
MainLoop(0); // Tell the main loop we are still playing a track
// }
}
}
return 0;
}
void UART_TxString(uint8_t var_uartChannel_u8, char *ptr_stringPointer_u8)
{
while(*ptr_stringPointer_u8)
UART_TxChar(var_uartChannel_u8, *ptr_stringPointer_u8++);// Loop through the string and transmit char by char
}
void UART_TxString(char *ptr_stringPointer_u8)
{
while(*ptr_stringPointer_u8)
UART_TxChar(*ptr_stringPointer_u8++);// Loop through the string and transmit char by char
}
/* Print the result of an executed command. Done so that all commands have a response and so that
* they can indicate errors.
*/
static void PrintCmdStatus(cmdstatus_t status)
{
UART_TxChar('!');
UART_TxHexByte((uint8_t)status);
UART_TxChar('\r');
}
/*
main routine
Program entry point
*/
int main(void)
{
Uint8 TxBuf[BCMsgSize];
Uint8 RxBuf[BCMsgSize];
Uint8 Address; // Address of device in bay
Uint8 Destination; // Address we will reply to
Uint8 Param,Param2;
Uint8 Volume = 0;
Uint8 TempInt;
#ifdef CTRL_LED
Uint8 TempInt;
Uint8 RceiveAddress;
Uint8 i;
i = 0;
#endif
MainInit();
UART_TxStr("\r\nPower up\r\n");
UART_Rx(RxData, 9); // Input register setting command
Address = BCAOutput + ReadPosition();
BCMessageInit(Address); // Set up the UART
BCMessageReceive(RxBuf); // Kick off receive
if(ReadProductID()) // 1:pill 2:beats box 3:rave
ChannelNumbers = 1;
else
ChannelNumbers = 5;//0:5 position headphone
// Enter the main loop
LED1_ON();
LED2_ON();
LED_GRAPHICAL_ON();
SetLamps(3);
for( ; ; ) { // Run forever
Timer_Clear();
DelayMS(LoopRate);
TempInt++;
SettingsControl();
if (BCRXAvail)
{ // We have a new message
//send data
#ifdef SecondUART
#ifdef DumpComms
UART_TxStr("Receive: ");
for (TempInt = BCPSOH; TempInt <= BCPChecksum; TempInt++)
{
UART_TxUint8(RxBuf[TempInt]);
UART_TxChar(' ');
}
UART_TxStr("\r\n");
#endif
#endif
if ((RxBuf[BCPAddr] & 0b1111) == Address) // Check it is for us
{
Destination = RxBuf[BCPAddr] >> 4; // Pre-setup assuming we will reply
Destination &= 0b1111;
Destination |= Address << 4;
TxBuf[BCPAddr] = Destination;
DelayMS(2); // Allow line turn around delay
switch (RxBuf[BCPType])
{
case BCTInquire: // Master request of slave ID
TxBuf[BCPType] = BCTInquireAnswer;
TxBuf[BCPParam1] = ReadProductID();
TxBuf[BCPParam2] = 0;
BCMessageSend(TxBuf,true); // Send the reply
break;
case BCTLamps: // Set lamps
TxBuf[BCPType] = BCTAck;
TxBuf[BCPParam1] = 0;
TxBuf[BCPParam2] = 0;
BCMessageSend(TxBuf, true); // Send the reply
Param = RxBuf[BCPParam1];
SetLamps(Param);
break;
case BCTVolume: // Volume set
TxBuf[BCPType] = BCTAck;
TxBuf[BCPParam1] = 0;
TxBuf[BCPParam2] = 0;
BCMessageSend(TxBuf,true); // Send the reply
Volume = RxBuf[BCPParam1]; // Save parameter so we can receive next frame while processing this request
Param2 = RxBuf[BCPParam2]; // Save parameter so we can receive next frame while processing this request
Volume_Set(Volume,Param2);
break;
case BCTHeadphoneChGain: // Volume set
TxBuf[BCPType] = BCTAck;
TxBuf[BCPParam1] = 0;
TxBuf[BCPParam2] = 0;
BCMessageSend(TxBuf,true); // Send the reply
Param = RxBuf[BCPParam1]; // Save parameter so we can receive next frame while processing this request
Param2 = RxBuf[BCPParam2]; // Save parameter so we can receive next frame while processing this request
SetChannelAdjust(Param,Param2);
break;
case BCTHeadphoneChMax: // Volume set
TxBuf[BCPType] = BCTAck;
TxBuf[BCPParam1] = 0;
TxBuf[BCPParam2] = 0;
BCMessageSend(TxBuf,true); // Send the reply
Param = RxBuf[BCPParam1]; // Save parameter so we can receive next frame while processing this request
Param2 = RxBuf[BCPParam2]; // Save parameter so we can receive next frame while processing this request
SetChMaxVolume(Param, Param2);
break;
case BCTAudioFormat: // Audio format set
TxBuf[BCPType] = BCTAck;
TxBuf[BCPParam1] = 0;
TxBuf[BCPParam2] = 0;
BCMessageSend(TxBuf,true); // Send the reply
Param = RxBuf[BCPParam1]; // Save parameter so we can receive next frame while processing this request
WM8960_SetAudioFormat(Param);
break;
case BCTBrightness: // Set lamp brightness
TxBuf[BCPType] = BCTAck;
TxBuf[BCPParam1] = 0;
TxBuf[BCPParam2] = 0;
BCMessageSend(TxBuf, true); // Send the reply
Param = RxBuf[BCPParam1]; // Save parameter so we can receive next frame while processing this request
Param2 = RxBuf[BCPParam2]; // Save parameter so we can receive next frame while processing this request
if (Param == 1)
LED1 = Param2;
else if(Param == 2)
LED2 = Param2;
break;
case BCTReset: // Volume set
TxBuf[BCPType] = BCTAck;
TxBuf[BCPParam1] = 0;
TxBuf[BCPParam2] = 0;
BCMessageSend(TxBuf,true); // Send the reply
Param = RxBuf[BCPParam1]; // Save parameter so we can receive next frame while processing this request
BCMessageReceive(RxBuf); // Kick off receive of next frame
asm("jmp 0x0000");//reset
break;
default: // Unknown command
TxBuf[BCPType] = BCTNAck;
TxBuf[BCPParam1] = BCNUnkownType;
TxBuf[BCPParam2] = RxBuf[BCPType];
BCMessageSend(TxBuf,true); // Send the reply
// BCMessageReceive(RxBuf); // Kick off receive of next frame
break;
}
//this send command tv change to 031-517-209 board
#if VideoTrackCtrl
Uint8 VideoTrack;
Uint8 SendVideoFlag;
if(Volume > 47)
{
if(SendVideoFlag)
{
SendVideoFlag = false;
if(Address == BCARightBay)
{
VideoTrack = 1;
}
else if(Address == BCALeftBay)
{
VideoTrack = 2;
}
TxBuf[BCPAddr] = Address << 4;
TxBuf[BCPAddr] |= BDCLCD;
TxBuf[BCPType] = BCTPlayTrack;
TxBuf[BCPParam1] = VideoTrack;
TxBuf[BCPParam2] = 0;
BCMessageSend(TxBuf, true); // Send the reply
}
}
else
{
SendVideoFlag = 1;
}
#endif
}
//this for ctrl LED it itself
#ifdef CTRL_LED
if(RxBuf[BCPType] == BCTVolume)
{
RceiveAddress = RxBuf[BCPAddr] & 0b1111;
a_Volume[RceiveAddress-BCAOutput] = RxBuf[BCPParam1];
if((a_Volume[RceiveAddress-BCAOutput] > 47) && (LastVolume[RceiveAddress-BCAOutput] > 47))//have volume
{
if((RceiveAddress) == Address)
{
LED1_ON();
}
else
{
LED1_OFF();
}
}
i = 0;
for(TempInt = 0; TempInt < 4; ) //all volume off
{
if((a_Volume[TempInt] <= 47) && (LastVolume[TempInt] <= 47))
i++;
TempInt++;
}
if(i >= TempInt)
{
LED1_ON();
}
LastVolume[RceiveAddress-BCAOutput] = a_Volume[RceiveAddress-BCAOutput];
}
#endif
BCMessageReceive(RxBuf); // Kick off receive of next frame
}
}
/* Run one iteration of the interface state machine. This is responsible for displaying the command
* prompt, receiving characters, and running the resulting command by searching for and calling the
* proper command function. Call this in your main loop.
*/
void Cmd_ProcessInterface()
{
switch(m_cmdstate)
{
case eCmd_Prompt:
if(UART_TxAvailable() >= 4)
{
UART_TxData("\r#> ", 4);
m_cmdlen = 0;
++m_cmdstate;
}
break;
case eCmd_Receive:
{
uint16_t avail = UART_RxAvailable();
while(avail--)
{
char c = UART_RxChar();
wdt_reset();
if(0x08 == c) // backspace -- remove last character
{
if(m_cmdlen > 0)
--m_cmdlen;
}
else if(0x1B == c) // escape -- clear prompt
{
m_cmdstate = eCmd_Prompt;
break;
}
else // add the character to the buffer
{
m_cmdbuf[m_cmdlen] = c;
++m_cmdlen;
// either got a command or buffer is full
if(c == '\r' || m_cmdlen >= CMD_BUFSIZE)
{
m_cmdbuf[m_cmdlen] = 0; // terminate command
++m_cmdstate;
break;
}
}
}
wdt_reset();
}
break;
case eCmd_Run:
m_cmdstate = eCmd_Prompt;
if(m_numcmds > 0)
{
uint8_t i;
// look for the right command and call its function
for(i = 0; i < m_numcmds; ++i)
{
size_t len = strlen(m_cmds[i].name);
if(0 == strncmp(m_cmds[i].name, m_cmdbuf, len) &&
(m_cmdbuf[len] == ' ' || m_cmdbuf[len] == '\r'))
{
m_cmds[i].cmdfunc(m_cmdbuf, m_cmdlen);
break;
}
}
// didn't find the command
if(i == m_numcmds)
UART_TxData_P(PSTR("Unknown command\r"), 16);
}
break;
case eCmd_Help:
if(m_helpindex < m_numcmds)
{
size_t txlen = (strlen(m_cmds[m_helpindex].name) +
strlen_P(m_cmds[m_helpindex].help) + 5);
if(txlen > UART_TX_BUFSIZE)
txlen = UART_TX_BUFSIZE;
if(UART_TxAvailable() >= txlen)
{
UART_TxString(m_cmds[m_helpindex].name);
UART_TxData("\t - ", 4);
UART_TxString_P(m_cmds[m_helpindex].help);
UART_TxChar('\r');
++m_helpindex;
}
}
else
{
m_cmdstate = eCmd_Prompt;
m_helpindex = 0;
}
break;
default:
m_cmdstate = eCmd_Prompt;
break;
}
}
/*----------------------------------------------------------------------------------
void UART_TxString(char *string_ptr)
-----------------------------------------------------------------------------------
* I/P Arguments: String(Address of the string) to be transmitted.
* Return value : none
* description :This function is used to transmit the ASCII string through UART..
The string_ptr points to the first char of the string.
And it is incremented each time to traverse till the end(NULL CHAR).
Each time a char is sent to UART_TxChar() fun to transmit it through UART
___________________________________________________________________________________*/
void UART_TxString(char *string_ptr)
{
while(*string_ptr)
UART_TxChar(*string_ptr++);
}
