openpilot

opendbc

class CANPacker

Public Functions

CANPacker(const std::string &dbc_name)

std::vector<uint8_t> pack(uint32_t address, const std::vector<SignalPackValue> &values)

Msg *lookup_message(uint32_t address)

Private Members

const DBC *dbc = NULL

std::map<std::pair<uint32_t, std::string>, Signal> signal_lookup

std::map<uint32_t, Msg> message_lookup

std::map<uint32_t, uint32_t> counters

class CANParser

Public Functions

CANParser(int abus, const std::string &dbc_name, const std::vector<std::pair<uint32_t, int>> &messages)

CANParser(int abus, const std::string &dbc_name, bool ignore_checksum, bool ignore_counter)

void update_string(const std::string &data, bool sendcan)

void update_strings(const std::vector<std::string> &data, std::vector<SignalValue> &vals, bool sendcan)

void UpdateCans(uint64_t nanos, const capnp::List<cereal::CanData>::Reader &cans)

void UpdateCans(uint64_t nanos, const capnp::DynamicStruct::Reader &cans)

void UpdateValid(uint64_t nanos)

void query_latest(std::vector<SignalValue> &vals, uint64_t last_ts = 0)

Public Members

bool can_valid = false

bool bus_timeout = false

uint64_t first_nanos = 0

uint64_t last_nanos = 0

uint64_t last_nonempty_nanos = 0

uint64_t bus_timeout_threshold = 0

uint64_t can_invalid_cnt = CAN_INVALID_CNT

Private Members

const int bus

kj::Array<capnp::word> aligned_buf

const DBC *dbc = NULL

std::unordered_map<uint32_t, MessageState> message_states

class MessageState

Public Functions

bool parse(uint64_t nanos, const std::vector<uint8_t> &dat)

bool update_counter_generic(int64_t v, int cnt_size)

Public Members

std::string name

uint32_t address

unsigned int size

std::vector<Signal> parse_sigs

std::vector<double> vals

std::vector<std::vector<double>> all_vals

uint64_t last_seen_nanos

uint64_t check_threshold

uint8_t counter

uint8_t counter_fail

bool ignore_checksum = false

bool ignore_counter = false

file common.h

#include <map>

#include <string>

#include <utility>

#include <unordered_map>

#include <vector>

#include <capnp/dynamic.h>

#include <capnp/serialize.h>

#include “cereal/gen/cpp/log.capnp.h”

#include “opendbc/can/common_dbc.h”

Defines

INFO

WARN

DEBUG(...)

MAX_BAD_COUNTER

CAN_INVALID_CNT

Functions

void init_crc_lookup_tables()

unsigned int honda_checksum(uint32_t address, const Signal &sig, const std::vector<uint8_t> &d)

unsigned int toyota_checksum(uint32_t address, const Signal &sig, const std::vector<uint8_t> &d)

unsigned int subaru_checksum(uint32_t address, const Signal &sig, const std::vector<uint8_t> &d)

unsigned int chrysler_checksum(uint32_t address, const Signal &sig, const std::vector<uint8_t> &d)

unsigned int volkswagen_mqb_checksum(uint32_t address, const Signal &sig, const std::vector<uint8_t> &d)

unsigned int xor_checksum(uint32_t address, const Signal &sig, const std::vector<uint8_t> &d)

unsigned int hkg_can_fd_checksum(uint32_t address, const Signal &sig, const std::vector<uint8_t> &d)

unsigned int pedal_checksum(uint32_t address, const Signal &sig, const std::vector<uint8_t> &d)

dir /tmp/openpilot/opendbc/can

dir /tmp/openpilot/opendbc

cereal

messaging

class AlignedBuffer

Public Functions

kj::ArrayPtr<const capnp::word> align(const char *data, const size_t size)

kj::ArrayPtr<const capnp::word> align(Message *m)

Private Members

kj::Array<capnp::word> aligned_buf

size_t words_size

class Context

Subclassed by MSGQContext, ZMQContext

Public Functions

virtual void *getRawContext() = 0

virtual ~Context()

Public Static Functions

static Context *create()

class Event

Public Functions

Event(int fd = -1)

void set() const

int clear() const

void wait(int timeout_sec = -1) const

bool peek() const

bool is_valid() const

int fd() const

Public Static Functions

static int wait_for_one(const std::vector<Event> &events, int timeout_sec = -1)

Private Functions

void throw_if_invalid() const

Private Members

int event_fd = -1

struct EventState

Public Members

int fds[2]

bool enabled

class FakePoller : public Poller 

Public Functions

void registerSocket(SubSocket *socket)

std::vector<SubSocket*> poll(int timeout)

~FakePoller()

Private Members

std::vector<SubSocket*> sockets

template<typename TSubSocket> class FakeSubSocket : public TSubSocket 

Public Functions

FakeSubSocket()

~FakeSubSocket()

int connect(Context *context, std::string endpoint, std::string address, bool conflate = false, bool check_endpoint = true)

Message *receive(bool non_blocking = false)

Private Members

Event *recv_called = nullptr

Event *recv_ready = nullptr

EventState *state = nullptr

class Message

Subclassed by MSGQMessage, ZMQMessage

Public Functions

virtual void init(size_t size) = 0

virtual void init(char *data, size_t size) = 0

virtual void close() = 0

virtual size_t getSize() = 0

virtual char *getData() = 0

virtual ~Message()

class MessageBuilder : public MallocMessageBuilder

Public Functions

MessageBuilder()

cereal::Event::Builder initEvent(bool valid = true)

kj::ArrayPtr<capnp::byte> toBytes()

size_t getSerializedSize()

int serializeToBuffer(unsigned char *buffer, size_t buffer_size)

Private Members

kj::Array<capnp::word> heapArray_

struct msgq_header_t

Public Members

uint64_t num_readers

uint64_t write_pointer

uint64_t write_uid

uint64_t read_pointers[NUM_READERS]

uint64_t read_valids[NUM_READERS]

uint64_t read_uids[NUM_READERS]

struct msgq_msg_t

Public Members

size_t size

char *data

struct msgq_pollitem_t

Public Members

msgq_queue_t *q

int revents

struct msgq_queue_t

Public Members

std::atomic<uint64_t> *num_readers

std::atomic<uint64_t> *write_pointer

std::atomic<uint64_t> *write_uid

std::atomic<uint64_t> *read_pointers[NUM_READERS]

std::atomic<uint64_t> *read_valids[NUM_READERS]

std::atomic<uint64_t> *read_uids[NUM_READERS]

char *mmap_p

char *data

size_t size

int reader_id

uint64_t read_uid_local

uint64_t write_uid_local

bool read_conflate

std::string endpoint

class MSGQContext : public Context 

Public Functions

MSGQContext()

void *getRawContext()

~MSGQContext()

Private Members

void *context = NULL

class MSGQMessage : public Message 

Public Functions

void init(size_t size)

void init(char *data, size_t size)

void takeOwnership(char *data, size_t size)

size_t getSize()

char *getData()

void close()

~MSGQMessage()

Private Members

char *data

size_t size

class MSGQPoller : public Poller 

Public Functions

void registerSocket(SubSocket *socket)

std::vector<SubSocket*> poll(int timeout)

~MSGQPoller()

Private Members

std::vector<SubSocket*> sockets

msgq_pollitem_t polls[MAX_POLLERS]

size_t num_polls = 0

class MSGQPubSocket : public PubSocket 

Public Functions

int connect(Context *context, std::string endpoint, bool check_endpoint = true)

int sendMessage(Message *message)

int send(char *data, size_t size)

bool all_readers_updated()

~MSGQPubSocket()

Private Members

msgq_queue_t *q = NULL

class MSGQSubSocket : public SubSocket 

Public Functions

int connect(Context *context, std::string endpoint, std::string address, bool conflate = false, bool check_endpoint = true)

void setTimeout(int timeout)

void *getRawSocket()

Message *receive(bool non_blocking = false)

~MSGQSubSocket()

Private Members

msgq_queue_t *q = NULL

int timeout

class Poller

Subclassed by FakePoller, MSGQPoller, ZMQPoller

Public Functions

virtual void registerSocket(SubSocket *socket) = 0

virtual std::vector<SubSocket*> poll(int timeout) = 0

virtual ~Poller()

Public Static Functions

static Poller *create()

static Poller *create(std::vector<SubSocket*> sockets)

class PubMaster

Public Functions

PubMaster(const std::vector<const char*> &service_list)

int send(const char *name, capnp::byte *data, size_t size)

int send(const char *name, MessageBuilder &msg)

~PubMaster()

Private Members

std::map<std::string, PubSocket*> sockets_

class PubSocket

Subclassed by MSGQPubSocket, ZMQPubSocket

Public Functions

virtual int connect(Context *context, std::string endpoint, bool check_endpoint = true) = 0

virtual int sendMessage(Message *message) = 0

virtual int send(char *data, size_t size) = 0

virtual bool all_readers_updated() = 0

virtual ~PubSocket()

Public Static Functions

static PubSocket *create()

static PubSocket *create(Context *context, std::string endpoint, bool check_endpoint = true)

static PubSocket *create(Context *context, std::string endpoint, int port, bool check_endpoint = true)

class SocketEventHandle

Public Functions

SocketEventHandle(std::string endpoint, std::string identifier = "", bool override = true)

~SocketEventHandle()

bool is_enabled()

void set_enabled(bool enabled)

Event recv_called()

Event recv_ready()

Public Static Functions

static void toggle_fake_events(bool enabled)

static void set_fake_prefix(std::string prefix)

static std::string fake_prefix()

Private Members

std::string shm_path

EventState *state

class SubMaster

Public Functions

SubMaster(const std::vector<const char*> &service_list, const std::vector<const char*> &poll = {}, const char *address = nullptr, const std::vector<const char*> &ignore_alive = {})

void update(int timeout = 1000)

void update_msgs(uint64_t current_time, const std::vector<std::pair<std::string, cereal::Event::Reader>> &messages)

bool allAlive(const std::vector<const char*> &service_list = {})

bool allValid(const std::vector<const char*> &service_list = {})

bool allAliveAndValid(const std::vector<const char*> &service_list = {})

void drain()

~SubMaster()

bool updated(const char *name) const

bool alive(const char *name) const

bool valid(const char *name) const

uint64_t rcv_frame(const char *name) const

uint64_t rcv_time(const char *name) const

cereal::Event::Reader &operator[](const char *name) const

Public Members

uint64_t frame = 0

Private Functions

bool all_(const std::vector<const char*> &service_list, bool valid, bool alive)

Private Members

Poller *poller_ = nullptr

std::map<SubSocket*, SubMessage*> messages_

std::map<std::string, SubMessage*> services_

class SubSocket

Subclassed by MSGQSubSocket, ZMQSubSocket

Public Functions

virtual int connect(Context *context, std::string endpoint, std::string address, bool conflate = false, bool check_endpoint = true) = 0

virtual void setTimeout(int timeout) = 0

virtual Message *receive(bool non_blocking = false) = 0

virtual void *getRawSocket() = 0

virtual ~SubSocket()

Public Static Functions

static SubSocket *create()

static SubSocket *create(Context *context, std::string endpoint, std::string address = "127.0.0.1", bool conflate = false, bool check_endpoint = true)

class ZMQContext : public Context 

Public Functions

ZMQContext()

void *getRawContext()

~ZMQContext()

Private Members

void *context = NULL

class ZMQMessage : public Message 

Public Functions

void init(size_t size)

void init(char *data, size_t size)

size_t getSize()

char *getData()

void close()

~ZMQMessage()

Private Members

char *data

size_t size

class ZMQPoller : public Poller 

Public Functions

void registerSocket(SubSocket *socket)

std::vector<SubSocket*> poll(int timeout)

~ZMQPoller()

Private Members

std::vector<SubSocket*> sockets

zmq_pollitem_t polls[MAX_POLLERS]

size_t num_polls = 0

class ZMQPubSocket : public PubSocket 

Public Functions

int connect(Context *context, std::string endpoint, bool check_endpoint = true)

int sendMessage(Message *message)

int send(char *data, size_t size)

bool all_readers_updated()

~ZMQPubSocket()

Private Members

void *sock

std::string full_endpoint

int pid = -1

class ZMQSubSocket : public SubSocket 

Public Functions

int connect(Context *context, std::string endpoint, std::string address, bool conflate = false, bool check_endpoint = true)

void setTimeout(int timeout)

void *getRawSocket()

Message *receive(bool non_blocking = false)

~ZMQSubSocket()

Private Members

void *sock

std::string full_endpoint

file event.h

#include <string>

#include <vector>

Defines

CEREAL_EVENTS_PREFIX

Enums

enum EventPurpose

Values:

enumerator RECV_CALLED

enumerator RECV_READY

Functions

void event_state_shm_mmap(std::string endpoint, std::string identifier, char **shm_mem, std::string *shm_path)

file impl_fake.h: #include <cassert>

#include <iostream>

#include <string>

#include <vector>

#include <filesystem>

