UART Devices: GPS, Bluetooth, and RS-485

/* Private defines */
#define GPS_BUF_SIZE  512
#define BT_TX_SIZE    128
#define RS485_TX_SIZE 128

/* Private variables */
uint8_t gps_dma_buf[GPS_BUF_SIZE];
volatile uint16_t gps_dma_head = 0;    /* Last processed position */
volatile uint8_t  gps_data_ready = 0;

char nmea_line[128];         /* Single NMEA sentence buffer */
uint16_t nmea_pos = 0;

char bt_tx_buf[BT_TX_SIZE];
char rs485_tx_buf[RS485_TX_SIZE];

/* Start DMA reception (call once after init) */
void gps_start_dma(void) {
    __HAL_UART_ENABLE_IT(&huart1, UART_IT_IDLE);
    HAL_UART_Receive_DMA(&huart1, gps_dma_buf, GPS_BUF_SIZE);
}

/* Add to USART1_IRQHandler in stm32f1xx_it.c, or use callback */
void HAL_UART_IdleCpltCallback(UART_HandleTypeDef *huart) {
    if (huart->Instance == USART1) {
        gps_data_ready = 1;
    }
}

/* Override the IRQ handler to catch the idle flag */
void USART1_IRQHandler(void) {
    if (__HAL_UART_GET_FLAG(&huart1, UART_FLAG_IDLE)) {
        __HAL_UART_CLEAR_IDLEFLAG(&huart1);
        gps_data_ready = 1;
    }
    HAL_UART_IRQHandler(&huart1);
}

uint16_t gps_process_buffer(void) {
    uint16_t tail = GPS_BUF_SIZE - __HAL_DMA_GET_COUNTER(huart1.hdmarx);
    uint16_t count = 0;

    while (gps_dma_head != tail) {
        uint8_t ch = gps_dma_buf[gps_dma_head];
        gps_dma_head = (gps_dma_head + 1) % GPS_BUF_SIZE;

        if (ch == '\n') {
            nmea_line[nmea_pos] = '\0';
            nmea_pos = 0;
            count++;
            /* Process the completed NMEA sentence */
            if (strncmp(nmea_line, "$GPRMC", 6) == 0 ||
                strncmp(nmea_line, "$GNRMC", 6) == 0) {
                parse_rmc(nmea_line);
            } else if (strncmp(nmea_line, "$GPGGA", 6) == 0 ||
                       strncmp(nmea_line, "$GNGGA", 6) == 0) {
                parse_gga(nmea_line);
            }
        } else if (ch != '\r' && nmea_pos < sizeof(nmea_line) - 1) {
            nmea_line[nmea_pos++] = ch;
        }
    }
    return count;
}

typedef struct {
    /* From RMC */
    uint8_t  fix_valid;       /* 'A' = valid, 'V' = void */
    float    latitude;        /* Decimal degrees (positive = N) */
    float    longitude;       /* Decimal degrees (positive = E) */
    float    speed_knots;
    float    course_deg;
    uint8_t  hour, minute, second;
    uint8_t  day, month, year;
    /* From GGA */
    uint8_t  fix_quality;     /* 0=none, 1=GPS, 2=DGPS */
    uint8_t  satellites;
} gps_data_t;

gps_data_t gps;

/* Extract the nth comma-separated field from an NMEA sentence */
static char* nmea_field(char *sentence, int index) {
    static char field[20];
    int current = 0;
    char *p = sentence;

    while (*p && current < index) {
        if (*p == ',') current++;
        p++;
    }

    int i = 0;
    while (*p && *p != ',' && *p != '*' && i < 19) {
        field[i++] = *p++;
    }
    field[i] = '\0';
    return field;
}

/* Convert NMEA coordinate (DDDMM.MMMM) to decimal degrees */
static float nmea_to_degrees(const char *coord, const char *dir) {
    if (coord[0] == '\0') return 0.0f;
    float raw = atof(coord);
    int degrees = (int)(raw / 100);
    float minutes = raw - (degrees * 100);
    float result = degrees + (minutes / 60.0f);
    if (dir[0] == 'S' || dir[0] == 'W') result = -result;
    return result;
}

