mqtt_client: init

examples/mqtt_client.rs

@@ -0,0 +1,216 @@
+#![no_std]
+#![no_main]
+
+use smoltcp as net;
+use stm32h7_ethernet as 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::ethernet_init(
+            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::<consts::U256, _>::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();
+        }
+    }
+}