/**
* @fn void __ISR( _UART2_VECTOR, IPL2SOFT ) intUart3AHandler( void )
* @brief Vecteur d'interruption de l'UART1A
*/
void __ISR(_UART1_VECTOR, IPL2SOFT ) IntUart1Handler(void) {
// Si on a reçu une donnée
if (mU1ARXGetIntFlag()) {
aux = uartGetChar();
// Notification de réception
flagReception = 1;
// On baisse le flag
mU1ARXClearIntFlag();
}
// On ignore les interruptions sur TX
if (mU1ATXGetIntFlag());
mU1ATXClearIntFlag();
}
/**
* @fn void __ISR( _UART2_VECTOR, IPL2SOFT ) intUart3AHandler( void )
* @brief Vecteur d'interruption de l'UART1A
*/
void __ISR(_UART1_VECTOR, IPL2SOFT ) IntUart1Handler(void) {
// Si on a reçu une donnée
if (mU1ARXGetIntFlag()) {
// Réception de l'ordre
aux = uartGetChar();
// Notification de réception
xTaskResumeFromISR(xDialogueUARTHandle);
// On baisse le flag
mU1ARXClearIntFlag();
}
// On ignore les interruptions sur TX
mU1ATXClearIntFlag();
}
int main(void) {
/* stop the watchdog timer */
WDTCTL = WDTPW + WDTHOLD;
/* set up the clocks for 1 mhz */
BCSCTL1 = CALBC1_1MHZ; // Set range
DCOCTL = CALDCO_1MHZ;
BCSCTL2 &= ~(DIVS_3); // SMCLK = DCO / 8 = 1Mhz
/* LEDs off, but we can use them for debugging if we want */
P1DIR |= RED_LED+GRN_LED;
P1OUT &= ~ (RED_LED + GRN_LED );
initUart();
/* Start listening for data */
UART_Start();
/* enable interrupts */
__bis_SR_register( GIE );
uartPrint("\n\rCli Started.\n\r");
cliHelp();
uartPrint(PROMPT);
char in_char;
while(1) {
while(rx_size() > 0) {
in_char = uartGetChar();
uartPutChar(in_char);
cli_input(in_char);
}
/* go to sleep and wait for data */
__bis_SR_register( LPM0_bits );
}
}
//
// main function
//
int main(void) {
char c;
uint16_t loop = 0;
uint8_t bootloaderEnableFlag = FALSE;
// relocate interrupt vector table to bottom of flash
// in case the bootloader will not be started
myIVSELREG = _BV(IVCE);
myIVSELREG = 0;
// init USART
myUBRRH = (F_CPU/(BAUDRATE*16L)-1) >> 8; // calculate baudrate and set high byte
myUBRRL = (uint8_t)(F_CPU/(BAUDRATE*16L)-1); // and low byte
myUCSRB = _BV(myTXEN) | _BV(myRXEN) | _BV(myRXCIE); // enable transmitter and receiver and receiver interrupt
myUCSRC = myURSEL | _BV(myUCSZ1) | _BV(myUCSZ0); // 8 bit character size, 1 stop bit, no parity
// the bootloader may be activated either if
// the character 'i' (interactive mode) was received from USART
// or the flash is (still) empty
// poll USART receive complete flag 64k times to catch the 'i' reliably
do {
if(bit_is_set(myUCSRA, myRXC))
if(myUDR == 'i')
bootloaderEnableFlag = TRUE;
} while(--loop);
// test if flash is empty (i.e. flash content is 0xff)
if(pgm_read_byte_near(0x0000) == 0xFF) {
bootloaderEnableFlag = TRUE; // set enable flag
}
// check enable flag and start application if FALSE
if(bootloaderEnableFlag == FALSE) {
myUCSRB = 0; // clear USART register to reset default
startApplication(); // start application code
}
//
// now the bootloader code begins
//
// welcome message and prompt
uartPutChar('\r');
uartPutChar('>');
// loop until a valid character is received
do {
c = uartGetChar(); // read a character
if(c == 'f') { // 'f' selects flash programming
uartPutChar('f'); // echo the 'f'
programThisMemory = FLASH; // set flag
}
#ifdef EEPROM_CODE
if(c == 'e') { // 'e' selects eeprom programming
uartPutChar('e'); // echo the 'e'
programThisMemory = EEPROM; // set flag
}
#endif
if(c == 'g') { // 'g' starts the application
uartPutChar('g'); // echo the 'g'
startApplication(); // and jump to 0x0000
}
} while(!programThisMemory); // exit loop when a valid key was pressed
// move interrupt vector table to boot loader area
myIVSELREG = _BV(IVCE);
myIVSELREG = _BV(IVSEL);
uartPutChar('\r'); // set cursor to next line
receiveBufferFull = FALSE; // reset full flag
receiveBufferPointer = (char *)receiveBuffer; // reset buffer pointer to start of buffer
// enable interrupts
sei();
// endless loop
while(1) {
// if buffer is full, parse the buffer and write to flash
if(receiveBufferFull) {
cli(); // disable interrupts
// if parsing produced an error, restart bootloader
if(!parseSrecBuffer(receiveBuffer)) {
uartPutChar('\r'); // set cursor to next line
startBootloader(); // restart the bootloader
}
// was an end-of-file s-record found?
if(srecEndOfFile) {
uartPutChar('O'); // 'OK' indicates successful programming
uartPutChar('K');
loop_until_bit_is_set(myUCSRA, myUDRE); // wait until character is transmitted
startBootloader(); // restart the bootloader
}
receiveBufferFull = FALSE; // reset full flag
receiveBufferPointer = (char *)receiveBuffer; // reset buffer pointer to start of buffer
sei(); // enable interrupts
}
}
}
/*
* State machine for machester encoding.
* Achieve wave phase.
*/
void encode_machine(void)
{
state_t sta = enc.state;
switch(sta){
case Waiting:
if( 0 == ticker % 2){
dbg_led = 0;
if( uartGetAmount() ){
enc.data = uartGetChar();
enc.byte_rev = 1;
HIJACK_CompareConfig(hijackOutputModeSet); //next is 0x00, falling
enc_odd = 0;
}
else{
HIJACK_CompareConfig(hijackOutputModeClear); //next is 0x80, rising
enc.byte_rev = 0;
}
}
else{
if(enc.byte_rev){//new byte
HIJACK_CompareConfig(hijackOutputModeClear); //falling
enc.state = Sta0; //state switch
}
else{ //no byte
HIJACK_CompareConfig(hijackOutputModeSet); //rising, keep in waiting state
}
}
break;
//
case Sta0: //prepare for sta1, rising edge
findParam(BIT0, Bit0);
break;
//
case Sta1: //prepare for sta2, falling edge
if( 0 == ticker % 2){
HIJACK_CompareConfig(hijackOutputModeSet); //next is 0x00, for falling
}
else{
HIJACK_CompareConfig(hijackOutputModeClear); //falling
enc.state = Sta2; //state switch
}
break;
//
case Sta2: //prepare for sta3, rising edge
if( 0 == ticker % 2){
HIJACK_CompareConfig(hijackOutputModeClear); //next is 0x80, for rising
}
else{
HIJACK_CompareConfig(hijackOutputModeSet); //rising
enc.state = Sta3; //state switch
}
break;
//
case Sta3: //prepare for bit7
findParam(BIT7, Bit7);
break;
//
case Bit0: //prepare for Bit1
findParam(BIT1, Bit1);
break;
//
case Bit1: //prepare for Bit2
findParam(BIT2, Bit2);
break;
//
case Bit2: //prepare for Bit3
findParam(BIT3, Bit3);
break;
//
case Bit3: //prepare for Bit4
findParam(BIT4, Bit4);
break;
//
case Bit4: //prepare for Bit5
findParam(BIT5, Bit5);
break;
//
case Bit5: //prepare for Bit6
findParam(BIT6, Bit6);
break;
//
case Bit6: //prepare for Bit7
findParam(BIT7, Bit7);
break;
//
case Bit7: //prepare for parity
if( 0 == ticker % 2){
if( 0 == ( enc_odd%2 ) ){//there is even 1(s), output 1
enc.edge = rising;
HIJACK_CompareConfig(hijackOutputModeClear); //next is 0x80, for rising
dbg_led = 1;
}
else{//there is odd 1(s), output 0
enc.edge = falling;
HIJACK_CompareConfig(hijackOutputModeSet); //next is 0x00, for falling
dbg_led = 0;
}
}
else{
if( rising == enc.edge ){
HIJACK_CompareConfig(hijackOutputModeSet); //rising
}
else{
HIJACK_CompareConfig(hijackOutputModeClear); //falling
}
enc.state = Parity; //state switch
}
break;
//
case Parity://prepare for stop bit, it is always 1
if( 0 == ticker % 2){
HIJACK_CompareConfig(hijackOutputModeClear); //next is 0x80, for rising
dbg_led = 0 ;
}
else{
HIJACK_CompareConfig(hijackOutputModeSet); //rising
enc.state = Sto0; //state switch
}
break;
//
case Sto0: //back to waiting
if( 0 == ticker % 2){
HIJACK_CompareConfig(hijackOutputModeClear); //next is 0x80, for rising
}
else{
HIJACK_CompareConfig(hijackOutputModeSet); //rising
enc.state = Waiting; //state switch
}
break;
//
#if 0
case Sto1: //go to waiting mode
enc.state = Waiting;
break;
//
#endif
default:
break;
//
}
}
