#![no_std] #![no_main] use smoltcp as net; use stm32h7xx_hal::ethernet; use stm32h7xx_hal::{gpio::Speed, prelude::*, spi, pac}; use embedded_hal::{blocking::spi::Transfer}; use heapless::{consts, String}; use cortex_m; use cortex_m_rt::{ entry, exception, }; use cortex_m_semihosting::hprintln; use panic_halt as _; use rtic::cyccnt::{Instant, U32Ext}; use minimq::{ embedded_nal::{IpAddr, Ipv4Addr, TcpStack, SocketAddr, Mode}, MqttClient, QoS, }; use firmware::nal_tcp_client::{NetworkStack, NetStorage, NetworkInterface}; use firmware::{Urukul}; use firmware::cpld::{CPLD}; static mut NET_STORE: NetStorage = NetStorage { // Placeholder for the real IP address, which is initialized at runtime. ip_addrs: [net::wire::IpCidr::Ipv6( net::wire::Ipv6Cidr::SOLICITED_NODE_PREFIX, )], neighbor_cache: [None; 8], routes_cache: [None; 8], }; #[link_section = ".sram3.eth"] static mut DES_RING: ethernet::DesRing = ethernet::DesRing::new(); macro_rules! add_socket { ($sockets:ident, $tx_storage:ident, $rx_storage:ident) => { let mut $rx_storage = [0; 4096]; let mut $tx_storage = [0; 4096]; let tcp_socket = { let tx_buffer = net::socket::TcpSocketBuffer::new(&mut $tx_storage[..]); let rx_buffer = net::socket::TcpSocketBuffer::new(&mut $rx_storage[..]); net::socket::TcpSocket::new(tx_buffer, rx_buffer) }; let _handle = $sockets.add(tcp_socket); }; } #[entry] fn main() -> ! { let mut cp = cortex_m::Peripherals::take().unwrap(); let dp = pac::Peripherals::take().unwrap(); cp.DWT.enable_cycle_counter(); // Enable SRAM3 for the descriptor ring. dp.RCC.ahb2enr.modify(|_, w| w.sram3en().set_bit()); let rcc = dp.RCC.constrain(); let pwr = dp.PWR.constrain(); let vos = pwr.freeze(); let ccdr = rcc .sysclk(400.mhz()) .hclk(200.mhz()) .per_ck(100.mhz()) .pll1_q_ck(48.mhz()) // for SPI .pll2_p_ck(100.mhz()) .pll2_q_ck(100.mhz()) .freeze(vos, &dp.SYSCFG); let gpioa = dp.GPIOA.split(ccdr.peripheral.GPIOA); let gpiob = dp.GPIOB.split(ccdr.peripheral.GPIOB); let gpioc = dp.GPIOC.split(ccdr.peripheral.GPIOC); let gpiod = dp.GPIOD.split(ccdr.peripheral.GPIOD); let gpioe = dp.GPIOE.split(ccdr.peripheral.GPIOE); let gpiof = dp.GPIOF.split(ccdr.peripheral.GPIOF); let gpiog = dp.GPIOG.split(ccdr.peripheral.GPIOG); // Configure ethernet IO { let _rmii_refclk = gpioa.pa1.into_alternate_af11().set_speed(Speed::VeryHigh); let _rmii_mdio = gpioa.pa2.into_alternate_af11().set_speed(Speed::VeryHigh); let _rmii_mdc = gpioc.pc1.into_alternate_af11().set_speed(Speed::VeryHigh); let _rmii_crs_dv = gpioa.pa7.into_alternate_af11().set_speed(Speed::VeryHigh); let _rmii_rxd0 = gpioc.pc4.into_alternate_af11().set_speed(Speed::VeryHigh); let _rmii_rxd1 = gpioc.pc5.into_alternate_af11().set_speed(Speed::VeryHigh); let _rmii_tx_en = gpiog.pg11.into_alternate_af11().set_speed(Speed::VeryHigh); let _rmii_txd0 = gpiog.pg13.into_alternate_af11().set_speed(Speed::VeryHigh); let _rmii_txd1 = gpiob.pb13.into_alternate_af11().set_speed(Speed::VeryHigh); } // Configure ethernet let mac_addr = net::wire::EthernetAddress([0xAC, 0x6F, 0x7A, 0xDE, 0xD6, 0xC8]); let (eth_dma, _eth_mac) = unsafe { ethernet::new_unchecked( dp.ETHERNET_MAC, dp.ETHERNET_MTL, dp.ETHERNET_DMA, &mut DES_RING, mac_addr.clone(), ) }; unsafe { ethernet::enable_interrupt() } let store = unsafe { &mut NET_STORE }; store.ip_addrs[0] = net::wire::IpCidr::new(net::wire::IpAddress::v4(192, 168, 1, 200), 24); let neighbor_cache = net::iface::NeighborCache::new(&mut store.neighbor_cache[..]); let default_v4_gw = net::wire::Ipv4Address::new(192, 168, 1, 1); let mut routes = net::iface::Routes::new(&mut store.routes_cache[..]); routes.add_default_ipv4_route(default_v4_gw).unwrap(); let mut net_interface = net::iface::EthernetInterfaceBuilder::new(eth_dma) .ethernet_addr(mac_addr) .neighbor_cache(neighbor_cache) .ip_addrs(&mut store.ip_addrs[..]) // .routes(routes) .finalize(); /* * Using SPI1, AF5 * SCLK -> PA5 * MOSI -> PB5 * MISO -> PA6 * CS -> 0: PB12, 1: PA15, 2: PC7 * I/O_Update -> PB15 */ let sclk = gpioa.pa5.into_alternate_af5(); let mosi = gpiob.pb5.into_alternate_af5(); let miso = gpioa.pa6.into_alternate_af5(); let (cs0, cs1, cs2) = ( gpiob.pb12.into_push_pull_output(), gpioa.pa15.into_push_pull_output(), gpioc.pc7.into_push_pull_output(), ); let io_update = gpiob.pb15.into_push_pull_output(); let spi = dp.SPI1.spi( (sclk, miso, mosi), spi::MODE_0, 3.mhz(), ccdr.peripheral.SPI1, &ccdr.clocks, ); let cpld = CPLD::new(spi, (cs0, cs1, cs2), io_update); let parts = cpld.split(); let urukul = Urukul::new( parts.spi1, parts.spi2, parts.spi3, parts.spi4, parts.spi5, parts.spi6, parts.spi7, [25_000_000, 25_000_000, 25_000_000, 25_000_000] ); cp.SCB.enable_icache(); let mut time: u32 = 0; let mut next_ms = Instant::now(); next_ms += 400_00.cycles(); let mut socket_set_entries: [_; 8] = Default::default(); let mut sockets = net::socket::SocketSet::new(&mut socket_set_entries[..]); add_socket!(sockets, rx_storage, tx_storage); let tcp_stack = NetworkStack::new(&mut net_interface, sockets); let mut client = MqttClient::::new( IpAddr::V4(Ipv4Addr::new(192, 168, 1, 125)), "nucleo", tcp_stack, ) .unwrap(); loop { let tick = Instant::now() > next_ms; if tick { next_ms += 400_000.cycles(); time += 1; } if tick && (time % 1000) == 0 { client .publish("nucleo", "Hello, World!".as_bytes(), QoS::AtMostOnce, &[]) .unwrap(); } client .poll(|_client, topic, message, _properties| match topic { _ => hprintln!("On '{:?}', received: {:?}", topic, message).unwrap(), }) .unwrap(); // Update the TCP stack. let sleep = client.network_stack.update(time); if sleep { //cortex_m::asm::wfi(); cortex_m::asm::nop(); } } }