https://github.com/adobe-after-effects-crack-on-us

main.rs

diagram.json

[package]
name = "rust-avr-servo"
version = "0.1.0"
authors = ["Kevin Oberlies<favilo@Gmail.com>"]
edition = "2021"
license = "MIT OR Apache-2.0"

[[bin]]
name = "rust-avr-servo"
test = false
bench = false

[dependencies]
panic-halt = "0.2.0"
ufmt = "0.1.0"
nb = "0.1.2"
avr-device = { version = "0.5.4", features = ["atmega328p"] }
embassy-executor = { version = "0.6.0", features = [
    "nightly",
    "arch-avr",
    "executor-thread",
    "task-arena-size-64",
] }
embassy-sync = { version = "0.6.0", default-features = false }
embassy-time = { version = "0.3.2", features = ["tick-hz-16_000_000"] }
embedded-hal = "1.0.0"
itoa = "1.0.9"
nb = "1.1.0"
portable-atomic = { version = "1.7.0", default-features = false, features = [
    "unsafe-assume-single-core",
] }
ufmt = "0.2.0"
vcell = "0.1.3"
futures-util = { version = "0.3.29", default-features = false, features = [
    "portable-atomic",
] }


[workspace.dependencies.atmega-hal]
git = "https://github.com/rahix/avr-hal"
rev = "65b304ec974a13f27ebc2ced21aa462c4b81ce82"

[workspace.dependencies.arduino-hal]
git = "https://github.com/rahix/avr-hal.git"
rev = "65b304ec974a13f27ebc2ced21aa462c4b81ce82"
features = ["arduino-nano", "critical-section-impl"]

[workspace.dependencies.avr-hal-generic]
git = "https://github.com/rahix/avr-hal.git"
rev = "65b304ec974a13f27ebc2ced21aa462c4b81ce82"

# Configure the build for minimal size - AVRs have very little program memory
[profile.release]
panic = "abort"
codegen-units = 1
debug = true
lto = true
opt-level = "s"


Cargo.toml


use core::sync::atomic::Ordering;

use atmega_hal::pac::TC1;
use atmega_hal::port::{mode::Output, Dynamic, Pin};
use avr_hal_generic::hal::digital::OutputPin;
use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
use embassy_sync::blocking_mutex::Mutex;
use heapless::Vec;
use portable_atomic::{AtomicBool, AtomicU16, AtomicU8};
use vcell::VolatileCell;

const F_CPU: u32 = 16_000_000;
const F_CPU_US: u32 = 16;
const PRESCALER: u32 = 8;
const MIN_PULSE_WIDTH: i16 = 544;
const MAX_PULSE_WIDTH: i16 = 2400;
const REFRESH_INTERVAL: u16 = 20000;

type Handle = u8;

#[derive(Debug)]
pub enum Error {
    /// Too many servos have been created.
    TooManyServos,

    /// The servo handle is invalid.
    InvalidServo,

    /// The servo system has not been initialized.
    /// Do so by calling `avr_servo::initialize_isr`.
    NotInitialized,

    /// The servo system has already been initialized.
    /// Do not call `avr_servo::initialize_isr` more than once.
    AlreadyInitialized,
}

pub struct Servo {
    handle: Handle,
    min: i8,
    max: i8,
}

struct ServoState {
    pin: Pin<Output, Dynamic>,
    active: bool,
    ticks: AtomicU16,
}

const WAITING_SENTINEL: u8 = 255;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ChannelState {
    /// We are currently waiting for the rest of the 20 ms to elapse
    Waiting,

    /// We are currently pulsing servo with the specified index.
    Pulsing(u8),
}
impl ChannelState {
    fn increment(&self, max_value: u8) -> Self {
        match self {
            ChannelState::Waiting => ChannelState::Pulsing(0),
            ChannelState::Pulsing(value) if value < &max_value => ChannelState::Pulsing(value + 1),
            _ => ChannelState::Waiting,
        }
    }
}

impl From<u8> for ChannelState {
    fn from(value: u8) -> Self {
        match value {
            WAITING_SENTINEL => ChannelState::Waiting,
            _ => ChannelState::Pulsing(value),
        }
    }
}

