Форум arduino.ua

Ви хочете розібратись і навчитись, чи просто отримати готовий результат?

Якщо перше, то почніть з простої програми, поступово додаючи потрібні функції. Почитайте туторіали, подивіться навчальні відео, їх зараз мільйони. Якісь конкретні питання - пишіть, що саме незрозуміло.

Якщо друге, то шукайте виконавця, який зробить вам послугу за відповідну оплату.

Можна в ISO C99, а з gcc можна і в C++. Але чи варто - залежить від контексту. В даному випадку навряд чи.

Навіщо зберігати символи в String, якщо потім їх копіювати в char[] ?

Навіщо присвоювати token = nullptr, якщо відразу ж присвоюється token = commaPos + 1?
Раз на то пішло, то хоча б

switch (fieldIndex) {
    case 1: printFormattedTime(token); break;
    case 2: printFormattedValid(token); break;
    case 7: printFormattedSpeed(token); break;
    case 9: printFormattedDate(token); break;
    default: break;
}
token = commaPos + 1;

Якщо вже так хочеться float, навіщо проміжна змінна і C-style кастинг? Такий же результат дасть

int speedKmh = atof(rawKnot) * 1.852;

А краще

int speedKmh = round(atof(rawKnot) * 1.8523);

У разі невалідних вхідних даних може бути переповнення буфера. Хоча б

sprintf(fullSpeed, sizeof(fullSpeed), "%03d", speedKmh);

Хоча у разі невалідних вхідних даних переповнення буфера буде ще на стадії отримання строки з UART.

Цікаво. Цих не доводилось щупати.
Трохи грався з CH32V. Наче нічо, але в "продакшн" їх брати поки б не ризикував. Документація мізерна, є питання щодо надійності в довгостроковій перспективі. Ну і треба розуміти, що кілобайт на AVR8 і кілобайт на RV32 - це дещо різний кілобайт.

Так правду кажуть, мультипоточність - для тих, хто не зрозумів конечні автомати
Це зручно, але кожній задачі потрібен стек, як мінімум щоб зберігати контекст. На Attiny13 ОЗУ 64 байта, а контекст регістрів - 32 байта. На Attiny15 взагалі ОЗУ нема

Мені здається, навпаки, для більшості задач, які намагаються вирішувати за допомогою ардуіни (в тому числі і тут на форумі), декларативна парадигма так і проситься. Але то таке, філософія.

Це поки самі value не містять в собі comma, які можуть бути не тільки екрановані, а і в складі літералів у одинарних або подвійних лапках, наприклад.

Ви про цей вираз? Так і формат адреси відповідно до RFC 822 непростий. До того ж, такі вирази не пишуться вручну, а генеруються з простіших частин. Ви ж не звинувачуєте компілятор C++, що він генерує машинний код, який людині складно розібрати? Регулярний вираз - той же "машинний код" для КА.

"Звичайна" програма з розгалуженнями і циклами - це теж КА (як мінімум).

Саме так. Але це має сенс для парсинга нерегулярних синтаксисів. Для регулярних, типу як в NEMA, достатньо КА.
Якби в arduino core була підтримка регулярних виразів, весь той КА можна було би описати однією строкою. Хіба що обчислення контрольної суми довелось би реалізовувати окремо.

Та ось вам іще одна наївна реалізація

class nmea
{
    void (nmea::*context_)(char);

    uint8_t buf_idx_;
    uint8_t tok_idx_;
    uint8_t tok_start_;
    uint8_t checksum_;
    bool ready_;

    char buf_[80];
    uint8_t tokens_[80];

    void update_checksum(uint8_t c)
    {
        checksum_ ^= c;
    }

    void skip()
    {
        context_ = &nmea::ctx_skip;
    }

    void reset()
    {
        context_ = &nmea::ctx_reset;
    }