#include <sys/mman.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include “cereal/messaging/messaging.h”

#include “cereal/messaging/event.h”

file impl_msgq.h

#include <string>

#include <vector>

#include “cereal/messaging/messaging.h”

#include “cereal/messaging/msgq.h”

Defines

MAX_POLLERS

file impl_zmq.h

#include <zmq.h>

#include <string>

#include <vector>

#include “cereal/messaging/messaging.h”

Defines

MAX_POLLERS

file messaging.h

#include <cstddef>

#include <map>

#include <string>

#include <vector>

#include <utility>

#include <time.h>

#include <capnp/serialize.h>

#include “cereal/gen/cpp/log.capnp.h”

Defines

MSG_MULTIPLE_PUBLISHERS

Functions

bool messaging_use_zmq()

file msgq.h

#include <cstdint>

#include <cstring>

#include <string>

#include <atomic>

Defines

DEFAULT_SEGMENT_SIZE

NUM_READERS

ALIGN(n)

UNUSED(x)

UNPACK64(higher, lower, input)

PACK64(output, higher, lower)

Functions

void msgq_wait_for_subscriber(msgq_queue_t *q)

void msgq_reset_reader(msgq_queue_t *q)

int msgq_msg_init_size(msgq_msg_t *msg, size_t size)

int msgq_msg_init_data(msgq_msg_t *msg, char *data, size_t size)

int msgq_msg_close(msgq_msg_t *msg)

int msgq_new_queue(msgq_queue_t *q, const char *path, size_t size)

void msgq_close_queue(msgq_queue_t *q)

void msgq_init_publisher(msgq_queue_t *q)

void msgq_init_subscriber(msgq_queue_t *q)

int msgq_msg_send(msgq_msg_t *msg, msgq_queue_t *q)

int msgq_msg_recv(msgq_msg_t *msg, msgq_queue_t *q)

int msgq_msg_ready(msgq_queue_t *q)

int msgq_poll(msgq_pollitem_t *items, size_t nitems, int timeout)

bool msgq_all_readers_updated(msgq_queue_t *q)

dir /tmp/openpilot/cereal

dir /tmp/openpilot/cereal/messaging

visionipc

class VisionBuf

Public Functions

void allocate(size_t len)

void import()

void init_cl(cl_device_id device_id, cl_context ctx)

void init_rgb(size_t width, size_t height, size_t stride)

void init_yuv(size_t width, size_t height, size_t stride, size_t uv_offset)

int sync(int dir)

int free()

void set_frame_id(uint64_t id)

uint64_t get_frame_id()

Public Members

size_t len = 0

size_t mmap_len = 0

void *addr = nullptr

uint64_t *frame_id

int fd = 0

bool rgb = false

size_t width = 0

size_t height = 0

size_t stride = 0

size_t uv_offset = 0

uint8_t *y = nullptr

uint8_t *uv = nullptr

uint64_t server_id = 0

size_t idx = 0

VisionStreamType type

cl_mem buf_cl = nullptr

cl_command_queue copy_q = nullptr

int handle = 0

class VisionIpcClient

Public Functions

VisionIpcClient(std::string name, VisionStreamType type, bool conflate, cl_device_id device_id = nullptr, cl_context ctx = nullptr)

~VisionIpcClient()

VisionBuf *recv(VisionIpcBufExtra *extra = nullptr, const int timeout_ms = 100)

bool connect(bool blocking = true)

bool is_connected()

Public Members

bool connected = false

VisionStreamType type

int num_buffers = 0

VisionBuf buffers[VISIONIPC_MAX_FDS]

Public Static Functions

static std::set<VisionStreamType> getAvailableStreams(const std::string &name, bool blocking = true)

Private Members

std::string name

Context *msg_ctx

SubSocket *sock

Poller *poller

cl_device_id device_id = nullptr

cl_context ctx = nullptr

class VisionIpcServer

Public Functions

VisionIpcServer(std::string name, cl_device_id device_id = nullptr, cl_context ctx = nullptr)

~VisionIpcServer()

VisionBuf *get_buffer(VisionStreamType type)

void create_buffers(VisionStreamType type, size_t num_buffers, bool rgb, size_t width, size_t height)

void create_buffers_with_sizes(VisionStreamType type, size_t num_buffers, bool rgb, size_t width, size_t height, size_t size, size_t stride, size_t uv_offset)

void send(VisionBuf *buf, VisionIpcBufExtra *extra, bool sync = true)

void start_listener()

Private Functions

void listener(void)

Private Members

cl_device_id device_id = nullptr

cl_context ctx = nullptr

uint64_t server_id

std::atomic<bool> should_exit = false

std::string name

std::thread listener_thread

std::map<VisionStreamType, std::atomic<size_t>> cur_idx

std::map<VisionStreamType, std::vector<VisionBuf*>> buffers

Context *msg_ctx

std::map<VisionStreamType, PubSocket*> sockets

file ipc.h

#include <cstddef>

Functions

int ipc_connect(const char *socket_path)

int ipc_bind(const char *socket_path)

int ipc_sendrecv_with_fds(bool send, int fd, void *buf, size_t buf_size, int *fds, int num_fds, int *out_num_fds)

file visionbuf.h

#include “cereal/visionipc/visionipc.h”

#include <CL/cl.h>

Defines

CL_USE_DEPRECATED_OPENCL_1_2_APIS

VISIONBUF_SYNC_FROM_DEVICE

VISIONBUF_SYNC_TO_DEVICE

Enums

enum VisionStreamType

Values:

enumerator VISION_STREAM_ROAD

enumerator VISION_STREAM_DRIVER

enumerator VISION_STREAM_WIDE_ROAD

enumerator VISION_STREAM_MAP

enumerator VISION_STREAM_MAX

Functions

void visionbuf_compute_aligned_width_and_height(int width, int height, int *aligned_w, int *aligned_h)

file visionipc_client.h: #include <set>

#include <string>

#include “cereal/messaging/messaging.h”

#include “cereal/visionipc/visionbuf.h”

file visionipc_server.h

#include <vector>

#include <string>

#include <thread>

#include <atomic>

#include <map>

#include “cereal/messaging/messaging.h”

#include “cereal/visionipc/visionbuf.h”

Functions

std::string get_endpoint_name(std::string name, VisionStreamType type)

std::string get_ipc_path(const std::string &name)

dir /tmp/openpilot/cereal

dir /tmp/openpilot/cereal/visionipc

selfdrive

camerad

class CameraBuf

Public Functions

CameraBuf()

~CameraBuf()

void init(cl_device_id device_id, cl_context context, CameraState *s, VisionIpcServer *v, int frame_cnt, VisionStreamType type)

bool acquire()

void queue(size_t buf_idx)

Public Members

cl_command_queue q

FrameMetadata cur_frame_data

VisionBuf *cur_yuv_buf

VisionBuf *cur_camera_buf

std::unique_ptr<VisionBuf[]> camera_bufs

std::unique_ptr<FrameMetadata[]> camera_bufs_metadata

int rgb_width

int rgb_height

Private Members

VisionIpcServer *vipc_server

ImgProc *imgproc = nullptr

VisionStreamType stream_type

int cur_buf_idx

SafeQueue<int> safe_queue

int frame_buf_count

class CameraState

Public Functions

void handle_camera_event(void *evdat)

void update_exposure_score(float desired_ev, int exp_t, int exp_g_idx, float exp_gain)

void set_camera_exposure(float grey_frac)

void sensors_start()

void camera_open(MultiCameraState *multi_cam_state, int camera_num, bool enabled)

void set_exposure_rect()

void sensor_set_parameters()

void camera_map_bufs(MultiCameraState *s)

void camera_init(MultiCameraState *s, VisionIpcServer *v, cl_device_id device_id, cl_context ctx, VisionStreamType yuv_type, float focal_len)

void camera_close()

void config_isp(int io_mem_handle, int fence, int request_id, int buf0_mem_handle, int buf0_offset)

void enqueue_req_multi(int start, int n, bool dp)

void enqueue_buffer(int i, bool dp)

int clear_req_queue()

int sensors_init()

void sensors_poke(int request_id)

void sensors_i2c(const struct i2c_random_wr_payload *dat, int len, int op_code, bool data_word)

Public Members

MultiCameraState *multi_cam_state

std::unique_ptr<const SensorInfo> ci

bool enabled

std::mutex exp_lock

int exposure_time

bool dc_gain_enabled

int dc_gain_weight

int gain_idx

float analog_gain_frac

float cur_ev[3]

float best_ev_score

int new_exp_g

int new_exp_t

Rect ae_xywh

float measured_grey_fraction

float target_grey_fraction

unique_fd sensor_fd

unique_fd csiphy_fd

int camera_num

float fl_pix

int32_t session_handle

int32_t sensor_dev_handle

int32_t isp_dev_handle

int32_t csiphy_dev_handle

int32_t link_handle

int buf0_handle

int buf_handle[FRAME_BUF_COUNT]

int sync_objs[FRAME_BUF_COUNT]

int request_ids[FRAME_BUF_COUNT]

int request_id_last

int frame_id_last

int idx_offset

bool skipped

CameraBuf buf

MemoryManager mm

Private Members

Params params

struct FrameMetadata

Public Members

uint32_t frame_id

uint32_t request_id

uint64_t timestamp_sof

uint64_t timestamp_eof

unsigned int integ_lines

bool high_conversion_gain

float gain

float measured_grey_fraction

float target_grey_fraction

float processing_time

class MemoryManager

Public Functions

void init(int _video0_fd)

~MemoryManager()

template<class T> auto alloc(int len, uint32_t *handle)

Private Functions

void *alloc_buf(int len, uint32_t *handle)

void free(void *ptr)

Private Members

std::mutex lock

std::map<void*, uint32_t> handle_lookup

std::map<void*, int> size_lookup

std::map<int, std::queue<void*>> cached_allocations

int video0_fd

struct MultiCameraState

Public Members

unique_fd video0_fd

unique_fd cam_sync_fd

unique_fd isp_fd

int device_iommu

int cdm_iommu

CameraState road_cam

CameraState wide_road_cam

CameraState driver_cam

PubMaster *pm

file camera_common.h

#include <fcntl.h>

#include <memory>

#include <thread>

#include “cereal/messaging/messaging.h”

#include “cereal/visionipc/visionipc_server.h”

#include “common/queue.h”

#include “common/util.h”

Typedefs

typedef struct FrameMetadata FrameMetadata

typedef void (*process_thread_cb)(MultiCameraState *s, CameraState *c, int cnt)

Enums

enum CameraType

Values:

enumerator RoadCam

enumerator DriverCam

enumerator WideRoadCam

Functions

void fill_frame_data(cereal::FrameData::Builder &framed, const FrameMetadata &frame_data, CameraState *c)

kj::Array<uint8_t> get_raw_frame_image(const CameraBuf *b)

float set_exposure_target(const CameraBuf *b, Rect ae_xywh, int x_skip, int y_skip)

std::thread start_process_thread(MultiCameraState *cameras, CameraState *cs, process_thread_cb callback)

void cameras_init(VisionIpcServer *v, MultiCameraState *s, cl_device_id device_id, cl_context ctx)

void cameras_open(MultiCameraState *s)

void cameras_run(MultiCameraState *s)

void cameras_close(MultiCameraState *s)

void camerad_thread()

int open_v4l_by_name_and_index(const char name[], int index = 0, int flags = O_RDWR | O_NONBLOCK)

Variables

const int YUV_BUFFER_COUNT = 20

const bool env_disable_road = getenv("DISABLE_ROAD") != NULL

const bool env_disable_wide_road = getenv("DISABLE_WIDE_ROAD") != NULL

const bool env_disable_driver = getenv("DISABLE_DRIVER") != NULL

const bool env_debug_frames = getenv("DEBUG_FRAMES") != NULL

const bool env_log_raw_frames = getenv("LOG_RAW_FRAMES") != NULL

const bool env_ctrl_exp_from_params = getenv("CTRL_EXP_FROM_PARAMS") != NULL

file camera_qcom2.h

#include <memory>

#include <utility>

#include “system/camerad/cameras/camera_common.h”

#include “system/camerad/cameras/camera_util.h”

#include “system/camerad/sensors/sensor.h”

#include “common/params.h”

#include “common/util.h”

Defines

FRAME_BUF_COUNT

ROAD_FL_MM

WIDE_FL_MM

DRIVER_FL_MM

Typedefs

typedef struct MultiCameraState MultiCameraState

file camera_util.h

#include <functional>

#include <map>

#include <memory>

#include <mutex>

#include <optional>

#include <queue>

#include <media/cam_req_mgr.h>

Functions

std::optional<int32_t> device_acquire(int fd, int32_t session_handle, void *data, uint32_t num_resources = 1)

int device_config(int fd, int32_t session_handle, int32_t dev_handle, uint64_t packet_handle)

int device_control(int fd, int op_code, int session_handle, int dev_handle)

int do_cam_control(int fd, int op_code, void *handle, int size)

