AVRFreaks.net

time: (current GPS time)

//   atmega8    //


#include <avr/io.h>
#include <inttypes.h>
#include <util/delay.h>
#include <avr/interrupt.h>


#define USART_BAUDRATE 4800
#define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1)


volatile uint8_t data, parsing_state, state;
volatile int8_t ReceivedByte[5], time[13], latitude[12];
volatile int8_t longitude[13], speed[6], date[9] ;


void init_uart()
{
   // enable Tx/Rx circuitry
   UCSRB |= (1<<RXEN) | (1<<TXEN);

   // 4800bps, 8-bit data, no parity, 1 stop bit
   UCSRC |= (1<<URSEL) | (1<<UCSZ0) | (1<<UCSZ1);

   UBRRL = BAUD_PRESCALE;
   UBRRH = (BAUD_PRESCALE>>8);
}


void gprmc_only()
{
   int8_t GPRMC[] = "$PSTMNMEACONFIG,0,4800,64,1\r\n";

   while (GPRMC[data] != 0x00)
   {
      while ((UCSRA & (1<<UDRE)) == 0) {};
      UDR = GPRMC[data++];
   }
}


void time_menu()
{   
   data = 0;

   int8_t real_time[] = "time: ";
   
   while (real_time[data] != 0x00)
   {
      while ((UCSRA & (1<<UDRE)) == 0) {};
      UDR = real_time[data++];
   }
   
   data = 0;
   
   while (time[data] != ',')
   {
      while ((UCSRA & (1<<UDRE)) == 0) {};
      UDR = time[data++];
   }

   state = 0;   
}               

int main (void)
{
   init_uart();

   state = 0;
   parsing_state = 0;
   data = 0;
   
   UCSRB |= (1<<RXCIE);   // enable Rx complete interrupt

   _delay_ms(1000);
   _delay_ms(1000);
   _delay_ms(1000);

   gprmc_only();

   sei();   // enable all interrupt

   while (1)
   {
      if (state == 1)
      {
         UCSRB |= (0<<RXCIE); // disable Rx interrupt
         
         time_menu();
   
         UCSRB |= (1<<RXCIE); // enable Tx interrupt
      }

   }
}


ISR (USART_RXC_vect)
{
   switch (parsing_state)
   {
      case 0:

         data = 0;

         ReceivedByte[data] = UDR;
         
         if (ReceivedByte[data] == '$')
            parsing_state++;
         
         else
         {
            parsing_state = 0;
            state = 0;
         }

         break;


      case 1:
   
         ReceivedByte[data] = UDR;
         
         if (ReceivedByte[data] == ',')
            parsing_state++;
         
         else
         {
            parsing_state = 1;
            state = 0;
         }
            
         break;   


      case 2:

         data = 0;

         time[data] = UDR;

         if (time[data] == ',')
            parsing_state++;
         
         else
         {
            data++;
            parsing_state = 2;
            state = 0;
         }

         break;


      case 3:
         
         data = 0;

         ReceivedByte[data] = UDR;
         
         if (ReceivedByte[data] == ',')
            parsing_state++;

         else
         {
            parsing_state = 3;
            state =0;
         }

         break;

      case 4:
         

         data = 0;

         latitude[data] = UDR;

         if (latitude[data] == ',')
            parsing_state++;

         else
         {
            parsing_state = 4;
            data++;
            state = 0;
         }
            
         break;

      case 5:


         data = 0;

         ReceivedByte[data] = UDR;

         if (ReceivedByte[data] == ',')
            parsing_state++;

         else
         {
            parsing_state = 5;
            state = 0;
         }

         break;


      case 6:
         
         data = 0;

         longitude[data] = UDR;

         if (latitude[data] == ',')
            parsing_state++;

         else
         {
            parsing_state = 6;
            data++;
            state = 0;
         }

         break;


      case 7:
   
         data = 0;
         
         ReceivedByte[data] = UDR;
         
         if (ReceivedByte[data] == ',')
            parsing_state++;
         
         else
         {
            parsing_state = 7;
            state = 0;
         }
            
         break;

                  
      case 8:
         
         data = 0 ;

         speed[data] = UDR;

         if (speed[data] == ',')
            parsing_state++;

         else
         {
            parsing_state = 8;
            data++;
            state = 0;
         }

         break;


      case 9:
         
         data = 0;

         ReceivedByte[data] = UDR;

         if (ReceivedByte[data] == ',')
            parsing_state++;

         else
         {
            parsing_state = 9;
            state = 0;
         }

         break;

                        
      case 10:
         
         data = 0;

         date[data] = UDR;

         if (date[data] == ',')
            parsing_state++;

         else
         {
            parsing_state = 10;
            data++;
            state = 0;
         }
         
         break;


      case 11:

         data = 0;
         
         ReceivedByte[data] = UDR;

         if (ReceivedByte[data] == 0x00)
         {
            parsing_state = 0;
            state = 1;
         }
            
         else
         {
            parsing_state = 11;
            state = 0;
         }
         break;
      
   }

}

