fafo/maasier
15
0
Fork 0
Code Issues 6 Pull requests Projects Releases Packages Wiki Activity Actions

*: cargo fmt

Browse source
This commit is contained in:
Serge Bazanski 2026-01-23 21:28:46 +01:00
parent 9948a76602
commit fe8942575a
7 changed files with 156 additions and 151 deletions
Download patch file Download diff file Expand all files Collapse all files

55
spinnyboy_rust/src/bin/dc_driver/afroesc.rs
View file

@ -1,56 +1,59 @@
use esp_hal::mcpwm::operator::PwmPin;
use esp_hal::delay::Delay;
use crate::dc_driver::EscState;
pub struct AfroEsc<'a>{
pub pwm_pin: &'a mut PwmPin<'a, esp_hal::peripherals::MCPWM0<'a>, 0,true>,
use esp_hal::delay::Delay;
use esp_hal::mcpwm::operator::PwmPin;
pub struct AfroEsc<'a> {
pub pwm_pin: &'a mut PwmPin<'a, esp_hal::peripherals::MCPWM0<'a>, 0, true>,
state: crate::dc_driver::EscState,
}
const ARMING_SEQUENCE:u16 = 1055;
const MIN_THROTTLE:u16 = 1121;
const MAX_THROTTLE:u16 = 1421;
const GAP:u16 = (MAX_THROTTLE - MIN_THROTTLE)/100;
const ARMING_SEQUENCE: u16 = 1055;
const MIN_THROTTLE: u16 = 1121;
const MAX_THROTTLE: u16 = 1421;
const GAP: u16 = (MAX_THROTTLE - MIN_THROTTLE) / 100;
impl AfroEsc<'_>{
impl AfroEsc<'_> {
//this is a little hacky tbh
pub fn new<'a>(pwm_pin:&'a mut PwmPin<'a, esp_hal::peripherals::MCPWM0<'a>, 0,true>)-> AfroEsc<'a> {
let mut esc = AfroEsc{pwm_pin:pwm_pin,state:EscState::Starting};
pub fn new<'a>(
pwm_pin: &'a mut PwmPin<'a, esp_hal::peripherals::MCPWM0<'a>, 0, true>,
) -> AfroEsc<'a> {
let mut esc = AfroEsc {
pwm_pin: pwm_pin,
state: EscState::Starting,
};
let delay = Delay::new();
esc.send_arming_sequence();
delay.delay_millis(3000);
esc
}
pub fn set_timestamp(&mut self,value:u16){
pub fn set_timestamp(&mut self, value: u16) {
self.pwm_pin.set_timestamp(value);
}
//range is from 1121 till 1421
pub fn set_duty_percent(&mut self,value:u16){
pub fn set_duty_percent(&mut self, value: u16) {
if value > 100 {
// failsafe!
self.pwm_pin.set_timestamp(1055);
}
let new_timestamp = MIN_THROTTLE+value*GAP;
let new_timestamp = MIN_THROTTLE + value * GAP;
self.pwm_pin.set_timestamp(new_timestamp);
}
pub fn send_arming_sequence(&mut self){
pub fn send_arming_sequence(&mut self) {
self.set_timestamp(1055);
}
fn set_state(&mut self, state:EscState){
fn set_state(&mut self, state: EscState) {
self.state = state;
}
pub fn get_state(self) -> EscState{
pub fn get_state(self) -> EscState {
self.state
}
pub fn map_duty(&mut self, x:i32){
if x <=0 {
pub fn map_duty(&mut self, x: i32) {
if x <= 0 {
self.pwm_pin.set_timestamp(1055);
}
else{
let duty:u16 = crate::dc_driver::arduino_map(x, 0, 100, MIN_THROTTLE.into(), MAX_THROTTLE.into()).try_into().expect("INTEGER TOO LARGE");
} else {
let duty: u16 =
crate::dc_driver::arduino_map(x, 0, 100, MIN_THROTTLE.into(), MAX_THROTTLE.into())
.try_into()
.expect("INTEGER TOO LARGE");
self.pwm_pin.set_timestamp(duty);
}
}
}

19
spinnyboy_rust/src/bin/dc_driver/dshot.rs
View file

@ -41,8 +41,8 @@ impl BitTicks {
Self {
t0_h,
t1_h,
t0_l:t1_h,
t1_l:t0_h,
t0_l: t1_h,
t1_l: t0_h,
}
}
@ -58,10 +58,9 @@ impl BitTicks {
let t1_h = (speed.bit_times().t1_h / tick_len).round() as u16;
let t0_h = (speed.bit_times().t0_h / tick_len).round() as u16;
let mut bittick = Self::new(t1_h, t0_h);
bittick.t0_l = bit_ticks -t0_h;
bittick.t0_l = bit_ticks - t0_h;
bittick.t1_l = bit_ticks - t1_h;
bittick
}
}
@ -140,8 +139,14 @@ impl<'a> DShot<'a> {
) -> Self {
let clk_speed = clk_speed.unwrap_or(80_000_000);
let clk_divider = clk_divider.unwrap_or(1);
let bit_ticks = BitTicks::from_clk(clk_speed, clk_divider, speed.bit_times(),speed);
rprint!("bit_ticks.t1_h:{},t1_l:{},t0_h:{},t0_l{}",bit_ticks.t1_h,bit_ticks.t1_l,bit_ticks.t0_h,bit_ticks.t0_l);
let bit_ticks = BitTicks::from_clk(clk_speed, clk_divider, speed.bit_times(), speed);
rprint!(
"bit_ticks.t1_h:{},t1_l:{},t0_h:{},t0_l{}",
bit_ticks.t1_h,
bit_ticks.t1_l,
bit_ticks.t0_h,
bit_ticks.t0_l
);
Self {
rx_channel: rx_channel,
tx_channel: tx_channel,
@ -195,7 +200,7 @@ impl<'a> DShot<'a> {
rprintln!("");
rprintln!("--------------------");
pulses[16] =0;
pulses[16] = 0;
pulses
}

8
spinnyboy_rust/src/bin/dc_driver/mod.rs
View file

@ -4,14 +4,10 @@ pub enum EscState {
Starting,
Running,
Stopping,
Stop
Stop,
}
//taken from: https://docs.arduino.cc/language-reference/en/functions/math/map/
//used for the ramp up of the spincoater
pub fn arduino_map(x:i32, in_min:i32, in_max:i32, out_min:i32, out_max:i32) -> i32 {
pub fn arduino_map(x: i32, in_min: i32, in_max: i32, out_min: i32, out_max: i32) -> i32 {
return (x - in_min) * (out_max - out_min) / (in_max - in_min) + out_min;
}

51
spinnyboy_rust/src/bin/main.rs
View file

@ -6,18 +6,18 @@
holding buffers for the duration of a data transfer."
)]
use alloc::string::ToString;
use esp_hal::uart::{Config, Uart};
use esp_hal::clock::CpuClock;
use esp_hal::delay::Delay;
use esp_hal::main;
use esp_hal::uart::{Config, Uart};
use esp_hal::gpio::Event;
use esp_hal::gpio::{Input, InputConfig};
use esp_hal::handler;
use esp_hal::mcpwm::operator::PwmPinConfig;
use esp_hal::mcpwm::timer::PwmWorkingMode;
use esp_hal::time::Rate;
use esp_hal::rmt::{Rmt, TxChannelConfig, TxChannelCreator};
use esp_hal::handler;
use esp_hal::time::Rate;
use core::cell::RefCell;
use critical_section::Mutex;
@ -36,10 +36,10 @@ use peripherals::nextion::Nextion;
use dc_driver::dshot::DShot;
use dc_driver::dshot::DShotSpeed;
use esp_hal::rmt::RxChannelCreator;
use esp_hal::rmt::RxChannelConfig;
use crate::dc_driver::dshot;
use crate::peripherals::ErrCommand;
use esp_hal::rmt::RxChannelConfig;
use esp_hal::rmt::RxChannelCreator;
#[panic_handler]
fn panic(_: &core::panic::PanicInfo) -> ! {
rprintln!("PANIC!");
@ -57,8 +57,8 @@ const DEFAULT_SPIN_TIME: u32 = 10;
// For more information see: <https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/system/app_image_format.html#application-description>
esp_bootloader_esp_idf::esp_app_desc!();
use crate::peripherals::Command;
use esp_hal::gpio::Output;
use esp_hal::gpio::Level;
use esp_hal::gpio::Output;
use esp_hal::gpio::OutputConfig;
#[main]
@ -92,16 +92,27 @@ fn main() -> ! {
let rx_config = RxChannelConfig::default().with_clk_divider(1);
let tx_config = TxChannelConfig::default().with_clk_divider(1);
let mut toggle_pin = Output::new(peripherals.GPIO2, Level::Low, OutputConfig::default());
let mut tx_channel = rmt.channel0.configure_tx(peripherals.GPIO23,tx_config ).expect("creation of TX_CHANNEL FAILED!");
let mut rx_channel = rmt.channel3.configure_rx(peripherals.GPIO14,rx_config).unwrap();
let mut dshot_esc = dshot::DShot::new(&mut rx_channel, &mut tx_channel, DShotSpeed::DShot600, Some(80_000_000), Some(1));
let mut tx_channel = rmt
.channel0
.configure_tx(peripherals.GPIO23, tx_config)
.expect("creation of TX_CHANNEL FAILED!");
let mut rx_channel = rmt
.channel3
.configure_rx(peripherals.GPIO14, rx_config)
.unwrap();
let mut dshot_esc = dshot::DShot::new(
&mut rx_channel,
&mut tx_channel,
DShotSpeed::DShot600,
Some(80_000_000),
Some(1),
);
rprintln!("SENDING RMT");
loop{
loop {
delay.delay_millis(1000);
toggle_pin.set_high();
dshot_esc.write_throttle(2047,true);
dshot_esc.write_throttle(2047, true);
toggle_pin.set_low();
}
// rprintln!("RMT SENT!");
// let mut esc = AfroEsc::new(&mut pwm_pin);;
@ -150,29 +161,29 @@ fn main() -> ! {
Ok(Command::Start) => {
rprintln!("START");
started = true;
},
}
Ok(Command::Stop) => {
rprintln!("STOP");
started = false;
// spincoater.stop();
},
}
Ok(Command::SetRpm(x)) => {
rprintln!("SET_RPM with {}", x);
rpm = x;
},
}
Ok(Command::SetTimer(x)) => {
rprintln!("SETTING TIMER {}", x);
timer = x;
},
}
Ok(Command::SendConfig) => {
rprintln!("SEND CONFIG");
let command = format!("rpm.val={}",DEFAULT_TARGET_RPM);
let command = format!("rpm.val={}", DEFAULT_TARGET_RPM);
display.send_command(command.to_string().as_bytes());
},
}
Err(ErrCommand::NoValidCmd) => {
rprintln!(" NOT A VALID CMD!");
},
Err(ErrCommand::ReadError) =>{
}
Err(ErrCommand::ReadError) => {
rprintln!("READ FAILED!");
}
}

8
spinnyboy_rust/src/bin/peripherals/mod.rs
View file

@ -1,15 +1,15 @@
pub mod nextion;
#[derive(Debug)]
pub enum Command{
pub enum Command {
SetRpm(u32),
SetTimer(u32),
Start,
Stop,
SendConfig,
CommandSuccess
CommandSuccess,
}
#[derive(Debug)]
pub enum ErrCommand{
pub enum ErrCommand {
NoValidCmd,
ReadError
ReadError,
}

42
spinnyboy_rust/src/bin/peripherals/nextion.rs
View file

@ -1,9 +1,9 @@
use esp_hal::Blocking;
use esp_hal::uart::RxError;
use esp_hal::uart::{Uart};
use esp_hal::{Blocking };
use esp_hal::uart::Uart;
use rtt_target::rprintln;
use crate::peripherals::{ErrCommand,Command};
use crate::peripherals::{Command, ErrCommand};
enum UartStatemachine {
WaitingP,
@ -93,42 +93,32 @@ impl<'a> Nextion<'a> {
}
}
}
pub fn read_command(&mut self) -> Result<Command,ErrCommand>{
let mut buf:[u8;8] = [0;8];
let _read_bytes = match self.read_frame(&mut buf){
pub fn read_command(&mut self) -> Result<Command, ErrCommand> {
let mut buf: [u8; 8] = [0; 8];
let _read_bytes = match self.read_frame(&mut buf) {
Ok(x) => x,
Err(e) => {rprintln!("ERROR while reading");
Err(e) => {
rprintln!("ERROR while reading");
return Err(ErrCommand::NoValidCmd);
}
};
rprintln!("READ SUCCESS!:{:?}",buf);
match buf[0]{
01 => {Ok(Command::Start)},
02 =>{Ok(Command::Stop)},
rprintln!("READ SUCCESS!:{:?}", buf);
match buf[0] {
01 => Ok(Command::Start),
02 => Ok(Command::Stop),
03 => {
let rpm = u32::from_le_bytes(buf[1..5].try_into().expect("failed to parse rpm!"));
Ok(Command::SetRpm(rpm))
},
}
04 => {
let time = u32::from_le_bytes(buf[1..5].try_into().expect("failed to parse time!"));
Ok(Command::SetTimer(time))
}
05 =>{
Ok(Command::SendConfig)
05 => Ok(Command::SendConfig),
00 => Ok(Command::CommandSuccess),
_ => Err(ErrCommand::NoValidCmd),
}
00 => {
Ok(Command::CommandSuccess)
},
_ => {
Err(ErrCommand::NoValidCmd)
}
}
}
pub fn read_ready(&mut self) -> bool {
self.interface.read_ready()