void *alloc_w_mmu_hdl(int video0_fd, int len, uint32_t *handle, int align = 8, int flags = CAM_MEM_FLAG_KMD_ACCESS | CAM_MEM_FLAG_UMD_ACCESS | CAM_MEM_FLAG_CMD_BUF_TYPE, int mmu_hdl = 0, int mmu_hdl2 = 0)

void release(int video0_fd, uint32_t handle)

dir /tmp/openpilot/system/camerad

dir /tmp/openpilot/system/camerad/cameras

dir /tmp/openpilot/system

locationd

class Localizer

Public Functions

Localizer(LocalizerGnssSource gnss_source = LocalizerGnssSource::UBLOX)

int locationd_thread()

void reset_kalman(double current_time = NAN)

void reset_kalman(double current_time, const Eigen::VectorXd &init_orient, const Eigen::VectorXd &init_pos, const Eigen::VectorXd &init_vel, const MatrixXdr &init_pos_R, const MatrixXdr &init_vel_R)

void reset_kalman(double current_time, const Eigen::VectorXd &init_x, const MatrixXdr &init_P)

void finite_check(double current_time = NAN)

void time_check(double current_time = NAN)

void update_reset_tracker()

bool is_gps_ok()

bool critical_services_valid(const std::map<std::string, double> &critical_services)

bool is_timestamp_valid(double current_time)

void determine_gps_mode(double current_time)

bool are_inputs_ok()

void observation_timings_invalid_reset()

kj::ArrayPtr<capnp::byte> get_message_bytes(MessageBuilder &msg_builder, bool inputsOK, bool sensorsOK, bool gpsOK, bool msgValid)

void build_live_location(cereal::LiveLocationKalman::Builder &fix)

Eigen::VectorXd get_position_geodetic()

Eigen::VectorXd get_state()

Eigen::VectorXd get_stdev()

void handle_msg_bytes(const char *data, const size_t size)

void handle_msg(const cereal::Event::Reader &log)

void handle_sensor(double current_time, const cereal::SensorEventData::Reader &log)

void handle_gps(double current_time, const cereal::GpsLocationData::Reader &log, const double sensor_time_offset)

void handle_gnss(double current_time, const cereal::GnssMeasurements::Reader &log)

void handle_car_state(double current_time, const cereal::CarState::Reader &log)

void handle_cam_odo(double current_time, const cereal::CameraOdometry::Reader &log)

void handle_live_calib(double current_time, const cereal::LiveCalibrationData::Reader &log)

void input_fake_gps_observations(double current_time)

Private Functions

void configure_gnss_source(const LocalizerGnssSource &source)

Private Members

std::unique_ptr<LiveKalman> kf

Eigen::VectorXd calib

MatrixXdr device_from_calib

MatrixXdr calib_from_device

bool calibrated = false

double car_speed = 0.0

double last_reset_time = NAN

std::deque<double> posenet_stds

std::unique_ptr<LocalCoord> converter

int64_t unix_timestamp_millis = 0

double reset_tracker = 0.0

bool device_fell = false

bool gps_mode = false

double first_valid_log_time = NAN

double ttff = NAN

double last_gps_msg = 0

LocalizerGnssSource gnss_source

bool observation_timings_invalid = false

std::map<std::string, double> observation_values_invalid

bool standstill = true

int32_t orientation_reset_count = 0

float gps_std_factor

float gps_variance_factor

float gps_vertical_variance_factor

double gps_time_offset

Eigen::VectorXd camodo_yawrate_distribution = Eigen::Vector2d(0.0, 10.0)

file locationd.h

#include <eigen3/Eigen/Dense>

#include <deque>

#include <fstream>

#include <memory>

#include <map>

#include <string>

#include “cereal/messaging/messaging.h”

#include “common/transformations/coordinates.hpp”

#include “common/transformations/orientation.hpp”

#include “common/params.h”

#include “common/swaglog.h”

#include “common/timing.h”

#include “common/util.h”

#include “system/sensord/sensors/constants.h”

#include “selfdrive/locationd/models/live_kf.h”

Defines

VISION_DECIMATION

SENSOR_DECIMATION

POSENET_STD_HIST_HALF

Enums

enum LocalizerGnssSource

Values:

enumerator UBLOX

enumerator QCOM

dir /tmp/openpilot/selfdrive/locationd

dir /tmp/openpilot/selfdrive

ui

class Device : public QObject

Public Functions

Device(QObject *parent = 0)

bool isAwake()

void setOffroadBrightness(int brightness)

Public Slots

void resetInteractiveTimeout(int timeout = -1)

void update(const UIState &s)

Signals

void displayPowerChanged(bool on)

void interactiveTimeout()

Private Functions

void updateBrightness(const UIState &s)

void updateWakefulness(const UIState &s)

void setAwake(bool on)

Private Members

bool awake = false

int interactive_timeout = 0

bool ignition_on = false

int offroad_brightness = BACKLIGHT_OFFROAD 

int last_brightness = 0

FirstOrderFilter brightness_filter

QFuture<void> brightness_future

struct UIScene

Public Members

bool calibration_valid = false

bool calibration_wide_valid = false

bool wide_cam = true

mat3 view_from_calib = DEFAULT_CALIBRATION 

mat3 view_from_wide_calib = DEFAULT_CALIBRATION 

cereal::PandaState::PandaType pandaType

float lane_line_probs[4]

float road_edge_stds[2]

QPolygonF track_vertices

QPolygonF lane_line_vertices[4]

QPolygonF road_edge_vertices[2]

QPointF lead_vertices[2]

float driver_pose_vals[3]

float driver_pose_diff[3]

float driver_pose_sins[3]

float driver_pose_coss[3]

vec3 face_kpts_draw[std::size(default_face_kpts_3d)]

cereal::LongitudinalPersonality personality

float light_sensor

bool started

bool ignition

bool is_metric

bool map_on_left

bool longitudinal_control

bool world_objects_visible = false

uint64_t started_frame

class UIState : public QObject

Public Functions

UIState(QObject *parent = 0)

void updateStatus()

bool engaged() const

void setPrimeType(PrimeType type)

PrimeType primeType() const

bool hasPrime() const

Public Members

int fb_w = 0

int fb_h = 0

std::unique_ptr<SubMaster> sm

UIStatus status

UIScene scene = {}

QString language

QTransform car_space_transform

Signals

void uiUpdate(const UIState &s)

void offroadTransition(bool offroad)

void primeChanged(bool prime)

void primeTypeChanged(PrimeType prime_type)

Private Members

QTimer *timer

bool started_prev = false

PrimeType prime_type = PrimeType::UNKNOWN 

Private Slots

void update()

file ui.h

#include <memory>

#include <string>

#include <QObject>

#include <QTimer>

#include <QColor>

#include <QFuture>

#include <QPolygonF>

#include <QTransform>

#include “cereal/messaging/messaging.h”

#include “common/mat.h”

#include “common/params.h”

#include “common/timing.h”

#include “system/hardware/hw.h”

Typedefs

typedef enum UIStatus UIStatus

typedef struct UIScene UIScene

Enums

enum UIStatus

Values:

enumerator STATUS_DISENGAGED

enumerator STATUS_OVERRIDE

enumerator STATUS_ENGAGED

enum PrimeType

Values:

enumerator UNKNOWN

enumerator UNPAIRED

enumerator NONE

enumerator MAGENTA

enumerator LITE

enumerator BLUE

enumerator MAGENTA_NEW

enumerator PURPLE

Functions

UIState *uiState()

Device *device()

void ui_update_params(UIState *s)

int get_path_length_idx(const cereal::XYZTData::Reader &line, const float path_height)

void update_model(UIState *s, const cereal::ModelDataV2::Reader &model, const cereal::UiPlan::Reader &plan)

void update_dmonitoring(UIState *s, const cereal::DriverStateV2::Reader &driverstate, float dm_fade_state, bool is_rhd)

void update_leads(UIState *s, const cereal::RadarState::Reader &radar_state, const cereal::XYZTData::Reader &line)

void update_line_data(const UIState *s, const cereal::XYZTData::Reader &line, float y_off, float z_off, QPolygonF *pvd, int max_idx, bool allow_invert)

Variables

const int UI_BORDER_SIZE = 30

const int UI_HEADER_HEIGHT = 420

const int UI_FREQ = 20

const int BACKLIGHT_OFFROAD = 50

const float MIN_DRAW_DISTANCE = 10.0

const float MAX_DRAW_DISTANCE = 100.0

constexpr mat3 DEFAULT_CALIBRATION = {{0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0}}

constexpr mat3 FCAM_INTRINSIC_MATRIX = (mat3){{2648.0, 0.0, 1928.0 / 2, 0.0, 2648.0, 1208.0 / 2, 0.0, 0.0, 1.0}}

constexpr mat3 ECAM_INTRINSIC_MATRIX = (mat3){{567.0, 0.0, 1928.0 / 2, 0.0, 567.0, 1208.0 / 2, 0.0, 0.0, 1.0}}

constexpr vec3 default_face_kpts_3d[] = {{-5.98, -51.20, 8.00}, {-17.64, -49.14, 8.00}, {-23.81, -46.40, 8.00}, {-29.98, -40.91, 8.00}, {-32.04, -37.49, 8.00}, {-34.10, -32.00, 8.00}, {-36.16, -21.03, 8.00}, {-36.16, 6.40, 8.00}, {-35.47, 10.51, 8.00}, {-32.73, 19.43, 8.00}, {-29.30, 26.29, 8.00}, {-24.50, 33.83, 8.00}, {-19.01, 41.37, 8.00}, {-14.21, 46.17, 8.00}, {-12.16, 47.54, 8.00}, {-4.61, 49.60, 8.00}, {4.99, 49.60, 8.00}, {12.53, 47.54, 8.00}, {14.59, 46.17, 8.00}, {19.39, 41.37, 8.00}, {24.87, 33.83, 8.00}, {29.67, 26.29, 8.00}, {33.10, 19.43, 8.00}, {35.84, 10.51, 8.00}, {36.53, 6.40, 8.00}, {36.53, -21.03, 8.00}, {34.47, -32.00, 8.00}, {32.42, -37.49, 8.00}, {30.36, -40.91, 8.00}, {24.19, -46.40, 8.00}, {18.02, -49.14, 8.00}, {6.36, -51.20, 8.00}, {-5.98, -51.20, 8.00},}

const QColor bg_colors [] = {[STATUS_DISENGAGED] = QColor(0x17, 0x33, 0x49, 0xc8),[STATUS_OVERRIDE] = QColor(0x91, 0x9b, 0x95, 0xf1),[STATUS_ENGAGED] = QColor(0x17, 0x86, 0x44, 0xf1),}

dir /tmp/openpilot/selfdrive

dir /tmp/openpilot/selfdrive/ui

replay

struct Camera

Public Members

CameraType type

VisionStreamType stream_type

int width

int height

std::thread thread

SafeQueue<std::pair<FrameReader*, const Event*>> queue

std::set<VisionBuf*> cached_buf

class CameraServer

Public Functions

CameraServer(std::pair<int, int> camera_size[MAX_CAMERAS] = nullptr)

~CameraServer()

void pushFrame(CameraType type, FrameReader *fr, const Event *event)

void waitForSent()

Protected Functions

void startVipcServer()

void cameraThread(Camera &cam)

VisionBuf *getFrame(Camera &cam, FrameReader *fr, int32_t segment_id, uint32_t frame_id)

Protected Attributes

Camera cameras_ [MAX_CAMERAS] = {{.type = RoadCam, .stream_type = VISION_STREAM_ROAD},{.type = DriverCam, .stream_type = VISION_STREAM_DRIVER},{.type = WideRoadCam, .stream_type = VISION_STREAM_WIDE_ROAD},}

std::atomic<int> publishing_ = 0

std::unique_ptr<VisionIpcServer> vipc_server_

class ConsoleUI : public QObject

Public Functions

ConsoleUI(Replay *replay, QObject *parent = 0)

~ConsoleUI()

Signals

void updateProgressBarSignal(uint64_t cur, uint64_t total, bool success)

void logMessageSignal(ReplyMsgType type, const QString &msg)

Public Static Attributes

static const std::array speed_array = {0.2f, 0.5f, 1.0f, 2.0f, 3.0f}

Private Types

enum Status

Values:

enumerator Waiting

enumerator Playing

enumerator Paused

enum Win

Values:

enumerator Title

enumerator Stats

enumerator Log

enumerator LogBorder

enumerator DownloadBar

enumerator Timeline

enumerator TimelineDesc

enumerator Help

enumerator CarState

enumerator Max

Private Functions

void initWindows()

void handleKey(char c)

void displayHelp()

void displayTimelineDesc()

void updateTimeline()

void updateSummary()

void updateStatus()

void pauseReplay(bool pause)

Private Members

std::array<WINDOW*, Win::Max> w = {}

SubMaster sm

Replay *replay

QBasicTimer getch_timer

QTimer sm_timer

QSocketNotifier notifier = {0, QSocketNotifier::Read, this}

int max_width

int max_height

Status status = Status::Waiting