impl From<ChannelState> for u8 {
    fn from(value: ChannelState) -> Self {
        match value {
            ChannelState::Waiting => WAITING_SENTINEL,
            ChannelState::Pulsing(value) => value,
        }
    }
}

#[derive(Debug)]
#[repr(transparent)]
struct ChannelStateWrapper(AtomicU8);
impl ChannelStateWrapper {
    fn load(&self) -> ChannelState {
        self.0.load(Ordering::Acquire).into()
    }

    fn increment(&self, max_value: usize) {
        self.0
            .fetch_update(Ordering::Acquire, Ordering::Release, |value| {
                let state = ChannelState::from(value).increment(max_value as u8);
                Some(state.into())
            });
    }
}

struct GlobalServoState {
    current_state: ChannelStateWrapper,
    servos: Vec<ServoState, 12>,
}

static ALREADY_INITIALIZED: AtomicBool = AtomicBool::new(false);

static STATE: Mutex<CriticalSectionRawMutex, VolatileCell<GlobalServoState>> =
    Mutex::new(VolatileCell::new(GlobalServoState {
        current_state: ChannelStateWrapper(AtomicU8::new(0)),
        servos: Vec::new(),
    }));

impl Servo {
    pub fn new(pin: Pin<Output, Dynamic>, ticks: u16) -> Result<Self, Error> {
        if !ALREADY_INITIALIZED.load(Ordering::Acquire) {
            return Err(Error::NotInitialized);
        }
        let handle = STATE.lock(|servos| {
            let servos_ptr = servos.as_ptr();
            // SAFETY: STATE is guarded by our lock call above
            let servos = &mut unsafe { &mut *servos_ptr }.servos;
            let handle = servos.len();
            servos
                .push(ServoState {
                    pin,
                    active: true,
                    ticks: AtomicU16::new(ticks),
                })
                .map_err(|_| Error::TooManyServos)?;
            Ok(handle as Handle)
        })?;
        Ok(Self {
            handle,
            min: 0,
            max: 0,
        })
    }

    pub fn with_min(mut self, min: u8) -> Self {
        self.min = ((MAX_PULSE_WIDTH - min as i16) / 4) as i8;
        self
    }

    pub fn with_max(mut self, max: u8) -> Self {
        self.max = ((MAX_PULSE_WIDTH - max as i16) / 4) as i8;
        self
    }

    pub fn max(&self) -> i16 {
        MAX_PULSE_WIDTH - self.max as i16 * 4
    }

    pub fn min(&self) -> i16 {
        MAX_PULSE_WIDTH - self.min as i16 * 4
    }

    pub fn write(&mut self, value: i16) -> Result<(), Error> {
        let value = map(value.clamp(0, 180), 0, 180, self.min(), self.max());

        self.write_microseconds(value)
    }

    fn write_microseconds(&mut self, value: i16) -> Result<(), Error> {
        let value = map(value, 0, 180, self.min(), self.max());
        let value = value as u16;
        let ticks = us_to_ticks(value);

        STATE.lock(|state| {
            let servos = &mut unsafe { &mut *state.as_ptr() }.servos;
            let servo = servos
                .get_mut(self.handle as usize)
                .ok_or(Error::InvalidServo)?;
            servo.ticks.store(ticks, Ordering::Relaxed);
            Ok(())
        })
    }
}

macro_rules! tc1 {
    () => {
        // SAFETY: This is a zst and we've stolen the peripheral
        unsafe { core::mem::MaybeUninit::<TC1>::uninit().assume_init() }
    };
}

