ESP32 Forum

Code: Select all

 
#![no_std]
#![no_main]
#![deny(
    clippy::mem_forget,
    reason = "mem::forget is generally not safe to do with esp_hal types, especially those \
    holding buffers for the duration of a data transfer."
)]
#![deny(clippy::large_stack_frames)]

use esp_hal::clock::CpuClock;
use esp_hal::delay::Delay;
use esp_hal::gpio::{Level, Output, OutputConfig};
use esp_hal::main;
use esp_hal::uart::{Config, DataBits, Parity, StopBits, Uart};

use {esp_backtrace as _, esp_println as _};

// This creates a default app-descriptor required by the esp-idf bootloader.
// 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!();

#[allow(
    clippy::large_stack_frames,
    reason = "it's not unusual to allocate larger buffers etc. in main"
)]
#[main]
fn main() -> ! {
    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
    let mut peripherals = esp_hal::init(config);

    let delay = Delay::new();

    let uart_config = Config::default()
        .with_baudrate(250_000)
        .with_data_bits(DataBits::_8)
        .with_parity(Parity::None)
        .with_stop_bits(StopBits::_2);

    let mut frame = [0u8; 513];
    frame[0] = 0x00;
    frame[1] = 50;
    frame[2] = 200;
    frame[3] = 30;
    frame[4] = 125;

    let mut en_pin = Output::new(peripherals.GPIO5, Level::Low, OutputConfig::default());
    en_pin.set_high();

    loop {
        let mut tx_pin = Output::new(
            peripherals.GPIO4.reborrow(),
            Level::High,
            OutputConfig::default(),
        );

        tx_pin.set_low();
        delay.delay_micros(200);

        tx_pin.set_high();
        delay.delay_micros(20);

        core::mem::drop(tx_pin);

        let mut uart = Uart::new(peripherals.UART0.reborrow(), uart_config)
            .unwrap()
            .with_tx(peripherals.GPIO4.reborrow());

        uart.write(&frame).unwrap();
        uart.flush().unwrap();

        core::mem::drop(uart);

        delay.delay_millis(30);
    }
}

Code: Select all

#![no_std]
#![no_main]

use esp_backtrace as _;
use esp_hal::{
    clock::CpuClock,
    delay::Delay,
    gpio::{Level, Output, OutputConfig},
    main,
    uart::{Config, DataBits, Parity, StopBits, Uart},
};

#[main]
fn main() -> ! {
    let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
    let peripherals = esp_hal::init(config);

    let delay = Delay::new();

    let mut uart = Uart::new(
        peripherals.UART0,
        Config::default()
            .with_baudrate(250_000)
            .with_data_bits(DataBits::_8)
            .with_parity(Parity::None)
            .with_stop_bits(StopBits::_2),
    )
    .unwrap()
    .with_tx(peripherals.GPIO4);

    // --- RS485 driver enable pin ---
    let mut en_pin = Output::new(peripherals.GPIO5, Level::Low, OutputConfig::default());
    en_pin.set_high();

    // --- DMX frame ---
    let mut frame = [0u8; 513];
    frame[0] = 0x00; // start code
    frame[1] = 125;
    frame[2] = 255;
    frame[3] = 0;
    frame[4] = 0;

    // let break_bits = 100 / (1_000_000 / 250_000);
    // let mab_bits = 12 / (1_000_000 / 250_000);

    loop {
        en_pin.set_high();

        // --- BREAK ---
        uart.send_break(22);

        // MAB: HIGH for 24 µs
        delay.delay_micros(24);

        // --- DMX data ---
        uart.write(&frame).unwrap();
        uart.flush().unwrap();

        en_pin.set_low();

        delay.delay_millis(30); // DMX refresh rate
    }
}