harp_synchronizer.h

Go to the documentation of this file.

#ifndef HARP_SYNCHRONIZER_H
#define HARP_SYNCHRONIZER_H
#include <stdint.h>
#include <pico/stdlib.h>
#include <hardware/uart.h>
#include <hardware/irq.h>
#include <hardware/sync.h>
#include <hardware/structs/timer.h>
 
#ifdef DEBUG
#include <cstdio> // for printf
#endif
 
#define HARP_SYNC_BAUDRATE (100'000UL)
#define HARP_SYNC_DATA_BITS (8)
#define HARP_SYNC_STOP_BITS (1)
#define HARP_SYNC_PARITY (UART_PARITY_NONE)
 
#define HARP_SYNC_OFFSET_US (672 - 90) // time (in [us]) from the **end** of
                                       // the last packet byte and the time
                                       // specified in that packet.
 
// Synchronizer that updates RP2040's timekeeping registers according to
//  specific uart input. Singleton.
class HarpSynchronizer
{
public:
    enum SyncState
    {
        RECEIVE_HEADER_0,
        RECEIVE_HEADER_1,
        RECEIVE_TIMESTAMP
    };
 
private:
    // Make constructor/destructor private.
    HarpSynchronizer(uart_inst_t* uart_id, uint8_t uart_rx_pin);
    ~HarpSynchronizer();
public:
    // Disable default constructor, copy constructor, and assignment operator.
    HarpSynchronizer() = delete;
    HarpSynchronizer(HarpSynchronizer& other) = delete;
    void operator=(const HarpSynchronizer& other) = delete;
 
    static HarpSynchronizer& init(uart_inst_t* uart, uint8_t uart_rx_pin);
 
    static HarpSynchronizer& instance(){return *self;}
 
    static inline uint64_t system_to_harp_us_64(uint64_t system_time_us)
    {return system_time_us - self->offset_us_64_;}
 
    static inline void set_harp_time_us_64(uint64_t harp_time_us)
    {self->offset_us_64_ = ::time_us_64() - harp_time_us;}
 
    static inline uint64_t time_us_64()
    {return system_to_harp_us_64(::time_us_64());}
 
    static inline uint32_t time_us_32()
    {return uint32_t(time_us_64());}    // FIXME: this should execute faster
                                        // but truncating for speed involves
                                        // checking a bunch of edge cases.
 
    static inline uint64_t harp_to_system_us_64(uint64_t harp_time_us)
    {return harp_time_us + self->offset_us_64_;}
 
    static inline uint32_t harp_to_system_us_32(uint64_t harp_time_us)
    {return uint32_t(harp_to_system_us_64(harp_time_us));}
 
    static inline bool is_synced()
    {return self->has_synced_;}
 
private:
    static inline HarpSynchronizer* self = nullptr;
 
    static void uart_rx_callback();
 
    uart_inst_t* uart_id_;
 
    // members edited within an ISR must be volatile.
    volatile SyncState state_;
    volatile uint8_t packet_index_;
    volatile bool new_timestamp_;
 
    volatile uint64_t offset_us_64_;
 
    volatile bool has_synced_;
    alignas(uint32_t) volatile uint8_t sync_data_[4];
 
    friend class HarpCore;
};
 
#endif // HARP_SYNCHRONIZER_H