void parse_rmc(char *sentence) {
    /*
     * nmea_field returns a pointer to a static buffer, so each call
     * overwrites the previous result. Copy each field immediately.
     */
    char time_str[20], status[4], lat_buf[20], lat_d[4];
    char lon_buf[20], lon_d[4], spd[12], crs[12], date_str[12];

    strncpy(time_str, nmea_field(sentence, 1), 19); time_str[19] = '\0';
    strncpy(status,   nmea_field(sentence, 2), 3);  status[3] = '\0';
    strncpy(lat_buf,  nmea_field(sentence, 3), 19); lat_buf[19] = '\0';
    strncpy(lat_d,    nmea_field(sentence, 4), 3);  lat_d[3] = '\0';
    strncpy(lon_buf,  nmea_field(sentence, 5), 19); lon_buf[19] = '\0';
    strncpy(lon_d,    nmea_field(sentence, 6), 3);  lon_d[3] = '\0';
    strncpy(spd,      nmea_field(sentence, 7), 11); spd[11] = '\0';
    strncpy(crs,      nmea_field(sentence, 8), 11); crs[11] = '\0';
    strncpy(date_str, nmea_field(sentence, 9), 11); date_str[11] = '\0';

    gps.fix_valid = (status[0] == 'A') ? 1 : 0;

    if (strlen(time_str) >= 6) {
        gps.hour   = (time_str[0] - '0') * 10 + (time_str[1] - '0');
        gps.minute = (time_str[2] - '0') * 10 + (time_str[3] - '0');
        gps.second = (time_str[4] - '0') * 10 + (time_str[5] - '0');
    }

    if (strlen(date_str) >= 6) {
        gps.day   = (date_str[0] - '0') * 10 + (date_str[1] - '0');
        gps.month = (date_str[2] - '0') * 10 + (date_str[3] - '0');
        gps.year  = (date_str[4] - '0') * 10 + (date_str[5] - '0');
    }

    if (gps.fix_valid) {
        gps.latitude    = nmea_to_degrees(lat_buf, lat_d);
        gps.longitude   = nmea_to_degrees(lon_buf, lon_d);
        gps.speed_knots = atof(spd);
        gps.course_deg  = atof(crs);
    }
}

void parse_gga(char *sentence) {
    char *fix_q = nmea_field(sentence, 6);
    char *sats  = nmea_field(sentence, 7);

    gps.fix_quality = atoi(fix_q);
    gps.satellites  = atoi(sats);
}

void bt_send_position(void) {
    if (!gps.fix_valid) {
        snprintf(bt_tx_buf, BT_TX_SIZE,
                 "NO FIX | Sats: %d | %02d:%02d:%02d UTC\r\n",
                 gps.satellites, gps.hour, gps.minute, gps.second);
    } else {
        int lat_deg = (int)gps.latitude;
        int lat_frac = (int)((gps.latitude - lat_deg) * 10000);
        if (lat_frac < 0) lat_frac = -lat_frac;

        int lon_deg = (int)gps.longitude;
        int lon_frac = (int)((gps.longitude - lon_deg) * 10000);
        if (lon_frac < 0) lon_frac = -lon_frac;

        snprintf(bt_tx_buf, BT_TX_SIZE,
                 "LAT:%d.%04d LON:%d.%04d SPD:%.1fkn SAT:%d %02d:%02d:%02d\r\n",
                 lat_deg, lat_frac, lon_deg, lon_frac,
                 gps.speed_knots, gps.satellites,
                 gps.hour, gps.minute, gps.second);
    }
    HAL_UART_Transmit(&huart2, (uint8_t*)bt_tx_buf, strlen(bt_tx_buf), 500);
}

#define RS485_TX_EN()  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_SET)
#define RS485_RX_EN()  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET)

void rs485_send(const char *data, uint16_t len) {
    RS485_TX_EN();
    /* Small delay for direction switching (1 bit time at 9600 = ~104 us) */
    for (volatile int i = 0; i < 100; i++);

    HAL_UART_Transmit(&huart3, (uint8_t*)data, len, 500);

    /* Wait for transmit complete (shift register empty) */
    while (__HAL_UART_GET_FLAG(&huart3, UART_FLAG_TC) == RESET);

    RS485_RX_EN();
}

void rs485_send_position(void) {
    if (!gps.fix_valid) return;

    int lat_deg = (int)gps.latitude;
    int lat_frac = (int)((gps.latitude - lat_deg) * 10000);
    if (lat_frac < 0) lat_frac = -lat_frac;

    int lon_deg = (int)gps.longitude;
    int lon_frac = (int)((gps.longitude - lon_deg) * 10000);
    if (lon_frac < 0) lon_frac = -lon_frac;

    snprintf(rs485_tx_buf, RS485_TX_SIZE,
             "\x02LAT:%d.%04d,LON:%d.%04d,SAT:%d\x03",
             lat_deg, lat_frac, lon_deg, lon_frac, gps.satellites);

    rs485_send(rs485_tx_buf, strlen(rs485_tx_buf));
}