Private Slots

void readyRead()

void timerEvent(QTimerEvent *ev)

void updateProgressBar(uint64_t cur, uint64_t total, bool success)

void logMessage(ReplyMsgType type, const QString &msg)

class Event

Public Functions

Event(cereal::Event::Which which, uint64_t mono_time, const kj::ArrayPtr<const capnp::word> &data, int eidx_segnum = -1)

bool operator<(const Event &other) const

Public Members

uint64_t mono_time

cereal::Event::Which which

kj::ArrayPtr<const capnp::word> data

int32_t eidx_segnum

class FileReader

Public Functions

FileReader(bool cache_to_local, size_t chunk_size = 0, int retries = 3)

virtual ~FileReader()

std::string read(const std::string &file, std::atomic<bool> *abort = nullptr)

Private Functions

std::string download(const std::string &url, std::atomic<bool> *abort)

Private Members

size_t chunk_size_

int max_retries_

bool cache_to_local_

class FrameReader

Public Functions

FrameReader()

~FrameReader()

bool load(CameraType type, const std::string &url, bool no_hw_decoder = false, std::atomic<bool> *abort = nullptr, bool local_cache = false, int chunk_size = -1, int retries = 0)

bool loadFromFile(CameraType type, const std::string &file, bool no_hw_decoder = false, std::atomic<bool> *abort = nullptr)

bool get(int idx, VisionBuf *buf)

size_t getFrameCount() const

Public Members

int width = 0

int height = 0

VideoDecoder *decoder_ = nullptr

AVFormatContext *input_ctx = nullptr

int prev_idx = -1

std::vector<PacketInfo> packets_info

class LogReader

Public Functions

LogReader(const std::vector<bool> &filters = {})

bool load(const std::string &url, std::atomic<bool> *abort = nullptr, bool local_cache = false, int chunk_size = -1, int retries = 0)

bool load(const char *data, size_t size, std::atomic<bool> *abort = nullptr)

Public Members

std::vector<Event> events

Private Members

std::string raw_

std::vector<bool> filters_

MonotonicBuffer buffer_ = {1024 * 1024}

class MonotonicBuffer

Public Functions

MonotonicBuffer(size_t initial_size)

~MonotonicBuffer()

void *allocate(size_t bytes, size_t alignment = 16ul)

void deallocate(void *p)

Private Members

void *current_buf = nullptr

size_t next_buffer_size = 0

size_t available = 0

std::deque<void*> buffers

Private Static Attributes

static constexpr float growth_factor = 1.5

struct PacketInfo

Public Members

int flags

int64_t pos

class Replay : public QObject

Public Functions

Replay(QString route, QStringList allow, QStringList block, SubMaster *sm = nullptr, uint32_t flags = REPLAY_FLAG_NONE, QString data_dir = "", QObject *parent = 0)

~Replay()

bool load()

void start(int seconds = 0)

void pause(bool pause)

void seekToFlag(FindFlag flag)

void seekTo(double seconds, bool relative)

bool isPaused() const

void installEventFilter(replayEventFilter filter, void *opaque)

int segmentCacheLimit() const

void setSegmentCacheLimit(int n)

bool hasFlag(REPLAY_FLAGS flag) const

void addFlag(REPLAY_FLAGS flag)

void removeFlag(REPLAY_FLAGS flag)

const Route *route() const

double currentSeconds() const

QDateTime routeDateTime() const

QDateTime currentDateTime() const

uint64_t routeStartTime() const

double toSeconds(uint64_t mono_time) const

int totalSeconds() const

void setSpeed(float speed)

float getSpeed() const

const std::vector<Event> *events() const

const std::map<int, std::unique_ptr<Segment>> &segments() const

const std::string &carFingerprint() const

const std::vector<std::tuple<double, double, TimelineType>> getTimeline()

Signals

void streamStarted()

void segmentsMerged()

void seekedTo(double sec)

void qLogLoaded(int segnum, std::shared_ptr<LogReader> qlog)

Protected Types

typedef std::map<int, std::unique_ptr<Segment>> SegmentMap

Protected Functions

std::optional<uint64_t> find(FindFlag flag)

void pauseStreamThread()

void startStream(const Segment *cur_segment)

void streamThread()

void updateSegmentsCache()

void loadSegmentInRange(SegmentMap::iterator begin, SegmentMap::iterator cur, SegmentMap::iterator end)

void mergeSegments(const SegmentMap::iterator &begin, const SegmentMap::iterator &end)

void updateEvents(const std::function<bool()> &update_events_function)

std::vector<Event>::const_iterator publishEvents(std::vector<Event>::const_iterator first, std::vector<Event>::const_iterator last)

void publishMessage(const Event *e)

void publishFrame(const Event *e)

void buildTimeline()

bool isSegmentMerged(int n) const

Protected Attributes

pthread_t stream_thread_id = 0

QThread *stream_thread_ = nullptr

std::mutex stream_lock_

bool user_paused_ = false

std::condition_variable stream_cv_

std::atomic<int> current_segment_ = 0

double seeking_to_seconds_ = -1

SegmentMap segments_

std::atomic<bool> exit_ = false

std::atomic<bool> paused_ = false

bool events_ready_ = false

QDateTime route_date_time_

uint64_t route_start_ts_ = 0

std::atomic<uint64_t> cur_mono_time_ = 0

std::vector<Event> events_

std::set<int> merged_segments_

SubMaster *sm = nullptr

std::unique_ptr<PubMaster> pm

std::vector<const char*> sockets_

std::vector<bool> filters_

std::unique_ptr<Route> route_

std::unique_ptr<CameraServer> camera_server_

std::atomic<uint32_t> flags_ = REPLAY_FLAG_NONE 

std::mutex timeline_lock

QFuture<void> timeline_future

std::vector<std::tuple<double, double, TimelineType>> timeline

std::string car_fingerprint_

std::atomic<float> speed_ = 1.0

replayEventFilter event_filter = nullptr

void *filter_opaque = nullptr

int segment_cache_limit = MIN_SEGMENTS_CACHE 

Protected Slots

void segmentLoadFinished(bool success)

class Route

Public Functions

Route(const QString &route, const QString &data_dir = {})

bool load()

const QString &name() const

const QDateTime datetime() const

const QString &dir() const

const RouteIdentifier &identifier() const

const std::map<int, SegmentFile> &segments() const

const SegmentFile &at(int n)

Public Static Functions

static RouteIdentifier parseRoute(const QString &str)

Protected Functions

bool loadFromLocal()

bool loadFromServer(int retries = 3)

bool loadFromJson(const QString &json)

void addFileToSegment(int seg_num, const QString &file)

Protected Attributes

RouteIdentifier route_ = {}

QString data_dir_

std::map<int, SegmentFile> segments_

QDateTime date_time_

struct RouteIdentifier

Public Members

QString dongle_id

QString timestamp

int begin_segment = 0

int end_segment = -1

QString str

class Segment : public QObject

Public Functions

Segment(int n, const SegmentFile &files, uint32_t flags, const std::vector<bool> &filters = {})

~Segment()

bool isLoaded() const

Public Members

const int seg_num = 0

std::unique_ptr<LogReader> log

std::unique_ptr<FrameReader> frames[MAX_CAMERAS] = {}

Signals

void loadFinished(bool success)

Protected Functions

void loadFile(int id, const std::string file)

Protected Attributes

std::atomic<bool> abort_ = false

std::atomic<int> loading_ = 0

QFutureSynchronizer<void> synchronizer_

uint32_t flags

std::vector<bool> filters_

struct SegmentFile

Public Members

QString rlog

QString qlog

QString road_cam

QString driver_cam

QString wide_road_cam

QString qcamera

class VideoDecoder

Public Functions

VideoDecoder()

~VideoDecoder()

bool open(AVCodecParameters *codecpar, bool hw_decoder)

bool decode(FrameReader *reader, int idx, VisionBuf *buf)

Public Members

int width = 0

int height = 0

Private Functions

bool initHardwareDecoder(AVHWDeviceType hw_device_type)

AVFrame *decodeFrame(AVPacket *pkt)

bool copyBuffer(AVFrame *f, VisionBuf *buf)

Private Members

AVFrame *av_frame_

AVFrame *hw_frame_

AVCodecContext *decoder_ctx = nullptr

AVPixelFormat hw_pix_fmt = AV_PIX_FMT_NONE

AVBufferRef *hw_device_ctx = nullptr

file camera.h

#include <memory>

#include <set>

#include <tuple>

#include <utility>

#include “cereal/visionipc/visionipc_server.h”

#include “common/queue.h”

#include “tools/replay/framereader.h”

#include “tools/replay/logreader.h”

Functions

std::tuple<size_t, size_t, size_t> get_nv12_info(int width, int height)

file consoleui.h: #include <array>

#include <QBasicTimer>

#include <QObject>

#include <QSocketNotifier>

#include <QTimer>

#include <QTimerEvent>

#include “tools/replay/replay.h”

#include <ncurses.h>

file filereader.h

#include <atomic>

#include <string>

Functions

std::string cacheFilePath(const std::string &url)

file framereader.h: #include <string>

#include <vector>

#include “cereal/visionipc/visionbuf.h”

#include “system/camerad/cameras/camera_common.h”

#include “tools/replay/filereader.h”

#include <libavcodec/avcodec.h>

#include <libavformat/avformat.h>

file logreader.h

#include <string>

#include <vector>

#include “cereal/gen/cpp/log.capnp.h”

#include “system/camerad/cameras/camera_common.h”

#include “tools/replay/util.h”

Variables

const CameraType ALL_CAMERAS[] = {RoadCam, DriverCam, WideRoadCam}

const int MAX_CAMERAS = std::size(ALL_CAMERAS)

file replay.h

#include <algorithm>

#include <map>

#include <memory>

#include <optional>

#include <set>

#include <string>

#include <tuple>

#include <vector>

#include <utility>

#include <QThread>

#include “tools/replay/camera.h”

#include “tools/replay/route.h”

Typedefs

typedef bool (*replayEventFilter)(const Event*, void*)

Enums

enum REPLAY_FLAGS

Values:

enumerator REPLAY_FLAG_NONE

enumerator REPLAY_FLAG_DCAM

enumerator REPLAY_FLAG_ECAM

enumerator REPLAY_FLAG_NO_LOOP

enumerator REPLAY_FLAG_NO_FILE_CACHE

enumerator REPLAY_FLAG_QCAMERA

enumerator REPLAY_FLAG_NO_HW_DECODER

enumerator REPLAY_FLAG_NO_VIPC

enumerator REPLAY_FLAG_ALL_SERVICES

enum FindFlag

Values:

enumerator nextEngagement

enumerator nextDisEngagement

enumerator nextUserFlag

enumerator nextInfo

enumerator nextWarning

enumerator nextCritical

enum TimelineType

Values:

enumerator None

enumerator Engaged

enumerator AlertInfo

enumerator AlertWarning

enumerator AlertCritical

enumerator UserFlag

Functions

Q_DECLARE_METATYPE(std::shared_ptr<LogReader>)

Variables

const QString DEMO_ROUTE = "a2a0ccea32023010|2023-07-27--13-01-19"

constexpr int MIN_SEGMENTS_CACHE = 5

file route.h: #include <map>

#include <memory>

#include <string>

#include <vector>

#include <QDateTime>

#include <QFutureSynchronizer>

#include “tools/replay/framereader.h”

#include “tools/replay/logreader.h”

#include “tools/replay/util.h”

file util.h

#include <atomic>

#include <deque>

#include <functional>

#include <string>

Defines

rInfo(fmt, ...)

rDebug(fmt, ...)

rWarning(fmt, ...)

rError(fmt, ...)

Typedefs

typedef std::function<void(ReplyMsgType type, const std::string msg)> ReplayMessageHandler

typedef std::function<void(uint64_t cur, uint64_t total, bool success)> DownloadProgressHandler

Enums

enum ReplyMsgType

Values:

enumerator Info

enumerator Debug

enumerator Warning

enumerator Critical

Functions

void installMessageHandler(ReplayMessageHandler)

void logMessage(ReplyMsgType type, const char *fmt, ...)

std::string sha256(const std::string &str)

void precise_nano_sleep(int64_t nanoseconds)

std::string decompressBZ2(const std::string &in, std::atomic<bool> *abort = nullptr)

std::string decompressBZ2(const std::byte *in, size_t in_size, std::atomic<bool> *abort = nullptr)

std::string getUrlWithoutQuery(const std::string &url)

size_t getRemoteFileSize(const std::string &url, std::atomic<bool> *abort = nullptr)

std::string httpGet(const std::string &url, size_t chunk_size = 0, std::atomic<bool> *abort = nullptr)

void installDownloadProgressHandler(DownloadProgressHandler)

bool httpDownload(const std::string &url, const std::string &file, size_t chunk_size = 0, std::atomic<bool> *abort = nullptr)

std::string formattedDataSize(size_t size)

dir /tmp/openpilot/tools/replay

dir /tmp/openpilot/tools

qt