#[inline(always)]
fn __tc1_compa(tc: TC1) {
    STATE.lock(|state| {
        // SAFETY: We are holding the lock
        let state = unsafe { &mut *state.as_ptr() };
        // if( Channel[timer] < 0 )
        match state.current_state.load() {
            ChannelState::Waiting => {
                // *TCNTn = 0; // channel set to -1 indicated that refresh interval completed so reset the timer
                tc.tcnt1.write(|w| w.bits(0));
            }
            ChannelState::Pulsing(channel) => {
                // if( SERVO_INDEX(timer,Channel[timer]) < ServoCount && SERVO(timer,Channel[timer]).Pin.isActive == true )
                if let Some(servo) = state.servos.get_mut(channel as usize) {
                    if servo.active {
                        // digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,LOW); // pulse this channel low if activated
                        servo.pin.set_low();
                    }
                }
            }
        }
        // Channel[timer]++;    // increment to the next channel
        state.current_state.increment(state.servos.len());

        // if( SERVO_INDEX(timer,Channel[timer]) < ServoCount && Channel[timer] < SERVOS_PER_TIMER) {
        if let ChannelState::Pulsing(channel) = state.current_state.load() {
            if let Some(servo) = state.servos.get_mut(channel as usize) {
                // *OCRnA = *TCNTn + SERVO(timer,Channel[timer]).ticks;
                tc.ocr1a.write(|w| {
                    w.bits(tc.tcnt1.read().bits() + servo.ticks.load(Ordering::Relaxed))
                });
                // if(SERVO(timer,Channel[timer]).Pin.isActive == true)     // check if activated
                if servo.active {
                    // digitalWrite( SERVO(timer,Channel[timer]).Pin.nbr,HIGH); // it's an active channel so pulse it high
                    servo.pin.set_high();
                }
            }
        } else {
            // finished all channels so wait for the refresh period to expire before starting over
            // if( ((unsigned)*TCNTn) + 4 < usToTicks(REFRESH_INTERVAL) )  // allow a few ticks to ensure the next OCR1A not missed
            if tc.tcnt1.read().bits().saturating_add(4) < us_to_ticks(REFRESH_INTERVAL) {
                // *OCRnA = (unsigned int)usToTicks(REFRESH_INTERVAL);
                tc.ocr1a.write(|w| w.bits(us_to_ticks(REFRESH_INTERVAL)));
            } else {
                // *OCRnA = *TCNTn + 4;  // at least REFRESH_INTERVAL has elapsed
                tc.ocr1a.write(|w| w.bits(tc.tcnt1.read().bits() + 4));
            }
            // Channel[timer] = -1; // this will get incremented at the end of the refresh period to start again at the first channel
            // Already set to ChannelState::Waiting
        }
    });
}

#[avr_device::interrupt(atmega328p)]
fn TIMER1_COMPA() {
    __tc1_compa(tc1!());
}

// Steals the TC1 peripheral and configures it for the ISR
// SAFETY: We need to enable interrupts in this function, ensure the caller is aware of that.
pub unsafe fn initialize_isr(tc: TC1) -> Result<(), Error> {
    // TCCR1A = 0;             // normal counting mode
    // TCCR1B = _BV(CS11);     // set prescaler of 8
    // TCNT1 = 0;              // clear the timer count
    // TIFR1 |= _BV(OCF1A);     // clear any pending interrupts
    // TIMSK1 |=  _BV(OCIE1A) ; // enable the output compare interrupt

    if ALREADY_INITIALIZED.load(Ordering::Acquire) {
        return Err(Error::AlreadyInitialized);
    }
    // SAFETY: We are enabling interrupts for our timer, and we have ensured we haven't done so
    // before.
    unsafe {
        avr_device::interrupt::enable();
    };
    avr_device::interrupt::free(|_| {
        tc.tccr1b.write(|w| w.cs1().prescale_8());
        tc.tccr1a.write(|w| w.com1a().disconnected());
        tc.timsk1.write(|w| w.ocie1a().set_bit());
        tc.tcnt1.write(|w| w.bits(0));
        tc.tifr1.write(|w| w.ocf1a().set_bit());
    });
    ALREADY_INITIALIZED.store(true, Ordering::Release);
    Ok(())
}

/// Maps a value from one range to another.
#[inline(always)]
const fn map(src: i16, from_low: i16, from_high: i16, to_low: i16, to_high: i16) -> i16 {
    (src - from_low) * (to_high - to_low) / (from_high - from_low) + to_low
}

#[inline(always)]
const fn us_to_ticks(us: u16) -> u16 {
    ((F_CPU_US * us as u32) / PRESCALER) as u16
}
