outputs_pages.h

Go to the documentation of this file.

 
#pragma once
 
#include <stdint.h>
 
#include "outputs.h"

uint16_t link_driver_of(out_driver_t d);

uint8_t outputs_arm_roles_of(uint16_t arm);

uint16_t outputs_arm_value_of(uint8_t roles);

uint16_t outputs_arm_value_for(uint16_t far_minor, uint8_t roles);
 
/* --- SERVO: with the standard target, the frame rate of every PWM output
 *     rendering a surface; the page itself is servo_page.h */

uint8_t outputs_servo_rate_check(const outputs_t *o, uint16_t hz);

void    outputs_slot_rates(const outputs_t *o, uint16_t servo_hz,
                           uint16_t *rate);

uint8_t outputs_chan_cfg_rate_check(const outputs_t *o,
                                    const uint16_t *chan_cfg,
                                    uint16_t servo_hz);

uint8_t outputs_slots_rate_check(const outputs_t *o, const uint16_t *slots,
                                 uint16_t servo_hz);

uint8_t outputs_pulse_check(const outputs_t *o, uint16_t servo_hz,
                            uint16_t channels, uint16_t channels_hz);

uint8_t outputs_chan_cfg_pulse_check(const outputs_t *o,
                                     const uint16_t *chan_cfg,
                                     const uint16_t *slots,
                                     uint16_t servo_hz);

uint8_t outputs_slots_pulse_check(const outputs_t *o, const uint16_t *slots,
                                  uint16_t servo_hz);

unsigned outputs_slots_free_long(const outputs_t *o, uint16_t *slots);

uint8_t outputs_slots_changed(const uint16_t *prev, const uint16_t *next);

uint8_t outputs_bind_check(const outputs_t *o, uint8_t watch,
                           uint8_t bound_after);

uint8_t outputs_chan_cfg_armed_check(const uint16_t *regs,
                                     const uint16_t *next, bool armed);

uint8_t outputs_slots_armed_check(const uint16_t *regs, const uint16_t *next,
                                  bool armed);
 
/* --- CHAN_CFG: what each channel is -- role, slew, and its pulse endpoints */

void    outputs_chan_cfg_defaults(uint16_t *regs);

uint8_t outputs_chan_cfg_write(uint16_t *regs, uint8_t off, uint8_t n,
                               const uint16_t *in);

void    outputs_chan_cfg_apply(outputs_t *o, const uint16_t *regs);

void    outputs_chan_cfg_restore(uint16_t *regs, const uint16_t *saved);

bool    outputs_chan_cfg_set_throttle_range(uint16_t *regs, uint16_t min_us,
                                            uint16_t max_us);
 
/* --- OUTPUTS: which driver renders which channels, on which pin, how often */

void    outputs_slots_defaults(uint16_t *regs);

uint8_t outputs_slots_write(uint16_t *regs, uint8_t off, uint8_t n,
                            const uint16_t *in);

void    outputs_slots_apply(outputs_t *o, const uint16_t *regs);

uint8_t outputs_role_channels(const uint16_t *slots, const uint16_t *chan_cfg,
                              out_role_t role);

uint64_t outputs_role_pins(const uint16_t *slots, const uint16_t *chan_cfg,
                           out_role_t role);
 
/* --- CHANNELS: what each output is asked for.
 *
 * Clamped, not refused, because a command arrives many times a second from a
 * host that may be mid-drag. */

void    outputs_channels_defaults(uint16_t *regs);

void    outputs_channels_from_bank(const outputs_t *o, uint16_t *regs);

uint8_t outputs_channels_write(uint16_t *regs, uint8_t off, uint8_t n,
                               const uint16_t *in);

void    outputs_channels_apply(outputs_t *o, const uint16_t *regs,
                               uint32_t now_ms);