#include <stdint.h>
#include <stdbool.h>
#include "tm4c123gh6pm.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>


#define MAX_FIELD_SIZE 100
volatile char nmea_sentence[MAX_FIELD_SIZE];
volatile uint8_t nmea_index = 0;
volatile bool nmea_ready = false;

void GPIO_PORT_F_init(void);
void GPIO_PORT_B_init(void);
void UART1_WRITE(char data);
void control_leds_based_on_speed(float speed_kmh);
void process_nmea_sentence(const char *nmea_sentence);

void GPIO_PORT_F_init(void)
    {   SYSCTL_RCGC2_R |= 0x00000020;    // ENABLE CLOCK TO GPIOF
        GPIO_PORTF_LOCK_R = 0x4C4F434B;  // UNLOCK COMMIT REGISTER
        GPIO_PORTF_CR_R   = 0x1F;        // MAKE PORTF0 CONFIGURABLE
        GPIO_PORTF_DEN_R  = 0x1F;        // SET PORTF DIGITAL ENABLE
        GPIO_PORTF_DIR_R  = 0x0E;        // SET PF0, PF4 as input and PF1, PF2 and PF3 as output
        GPIO_PORTF_PUR_R  = 0x11;        // PORTF PF0 and PF4 IS PULLED UP
    }


#define STRELOAD *((volatile uint32_t *) 0xE000E014)    // RELOAD VALUE REGISTER
#define STCURRENT *((volatile uint32_t *) 0xE000E018)    // CURRENT VALUE REGISTER
#define STCTRL *((volatile uint32_t *) 0xE000E010)    // CONTROL AND STATUS REGISTER
#define COUNT_FLAG  (1 << 16)   // BIT 16 OF CSR AUTOMATICALLY SET TO 1
#define ENABLE      (1 << 0)    // BIT 0 OF CSR TO ENABLE THE TIMER
#define CLKINT      (1 << 2)    // BIT 2 OF CSR TO SPECIFY CPU CLOCK
#define INTEN      (1 << 1)     // BIT 1 OF CSR TO ENABLE INTERRUPT
#define CLOCK_HZ 16000000       // CLOCK FREQUENCY OF EK-TM4C123GXL
#define SYSTICK_RELOAD_VALUE(us) ((CLOCK_HZ /1000000) * (us) - 1 ) // SYSTICK RELOAD VALUE IN MICROSECONDS BASED ON CLOCK FREQUENCY

#define RED_LED  0x02;
#define BLUE_LED  0x04;
#define GREEN_LED  0x08;
volatile uint8_t LED_STATE = 0;

void systick_setting(void)     // SYSTICK SETUP FUNCTION
{
       STRELOAD = SYSTICK_RELOAD_VALUE(500000);  // SYSTICK RELOAD VALUE 500 milliseconds
       STCURRENT = 0;                             //CLEARING STCURRENT REGISTER VALUE
       STCTRL |= (CLKINT | ENABLE | INTEN);       // SET INTERNAL CLOCK, ENABLE THE TIMER AND INTERRUPT ENABLE
}

void delay(int us)               //DEFINING DELAY FUNCTION
{
    STRELOAD = SYSTICK_RELOAD_VALUE(us) ;     // RELOAD VALUE FOR REQUIRED DELAY IN MICROSECONDS
    STCURRENT = 0;                            //CLEARING STCURRENT REGISTER VALUE
    STCTRL |= (CLKINT | ENABLE | INTEN );     // SET INTERNAL CLOCK, ENABLE THE TIMER
    while ((STCTRL & COUNT_FLAG) == 0)        //WAIT UNTIL FLAG IS SET
    {          // DO NOTHING
    }
    STCTRL &= 0x0;                //  STOP THE TIMER
}

void SystickHandler(void)       //SYSTICK INTERRUPT HANDLER
{
    GPIO_PORTF_DATA_R ^= LED_STATE;

}


void GPIO_PORT_B_init(void)
{
    SYSCTL_RCGCGPIO_R |= 0x02;                // ENABLE CLOCK FOR GPIOB
    SYSCTL_RCGCUART_R |= 0x02;                // ENABLE CLOCK FOR UART1

    GPIO_PORTB_DEN_R |= 0x03;                 // DIGITAL ENABLE FOR PB0 AND PB1
    GPIO_PORTB_AFSEL_R |= 0x03;               // ENABLE ALTERNATE FUNCTION ON PB0,PB1

    GPIO_PORTB_PCTL_R = (GPIO_PORTB_PCTL_R & 0xFFFFFF00) | 0x00000011; // Set PB0, PB1 for UART

    UART1_CTL_R &= ~0x01;                     // DISABLE UART1 DURING SETUP
    UART1_IBRD_R = 104;                       // Set integer part of baud rate (for 9600 baud at 16 MHz clock)
    UART1_FBRD_R = 11;                        // Set fractional part of baud rate
    UART1_LCRH_R = 0x60;                      // 8-bit, No parity, 1 stop bit
    UART1_CC_R = 0x00;                        // Use system clock

    UART1_CTL_R |= 0x301;                     // Enable UART1, RX, and TX0
    UART1_IM_R |= 0x10;
    NVIC_EN0_R |= (1 << 6);
}