class DeclinePage : public QFrame

Public Functions

DeclinePage(QWidget *parent = 0)

Signals

void getBack()

Private Functions

void showEvent(QShowEvent *event)

class DevicePanel : public ListWidget

Public Functions

DevicePanel(SettingsWindow *parent)

void showEvent(QShowEvent *event)

Signals

void reviewTrainingGuide()

void showDriverView()

Private Members

Params params

ButtonControl *pair_device

Private Slots

void poweroff()

void reboot()

void updateCalibDescription()

class DriverViewWindow : public CameraWidget

Public Functions

DriverViewWindow(QWidget *parent)

Signals

void done()

Protected Functions

void showEvent(QShowEvent *event)

void hideEvent(QHideEvent *event)

void paintGL()

Protected Attributes

Params params

QPixmap face_img

class ExperimentalModeButton : public QPushButton

Public Functions

ExperimentalModeButton(QWidget *parent = 0)

Signals

void openSettings(int index = 0, const QString &toggle = "")

Protected Functions

void paintEvent(QPaintEvent *event)

Private Functions

void showEvent(QShowEvent *event)

Private Members

Params params

bool experimental_mode

int img_width = 100

int horizontal_padding = 30

QPixmap experimental_pixmap

QPixmap chill_pixmap

QLabel *mode_label

QLabel *mode_icon

class OnboardingWindow : public QStackedWidget

Public Functions

OnboardingWindow(QWidget *parent = 0)

void showTrainingGuide()

bool completed() const

Signals

void onboardingDone()

Private Functions

void updateActiveScreen()

Private Members

Params params

bool accepted_terms = false

bool training_done = false

class SettingsWindow : public QFrame

Public Functions

SettingsWindow(QWidget *parent = 0)

void setCurrentPanel(int index, const QString &param = "")

Signals

void closeSettings()

void reviewTrainingGuide()

void showDriverView()

void expandToggleDescription(const QString &param)

Protected Functions

void showEvent(QShowEvent *event)

Private Members

QPushButton *sidebar_alert_widget

QWidget *sidebar_widget

QButtonGroup *nav_btns

QStackedWidget *panel_widget

class SoftwarePanel : public ListWidget

Public Functions

SoftwarePanel(QWidget *parent = nullptr)

Private Functions

void showEvent(QShowEvent *event)

void updateLabels()

void checkForUpdates()

Private Members

bool is_onroad = false

QLabel *onroadLbl

LabelControl *versionLbl

ButtonControl *installBtn

ButtonControl *downloadBtn

ButtonControl *targetBranchBtn

Params params

ParamWatcher *fs_watch

class TermsPage : public QFrame

Public Functions

TermsPage(QWidget *parent = 0)

Public Slots

void enableAccept()

Signals

void acceptedTerms()

void declinedTerms()

Private Functions

void showEvent(QShowEvent *event)

Private Members

QPushButton *accept_btn

class TogglesPanel : public ListWidget

Public Functions

TogglesPanel(SettingsWindow *parent)

void showEvent(QShowEvent *event)

Public Slots

void expandToggleDescription(const QString &param)

Private Functions

void updateToggles()

Private Members

Params params

std::map<std::string, ParamControl*> toggles

ButtonParamControl *long_personality_setting

Private Slots

void updateState(const UIState &s)

class TrainingGuide : public QFrame

Public Functions

TrainingGuide(QWidget *parent = 0)

Signals

void completedTraining()

Private Functions

void showEvent(QShowEvent *event)

void paintEvent(QPaintEvent *event)

void mouseReleaseEvent(QMouseEvent *e)

QImage loadImage(int id)

Private Members

QImage image

QSize image_raw_size

int currentIndex = 0

const QRect continueBtn = {1840, 0, 320, 1080}

QVector<QRect> boundingRect{QRect(112, 804, 618, 164), continueBtn, continueBtn, QRect(1641, 558, 210, 313), QRect(1662, 528, 184, 108), continueBtn, QRect(1814, 621, 211, 170), QRect(1350, 0, 497, 755), QRect(1540, 386, 468, 238), QRect(112, 804, 1126, 164), QRect(1598, 199, 316, 333), continueBtn, QRect(1364, 90, 796, 990), continueBtn, QRect(1593, 114, 318, 853), QRect(1379, 511, 391, 243), continueBtn, continueBtn, QRect(630, 804, 626, 164), QRect(108, 804, 426, 164),}

const QString img_path = "../assets/training/"

QElapsedTimer click_timer

file driverview.h: #include “selfdrive/ui/qt/widgets/cameraview.h”

file experimental_mode.h: #include <QLabel>

#include <QPushButton>

#include “common/params.h”

file onboarding.h: #include <QElapsedTimer>

#include <QImage>

#include <QMouseEvent>

#include <QPushButton>

#include <QStackedWidget>

#include <QWidget>

#include “common/params.h”

#include “selfdrive/ui/qt/qt_window.h”

file settings.h: #include <map>

#include <string>

#include <QButtonGroup>

#include <QFrame>

#include <QLabel>

#include <QPushButton>

#include <QStackedWidget>

#include <QWidget>

#include “selfdrive/ui/ui.h”

#include “selfdrive/ui/qt/util.h”

#include “selfdrive/ui/qt/widgets/controls.h”

dir /tmp/openpilot/selfdrive/ui/qt/offroad

dir /tmp/openpilot/selfdrive/ui/qt

dir /tmp/openpilot/selfdrive

dir /tmp/openpilot/selfdrive/ui

class DestinationWidget : public QPushButton

Public Functions

DestinationWidget(QWidget *parent = nullptr)

void set(const QJsonObject &location, bool current = false)

void unset(const QString &label, bool current = false)

Signals

void actionClicked()

void navigateTo(const QJsonObject &destination)

Private Members

QLabel *icon

QLabel *title

QLabel *subtitle

QPushButton *action

QJsonObject dest

Private Static Functions

static NavIcons icons()

class MapETA : public QWidget

Public Functions

MapETA(QWidget *parent = nullptr)

void updateETA(float seconds, float seconds_typical, float distance)

Private Functions

void paintEvent(QPaintEvent *event)

void showEvent(QShowEvent *event)

Private Members

bool format_24h = false

QTextDocument eta_doc

Params param

class MapInstructions : public QWidget

Public Functions

MapInstructions(QWidget *parent = nullptr)

void buildPixmapCache()

void updateInstructions(cereal::NavInstruction::Reader instruction)

Private Members

QLabel *distance

QLabel *primary

QLabel *secondary

QLabel *icon_01

QHBoxLayout *lane_layout

bool is_rhd = false

std::vector<QLabel*> lane_labels

QHash<QString, QPixmap> pixmap_cache

class MapPanel : public QFrame

Public Functions

MapPanel(const QMapLibre::Settings &settings, QWidget *parent = nullptr)

Public Slots

void toggleMapSettings()

Signals

void mapPanelRequested()

Private Members

QStackedLayout *content_stack

class MapSettings : public QFrame

Public Functions

MapSettings(bool closeable = false, QWidget *parent = nullptr)

void navigateTo(const QJsonObject &place)

Signals

void closeSettings()

Private Functions

void showEvent(QShowEvent *event)

void refresh()

Private Members

QVBoxLayout *destinations_layout

DestinationWidget *current_widget

DestinationWidget *home_widget

DestinationWidget *work_widget

std::vector<DestinationWidget*> widgets

class MapWindow : public QOpenGLWidget

Public Functions

MapWindow(const QMapLibre::Settings&)

~MapWindow()

Public Slots

void offroadTransition(bool offroad)

Signals

void requestVisible(bool visible)

void requestSettings(bool settings)

Private Functions

void initializeGL()

void paintGL()

void resizeGL(int w, int h)

void initLayers()

void mousePressEvent(QMouseEvent *ev)

void mouseDoubleClickEvent(QMouseEvent *ev)

void mouseMoveEvent(QMouseEvent *ev)

void wheelEvent(QWheelEvent *ev)

bool event(QEvent *event)

bool gestureEvent(QGestureEvent *event)

void pinchTriggered(QPinchGesture *gesture)

void setError(const QString &err_str)

void clearRoute()

void updateDestinationMarker()

Private Members

QMapLibre::Settings m_settings

QScopedPointer<QMapLibre::Map> m_map

bool loaded_once = false

QPointF m_lastPos

int interaction_counter = 0

std::optional<QMapLibre::Coordinate> last_valid_nav_dest

std::optional<QMapLibre::Coordinate> last_position

std::optional<float> last_bearing

FirstOrderFilter velocity_filter

bool locationd_valid = false

bool routing_problem = false

QWidget *map_overlay

QLabel *error

MapInstructions *map_instructions

MapETA *map_eta

uint64_t route_rcv_frame = 0

Private Slots

void updateState(const UIState &s)

struct NavIcons

Public Members

QPixmap home

QPixmap work

QPixmap favorite

QPixmap recent

QPixmap directions

class NavManager : public QObject

Public Functions

QJsonArray currentLocations() const

QJsonObject currentDestination() const

void setCurrentDestination(const QJsonObject &loc)

qint64 getLastActivity(const QJsonObject &loc) const

Signals

void updated()

Public Static Functions

static NavManager *instance()

Private Functions

NavManager(QObject *parent)

void parseLocationsResponse(const QString &response, bool success)

void sortLocations()

Private Members

Params params

QString prev_response

QJsonArray locations

QJsonObject current_dest

std::future<void> write_param_future

file map.h: #include <optional>

#include <QGeoCoordinate>

#include <QGestureEvent>

#include <QLabel>

#include <QMap>

#include <QMapLibre/Map>

#include <QMapLibre/Settings>

#include <QMouseEvent>

#include <QOpenGLWidget>

#include <QPixmap>

#include <QPushButton>

#include <QScopedPointer>

#include <QString>

#include <QVBoxLayout>

#include <QWheelEvent>

#include “cereal/messaging/messaging.h”

#include “common/params.h”

#include “common/util.h”

#include “selfdrive/ui/ui.h”

#include “selfdrive/ui/qt/maps/map_eta.h”

#include “selfdrive/ui/qt/maps/map_instructions.h”

file map_eta.h: #include <QPaintEvent>

#include <QTextDocument>

#include <QWidget>

#include “common/params.h”

file map_helpers.h

#include <optional>

#include <string>

#include <utility>

#include <QMapLibre/Map>

#include <QMapLibre/Settings>

#include <eigen3/Eigen/Dense>

#include <QGeoCoordinate>

#include “common/util.h”

#include “common/transformations/coordinates.hpp”

#include “common/transformations/orientation.hpp”

#include “cereal/messaging/messaging.h”

Functions

QString get_mapbox_token()

QMapLibre::Settings get_mapbox_settings()

QGeoCoordinate to_QGeoCoordinate(const QMapLibre::Coordinate &in)

QMapLibre::CoordinatesCollections model_to_collection(const cereal::LiveLocationKalman::Measurement::Reader &calibratedOrientationECEF, const cereal::LiveLocationKalman::Measurement::Reader &positionECEF, const cereal::XYZTData::Reader &line)

QMapLibre::CoordinatesCollections coordinate_to_collection(const QMapLibre::Coordinate &c)

QMapLibre::CoordinatesCollections capnp_coordinate_list_to_collection(const capnp::List<cereal::NavRoute::Coordinate>::Reader &coordinate_list)

QMapLibre::CoordinatesCollections coordinate_list_to_collection(const QList<QGeoCoordinate> &coordinate_list)

QList<QGeoCoordinate> polyline_to_coordinate_list(const QString &polylineString)

std::optional<QMapLibre::Coordinate> coordinate_from_param(const std::string &param)

std::pair<QString, QString> map_format_distance(float d, bool is_metric)

Variables

const QString MAPBOX_TOKEN = util::getenv("MAPBOX_TOKEN").c_str()

const QString MAPS_HOST = util::getenv("MAPS_HOST", MAPBOX_TOKEN.isEmpty() ? "https://maps.comma.ai" : "https://api.mapbox.com").c_str()

const QString MAPS_CACHE_PATH = "/data/mbgl-cache-navd.db"

file map_instructions.h

#include <map>

#include <vector>

#include <QHash>

#include <QHBoxLayout>

#include <QLabel>

#include “cereal/gen/cpp/log.capnp.h”

Variables

static std::map<cereal::NavInstruction::Direction, QString> DIRECTIONS = {{cereal::NavInstruction::Direction::NONE, "none"}, {cereal::NavInstruction::Direction::LEFT, "left"}, {cereal::NavInstruction::Direction::RIGHT, "right"}, {cereal::NavInstruction::Direction::STRAIGHT, "straight"}, {cereal::NavInstruction::Direction::SLIGHT_LEFT, "slight_left"}, {cereal::NavInstruction::Direction::SLIGHT_RIGHT, "slight_right"},}

file map_panel.h: #include <QFrame>

#include <QMapLibre/Settings>

#include <QStackedLayout>

file map_settings.h

#include <future>

#include <vector>

#include <QFrame>

#include <QJsonArray>