    void append_buf(char c)
    {
        if (buf_idx_ >= sizeof(buf_)/sizeof(*buf_)) {
            skip();
            return;
        }
        buf_[buf_idx_++] = c;
    }

    void append_tok()
    {
        if (tok_idx_ < sizeof(tokens_)/sizeof(*tokens_)) {
            tokens_[tok_idx_++] = tok_start_;
        }
    }

    void ctx_reset(char c)
    {
        ready_ = false;

        if (c != '$') {
            return;
        }

        context_ = &nmea::ctx_tokens;
        buf_idx_ = 0;
        tok_idx_ = 0;
        tok_start_ = 0;
        checksum_ = 0;
    }

    void ctx_skip(char c)
    {
        if (c == '\n') {
            context_ = &nmea::ctx_reset;
        }
    }

    void ctx_tokens(char c)
    {
        if (c == '*') {
            context_ = &nmea::ctx_checksum;
            append_tok();
            append_buf('\0');
            tok_start_ = buf_idx_;
            return;
        }

        if (c == '\n') {
            reset();
            return;
        }

        update_checksum(c);

        if (c == ',') {
            append_tok();
            append_buf('\0');
            tok_start_ = buf_idx_;
            return;
        }

        append_buf(c);
    }

    void ctx_checksum(char c)
    {
        if (c == '\r') {
            if (buf_idx_ - tok_start_ != 2) {
                skip();
            }
            return;
        }
        if (c == '\n') {
            if (buf_idx_ - tok_start_ != 2) {
                reset();
                return;
            }
            append_buf('\0');
            char *endptr;
            uint8_t checksum = strtoul(buf_ + tok_start_, &endptr, 16);
            if (*endptr == '\0' && checksum == checksum_) {
                ready_ = true;
            }
            reset();
            return;
        }

        append_buf(c);
    }

public:
    nmea() : context_ { &nmea::ctx_reset } {};

    bool parse(char c)
    {
        (this->*context_)(c);
        return ready_;
    }

    const char *token(uint8_t idx) const
    {
        return (idx < tok_idx_) ? (buf_ + tokens_[idx]) : "";
    }
}

Детально на баги не тестив, на даних з оригінального поста наче працює.

Приклад використання:

nmea nmea;

void loop()
{
    for (int c; (c = SoftwareSerial.read()) != -1;) {
        if (!nmea.parse(c)) {
            continue;
        }
        const char *type = nmea.token(0);

        Serial.print(F("Parsed: "));
        Serial.print(type);

        if (strcmp(type, "GPGGA") == 0) {
            Serial.print(F(" time: "));
            Serial.print(nmea.token(1));
            Serial.print(F("; location: "));
            Serial.print(nmea.token(2));
            Serial.print(nmea.token(3));
            Serial.print(nmea.token(4));
            Serial.print(nmea.token(5));
        }

        Serial.println();
    }
}

Оффтоп: баг з бекслешами на цьому форумі колись пофіксять?

strtok() витягає тільки непусті токени. NMEA може містити пусті.

sscanf() - невдалий вибір для парсингу такого синтаксиса. Його тут можна застосувати для парсингу окремого токена, але для рядка в цілому він погано підходить.

Токени розділені комами, так шукайте символ коми. Або за допомогою strchr(), або своєю реалізацією, що не набагато складніше. Потім парсіть вміст між комами.

Навіщо копіювати кожний токен в окремий буфер? Він же і так уже присутній в памʼяті. Якщо для парсинга самого токена він має закінчуватись нульовим символом, заміняйте кому на нульовий символ. 

Якщо не помиляюсь, максимальна довжина рядка NMEA - 82 символи. Тобто буфера довжиною 83 символи буде достатньо. Чому 88?

Взагалі, ви спочатку накопичуєте всю строку в буфер, потім намагаєтесь її парсити. Звісно, можна і так. Але, мені здається, простіше парсити дані по мірі надходження.

Ага, і мабуть ще струмовий шунт між вхідним і вихідним мінусами.