lukas/home-aut-rp2040-ethernet
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: lukas:master
Branches Tags
lukas:master
lukas:test
..
compare: lukas:test
Branches Tags
lukas:test
lukas:master

1 Commits
master ... test

Author SHA1 Message Date
lukas-heiligenbrunner
b326a5013c add code to init w5500 2024-12-25 19:20:34 +01:00
3 changed files with 189 additions and 260 deletions
Show Stats Expand all files Collapse all files

1
Cargo.lock generated
View File

@ -712,7 +712,6 @@ dependencies = [
"embedded-hal 1.0.0",
"fugit",
"heapless 0.8.0",
"log",
"panic-halt",
"rp2040-boot2",
"rp2040-hal",

9
Cargo.toml
View File

@ -17,8 +17,9 @@ cortex-m-rt = "0.7"
rp2040-boot2 = { version = "0.3.0", optional = true }
rp2040-hal = {version = "0.10.2", features = ["rtic-monotonic"]}
waveshare-rp2040-zero = { version = "0.8.0", features = ["rt"] }
cortex-m-rtic = { version = "1", features = [] }
embedded-hal = {version = "1.0.0", features = []}
cortex-m-rtic = "1"
embedded-hal = "1.0.0"
usb-device = "0.3.2"
@ -30,8 +31,6 @@ usbd-serial = "0.2.2"
smart-leds = "0.3.0"
ws2812-pio = "0.8.0"
w5500-dhcp = { version = "0.7", features = ["eh0", "log"] }
w5500-mqtt = { version = "0.4", features = ["eh0", "log"] }
log = "0.4.22"
heapless = "0.8"
heapless = "0.8.0"

439
src/main.rs
View File

@ -1,15 +1,15 @@
#![no_std]
#![no_main]
use panic_halt as _;
#[rtic::app(device = waveshare_rp2040_zero::hal::pac, peripherals = true, dispatchers = [I2C0_IRQ])]
mod app {
use core::convert::TryInto;
use core::iter::once;
use cortex_m::delay::Delay;
use fugit::MicrosDurationU32;
use fugit::RateExtU32;
use rp2040_hal::gpio::bank0::{Gpio16, Gpio2, Gpio3, Gpio4, Gpio5};
use rp2040_hal::gpio::bank0::{Gpio16, Gpio2, Gpio3, Gpio4, Gpio5, Gpio7};
use rp2040_hal::gpio::{
FunctionPio0, FunctionSio, FunctionSpi, Pin, PullDown, PullNone, PullUp, SioOutput,
};
@ -18,7 +18,6 @@ mod app {
use rp2040_hal::{Clock, Spi};
use smart_leds::{brightness, SmartLedsWrite};
use usbd_serial::SerialPort;
use waveshare_rp2040_zero::hal::prelude::*;
use waveshare_rp2040_zero::hal::spi::Enabled;
use waveshare_rp2040_zero::{
hal::{
@ -33,7 +32,6 @@ mod app {
use waveshare_rp2040_zero::hal::pio::PIOExt;
use ws2812_pio::Ws2812;
use super::*;
use core::fmt::Write;
use embedded_hal::digital::OutputPin;
use fugit::ExtU32;
@ -72,15 +70,16 @@ mod app {
cortex_m::asm::delay(CYCLES_PER_MILLIS.saturating_mul(ms));
}
fn monotonic_secs() -> u32 {
app::monotonics::now()
.duration_since_epoch()
.to_secs()
.try_into()
.unwrap()
pub enum BlinkState {
GOOD,
Init,
EthernetError,
OtherError,
}
#[shared]
struct Shared {
timer: hal::Timer,
usb_dev: UsbDevice<'static, hal::usb::UsbBus>,
serial: SerialPort<'static, hal::usb::UsbBus>,
ws: Ws2812<PIO0, SM0, CountDown<'static>, hal::gpio::Pin<Gpio16, FunctionPio0, PullDown>>,
@ -96,10 +95,8 @@ mod app {
>,
Pin<Gpio5, FunctionSio<SioOutput>, PullDown>,
>,
dhcp: DhcpClient<'static>,
mqtt: MqttClient<'static>,
dhcp_spawn_at: Option<u32>,
mqtt_spawn_at: Option<u32>,
spi_reset: Pin<Gpio7, FunctionSio<SioOutput>, PullDown>,
blink_state: BlinkState,
}
#[local]
@ -123,8 +120,8 @@ mod app {
&mut resets,
&mut watchdog,
)
.ok()
.unwrap();
.ok()
.unwrap();
let sio = Sio::new(c.device.SIO);
let pins = waveshare_rp2040_zero::Pins::new(
@ -134,53 +131,29 @@ mod app {
&mut resets,
);
// Set up our SPI pins into the correct mode
let spi_sclk: hal::gpio::Pin<_, hal::gpio::FunctionSpi, hal::gpio::PullNone> =
pins.gp2.reconfigure();
let spi_mosi: hal::gpio::Pin<_, hal::gpio::FunctionSpi, hal::gpio::PullNone> =
pins.gp3.reconfigure();
let spi_miso: hal::gpio::Pin<_, hal::gpio::FunctionSpi, hal::gpio::PullUp> =
pins.gp4.reconfigure();
let spi_cs = pins.gp5.into_push_pull_output();
let mut spi_reset = pins.gp7.into_push_pull_output();
// Create the SPI driver instance for the SPI0 device
let spi = hal::spi::Spi::<_, _, _, 8>::new(c.device.SPI0, (spi_mosi, spi_miso, spi_sclk));
// Exchange the uninitialised SPI driver for an initialised one
let spi = spi.init(
&mut resets,
clocks.peripheral_clock.freq(),
1.MHz(),
W5500_MODE,
);
let mut w5500 = W5500::new(spi, spi_cs);
w5500_dhcp::ll::eh0::reset(&mut spi_reset, &mut Delay::new(c.core.SYST, SYSCLK_HZ))
.unwrap();
//let timer = Timer::new(c.device.TIMER, &mut c.device.RESETS, &clocks);
let dTIMER = c.device.TIMER;
let timer =
cortex_m::singleton!(: hal::Timer = hal::Timer::new(dTIMER, &mut resets, &clocks))
.unwrap();
let timer = cortex_m::singleton!(: hal::Timer = hal::Timer::new(dTIMER, &mut resets, &clocks)).unwrap();
let mut alarm = timer.alarm_0().unwrap();
let count_down: CountDown<'static> = timer.count_down();
let count_down: CountDown<'static> = timer.count_down();
let (mut pio, sm0, _, _, _) = c.device.PIO0.split(&mut resets);
let ws: Ws2812<PIO0, SM0, CountDown<'static>, hal::gpio::Pin<Gpio16, FunctionPio0, PullDown>> = Ws2812::new(
// The onboard NeoPixel is attached to GPIO pin #16 on the Waveshare RP2040-Zero.
pins.neopixel.into_function(),
&mut pio,
sm0,
clocks.peripheral_clock.freq(),
count_down,
);
let (mut pio, sm0, _, _, _) = c.device.PIO0.split(&mut resets);
let ws: Ws2812<
PIO0,
SM0,
CountDown<'static>,
hal::gpio::Pin<Gpio16, FunctionPio0, PullDown>,
> = Ws2812::new(
// The onboard NeoPixel is attached to GPIO pin #16 on the Waveshare RP2040-Zero.
pins.neopixel.into_function(),
&mut pio,
sm0,
clocks.peripheral_clock.freq(),
count_down,
);
// Set up the USB driver
let USBCTRL_REGS = c.device.USBCTRL_REGS;
@ -210,210 +183,176 @@ mod app {
let _ = serial.write(b"Hello, World!\r\n");
let _ = alarm.schedule(SCAN_TIME_US);
alarm.enable_interrupt();
let mac: Eui48Addr = Eui48Addr::new(0x00, 0x08, 0xDC, 0x00, 0x00, 0x00);
timer_irq::spawn_after(500_u32.millis().into()).unwrap();
timer_irq::spawn().unwrap();
// init ethernet stuff
// continually initialize the W5500 until we link up
// since we are using power over Ethernet we know that if the device
// has power it also has an Ethernet cable connected.
let _phy_cfg: PhyCfg = 'outer: loop {
// sanity check W5500 communications
assert_eq!(w5500.version().unwrap(), w5500_dhcp::ll::VERSION);
// Set up our SPI pins into the correct mode
let spi_sclk: hal::gpio::Pin<_, hal::gpio::FunctionSpi, hal::gpio::PullNone> =
pins.gp2.reconfigure();
let spi_mosi: hal::gpio::Pin<_, hal::gpio::FunctionSpi, hal::gpio::PullNone> =
pins.gp3.reconfigure();
let spi_miso: hal::gpio::Pin<_, hal::gpio::FunctionSpi, hal::gpio::PullUp> =
pins.gp4.reconfigure();
let spi_cs = pins.gp5.into_push_pull_output();
let mut spi_reset = pins.gp7.into_push_pull_output();
// load the MAC address we got from EEPROM
w5500.set_shar(&mac).unwrap();
debug_assert_eq!(w5500.shar().unwrap(), mac);
// wait for the PHY to indicate the Ethernet link is up
let mut attempts: u32 = 0;
serial.write(b"Polling for link up\r\n");
const PHY_CFG: PhyCfg = PhyCfg::DEFAULT.set_opmdc(OperationMode::FullDuplex10bt);
w5500.set_phycfgr(PHY_CFG).unwrap();
const LINK_UP_POLL_PERIOD_MILLIS: u32 = 100;
const LINK_UP_POLL_ATTEMPTS: u32 = 50;
loop {
let phy_cfg: PhyCfg = w5500.phycfgr().unwrap();
if phy_cfg.lnk() == LinkStatus::Up {
break 'outer phy_cfg;
}
if attempts >= LINK_UP_POLL_ATTEMPTS {
let mut data: heapless::String<16> = heapless::String::new();
write!(
&mut data,
"Failed to link up in {} ms\r\n",
attempts * LINK_UP_POLL_PERIOD_MILLIS
)
.unwrap();
serial.write(data.as_bytes());
break;
}
delay_ms(LINK_UP_POLL_PERIOD_MILLIS);
attempts += 1;
}
spi_reset.set_low().unwrap();
delay_ms(1);
spi_reset.set_high().unwrap();
delay_ms(3);
};
let mut data: heapless::String<16> = heapless::String::new();
write!(&mut data, "Done link up\n{}", _phy_cfg).unwrap();
serial.write(data.as_bytes());
let mut mqtt: MqttClient = MqttClient::new(MQTT_SN, MQTT_SRC_PORT, MQTT_SERVER);
mqtt.set_client_id(CLIENT_ID);
let seed: u64 = u64::from(cortex_m::peripheral::SYST::get_current()) << 32
| u64::from(cortex_m::peripheral::SYST::get_current());
let dhcp = DhcpClient::new(DHCP_SN, seed, mac, HOSTNAME);
dhcp.setup_socket(&mut w5500).unwrap();
// start the DHCP client
//dhcp_sn::spawn().unwrap();
// start the timeout tracker
//timeout_tracker::spawn().unwrap();
(
Shared {
usb_dev,
serial,
ws,
w5500,
dhcp,
mqtt,
dhcp_spawn_at: None,
mqtt_spawn_at: None,
},
Local {},
init::Monotonics(Monotonic::new(*timer, alarm)),
)
}
#[task(shared = [dhcp_spawn_at, mqtt_spawn_at])]
fn timeout_tracker(mut cx: timeout_tracker::Context) {
timeout_tracker::spawn_after(1_u32.secs().into()).unwrap();
let now: u32 = monotonic_secs();
cx.shared.dhcp_spawn_at.lock(|dhcp_spawn_at| {
if let Some(then) = dhcp_spawn_at {
if now >= *then {
if dhcp_sn::spawn().is_err() {
log::error!("DHCP task is already spawned")
}
*dhcp_spawn_at = None;
}
}
});
cx.shared.mqtt_spawn_at.lock(|mqtt_spawn_at| {
if let Some(then) = mqtt_spawn_at {
if now >= *then {
if mqtt_sn::spawn().is_err() {
log::error!("MQTT task is already spawned")
}
*mqtt_spawn_at = None;
}
}
});
}
#[task(shared = [w5500, mqtt, mqtt_spawn_at], local = [])]
fn mqtt_sn(cx: mqtt_sn::Context) {
log::info!("[TASK] mqtt_sn");
(cx.shared.w5500, cx.shared.mqtt, cx.shared.mqtt_spawn_at).lock(
|w5500, mqtt, mqtt_spawn_at| {
loop {
let now: u32 = monotonic_secs();
match mqtt.process(w5500, now) {
Ok(MqttEvent::CallAfter(secs)) => {
*mqtt_spawn_at = Some(now + secs);
break;
}
Ok(MqttEvent::ConnAck) => {
log::info!("[MQTT] ConnAck");
// can subscribe to topics here
// not needed for this
}
Ok(MqttEvent::Publish(reader)) => {
log::warn!("should not get Publish never subscribed");
reader.done().unwrap();
}
Ok(MqttEvent::SubAck(_) | MqttEvent::UnSubAck(_)) => {
log::warn!("should not get (Un)SubAck, never (un)subscribed");
}
Ok(MqttEvent::None) => {
{
let mut data: heapless::String<16> = heapless::String::new();
write!(&mut data, "{:.1}", 42).unwrap();
mqtt.publish(w5500, "test", data.as_bytes()).unwrap();
}
*mqtt_spawn_at = Some(now + 5);
break;
}
Err(e) => {
log::error!("[MQTT] {e:?}");
*mqtt_spawn_at = Some(now + 10);
break;
}
}
}
},
// Create the SPI driver instance for the SPI0 device
let spi = hal::spi::Spi::<_, _, _, 8>::new(c.device.SPI0, (spi_mosi, spi_miso, spi_sclk));
// Exchange the uninitialised SPI driver for an initialised one
let spi = spi.init(
&mut resets,
clocks.peripheral_clock.freq(),
400.kHz(),
W5500_MODE,
);
}
let w5500 = W5500::new(spi, spi_cs);
#[task(shared = [w5500, dhcp, dhcp_spawn_at])]
fn dhcp_sn(cx: dhcp_sn::Context) {
log::info!("[TASK] dhcp_sn");
w5500_dhcp::ll::eh0::reset(&mut spi_reset, &mut Delay::new(c.core.SYST, SYSCLK_HZ))
.unwrap();
(cx.shared.w5500, cx.shared.dhcp, cx.shared.dhcp_spawn_at).lock(
|w5500, dhcp, dhcp_spawn_at| {
let leased_before: bool = dhcp.has_lease();
let now: u32 = monotonic_secs();
let spawn_after_secs: u32 = dhcp.process(w5500, now).unwrap();
init_ethernet::spawn_after(5000_u32.millis().into()).unwrap();
let spawn_at: u32 = now + spawn_after_secs;
*dhcp_spawn_at = Some(spawn_at);
log::info!("[DHCP] spawning after {spawn_after_secs} seconds, at {spawn_at}");
// spawn MQTT task if bound
if dhcp.has_lease() && !leased_before && mqtt_sn::spawn().is_err() {
log::error!("MQTT task is already spawned")
}
},
)
(Shared { timer: *timer, usb_dev, serial, ws, w5500,spi_reset, blink_state: BlinkState::Init}, Local {}, init::Monotonics(Monotonic::new(*timer, alarm)))
}
#[task(
priority = 1,
shared = [serial, ws],
shared = [serial, ws, blink_state],
local = [tog: bool = true],
)]
fn timer_irq(mut c: timer_irq::Context) {
if *c.local.tog {
c.shared
.ws
.lock(|ws| ws.write(brightness(once((255, 0, 0).into()), 32)).unwrap());
c.shared.serial.lock(|serial| _ = serial.write(b"High\r\n"));
} else {
c.shared
.ws
.lock(|ws| ws.write(brightness(once((0, 0, 0).into()), 32)).unwrap());
c.shared.serial.lock(|serial| _ = serial.write(b"LOW\r\n"));
}
*c.local.tog = !*c.local.tog;
fn timer_irq(c: timer_irq::Context) {
let blink_state = c.shared.blink_state;
let ws = c.shared.ws;
let serial = c.shared.serial;
let tog = c.local.tog;
(blink_state, ws, serial).lock(|blink_state, ws, serial| {
if *tog {
match blink_state {
BlinkState::GOOD => {
ws.write(brightness(once((0, 255, 0).into()), 25)).unwrap();
_ = serial.write(b"High\r\n");
}
BlinkState::Init => {
ws.write(brightness(once((0, 0, 255).into()), 25)).unwrap();
_ = serial.write(b"Init\r\n");
}
BlinkState::EthernetError => {
ws.write(brightness(once((255, 255, 0).into()), 25)).unwrap();
_ = serial.write(b"Ethernet error error\r\n");
}
BlinkState::OtherError => {
ws.write(brightness(once((255, 0, 0).into()), 25)).unwrap();
_ = serial.write(b"Other error\r\n");
}
}
} else {
ws.write(brightness(once((0, 0, 0).into()), 32)).unwrap();
}
*tog = !*tog;
});
timer_irq::spawn_after(250.millis().into()).unwrap();
}
#[task(
shared = [w5500, serial,spi_reset, blink_state],)
]
fn init_ethernet(c: init_ethernet::Context) {
let mac: Eui48Addr = Eui48Addr::new(0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED );
let w5500 = c.shared.w5500;
let serial = c.shared.serial;
let spi_reset = c.shared.spi_reset;
let blink_state = c.shared.blink_state;
(w5500, serial,spi_reset, blink_state).lock(|w5500, serial, spi_reset, blink_state| {
// continually initialize the W5500 until we link up
// since we are using power over Ethernet we know that if the device
// has power it also has an Ethernet cable connected.
let _phy_cfg: PhyCfg = 'outer: loop {
// sanity check W5500 communications
_ = serial.write(b"Sanity checks\r\n");
let version = w5500.version();
match version {
Ok(v) => {
let mut data: heapless::String<16> = heapless::String::new();
write!(
&mut data,
"Read version of w5500 {}\r\n",
v
)
.unwrap();
_ = serial.write(data.as_bytes());
}
Err(_) => {
_ = serial.write(b"Failed to read W5500 version\r\n");
*blink_state = BlinkState::EthernetError;
return;
}
}
_ = serial.write(b"Sanity checks passed\r\n");
// load the MAC address we got from EEPROM
w5500.set_shar(&mac).unwrap();
debug_assert_eq!(w5500.shar().unwrap(), mac);
// wait for the PHY to indicate the Ethernet link is up
let mut attempts: u32 = 0;
_ = serial.write(b"Polling for link up\r\n");
const PHY_CFG: PhyCfg = PhyCfg::DEFAULT.set_opmdc(OperationMode::FullDuplex10bt);
w5500.set_phycfgr(PHY_CFG).unwrap();
const LINK_UP_POLL_PERIOD_MILLIS: u32 = 100;
const LINK_UP_POLL_ATTEMPTS: u32 = 50;
loop {
let phy_cfg: PhyCfg = w5500.phycfgr().unwrap();
if phy_cfg.lnk() == LinkStatus::Up {
break 'outer phy_cfg;
}
if attempts >= LINK_UP_POLL_ATTEMPTS {
let mut data: heapless::String<16> = heapless::String::new();
write!(
&mut data,
"Failed to link up in {} ms\r\n",
attempts * LINK_UP_POLL_PERIOD_MILLIS
)
.unwrap();
_ = serial.write(data.as_bytes());
break;
}
delay_ms(LINK_UP_POLL_PERIOD_MILLIS);
attempts += 1;
}
spi_reset.set_low().unwrap();
delay_ms(1);
spi_reset.set_high().unwrap();
delay_ms(3);
};
let mut data: heapless::String<16> = heapless::String::new();
write!(&mut data, "Done link up\n{}", _phy_cfg).unwrap();
_ = serial.write(data.as_bytes());
let mut mqtt: MqttClient = MqttClient::new(MQTT_SN, MQTT_SRC_PORT, MQTT_SERVER);
mqtt.set_client_id(CLIENT_ID);
let seed: u64 = u64::from(cortex_m::peripheral::SYST::get_current()) << 32
| u64::from(cortex_m::peripheral::SYST::get_current());
let dhcp = DhcpClient::new(DHCP_SN, seed, mac, HOSTNAME);
dhcp.setup_socket(w5500).unwrap();
});
timer_irq::spawn_after(500.millis().into()).unwrap();
}
#[task(
@ -455,14 +394,6 @@ mod app {
}
}
});
}
/// This is the W5500 interrupt.
///
/// The only interrupts we should get are for the DHCP & MQTT sockets.
#[task(binds = SPI0_IRQ, local = [], shared = [w5500])]
#[allow(clippy::collapsible_if)]
fn exti0(mut cx: exti0::Context) {
log::info!("[TASK] exti0");
}
}
}