#include <QJsonDocument>

#include <QJsonObject>

#include <QLabel>

#include <QPushButton>

#include <QVBoxLayout>

#include “common/params.h”

#include “selfdrive/ui/qt/util.h”

#include “selfdrive/ui/qt/widgets/controls.h”

Variables

const QString NAV_TYPE_FAVORITE = "favorite"

const QString NAV_TYPE_RECENT = "recent"

const QString NAV_FAVORITE_LABEL_HOME = "home"

const QString NAV_FAVORITE_LABEL_WORK = "work"

dir /tmp/openpilot/selfdrive/ui/qt/maps

dir /tmp/openpilot/selfdrive/ui/qt

dir /tmp/openpilot/selfdrive

dir /tmp/openpilot/selfdrive/ui

proclogd

struct CPUTime

Public Members

int id

unsigned long utime

unsigned long ntime

unsigned long stime

unsigned long itime

unsigned long iowtime

unsigned long irqtime

unsigned long sirqtime

struct ProcCache

Public Members

int pid

std::string name

std::string exe

std::vector<std::string> cmdline

struct ProcStat

Public Members

int pid

int ppid

int processor

char state

long cutime

long cstime

long priority

long nice

long num_threads

long rss

unsigned long utime

unsigned long stime

unsigned long vms

unsigned long long starttime

std::string name

namespace Parser

Functions

std::vector<int> pids()

std::optional<ProcStat> procStat(std::string stat)

std::vector<std::string> cmdline(std::istream &stream)

std::vector<CPUTime> cpuTimes(std::istream &stream)

std::unordered_map<std::string, uint64_t> memInfo(std::istream &stream)

const ProcCache &getProcExtraInfo(int pid, const std::string &name)

file proclog.h

#include <optional>

#include <string>

#include <unordered_map>

#include <vector>

#include “cereal/messaging/messaging.h”

Functions

void buildProcLogMessage(MessageBuilder &msg)

dir /tmp/openpilot/system/proclogd

dir /tmp/openpilot/system

modeld

struct LoadYUVState

Public Members

int width

int height

cl_kernel loadys_krnl

cl_kernel loaduv_krnl

cl_kernel copy_krnl

struct Transform

Public Members

cl_kernel krnl

cl_mem m_y_cl

cl_mem m_uv_cl

file loadyuv.h

#include “common/clutil.h”

Functions

void loadyuv_init(LoadYUVState *s, cl_context ctx, cl_device_id device_id, int width, int height)

void loadyuv_destroy(LoadYUVState *s)

void loadyuv_queue(LoadYUVState *s, cl_command_queue q, cl_mem y_cl, cl_mem u_cl, cl_mem v_cl, cl_mem out_cl, bool do_shift = false)

file transform.h

#include <CL/cl.h>

#include “common/mat.h”

Defines

CL_USE_DEPRECATED_OPENCL_1_2_APIS

Functions

void transform_init(Transform *s, cl_context ctx, cl_device_id device_id)

void transform_destroy(Transform *transform)

void transform_queue(Transform *s, cl_command_queue q, cl_mem yuv, int in_width, int in_height, int in_stride, int in_uv_offset, cl_mem out_y, cl_mem out_u, cl_mem out_v, int out_width, int out_height, const mat3 &projection)

dir /tmp/openpilot/selfdrive/modeld

dir /tmp/openpilot/selfdrive

dir /tmp/openpilot/selfdrive/modeld/transforms

class ModelFrame

Public Functions

ModelFrame(cl_device_id device_id, cl_context context)

~ModelFrame()

float *prepare(cl_mem yuv_cl, int width, int height, int frame_stride, int frame_uv_offset, const mat3 &transform, cl_mem *output)

Public Members

const int MODEL_WIDTH = 512

const int MODEL_HEIGHT = 256

const int MODEL_FRAME_SIZE = MODEL_WIDTH * MODEL_HEIGHT * 3 / 2

const int buf_size = MODEL_FRAME_SIZE * 2

Private Members

Transform transform

LoadYUVState loadyuv

cl_command_queue q

cl_mem y_cl

cl_mem u_cl

cl_mem v_cl

cl_mem net_input_cl

std::unique_ptr<float[]> input_frames

file commonmodel.h

#include <cfloat>

#include <cstdlib>

#include <memory>

#include <CL/cl.h>

#include “common/mat.h”

#include “cereal/messaging/messaging.h”

#include “selfdrive/modeld/transforms/loadyuv.h”

#include “selfdrive/modeld/transforms/transform.h”

Defines

CL_USE_DEPRECATED_OPENCL_1_2_APIS

Functions

void softmax(const float *input, float *output, size_t len)

float sigmoid(float input)

template<class T, size_t size> constexpr const kj::ArrayPtr<const T> to_kj_array_ptr(const std::array<T, size> &arr)

Variables

const bool send_raw_pred = getenv("SEND_RAW_PRED") != NULL

dir /tmp/openpilot/selfdrive/modeld

dir /tmp/openpilot/selfdrive/modeld/models

dir /tmp/openpilot/selfdrive

class SNPEModel : public RunModel

Public Functions

SNPEModel(const std::string path, float *_output, size_t _output_size, int runtime, bool use_tf8 = false, cl_context context = NULL)

void addInput(const std::string name, float *buffer, int size)

void execute()

Private Members

std::string model_data

std::unique_ptr<zdl::SNPE::SNPE> snpe

zdl::DlSystem::UserBufferMap input_map

zdl::DlSystem::UserBufferMap output_map

std::unique_ptr<zdl::DlSystem::IUserBuffer> output_buffer

bool use_tf8

float *output

size_t output_size

struct SNPEModelInput : public ModelInput

Public Functions

SNPEModelInput(const std::string _name, float *_buffer, int _size, std::unique_ptr<zdl::DlSystem::IUserBuffer> _snpe_buffer)

void setBuffer(float *_buffer, int _size)

Public Members

std::unique_ptr<zdl::DlSystem::IUserBuffer> snpe_buffer

class ThneedModel : public RunModel

Public Functions

ThneedModel(const std::string path, float *_output, size_t _output_size, int runtime, bool use_tf8 = false, cl_context context = NULL)

void *getCLBuffer(const std::string name)

void execute()

Private Members

Thneed *thneed = NULL

bool recorded

float *output

file snpemodel.h: #include <memory>

#include <string>

#include <utility>

#include <DlContainer/IDlContainer.hpp>

#include <DlSystem/DlError.hpp>

#include <DlSystem/ITensor.hpp>

#include <DlSystem/ITensorFactory.hpp>

#include <DlSystem/IUserBuffer.hpp>

#include <DlSystem/IUserBufferFactory.hpp>

#include <SNPE/SNPE.hpp>

#include <SNPE/SNPEBuilder.hpp>

#include <SNPE/SNPEFactory.hpp>

#include “selfdrive/modeld/runners/runmodel.h”

file thneedmodel.h: #include <string>

#include “selfdrive/modeld/runners/runmodel.h”

#include “selfdrive/modeld/thneed/thneed.h”

dir /tmp/openpilot/selfdrive/modeld

dir /tmp/openpilot/selfdrive/modeld/runners

dir /tmp/openpilot/selfdrive

common

class ExitHandler

Public Functions

ExitHandler()

operator bool()

ExitHandler &operator=(bool v)

Public Static Attributes

static std::atomic<bool> power_failure = false

static std::atomic<int> signal = 0

Private Static Functions

static void set_do_exit(int sig)

Private Static Attributes

static std::atomic<bool> do_exit = false

class FirstOrderFilter

Public Functions

FirstOrderFilter(float x0, float ts, float dt, bool initialized = true)

float update(float x)

void reset(float x)

float x()

Private Members

float x_

float k_

bool initialized_

class I2CBus

Public Functions

I2CBus(uint8_t bus_id)

~I2CBus()

int read_register(uint8_t device_address, uint register_address, uint8_t *buffer, uint8_t len)

int set_register(uint8_t device_address, uint register_address, uint8_t data)

Private Members

int i2c_fd

std::mutex m

class Params

Public Functions

Params(const std::string &path = {})

~Params()

Params(const Params&)

Params &operator=(const Params&)

std::vector<std::string> allKeys() const

bool checkKey(const std::string &key)

ParamKeyType getKeyType(const std::string &key)

std::string getParamPath(const std::string &key = {})

int remove(const std::string &key)

void clearAll(ParamKeyType type)

std::string get(const std::string &key, bool block = false)

bool getBool(const std::string &key, bool block = false)

std::map<std::string, std::string> readAll()

int put(const char *key, const char *val, size_t value_size)

int put(const std::string &key, const std::string &val)

int putBool(const std::string &key, bool val)

void putNonBlocking(const std::string &key, const std::string &val)

void putBoolNonBlocking(const std::string &key, bool val)

Private Functions

void asyncWriteThread()

Private Members

std::string params_path

std::string params_prefix

std::future<void> future

SafeQueue<std::pair<std::string, std::string>> queue

class RateKeeper

Public Functions

RateKeeper(const std::string &name, float rate, float print_delay_threshold = 0)

~RateKeeper()

bool keepTime()

bool monitorTime()

double frame() const

double remaining() const

Private Members

double interval

double next_frame_time

double last_monitor_time

double remaining_ = 0

float print_delay_threshold = 0

uint64_t frame_ = 0

std::string name

struct Rect

Public Members

int x

int y

int w

int h

struct unique_fd

Public Functions

unique_fd(int fd = -1)

unique_fd &operator=(unique_fd &&uf)

~unique_fd()

operator int() const

Public Members

int fd_

namespace util

Functions

void set_thread_name(const char *name)

int set_realtime_priority(int level)

int set_core_affinity(std::vector<int> cores)

int set_file_descriptor_limit(uint64_t limit)

template<typename T> T map_val(T x, T a1, T a2, T b1, T b2)

template<typename ...Args> std::string string_format(const std::string &format, Args... args)

std::string getenv(const char *key, std::string default_val = "")

int getenv(const char *key, int default_val)

float getenv(const char *key, float default_val)

std::string hexdump(const uint8_t *in, const size_t size)

bool starts_with(const std::string &s1, const std::string &s2)

bool ends_with(const std::string &s, const std::string &suffix)

int random_int(int min, int max)

std::string random_string(std::string::size_type length)

std::string read_file(const std::string &fn)

std::map<std::string, std::string> read_files_in_dir(const std::string &path)

int write_file(const char *path, const void *data, size_t size, int flags = O_WRONLY, mode_t mode = 0664)

FILE *safe_fopen(const char *filename, const char *mode)

size_t safe_fwrite(const void *ptr, size_t size, size_t count, FILE *stream)

int safe_fflush(FILE *stream)

int safe_ioctl(int fd, unsigned long request, void *argp)

std::string readlink(const std::string &path)

bool file_exists(const std::string &fn)

bool create_directories(const std::string &dir, mode_t mode)

std::string check_output(const std::string &command)

void sleep_for(const int milliseconds)

file clutil.h

#include <CL/cl.h>

#include <string>

Defines

CL_CHECK(_expr)

CL_CHECK_ERR(_expr)

Functions

cl_device_id cl_get_device_id(cl_device_type device_type)

cl_context cl_create_context(cl_device_id device_id)

cl_program cl_program_from_source(cl_context ctx, cl_device_id device_id, const std::string &src, const char *args = nullptr)

cl_program cl_program_from_binary(cl_context ctx, cl_device_id device_id, const uint8_t *binary, size_t length, const char *args = nullptr)

cl_program cl_program_from_file(cl_context ctx, cl_device_id device_id, const char *path, const char *args)

const char *cl_get_error_string(int err)

file gpio.h

Defines

GPIO_HUB_RST_N

GPIO_UBLOX_RST_N

GPIO_UBLOX_SAFEBOOT_N

GPIO_GNSS_PWR_EN

GPIO_STM_RST_N

GPIO_STM_BOOT0

GPIO_BMX_ACCEL_INT

GPIO_BMX_GYRO_INT

GPIO_BMX_MAGN_INT

GPIO_LSM_INT

GPIOCHIP_INT

Functions

int gpio_init(int pin_nr, bool output)

int gpio_set(int pin_nr, bool high)

int gpiochip_get_ro_value_fd(const char *consumer_label, int gpiochiop_id, int pin_nr)

file i2c.h: #include <cstdint>

#include <mutex>

#include <sys/types.h>

file params.h

#include <future>

#include <map>

#include <string>

#include <tuple>

#include <utility>

#include <vector>

#include “common/queue.h”

Enums

enum ParamKeyType

Values:

enumerator PERSISTENT

enumerator CLEAR_ON_MANAGER_START

enumerator CLEAR_ON_ONROAD_TRANSITION

enumerator CLEAR_ON_OFFROAD_TRANSITION

enumerator DONT_LOG

enumerator DEVELOPMENT_ONLY

enumerator ALL

file ratekeeper.h: #include <cstdint>

#include <string>

file swaglog.h

#include “common/timing.h”

Defines

CLOUDLOG_DEBUG