int main(void) {
  init_uart();
  while(1) {
     while ((UCSRA & (1<<UDRE)) == 0) {};
     UDR = 'A';
  }
}

//-----------------------------------------------
char cmd[80]; // buffer to construct parsable string terminating with CR

int main(void)
{     
.
.
.
     fgets( cmd, 80, stdin ); '//get command line string
     strip_newline( cmd, 80 ); //remove null terminator
.
.
.
     if ( strcmp ( cmd, "quit" ) == 0 )  //time to quit
      {
        //do something
      }
}
//-----------------------------------------------
// remove the null terminator from input string
void strip_newline( char *str, int size )
{
    int i;
    for (  i = 0; i < size; ++i )
    {
        if ( str[i] == '\n' )
        {
            str[i] = '\0';
            return;   /* we're done, exit function */
        }
    }
    /* if exit here, must not have been any newline! */
}
//-----------------------------------------------

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <string.h>

#define Buffer_Size 32
#define USART_BAUDRATE 9600
#define BAUD_PRESCALE 103

// Define the buffer structure
typedef struct buffer_
{
   char    data[Buffer_Size];
   uint8_t size;
} buffer;

// Set permanent buffer
   buffer   buf;   
   char    Command[Buffer_Size];
   
// Global variables
   uint8_t tel;

int main (void)
{
// Initialize Buffer
   buf.size = 0;

// Set RS485 enable pin as output
   DDRD |= (1<<DDD6);
   PORTD &= (0<<PORTD6);

// SETUP of USART 0
   // Turn on the TX RX
      UCSR0B |= (1 << RXEN0) | (1 << TXEN0);   

   // Use 8-bit char - Asynchronous, no parity, 1 Stop-bit
   UCSR0C |= (1 << UCSZ00) | (1 << UCSZ01);
        //Baud rate
   // Load lower 8-bits
   UBRR0L = BAUD_PRESCALE;
   // Load upper 8-bits
   UBRR0H = (BAUD_PRESCALE >> 8);
   
   tel = 0;

     // Enable the handling of USART interrupt vector
   UCSR0B |= (1 << RXCIE0)|(1 << TXCIE0);

      // Enable the Global Interrupts
      sei();

   for(;;)
   {
      if (tel == 1)
      {
                 //Set end of string     
         buf.data[buf.size] = 0;
                 //Copy string for command line
         strcpy(Command,&buf.data[1]);
                 // Reset buffer
         buf.size = 0;

         tel = 0;
                 //Output Enter
         PORTD |= (1<<PORTD6);
         UDR0 = '\r';
      }
   }
}

ISR(USART0_RX_vect)
{
   // Code to be executed when the USART receives a byte here
   char ReceivedByte;

   // Fetch the recieved byte
   ReceivedByte = UDR0;
   
   buf.size += 1;
   buf.data[buf.size] = ReceivedByte;

   if (ReceivedByte == '\r')
   {
      tel = 1;
   }
   else
   {
       //Clear previous data
                buf.data[buf.size+1] = 0;

            //Reflect received character
      PORTD |= (1<<PORTD6);
      UDR0 = buf.data[buf.size];
   }
}
   
ISR(USART0_TX_vect)
{
   PORTD &= (0<<PORTD6); // Enable RS485 receive
}

tel = 1;

if (tel == 1)
      {
                 //Set end of string     
         buf.data[buf.size] = 0;
                 //Copy string for command line
         strcpy(Command,&buf.data[1]);
                 // Reset buffer
         buf.size = 0;

         tel = 0;
                 //Output Enter
         PORTD |= (1<<PORTD6);
         UDR0 = '\r';
      }