300 lines
8.9 KiB
Rust
300 lines
8.9 KiB
Rust
#![no_std]
|
|
#![no_main]
|
|
|
|
#[macro_use]
|
|
extern crate log;
|
|
|
|
use smoltcp as net;
|
|
use stm32h7xx_hal::ethernet;
|
|
use stm32h7xx_hal::{gpio::Speed, prelude::*, spi, pac};
|
|
use embedded_hal::{
|
|
blocking::spi::Transfer,
|
|
digital::v2::OutputPin,
|
|
};
|
|
|
|
use heapless::{consts, String};
|
|
|
|
use cortex_m;
|
|
use cortex_m_rt::{
|
|
entry,
|
|
exception,
|
|
};
|
|
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::{
|
|
cpld::{
|
|
CPLD,
|
|
},
|
|
scpi::{
|
|
HelloWorldCommand,
|
|
Channel0SwitchCommand,
|
|
Channel1SwitchCommand,
|
|
Channel2SwitchCommand,
|
|
Channel3SwitchCommand,
|
|
Channel0AttenuationCommand,
|
|
Channel1AttenuationCommand,
|
|
Channel2AttenuationCommand,
|
|
Channel3AttenuationCommand,
|
|
ClockSourceCommand,
|
|
ClockDivisionCommand,
|
|
ProfileCommand,
|
|
Channel0Profile0Singletone
|
|
},
|
|
Urukul, scpi_root, recursive_scpi_tree, scpi_tree
|
|
};
|
|
use firmware::translation::MqttScpiTranslator;
|
|
|
|
use scpi::prelude::*;
|
|
use scpi::ieee488::commands::*;
|
|
use scpi::scpi::commands::*;
|
|
use scpi::{
|
|
ieee488_cls,
|
|
ieee488_ese,
|
|
ieee488_esr,
|
|
ieee488_idn,
|
|
ieee488_opc,
|
|
ieee488_rst,
|
|
ieee488_sre,
|
|
ieee488_stb,
|
|
ieee488_tst,
|
|
ieee488_wai,
|
|
scpi_crate_version,
|
|
scpi_status,
|
|
scpi_system,
|
|
};
|
|
use scpi::Context;
|
|
|
|
#[path = "util/logger.rs"]
|
|
mod logger;
|
|
|
|
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());
|
|
// Reset RCC clock
|
|
dp.RCC.rsr.write(|w| w.rmvf().set_bit());
|
|
|
|
let pwr = dp.PWR.constrain();
|
|
let vos = pwr.freeze();
|
|
|
|
let rcc = dp.RCC.constrain();
|
|
let ccdr = rcc
|
|
.use_hse(8.mhz())
|
|
.sysclk(400.mhz())
|
|
.hclk(200.mhz())
|
|
.pll1_q_ck(48.mhz()) // for SPI
|
|
.pll1_r_ck(400.mhz()) // for TRACECK
|
|
.freeze(vos, &dp.SYSCFG);
|
|
|
|
unsafe {
|
|
logger::enable_itm(&dp.DBGMCU, &mut cp.DCB, &mut cp.ITM);
|
|
}
|
|
logger::init();
|
|
let mut delay = cp.SYST.delay(ccdr.clocks);
|
|
|
|
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, mut 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 mut net_interface = net::iface::EthernetInterfaceBuilder::new(eth_dma)
|
|
.ethernet_addr(mac_addr)
|
|
.neighbor_cache(neighbor_cache)
|
|
.ip_addrs(&mut store.ip_addrs[..])
|
|
.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 mut urukul = Urukul::new(
|
|
parts.spi1, parts.spi2, parts.spi3, parts.spi4, parts.spi5, parts.spi6, parts.spi7
|
|
);
|
|
|
|
cp.SCB.invalidate_icache();
|
|
cp.SCB.enable_icache();
|
|
|
|
// Define SCPI tree
|
|
let tree = scpi_tree!();
|
|
|
|
// Device was declared in prior
|
|
let mut errors = ArrayErrorQueue::<[Error; 10]>::new();
|
|
let mut context = Context::new(&mut urukul, &mut errors, tree);
|
|
|
|
//Response bytebuffer
|
|
let mut buf = ArrayVecFormatter::<[u8; 256]>::new();
|
|
// SCPI configs END
|
|
|
|
// Time unit in ms
|
|
let mut time: u32 = 0;
|
|
|
|
// Cycle counter for 1 ms
|
|
// This effectively provides a conversion from rtic unit to ms
|
|
let mut next_ms = Instant::now();
|
|
next_ms += 400_000.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);
|
|
|
|
// Case dealt: Ethernet connection break down, neither side has timeout
|
|
// Limitation: Timeout inequality will cause TCP socket state to desync
|
|
// Probably fixed in latest smoltcp commit
|
|
let mut client = MqttClient::<consts::U256, _>::new(
|
|
IpAddr::V4(Ipv4Addr::new(192, 168, 1, 125)),
|
|
"Nucleo",
|
|
tcp_stack,
|
|
)
|
|
.unwrap();
|
|
|
|
let mut tick = false;
|
|
let mut has_subscribed = false;
|
|
|
|
loop {
|
|
// Update time accumulator in ms
|
|
// Tick once every ms
|
|
if Instant::now() > next_ms {
|
|
tick = true;
|
|
time += 1;
|
|
next_ms += 400_000.cycles();
|
|
}
|
|
|
|
// eth Poll if necessary
|
|
// Do not poll if eth link is down
|
|
if tick && client.network_stack.update_delay(time) == 0 && eth_mac.phy_poll_link() {
|
|
client.network_stack.update(time);
|
|
}
|
|
|
|
let connection = client
|
|
.poll(|_client, topic, message, _properties| match topic {
|
|
topic => {
|
|
info!("On '{:?}', received: {:?}", topic, message);
|
|
// Why is topic a string while message is a slice?
|
|
context.run_with_mqtt(topic,
|
|
core::str::from_utf8(message).unwrap(),
|
|
&mut buf)
|
|
.unwrap();
|
|
},
|
|
}).is_ok();
|
|
|
|
if connection && !has_subscribed && tick {
|
|
match client.subscribe("Urukul/Control", &[]) {
|
|
Ok(()) => has_subscribed = true,
|
|
Err(minimq::Error::NotReady) => {},
|
|
e => warn!("{:?}", e),
|
|
};
|
|
}
|
|
|
|
if connection && tick && (time % 3000) == 0 {
|
|
info!("Feedback from print publish: {:?}", client
|
|
.publish("Channel1/Switch", "Hello, World!".as_bytes(), QoS::AtMostOnce, &[]));
|
|
}
|
|
|
|
// Reset tick flag
|
|
tick = false;
|
|
}
|
|
} |