CLOUDLOG_INFO

CLOUDLOG_WARNING

CLOUDLOG_ERROR

CLOUDLOG_CRITICAL

SWAG_LOG_CHECK_FMT(a, b)

cloudlog(lvl, fmt, ...)

cloudlog_t(lvl, ...)

cloudlog_rl(burst, millis, lvl, fmt, ...)

LOGT(...)

LOGD(fmt, ...)

LOG(fmt, ...)

LOGW(fmt, ...)

LOGE(fmt, ...)

LOGD_100(fmt, ...)

LOG_100(fmt, ...)

LOGW_100(fmt, ...)

LOGE_100(fmt, ...)

Functions

void cloudlog_e(int levelnum, const char *filename, int lineno, const char *func, const char *fmt, ...)

void void cloudlog_te(int levelnum, const char * filename, int lineno, const char * func, const char * fmt, ...)

void void void cloudlog_te(int levelnum, const char * filename, int lineno, const char * func, uint32_t frame_id, const char * fmt, ...)

file util.h

#include <fcntl.h>

#include <sys/stat.h>

#include <unistd.h>

#include <algorithm>

#include <atomic>

#include <chrono>

#include <csignal>

#include <map>

#include <memory>

#include <mutex>

#include <string>

#include <thread>

#include <vector>

Defines

HANDLE_EINTR(x)

Typedefs

typedef void (*sighandler_t)(int sig)

typedef struct Rect Rect

Functions

template<typename T> void update_max_atomic(std::atomic<T> &max, T const &value)

Variables

const double MILE_TO_KM = 1.609344

const double KM_TO_MILE = 1. / MILE_TO_KM 

const double MS_TO_KPH = 3.6

const double MS_TO_MPH = MS_TO_KPH * KM_TO_MILE 

const double METER_TO_MILE = KM_TO_MILE / 1000.0

const double METER_TO_FOOT = 3.28084

file watchdog.h

#include <cstdint>

Functions

bool watchdog_kick(uint64_t ts)

dir /tmp/openpilot/common

sensorsd

class BMX055_Accel : public I2CSensor 

Public Functions

BMX055_Accel(I2CBus *bus)

int init()

bool get_event(MessageBuilder &msg, uint64_t ts = 0)

int shutdown()

Private Functions

uint8_t get_device_address()

class BMX055_Gyro : public I2CSensor 

Public Functions

BMX055_Gyro(I2CBus *bus)

int init()

bool get_event(MessageBuilder &msg, uint64_t ts = 0)

int shutdown()

Private Functions

uint8_t get_device_address()

class BMX055_Magn : public I2CSensor 

Public Functions

BMX055_Magn(I2CBus *bus)

int init()

bool get_event(MessageBuilder &msg, uint64_t ts = 0)

int shutdown()

Private Functions

uint8_t get_device_address()

bool perform_self_test()

bool parse_xyz(uint8_t buffer[8], int16_t *x, int16_t *y, int16_t *z)

Private Members

trim_data_t trim_data = {0}

class BMX055_Temp : public I2CSensor 

Public Functions

BMX055_Temp(I2CBus *bus)

int init()

bool get_event(MessageBuilder &msg, uint64_t ts = 0)

int shutdown()

Private Functions

uint8_t get_device_address()

class I2CSensor : public Sensor

Subclassed by BMX055_Accel, BMX055_Gyro, BMX055_Magn, BMX055_Temp, LSM6DS3_Accel, LSM6DS3_Gyro, LSM6DS3_Temp, MMC5603NJ_Magn

Public Functions

I2CSensor(I2CBus *bus, int gpio_nr = 0, bool shared_gpio = false)

~I2CSensor()

int read_register(uint register_address, uint8_t *buffer, uint8_t len)

int set_register(uint register_address, uint8_t data)

int init_gpio()

bool has_interrupt_enabled()

virtual int init() = 0

virtual bool get_event(MessageBuilder &msg, uint64_t ts = 0) = 0

virtual int shutdown() = 0

int verify_chip_id(uint8_t address, const std::vector<uint8_t> &expected_ids)

Private Functions

virtual uint8_t get_device_address() = 0

Private Members

I2CBus *bus

int gpio_nr

bool shared_gpio

class LSM6DS3_Accel : public I2CSensor 

Public Functions

LSM6DS3_Accel(I2CBus *bus, int gpio_nr = 0, bool shared_gpio = false)

int init()

bool get_event(MessageBuilder &msg, uint64_t ts = 0)

int shutdown()

Private Functions

uint8_t get_device_address()

int self_test(int test_type)

void wait_for_data_ready()

void read_and_avg_data(float *val_st_off)

Private Members

cereal::SensorEventData::SensorSource source = cereal::SensorEventData::SensorSource::LSM6DS3

class LSM6DS3_Gyro : public I2CSensor 

Public Functions

LSM6DS3_Gyro(I2CBus *bus, int gpio_nr = 0, bool shared_gpio = false)

int init()

bool get_event(MessageBuilder &msg, uint64_t ts = 0)

int shutdown()

Private Functions

uint8_t get_device_address()

int self_test(int test_type)

void wait_for_data_ready()

void read_and_avg_data(float *val_st_off)

Private Members

cereal::SensorEventData::SensorSource source = cereal::SensorEventData::SensorSource::LSM6DS3

class LSM6DS3_Temp : public I2CSensor 

Public Functions

LSM6DS3_Temp(I2CBus *bus)

int init()

bool get_event(MessageBuilder &msg, uint64_t ts = 0)

int shutdown()

Private Functions

uint8_t get_device_address()

Private Members

cereal::SensorEventData::SensorSource source = cereal::SensorEventData::SensorSource::LSM6DS3

class MMC5603NJ_Magn : public I2CSensor 

Public Functions

MMC5603NJ_Magn(I2CBus *bus)

int init()

bool get_event(MessageBuilder &msg, uint64_t ts = 0)

int shutdown()

Private Functions

uint8_t get_device_address()

void start_measurement()

std::vector<float> read_measurement()

struct trim_data_t

Public Members

int8_t dig_x1

int8_t dig_y1

int8_t dig_x2

int8_t dig_y2

uint16_t dig_z1

int16_t dig_z2

int16_t dig_z3

int16_t dig_z4

uint8_t dig_xy1

int8_t dig_xy2

uint16_t dig_xyz1

file bmx055_accel.h

#include “system/sensord/sensors/i2c_sensor.h”

Defines

BMX055_ACCEL_I2C_ADDR

BMX055_ACCEL_I2C_REG_ID

BMX055_ACCEL_I2C_REG_X_LSB

BMX055_ACCEL_I2C_REG_TEMP

BMX055_ACCEL_I2C_REG_BW

BMX055_ACCEL_I2C_REG_PMU

BMX055_ACCEL_I2C_REG_HBW

BMX055_ACCEL_I2C_REG_FIFO

BMX055_ACCEL_CHIP_ID

BMX055_ACCEL_HBW_ENABLE

BMX055_ACCEL_HBW_DISABLE

BMX055_ACCEL_DEEP_SUSPEND

BMX055_ACCEL_NORMAL_MODE

BMX055_ACCEL_BW_7_81HZ

BMX055_ACCEL_BW_15_63HZ

BMX055_ACCEL_BW_31_25HZ

BMX055_ACCEL_BW_62_5HZ

BMX055_ACCEL_BW_125HZ

BMX055_ACCEL_BW_250HZ

BMX055_ACCEL_BW_500HZ

BMX055_ACCEL_BW_1000HZ

file bmx055_gyro.h

#include “system/sensord/sensors/i2c_sensor.h”

Defines

BMX055_GYRO_I2C_ADDR

BMX055_GYRO_I2C_REG_ID

BMX055_GYRO_I2C_REG_RATE_X_LSB

BMX055_GYRO_I2C_REG_RANGE

BMX055_GYRO_I2C_REG_BW

BMX055_GYRO_I2C_REG_LPM1

BMX055_GYRO_I2C_REG_HBW

BMX055_GYRO_I2C_REG_FIFO

BMX055_GYRO_CHIP_ID

BMX055_GYRO_HBW_ENABLE

BMX055_GYRO_HBW_DISABLE

BMX055_GYRO_DEEP_SUSPEND

BMX055_GYRO_NORMAL_MODE

BMX055_GYRO_RANGE_2000

BMX055_GYRO_RANGE_1000

BMX055_GYRO_RANGE_500

BMX055_GYRO_RANGE_250

BMX055_GYRO_RANGE_125

BMX055_GYRO_BW_116HZ

file bmx055_magn.h

#include <tuple>

#include “system/sensord/sensors/i2c_sensor.h”

Defines

BMX055_MAGN_I2C_ADDR

BMX055_MAGN_I2C_REG_ID

BMX055_MAGN_I2C_REG_PWR_0

BMX055_MAGN_I2C_REG_MAG

BMX055_MAGN_I2C_REG_DATAX_LSB

BMX055_MAGN_I2C_REG_RHALL_LSB

BMX055_MAGN_I2C_REG_REPXY

BMX055_MAGN_I2C_REG_REPZ

BMX055_MAGN_I2C_REG_DIG_X1

BMX055_MAGN_I2C_REG_DIG_Y1

BMX055_MAGN_I2C_REG_DIG_Z4_LSB

BMX055_MAGN_I2C_REG_DIG_Z4_MSB

BMX055_MAGN_I2C_REG_DIG_X2

BMX055_MAGN_I2C_REG_DIG_Y2

BMX055_MAGN_I2C_REG_DIG_Z2_LSB

BMX055_MAGN_I2C_REG_DIG_Z2_MSB

BMX055_MAGN_I2C_REG_DIG_Z1_LSB

BMX055_MAGN_I2C_REG_DIG_Z1_MSB

BMX055_MAGN_I2C_REG_DIG_XYZ1_LSB

BMX055_MAGN_I2C_REG_DIG_XYZ1_MSB

BMX055_MAGN_I2C_REG_DIG_Z3_LSB

BMX055_MAGN_I2C_REG_DIG_Z3_MSB

BMX055_MAGN_I2C_REG_DIG_XY2

BMX055_MAGN_I2C_REG_DIG_XY1

BMX055_MAGN_CHIP_ID

BMX055_MAGN_FORCED

file bmx055_temp.h: #include “system/sensord/sensors/bmx055_accel.h”

#include “system/sensord/sensors/i2c_sensor.h”

file i2c_sensor.h

#include <cstdint>

#include <unistd.h>

#include <vector>

#include “cereal/gen/cpp/log.capnp.h”

#include “common/i2c.h”

#include “common/gpio.h”

#include “common/swaglog.h”

#include “system/sensord/sensors/constants.h”

#include “system/sensord/sensors/sensor.h”

Functions

int16_t read_12_bit(uint8_t lsb, uint8_t msb)

int16_t read_16_bit(uint8_t lsb, uint8_t msb)

int32_t read_20_bit(uint8_t b2, uint8_t b1, uint8_t b0)

file lsm6ds3_accel.h

#include “system/sensord/sensors/i2c_sensor.h”

Defines

LSM6DS3_ACCEL_I2C_ADDR

LSM6DS3_ACCEL_I2C_REG_DRDY_CFG

LSM6DS3_ACCEL_I2C_REG_ID

LSM6DS3_ACCEL_I2C_REG_INT1_CTRL

LSM6DS3_ACCEL_I2C_REG_CTRL1_XL

LSM6DS3_ACCEL_I2C_REG_CTRL3_C

LSM6DS3_ACCEL_I2C_REG_CTRL5_C

LSM6DS3_ACCEL_I2C_REG_CTR9_XL

LSM6DS3_ACCEL_I2C_REG_STAT_REG

LSM6DS3_ACCEL_I2C_REG_OUTX_L_XL

LSM6DS3_ACCEL_CHIP_ID

LSM6DS3TRC_ACCEL_CHIP_ID

LSM6DS3_ACCEL_FS_4G

LSM6DS3_ACCEL_ODR_52HZ

LSM6DS3_ACCEL_ODR_104HZ

LSM6DS3_ACCEL_INT1_DRDY_XL

LSM6DS3_ACCEL_DRDY_XLDA

LSM6DS3_ACCEL_DRDY_PULSE_MODE

LSM6DS3_ACCEL_IF_INC

LSM6DS3_ACCEL_IF_INC_BDU

LSM6DS3_ACCEL_XYZ_DEN

LSM6DS3_ACCEL_POSITIVE_TEST

LSM6DS3_ACCEL_NEGATIVE_TEST

LSM6DS3_ACCEL_MIN_ST_LIMIT_mg

LSM6DS3_ACCEL_MAX_ST_LIMIT_mg

file lsm6ds3_gyro.h

#include “system/sensord/sensors/i2c_sensor.h”

Defines

LSM6DS3_GYRO_I2C_ADDR

LSM6DS3_GYRO_I2C_REG_DRDY_CFG

LSM6DS3_GYRO_I2C_REG_ID

LSM6DS3_GYRO_I2C_REG_INT1_CTRL