/* Remote receiver: MAX485 RO connected to USART3 RX (PB11) */
/* DE+RE tied to PB1, held LOW for permanent receive mode */

#define RX_BUF_SIZE 128
uint8_t rx_buf[RX_BUF_SIZE];
uint8_t rx_pos = 0;
uint8_t msg_ready = 0;

void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart) {
    if (huart->Instance == USART3) {
        uint8_t ch = rx_buf[rx_pos];
        if (ch == 0x03) { /* ETX: end of message */
            rx_buf[rx_pos] = '\0';
            msg_ready = 1;
            rx_pos = 0;
        } else {
            if (rx_pos < RX_BUF_SIZE - 1) rx_pos++;
        }
        HAL_UART_Receive_IT(&huart3, &rx_buf[rx_pos], 1);
    }
}

/* In main loop: */
/* if (msg_ready) { process rx_buf (skip STX at index 0); msg_ready = 0; } */

/* Private variables */
uint32_t last_relay_tick = 0;
#define RELAY_INTERVAL_MS 2000

#define LED_FIX_ON()   HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET)
#define LED_FIX_OFF()  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_SET)

void led_update(void) {
    static uint32_t blink_tick = 0;
    static uint8_t  blink_state = 0;

    if (gps.fix_valid) {
        /* Blink: 100 ms on, 900 ms off */
        uint32_t now = HAL_GetTick();
        if (now - blink_tick >= (blink_state ? 100 : 900)) {
            blink_tick = now;
            blink_state = !blink_state;
            if (blink_state) LED_FIX_ON(); else LED_FIX_OFF();
        }
    } else {
        /* Steady on (active low) to indicate no fix */
        LED_FIX_ON();
    }
}

int main(void) {
    HAL_Init();
    SystemClock_Config();
    MX_GPIO_Init();
    MX_DMA_Init();
    MX_USART1_UART_Init();
    MX_USART2_UART_Init();
    MX_USART3_UART_Init();

    /* Initialize GPS DMA reception */
    gps_start_dma();

    /* Set RS-485 to receive mode by default */
    RS485_RX_EN();

    /* Clear GPS data */
    memset(&gps, 0, sizeof(gps));

    while (1) {
        uint32_t now = HAL_GetTick();

        /* Process GPS data when DMA buffer has new data */
        if (gps_data_ready) {
            gps_data_ready = 0;
            gps_process_buffer();
        }

        /* Relay position every 2 seconds */
        if (now - last_relay_tick >= RELAY_INTERVAL_MS) {
            last_relay_tick = now;

            /* Send to phone via Bluetooth */
            bt_send_position();

            /* Send to remote node via RS-485 */
            rs485_send_position();
        }

        /* Update fix LED */
        led_update();
    }
}

/* UBX-CFG-MSG: disable GSV on UART1 */
static const uint8_t ubx_disable_gsv[] = {
    0xB5, 0x62,       /* UBX sync bytes */
    0x06, 0x01,       /* CFG-MSG class/id */
    0x08, 0x00,       /* Payload length: 8 bytes */
    0xF0, 0x03,       /* NMEA class, GSV message id */
    0x00,             /* DDC (I2C): off */
    0x00,             /* UART1: off */
    0x00,             /* UART2: off */
    0x00,             /* USB: off */
    0x00,             /* SPI: off */
    0x00,             /* reserved */
    0x02, 0x38        /* Checksum (CK_A, CK_B) */
};

void gps_configure(void) {
    HAL_UART_Transmit(&huart1, (uint8_t*)ubx_disable_gsv,
                      sizeof(ubx_disable_gsv), 100);
    HAL_Delay(100);
    /* Add similar commands for other unwanted sentences (GSA, VTG, GLL) */
}

uint8_t nmea_verify_checksum(const char *sentence) {
    /* Sentence format: $GPRMC,...*XX  (XX = hex checksum) */
    if (sentence[0] != '$') return 0;

    uint8_t calc = 0;
    int i = 1;
    while (sentence[i] && sentence[i] != '*') {
        calc ^= sentence[i];
        i++;
    }
    if (sentence[i] != '*') return 0;

    /* Parse the two hex digits after the asterisk */
    char hex[3] = {sentence[i+1], sentence[i+2], '\0'};
    uint8_t expected = (uint8_t)strtol(hex, NULL, 16);

    return (calc == expected) ? 1 : 0;
}