void control_leds_based_on_speed(float speed_kmh)   // Control LEDs based on speed
{

    GPIO_PORTF_DATA_R &= 0x00;                       // Clear all LED bits (assuming LEDs are connected to bits 1, 2, and 3)

    if (speed_kmh >= 0.0 && speed_kmh < 0.5)        // Range 0-0.5 km/h
        {
            //GPIO_PORTF_DATA_R |= 0x08;                   // Blink Green LED
            LED_STATE = GREEN_LED;
        }
    else if (speed_kmh >= 0.5 && speed_kmh < 10.0)        // Range 0.5-10 km/h
    {
        GPIO_PORTF_DATA_R |= 0x08;                   // Green LED

    }
    else if (speed_kmh >= 10.0 && speed_kmh < 20.0)  // Range 10-20 km/h
    {
        GPIO_PORTF_DATA_R |= 0x0C;                   // Cyan LED
    }
    else if (speed_kmh >= 20.0 && speed_kmh < 30.0)  // Range 20-30 km/h
    {
        GPIO_PORTF_DATA_R |= 0x04;                   // Blue LED
    }
    else if (speed_kmh >= 30.0 && speed_kmh < 40.0)  // Range 30-40 km/h
    {
        GPIO_PORTF_DATA_R |= 0x06;                   // Yellow LED (Red + Green)
    }
    else if (speed_kmh >= 40.0 && speed_kmh < 50.0)  // Range 40-50 km/h
    {
        GPIO_PORTF_DATA_R |= 0x02;                   // RED LED
    }
    else                                             // Above 50 km/h
    {
        LED_STATE = RED_LED;                         // TOGGLING RED LED
    }
}



void nmea_sentence_process(const char *nmea_sentence)
{
    uint8_t i = 0;
    uint8_t field_number = 0;
    float speed_knots = 0.0;
    float speed_kmh = 0.0;
    uint8_t field_index = 0;

    if (nmea_sentence[0] != '$') return;  // Invalid sentence, exit

    if (strncmp(nmea_sentence + 1, "GPRMC", 5) == 0)
    {
     for (i = 6; nmea_sentence[i] != '\0'; i++)
     {
       if (nmea_sentence[i] == ',')
       {
          if (field_number == 7) // Speed in knots (field 7)
          {
          speed_knots = atof(nmea_sentence + i - field_index);
             speed_kmh = speed_knots * 1.852;
             control_leds_based_on_speed(speed_kmh);
          }
             field_number++;
             field_index = 0;
        }
       else if (nmea_sentence[i] == '*')
        {
           break;
        }
       else
        {
          field_index++;
        }
      }
     }
    else if (strncmp(nmea_sentence + 1, "GPVTG", 5) == 0)  // Process GPVTG sentence
    {
     for (i = 7; nmea_sentence[i] != '\0'; i++)
     {
     if (nmea_sentence[i] == ',')
       {
       if (field_number == 6)
           {
           speed_knots = atof(nmea_sentence + i - field_index);
           speed_kmh = speed_knots * 1.852;

              control_leds_based_on_speed(speed_kmh);
           }
              field_number++;
              field_index = 0;
                }
     else if (nmea_sentence[i] == '*')
          {
           break;
          }
     else {
           field_index++;
          }
         }
}
}

void UART1_Handler(void)
{
    char data = UART1_DR_R & 0xFF;
    if (data == '\n' || data == '\r')
    {
        nmea_sentence[nmea_index] = '\0';
        if (strncmp((const char *)nmea_sentence, "$GPRMC", 6) == 0)
        {
        nmea_ready = true;
        }
        nmea_index = 0;
    }
    else if (nmea_index < MAX_FIELD_SIZE - 1)
    {
        nmea_sentence[nmea_index++] = data;
    }
}

int main(void)
{
    GPIO_PORT_F_init();
    GPIO_PORT_B_init();
    systick_setting();
    while (1)
    {
     if (nmea_ready)
     {
      nmea_ready = false;
      nmea_sentence_process((const char *)nmea_sentence);
     }
    }
}