LSM6DS3_GYRO_I2C_REG_CTRL2_G

LSM6DS3_GYRO_I2C_REG_CTRL5_C

LSM6DS3_GYRO_I2C_REG_STAT_REG

LSM6DS3_GYRO_I2C_REG_OUTX_L_G

LSM6DS3_GYRO_POSITIVE_TEST

LSM6DS3_GYRO_NEGATIVE_TEST

LSM6DS3_GYRO_CHIP_ID

LSM6DS3TRC_GYRO_CHIP_ID

LSM6DS3_GYRO_FS_2000dps

LSM6DS3_GYRO_ODR_104HZ

LSM6DS3_GYRO_ODR_208HZ

LSM6DS3_GYRO_INT1_DRDY_G

LSM6DS3_GYRO_DRDY_GDA

LSM6DS3_GYRO_DRDY_PULSE_MODE

LSM6DS3_GYRO_MIN_ST_LIMIT_mdps

LSM6DS3_GYRO_MAX_ST_LIMIT_mdps

file lsm6ds3_temp.h

#include “system/sensord/sensors/i2c_sensor.h”

Defines

LSM6DS3_TEMP_I2C_ADDR

LSM6DS3_TEMP_I2C_REG_ID

LSM6DS3_TEMP_I2C_REG_OUT_TEMP_L

LSM6DS3_TEMP_CHIP_ID

LSM6DS3TRC_TEMP_CHIP_ID

file mmc5603nj_magn.h

#include <vector>

#include “system/sensord/sensors/i2c_sensor.h”

Defines

MMC5603NJ_I2C_ADDR

MMC5603NJ_I2C_REG_XOUT0

MMC5603NJ_I2C_REG_ODR

MMC5603NJ_I2C_REG_INTERNAL_0

MMC5603NJ_I2C_REG_INTERNAL_1

MMC5603NJ_I2C_REG_INTERNAL_2

MMC5603NJ_I2C_REG_ID

MMC5603NJ_CHIP_ID

MMC5603NJ_CMM_FREQ_EN

MMC5603NJ_AUTO_SR_EN

MMC5603NJ_CMM_EN

MMC5603NJ_EN_PRD_SET

MMC5603NJ_SET

MMC5603NJ_RESET

dir /tmp/openpilot/system/sensord

dir /tmp/openpilot/system/sensord/sensors

dir /tmp/openpilot/system

boardd

struct can_frame

Public Members

long address

std::string dat

long busTime

long src

class Panda

Public Functions

Panda(std::string serial = "", uint32_t bus_offset = 0)

bool connected()

bool comms_healthy()

std::string hw_serial()

cereal::PandaState::PandaType get_hw_type()

void set_safety_model(cereal::CarParams::SafetyModel safety_model, uint16_t safety_param = 0U)

void set_alternative_experience(uint16_t alternative_experience)

void set_fan_speed(uint16_t fan_speed)

uint16_t get_fan_speed()

void set_ir_pwr(uint16_t ir_pwr)

std::optional<health_t> get_state()

std::optional<can_health_t> get_can_state(uint16_t can_number)

void set_loopback(bool loopback)

std::optional<std::vector<uint8_t>> get_firmware_version()

bool up_to_date()

std::optional<std::string> get_serial()

void set_power_saving(bool power_saving)

void enable_deepsleep()

void send_heartbeat(bool engaged)

void set_can_speed_kbps(uint16_t bus, uint16_t speed)

void set_data_speed_kbps(uint16_t bus, uint16_t speed)

void set_canfd_non_iso(uint16_t bus, bool non_iso)

void can_send(capnp::List<cereal::CanData>::Reader can_data_list)

bool can_receive(std::vector<can_frame> &out_vec)

void can_reset_communications()

Public Members

cereal::PandaState::PandaType hw_type = cereal::PandaState::PandaType::UNKNOWN

const uint32_t bus_offset

Public Static Functions

static std::vector<std::string> list(bool usb_only = false)

Protected Functions

Panda(uint32_t bus_offset)

void pack_can_buffer(const capnp::List<cereal::CanData>::Reader &can_data_list, std::function<void(uint8_t*, size_t)> write_func)

bool unpack_can_buffer(uint8_t *data, uint32_t &size, std::vector<can_frame> &out_vec)

uint8_t calculate_checksum(uint8_t *data, uint32_t len)

Protected Attributes

uint8_t receive_buffer[RECV_SIZE + sizeof(can_header) + 64]

uint32_t receive_buffer_size = 0

Private Members

std::unique_ptr<PandaCommsHandle> handle

class PandaCommsHandle

Subclassed by PandaSpiHandle, PandaUsbHandle

Public Functions

PandaCommsHandle(std::string serial)

virtual ~PandaCommsHandle()

virtual void cleanup() = 0

virtual int control_write(uint8_t request, uint16_t param1, uint16_t param2, unsigned int timeout = TIMEOUT) = 0

virtual int control_read(uint8_t request, uint16_t param1, uint16_t param2, unsigned char *data, uint16_t length, unsigned int timeout = TIMEOUT) = 0

virtual int bulk_write(unsigned char endpoint, unsigned char *data, int length, unsigned int timeout = TIMEOUT) = 0

virtual int bulk_read(unsigned char endpoint, unsigned char *data, int length, unsigned int timeout = TIMEOUT) = 0

Public Members

std::string hw_serial

std::atomic<bool> connected = true

std::atomic<bool> comms_healthy = true

Public Static Functions

static std::vector<std::string> list()

class PandaSpiHandle : public PandaCommsHandle 

Public Functions

PandaSpiHandle(std::string serial)

~PandaSpiHandle()

int control_write(uint8_t request, uint16_t param1, uint16_t param2, unsigned int timeout = TIMEOUT)

int control_read(uint8_t request, uint16_t param1, uint16_t param2, unsigned char *data, uint16_t length, unsigned int timeout = TIMEOUT)

int bulk_write(unsigned char endpoint, unsigned char *data, int length, unsigned int timeout = TIMEOUT)

int bulk_read(unsigned char endpoint, unsigned char *data, int length, unsigned int timeout = TIMEOUT)

void cleanup()

Public Static Functions

static std::vector<std::string> list()

Private Functions

int wait_for_ack(uint8_t ack, uint8_t tx, unsigned int timeout, unsigned int length)

int bulk_transfer(uint8_t endpoint, uint8_t *tx_data, uint16_t tx_len, uint8_t *rx_data, uint16_t rx_len, unsigned int timeout)

int spi_transfer(uint8_t endpoint, uint8_t *tx_data, uint16_t tx_len, uint8_t *rx_data, uint16_t max_rx_len, unsigned int timeout)

int spi_transfer_retry(uint8_t endpoint, uint8_t *tx_data, uint16_t tx_len, uint8_t *rx_data, uint16_t max_rx_len, unsigned int timeout)

int lltransfer(spi_ioc_transfer &t)

Private Members

int spi_fd = -1

uint8_t tx_buf[SPI_BUF_SIZE]

uint8_t rx_buf[SPI_BUF_SIZE]

Private Static Attributes

static std::recursive_mutex hw_lock

class PandaUsbHandle : public PandaCommsHandle 

Public Functions

PandaUsbHandle(std::string serial)

~PandaUsbHandle()

int control_write(uint8_t request, uint16_t param1, uint16_t param2, unsigned int timeout = TIMEOUT)

int control_read(uint8_t request, uint16_t param1, uint16_t param2, unsigned char *data, uint16_t length, unsigned int timeout = TIMEOUT)

int bulk_write(unsigned char endpoint, unsigned char *data, int length, unsigned int timeout = TIMEOUT)

int bulk_read(unsigned char endpoint, unsigned char *data, int length, unsigned int timeout = TIMEOUT)

void cleanup()

Public Static Functions

static std::vector<std::string> list()

Private Functions

void handle_usb_issue(int err, const char func[])

Private Members

libusb_context *ctx = NULL

libusb_device_handle *dev_handle = NULL

std::recursive_mutex hw_lock

file boardd.h

#include <string>

#include <vector>

#include “selfdrive/boardd/panda.h”

Functions

bool safety_setter_thread(std::vector<Panda*> pandas)

void boardd_main_thread(std::vector<std::string> serials)

file panda.h

#include <cstdint>

#include <ctime>

#include <functional>

#include <list>

#include <memory>

#include <optional>

#include <string>

#include <vector>

#include “cereal/gen/cpp/car.capnp.h”

#include “cereal/gen/cpp/log.capnp.h”

#include “panda/board/health.h”

#include “panda/board/can_definitions.h”

#include “selfdrive/boardd/panda_comms.h”

Defines

USB_TX_SOFT_LIMIT

USBPACKET_MAX_SIZE

RECV_SIZE

CAN_REJECTED_BUS_OFFSET

CAN_RETURNED_BUS_OFFSET

PANDA_BUS_OFFSET

Functions

struct __attribute__((packed))

file panda_comms.h

#include <atomic>

#include <cstdint>

#include <mutex>

#include <string>

#include <vector>

#include <linux/spi/spidev.h>

#include <libusb-1.0/libusb.h>

Defines

TIMEOUT

SPI_BUF_SIZE

dir /tmp/openpilot/selfdrive/boardd

dir /tmp/openpilot/selfdrive

rednose

class EKFSym

Public Functions

EKFSym(std::string name, Eigen::Map<MatrixXdr> Q, Eigen::Map<Eigen::VectorXd> x_initial, Eigen::Map<MatrixXdr> P_initial, int dim_main, int dim_main_err, int N = 0, int dim_augment = 0, int dim_augment_err = 0, std::vector<int> maha_test_kinds = std::vector<int>(), std::vector<int> quaternion_idxs = std::vector<int>(), std::vector<std::string> global_vars = std::vector<std::string>(), double max_rewind_age = 1.0)

void init_state(Eigen::Map<Eigen::VectorXd> state, Eigen::Map<MatrixXdr> covs, double filter_time)

Eigen::VectorXd state()

MatrixXdr covs()

void set_filter_time(double t)

double get_filter_time()

void normalize_quaternions()

void normalize_slice(int slice_start, int slice_end_ex)

void set_global(std::string global_var, double val)

void reset_rewind()

void predict(double t)

std::optional<Estimate> predict_and_update_batch(double t, int kind, std::vector<Eigen::Map<Eigen::VectorXd>> z, std::vector<Eigen::Map<MatrixXdr>> R, std::vector<std::vector<double>> extra_args = {{}}, bool augment = false)

extra_routine_t get_extra_routine(const std::string &routine)

Private Functions

std::deque<Observation> rewind(double t)

void checkpoint(Observation &obs)

Estimate predict_and_update_batch(Observation &obs, bool augment)

Eigen::VectorXd update(int kind, Eigen::VectorXd z, MatrixXdr R, std::vector<double> extra_args)

Private Members

const EKF *ekf = NULL

Eigen::VectorXd x

MatrixXdr P

bool msckf

int N

int dim_augment

int dim_augment_err

int dim_main

int dim_main_err

int dim_x

int dim_err

double filter_time

std::vector<int> maha_test_kinds

std::vector<int> quaternion_idxs

std::vector<std::string> global_vars

MatrixXdr Q

double max_rewind_age

std::deque<double> rewind_t

std::deque<std::pair<Eigen::VectorXd, MatrixXdr>> rewind_states

std::deque<Observation> rewind_obscache

Eigen::VectorXd augment_times

std::vector<int> feature_track_kinds

struct Estimate

Public Members

Eigen::VectorXd xk1

Eigen::VectorXd xk

MatrixXdr Pk1

MatrixXdr Pk

double t

int kind

std::vector<Eigen::VectorXd> y

std::vector<Eigen::VectorXd> z

std::vector<std::vector<double>> extra_args

struct Observation

Public Members

double t

int kind

std::vector<Eigen::VectorXd> z

std::vector<MatrixXdr> R

std::vector<std::vector<double>> extra_args

namespace EKFS

Typedefs

typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> MatrixXdr

typedef struct EKFS::Observation Observation

typedef struct EKFS::Estimate Estimate

file ekf_load.h

#include <vector>

#include <string>

#include “ekf.h”

#include <iostream>

#include <cassert>

#include <deque>

#include <unordered_map>

#include <map>

#include <cmath>

#include <eigen3/Eigen/Dense>

Functions

std::vector<const EKF*> &ekf_get_all()

const EKF *ekf_lookup(const std::string &ekf_name)

void ekf_register(const EKF *ekf)

void ekf_load_and_register(const std::string &ekf_directory, const std::string &ekf_name)

file ekf_sym.h

#include <iostream>

#include <cassert>

#include <string>

#include <vector>

#include <deque>

#include <unordered_map>

#include <map>

#include <cmath>

#include <optional>

#include <eigen3/Eigen/Dense>

#include “ekf.h”

#include “ekf_load.h”

Defines

REWIND_TO_KEEP

dir /tmp/openpilot/rednose_repo/rednose/helpers

dir /tmp/openpilot/rednose_repo/rednose

dir /tmp/openpilot/rednose_repo