Replies: 4 comments 5 replies
-
|
Using https://docs.rs/static_cell/2.0.0/static_cell/macro.make_static.html on the descriptors should help with the lifetime issue |
Beta Was this translation helpful? Give feedback.
-
|
Thanks for the quick response! |
Beta Was this translation helpful? Give feedback.
-
|
You should be able to configure our driver without CS like this |
Beta Was this translation helpful? Give feedback.
-
|
Thanks again, now it compiles and i can flash it. However, it gets stuck in initializing the W5500 (at As far as I understand it never returns from here: esp-hal/esp-hal/src/spi/master.rs Line 1381 in 92e3ea5 (called via https://github.com/embassy-rs/embassy/blob/cb93823b4b0eb97ae92a6d2104dd0b9e00456c79/embassy-net-wiznet/src/lib.rs#L92, https://github.com/embassy-rs/embassy/blob/cb93823b4b0eb97ae92a6d2104dd0b9e00456c79/embassy-net-wiznet/src/device.rs#L29, https://github.com/embassy-rs/embassy/blob/cb93823b4b0eb97ae92a6d2104dd0b9e00456c79/embassy-net-wiznet/src/chip/w5500.rs#L62, https://github.com/rust-embedded/embedded-hal/blob/5e21d566e25049a85a74010e0c92708f732b2a7f/embedded-hal-bus/src/spi/exclusive.rs#L101, ) I think the wiring is ok, because i can run this Arduino example without any problems: https://mischianti.org/esp32-ethernet-w5500-with-plain-http-and-ssl-https/#Simple_HTTP_request Current compiling code: #![no_std]
#![no_main]
#![feature(type_alias_impl_trait)]
use core::str::FromStr;
use embassy_executor::Spawner;
use embassy_futures::yield_now;
use embassy_net::{Stack, StackResources};
use embassy_net_wiznet::chip::W5500;
use embassy_net_wiznet::*;
use embassy_time::{Delay, Duration, Timer};
use embedded_hal_bus::spi::ExclusiveDevice;
use embedded_io_async::Write;
use esp_backtrace as _;
use esp_hal::{
clock::ClockControl,
dma::*,
dma_descriptors,
embassy,
gpio::IO,
peripherals::{Peripherals, SPI3},
prelude::*,
spi::{
master::{prelude::*, Spi},
SpiMode,
},
timer::TimerGroup,
};
use esp_hal::{
gpio::{self, GpioPin, Input, Output, PullUp, PushPull},
spi::{master::dma::SpiDma, FullDuplexMode},
};
use esp_println::println;
use static_cell::make_static;
use static_cell::StaticCell;
#[embassy_executor::task]
async fn ethernet_task(
runner: Runner<
'static,
W5500,
ExclusiveDevice<
SpiDma<'static, SPI3, Spi3DmaChannel, FullDuplexMode>,
GpioPin<Output<PushPull>, 5>,
Delay,
>,
GpioPin<Input<PullUp>, 16>,
GpioPin<Output<PushPull>, 17>,
>,
) -> ! {
runner.run().await
}
#[embassy_executor::task]
async fn net_task(stack: &'static Stack<Device<'static>>) -> ! {
stack.run().await
}
#[main]
async fn main(spawner: Spawner) {
esp_println::println!("Starting...");
let peripherals = Peripherals::take();
let system = peripherals.SYSTEM.split();
let clocks = ClockControl::boot_defaults(system.clock_control).freeze();
let timg0 = TimerGroup::new(peripherals.TIMG0, &clocks);
embassy::init(&clocks, timg0);
let io = IO::new(peripherals.GPIO, peripherals.IO_MUX);
let sclk = io.pins.gpio18;
let miso = io.pins.gpio19;
let mosi = io.pins.gpio23;
let cs = io.pins.gpio5;
// let sclk = io.pins.gpio14; //for SPI2
// let miso = io.pins.gpio12; //for SPI2
// let mosi = io.pins.gpio13; //for SPI2
// let cs = io.pins.gpio15; //for SPI2
let dma = Dma::new(peripherals.DMA);
let dma_channel = dma.spi3channel;
let (descriptors, rx_descriptors) = dma_descriptors!(32000);
let descriptors = make_static!(descriptors);
let rx_descriptors = make_static!(rx_descriptors);
let spi = Spi::new(peripherals.SPI3, 100u32.kHz(), SpiMode::Mode0, &clocks)
.with_pins(Some(sclk), Some(mosi), Some(miso), None::<gpio::NoPinType> )
.with_dma(dma_channel.configure(
false,
descriptors,
rx_descriptors,
DmaPriority::Priority0,
));
let w5500_int = io.pins.gpio16.into_pull_up_input();
let w5500_reset = io.pins.gpio17.into_push_pull_output();
let mac_addr = [0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED ];
static STATE: StaticCell<State<8, 8>> = StaticCell::new();
let state = STATE.init(State::<8, 8>::new());
let ed = ExclusiveDevice::new(spi, cs.into_push_pull_output(), Delay);
let (device, runner) = embassy_net_wiznet::new::<8, 8, W5500, _, _, _>(
mac_addr,
state,
ed,
w5500_int,
w5500_reset,
)
.await;
println!("start runner...");
spawner.spawn(ethernet_task(runner)).ok();
//TODO Generate random seed
let seed = 42;
// Init network stack
static STACK: StaticCell<Stack<Device<'static>>> = StaticCell::new();
static RESOURCES: StaticCell<StackResources<2>> = StaticCell::new();
let stack = &*STACK.init(Stack::new(
device,
embassy_net::Config::dhcpv4(Default::default()),
RESOURCES.init(StackResources::<2>::new()),
seed, //TODO change to something more secure
));
println!("start netstack...");
// Launch network task
spawner.spawn(net_task(&stack)).ok();
println!("Waiting for DHCP...");
let cfg = wait_for_config(stack).await;
let local_addr = cfg.address.address();
println!("IP address: {:?}", local_addr);
let mut rx_buffer = [0; 4096];
let mut tx_buffer = [0; 4096];
loop {
let mut socket = embassy_net::tcp::TcpSocket::new(stack, &mut rx_buffer, &mut tx_buffer);
socket.set_timeout(Some(Duration::from_secs(10)));
println!("Connecting...");
let host_addr = embassy_net::Ipv4Address::from_str("192.168.178.42").unwrap();
if let Err(e) = socket.connect((host_addr, 6060)).await {
println!("connect error: {:?}", e);
continue;
}
println!("Connected to {:?}", socket.remote_endpoint());
let msg = b"Hello world!\n";
loop {
if let Err(e) = socket.write_all(msg).await {
println!("write error: {:?}", e);
break;
}
println!("txd: {}", core::str::from_utf8(msg).unwrap());
Timer::after_secs(1).await;
}
}
}
async fn wait_for_config(stack: &'static Stack<Device<'static>>) -> embassy_net::StaticConfigV4 {
loop {
if let Some(config) = stack.config_v4() {
return config.clone();
}
yield_now().await;
}
} |
Beta Was this translation helpful? Give feedback.
-
|
Wrapping the spi in |
Beta Was this translation helpful? Give feedback.
-
|
I have been wanting to play around with one of these modules for awhile now, so I will get one ordered once I'm back home (traveling right now). Hopefully we can resolve the issue before then, however worst case I can help debug at least. |
Beta Was this translation helpful? Give feedback.
-
|
That sounds great! I appreciate the help! :-) |
Beta Was this translation helpful? Give feedback.
-
|
Any news on this? I've been trying to do something similar with similar background (aka no embedded systems background). I want to make lora-rs work with my ESP32 and it's also getting stuck creating the instance of the #![no_std]
#![no_main]
#![feature(type_alias_impl_trait)]
use embassy_executor::Spawner;
use embassy_time::Delay;
use esp_backtrace as _;
use esp_hal::spi::master::prelude::_esp_hal_spi_master_dma_WithDmaSpi2;
use esp_hal::{
clock::ClockControl,
dma::{Dma, DmaPriority},
dma_descriptors,
gpio::{Input, Io, Level, Output, Pull},
peripherals::Peripherals,
prelude::*,
spi::{master::Spi, SpiMode},
system::SystemControl,
timer::timg::TimerGroup,
};
use esp_println::println;
// use embedded_hal_async::spi::SpiBus;
use embedded_hal_bus::spi::ExclusiveDevice;
use lora_phy::iv::GenericSx127xInterfaceVariant;
use lora_phy::lorawan_radio::LorawanRadio;
use lora_phy::sx127x::{self, Sx1276, Sx127x};
use lora_phy::LoRa;
use lorawan_device::async_device::{region, Device, EmbassyTimer, JoinMode};
use lorawan_device::default_crypto::DefaultFactory as Crypto;
use lorawan_device::{AppEui, AppKey, DevEui};
// warning: set these appropriately for the region
const LORAWAN_REGION: region::Region = region::Region::AU915;
const MAX_TX_POWER: u8 = 14;
#[main]
async fn main(_spawner: Spawner) {
let peripherals = Peripherals::take();
let system = SystemControl::new(peripherals.SYSTEM);
let clocks = ClockControl::boot_defaults(system.clock_control).freeze();
// setup system timer
let timg0 = TimerGroup::new_async(peripherals.TIMG0, &clocks);
esp_hal_embassy::init(&clocks, timg0);
// let delay = Delay::new(&clocks);
esp_println::logger::init_logger_from_env();
let io = Io::new(peripherals.GPIO, peripherals.IO_MUX);
let sclk = io.pins.gpio5;
let miso = io.pins.gpio19;
let mosi = io.pins.gpio27;
let cs = io.pins.gpio18;
let rst = io.pins.gpio14;
let dio1 = io.pins.gpio26;
let dma = Dma::new(peripherals.DMA);
let dma_channel = dma.spi2channel;
let (mut descriptors, mut rx_descriptors) = dma_descriptors!(32000);
// TODO: SpiDma (implements embedded_hal_async::spi::SpiBus)
let mut spi = Spi::new(peripherals.SPI2, 100.kHz(), SpiMode::Mode0, &clocks)
.with_sck(sclk)
.with_mosi(mosi)
.with_miso(miso)
.with_dma(dma_channel.configure_for_async(
false,
&mut descriptors,
&mut rx_descriptors,
DmaPriority::Priority0,
));
let send_buffer = [0, 1, 2, 3, 4, 5, 6, 7];
let mut buffer = [0; 8];
println!("Sending bytes");
embedded_hal_async::spi::SpiBus::transfer(&mut spi, &mut buffer, &send_buffer)
.await
.unwrap();
println!("sent!");
// let spi = FlashSafeDma::new(spi);
let spi = ExclusiveDevice::new(spi, Output::new(cs, Level::Low), Delay).unwrap();
// let spi = ExclusiveDevice::new(spi, Output::new(cs, Level::Low), Delay);
let config = sx127x::Config {
chip: Sx1276,
tcxo_used: false,
tx_boost: false,
rx_boost: false,
};
println!("Setting up iv");
let iv = GenericSx127xInterfaceVariant::new(
Output::new(rst, Level::Low),
Input::new(dio1, Pull::Down),
None,
None,
)
.unwrap();
println!("Setting up sx127x radio kind");
let rk = Sx127x::new(spi, iv, config);
println!("Setting up lora");
let lora = LoRa::new(rk, true, Delay).await.unwrap();
println!("Setting up radio");
let radio: LorawanRadio<_, _, MAX_TX_POWER> = lora.into();
let region: region::Configuration = region::Configuration::new(LORAWAN_REGION);
println!("Setting up device");
let mut device: Device<_, Crypto, _, _> = Device::new(
region,
radio,
EmbassyTimer::new(),
esp_hal::rng::Rng::new(peripherals.RNG),
);
println!("Joining LoRaWAN network");
// TODO: Adjust the EUI and Keys according to your network credentials
let resp = device
.join(&JoinMode::OTAA {
deveui: DevEui::from([0, 0, 0, 0, 0, 0, 0, 0]),
appeui: AppEui::from([0, 0, 0, 0, 0, 0, 0, 0]),
appkey: AppKey::from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]),
})
.await
.unwrap();
println!("LoRaWAN network joined: {:?}", resp);
}The output looks like this (there are more prints that I added to |
Beta Was this translation helpful? Give feedback.
-
|
I haven't managed to get it running yet, unfortunately. Currently, I also don't have much time... However, I would like to resume the project in two or three weeks. If you make any breakthroughs, please let me know! :-) |
Beta Was this translation helpful? Give feedback.
-
I'm quite new to embedded rust and I'm not sure if what i want to do is currently even possible.
I would appreciate if you can help me either fix this or just tell me to postpone this project for x month (either is ok :-) )
Thank you in advance!
Background:
I want to build a EspNow-Ethernet-Gateway with an ESP32 and a Wiznet W5500 Ethernet module, which should replace my Arduino EnigmaIOT setup i'm currently running at home.
Problem
My naive assumption was that i can quite easily get a very basic version of this to work by combining these two examples:
https://github.com/esp-rs/esp-hal/blob/v0.16.1/examples/src/bin/embassy_spi.rs
https://github.com/embassy-rs/embassy/blob/embassy-net-wiznet-v0.1.0/examples/rp/src/bin/ethernet_w5500_tcp_client.rs
by first creating a SpiDma (lines 44-74 in embassy_spi.rs) and feeding this into
ExclusiveDevice::new(line 65 of ethernet_w5500_tcp_client.rs).However, i'm unable to get this to compile (see code comments below)
Cargo.toml:
main.rs
Beta Was this translation helpful? Give feedback.
All reactions