filipriec/projekt1
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

I2C detection works well

Browse Source
This commit is contained in:
Priec
2026-01-08 20:55:28 +01:00
parent 70c37c344b
commit d8b4352a0f
16 changed files with 2388 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

17
mqtt_display/.cargo/config.toml Normal file
View File

@@ -0,0 +1,17 @@
[target.xtensa-esp32-none-elf]
runner = "espflash flash --monitor --chip esp32"
[env]
ESP_LOG="info"
[build]
rustflags = [
"-C", "link-arg=-nostartfiles",
"-C", "link-arg=-Tdefmt.x",
"-Z", "stack-protector=all",
]
target = "xtensa-esp32-none-elf"
[unstable]
build-std = ["alloc", "core"]

4
mqtt_display/.env_temp Normal file
View File

@@ -0,0 +1,4 @@
SSID = "nazov_wifi_siete"
PASSWORD = "heslo_od_wifi"
BROKER_IP= "5.196.78.28"
BROKER_PORT= "1883"

20
mqtt_display/.gitignore vendored Normal file
View File

@@ -0,0 +1,20 @@
# will have compiled files and executables
debug/
target/
.vscode/
.zed/
.helix/
.env
# These are backup files generated by rustfmt
**/*.rs.bk
# MSVC Windows builds of rustc generate these, which store debugging information
*.pdb
# RustRover
# JetBrains specific template is maintained in a separate JetBrains.gitignore that can
# be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
# and can be added to the global gitignore or merged into this file. For a more nuclear
# option (not recommended) you can uncomment the following to ignore the entire idea folder.
#.idea/

1585
mqtt_display/Cargo.lock generated Normal file
View File

File diff suppressed because it is too large Load Diff

90
mqtt_display/Cargo.toml Normal file
View File

@@ -0,0 +1,90 @@
[package]
edition = "2021"
name = "projekt_final"
rust-version = "1.86"
version = "0.1.0"
[[bin]]
name = "projekt_final"
path = "./src/bin/main.rs"
[dependencies]
esp-bootloader-esp-idf = { version = "0.2.0", features = ["esp32"] }
esp-hal = { version = "=1.0.0-rc.0", features = [
"esp32",
"log-04",
"unstable",
] }
log = "0.4.27"
embassy-net = { version = "0.7.0", features = [
"dhcpv4",
"proto-ipv6",
"log",
"medium-ethernet",
"tcp",
"udp",
] }
embedded-io = "0.6.1"
embedded-io-async = "0.6.1"
esp-alloc = "0.8.0"
esp-backtrace = { version = "0.17.0", features = [
"esp32",
"exception-handler",
"panic-handler",
"println",
] }
esp-println = { version = "0.15.0", features = ["esp32", "log-04"] }
# for more networking protocol support see https://crates.io/crates/edge-net
critical-section = "1.2.0"
embassy-executor = { version = "0.7.0", features = [
"log",
"task-arena-size-20480",
] }
embassy-time = { version = "0.5.0", features = ["log"] }
esp-hal-embassy = { version = "0.9.0", features = ["esp32", "log-04"] }
esp-wifi = { version = "0.15.0", features = [
"builtin-scheduler",
"esp-alloc",
"esp32",
"log-04",
"smoltcp",
"wifi",
] }
smoltcp = { version = "0.12.0", default-features = false, features = [
"log",
"medium-ethernet",
"multicast",
"proto-dhcpv4",
"proto-dns",
"proto-ipv4",
"proto-ipv6",
"socket-dns",
"socket-icmp",
"socket-raw",
"socket-tcp",
"socket-udp",
] }
static_cell = "2.1.1"
rust-mqtt = { version = "0.3.0", default-features = false, features = ["no_std"] }
defmt-rtt = "1.0.0"
embassy-futures = "0.1.2"
embassy-sync = "0.7.2"
heapless = "0.9.1"
[build-dependencies]
dotenvy = "0.15.7"
[profile.dev]
# Rust debug is too slow.
# For debug builds always builds with some optimization
opt-level = "s"
[profile.release]
codegen-units = 1 # LLVM can perform better optimizations using a single thread
debug = 2
debug-assertions = false
incremental = false
lto = 'fat'
opt-level = 's'
overflow-checks = false

12
mqtt_display/Makefile Normal file
View File

@@ -0,0 +1,12 @@
.PHONY: all build flash
all: build flash
build:
cargo build --release
flash:
cargo espflash flash --release --monitor
info:
espflash board-info

73
mqtt_display/build.rs Normal file
View File

@@ -0,0 +1,73 @@
fn main() {
// Explicitly load .env from the project root, even when called from other dirs
let project_root = std::env::var("CARGO_MANIFEST_DIR").unwrap();
let dotenv_path = std::path::Path::new(&project_root).join(".env");
if dotenvy::from_path(dotenv_path.clone()).is_ok() {
println!("cargo:rerun-if-changed={}", dotenv_path.display());
}
// Pass WIFI credentials into firmware
if let Ok(ssid) = std::env::var("SSID") {
println!("cargo:rustc-env=SSID={}", ssid);
}
if let Ok(password) = std::env::var("PASSWORD") {
println!("cargo:rustc-env=PASSWORD={}", password);
}
if let Ok(ip) = std::env::var("BROKER_IP") {
println!("cargo:rustc-env=BROKER_IP={}", ip);
}
if let Ok(port) = std::env::var("BROKER_PORT") {
println!("cargo:rustc-env=BROKER_PORT={}", port);
}
linker_be_nice();
println!("cargo:rustc-link-arg=-Tlinkall.x");
}
fn linker_be_nice() {
let args: Vec<String> = std::env::args().collect();
if args.len() > 1 {
let kind = &args[1];
let what = &args[2];
match kind.as_str() {
"undefined-symbol" => match what.as_str() {
"_defmt_timestamp" => {
eprintln!();
eprintln!("💡 `defmt` not found - make sure `defmt.x` is added as a linker script and you have included `use defmt_rtt as _;`");
eprintln!();
}
"_stack_start" => {
eprintln!();
eprintln!("💡 Is the linker script `linkall.x` missing?");
eprintln!();
}
"esp_wifi_preempt_enable"
| "esp_wifi_preempt_yield_task"
| "esp_wifi_preempt_task_create" => {
eprintln!();
eprintln!("💡 `esp-wifi` has no scheduler enabled. Make sure you have the `builtin-scheduler` feature enabled, or that you provide an external scheduler.");
eprintln!();
}
"embedded_test_linker_file_not_added_to_rustflags" => {
eprintln!();
eprintln!("💡 `embedded-test` not found - make sure `embedded-test.x` is added as a linker script for tests");
eprintln!();
}
_ => (),
},
// we don't have anything helpful for "missing-lib" yet
_ => {
std::process::exit(1);
}
}
std::process::exit(0);
}
println!(
"cargo:rustc-link-arg=-Wl,--error-handling-script={}",
std::env::current_exe().unwrap().display()
);
}

0
mqtt_display/expanded.rs Normal file
View File

2
mqtt_display/rust-toolchain.toml Normal file
View File

@@ -0,0 +1,2 @@
[toolchain]
channel = "esp"

185
mqtt_display/src/bin/main.rs Normal file
View File

@@ -0,0 +1,185 @@
// src/bin/main.rs
#![no_std]
#![no_main]
#![deny(
clippy::mem_forget,
reason = "mem::forget is generally not safe to do with esp_hal types"
)]
use embassy_executor::Spawner;
use embassy_futures::select::{select, Either};
use embassy_net::{Runner, StackResources};
use embassy_time::{Duration, Timer};
use esp_alloc as _;
use esp_backtrace as _;
use esp_hal::{clock::CpuClock, rng::Rng, timer::timg::TimerGroup};
use esp_wifi::{
init,
wifi::{ClientConfiguration, Configuration, WifiController, WifiDevice, WifiEvent, WifiState},
EspWifiController,
};
use log::info;
use rust_mqtt::packet::v5::publish_packet::QualityOfService;
use projekt_final::mqtt::client::{
mqtt_events, mqtt_publish, mqtt_subscribe, mqtt_task, IncomingMsg,
};
use projekt_final::i2c::com::i2c_check;
use defmt_rtt as _;
extern crate alloc;
esp_bootloader_esp_idf::esp_app_desc!();
macro_rules! mk_static {
($t:ty,$val:expr) => {{
static STATIC_CELL: static_cell::StaticCell<$t> = static_cell::StaticCell::new();
#[deny(unused_attributes)]
let x = STATIC_CELL.uninit().write(($val));
x
}};
}
const SSID: &str = env!("SSID");
const PASSWORD: &str = env!("PASSWORD");
#[esp_hal_embassy::main]
async fn main(spawner: Spawner) -> ! {
esp_println::logger::init_logger_from_env();
let config = esp_hal::Config::default().with_cpu_clock(CpuClock::max());
let peripherals = esp_hal::init(config);
esp_alloc::heap_allocator!(size: 72 * 1024);
let timg0 = TimerGroup::new(peripherals.TIMG0);
let mut rng = Rng::new(peripherals.RNG);
let esp_wifi_ctrl = &*mk_static!(
EspWifiController<'static>,
init(timg0.timer0, rng.clone()).unwrap()
);
let (controller, interfaces) =
esp_wifi::wifi::new(&esp_wifi_ctrl, peripherals.WIFI).unwrap();
let wifi_interface = interfaces.sta;
let timg1 = TimerGroup::new(peripherals.TIMG1);
esp_hal_embassy::init(timg1.timer0);
let config = embassy_net::Config::dhcpv4(Default::default());
let seed = (rng.random() as u64) << 32 | rng.random() as u64;
// Init network stack
let (stack, runner) = embassy_net::new(
wifi_interface,
config,
mk_static!(StackResources<3>, StackResources::<3>::new()),
seed,
);
spawner.spawn(connection(controller)).ok();
spawner.spawn(net_task(runner)).ok();
// Wait for link up
loop {
if stack.is_link_up() {
break;
}
Timer::after(Duration::from_millis(500)).await;
}
info!("Waiting to get IP address...");
loop {
if let Some(config) = stack.config_v4() {
info!("Got IP: {}", config.address);
break;
}
Timer::after(Duration::from_millis(500)).await;
}
spawner.spawn(mqtt_task(stack)).expect("failed to spawn MQTT task");
info!("MQTT task started");
spawner.spawn(i2c_check()).expect("failed to spawn I2C task");
info!("I2C scan task started");
mqtt_publish("esp32/topic", b"hello from ESP32 (init)", QualityOfService::QoS1, false).await;
info!("Sent initial MQTT message");
mqtt_subscribe("esp32/topic").await;
// Get a receiver for incoming MQTT messages
let mqtt_rx = mqtt_events();
loop {
// Drive both: either process an MQTT message or publish periodically
match select(mqtt_rx.receive(), Timer::after(Duration::from_secs(5))).await
{
// Received inbound MQTT message (from broker)
Either::First(msg) => {
handle_incoming(msg);
}
// Time-based example publish
Either::Second(_) => {
// mqtt_publish(
// "esp32/topic",
// b"hello from main",
// QualityOfService::QoS1,
// false,
// )
// .await;
}
}
}
}
fn handle_incoming(msg: IncomingMsg) {
if let Ok(txt) = core::str::from_utf8(&msg.payload) {
info!("MAIN RX [{}]: {}", msg.topic.as_str(), txt);
info!("Received MQTT message -> topic: '{}', payload: '{}'", msg.topic.as_str(), txt);
} else {
info!("MAIN RX [{}]: {:?}", msg.topic.as_str(), msg.payload);
}
}
#[embassy_executor::task]
async fn connection(mut controller: WifiController<'static>) {
info!("start connection task");
info!("Device capabilities: {:?}", controller.capabilities());
loop {
match esp_wifi::wifi::wifi_state() {
WifiState::StaConnected => {
controller.wait_for_event(WifiEvent::StaDisconnected).await;
Timer::after(Duration::from_millis(5000)).await
}
_ => {}
}
if !matches!(controller.is_started(), Ok(true)) {
let client_config = Configuration::Client(ClientConfiguration {
ssid: SSID.into(),
password: PASSWORD.into(),
..Default::default()
});
controller.set_configuration(&client_config).unwrap();
info!("Starting wifi");
controller.start_async().await.unwrap();
info!("Wifi started!");
}
info!("About to connect...");
match controller.connect_async().await {
Ok(_) => info!("Wifi connected!"),
Err(e) => {
info!("Failed to connect to wifi: {e:?}");
Timer::after(Duration::from_millis(5000)).await
}
}
}
}
#[embassy_executor::task]
async fn net_task(mut runner: Runner<'static, WifiDevice<'static>>) {
runner.run().await
}

37
mqtt_display/src/i2c/com.rs Normal file
View File

@@ -0,0 +1,37 @@
// src/i2c/com.rs
use embassy_executor::task;
use embassy_time::{Duration, Timer};
use esp_hal::{
gpio::Io,
i2c::master::{Config, I2c},
peripherals::Peripherals,
};
use esp_println::println;
#[task]
pub async fn i2c_check() {
let peripherals = unsafe { Peripherals::steal() };
let _io = Io::new(peripherals.IO_MUX);
let sda = peripherals.GPIO21;
let scl = peripherals.GPIO22;
let mut i2c = I2c::new(peripherals.I2C0, Config::default())
.expect("Failed to initialize I2C")
.with_sda(sda)
.with_scl(scl);
loop {
println!("I2C bus scan start");
// Skenujeme adresy 0x03 až 0x77
for addr in 0x03..0x78 {
// Skúsime zapísať prázdne dáta na adresu
if i2c.write(addr, &[]).is_ok() {
println!("Device found at address 0x{:02X}", addr);
}
}
println!("Scan finished");
Timer::after(Duration::from_secs(5)).await;
}
}

3
mqtt_display/src/i2c/mod.rs Normal file
View File

@@ -0,0 +1,3 @@
// src/i2c/mod.rs
pub mod com;

4
mqtt_display/src/lib.rs Normal file
View File

@@ -0,0 +1,4 @@
#![no_std]
pub mod mqtt;
pub mod i2c;

230
mqtt_display/src/mqtt/client.rs Normal file
View File

@@ -0,0 +1,230 @@
// src/mqtt/client.rs
use embassy_futures::select::{select, Either};
use embassy_net::{tcp::TcpSocket, Stack};
use embassy_time::{Duration, Timer};
use log::info;
use rust_mqtt::client::client::MqttClient;
use rust_mqtt::client::client_config::{ClientConfig, MqttVersion};
use rust_mqtt::packet::v5::publish_packet::QualityOfService;
use rust_mqtt::packet::v5::reason_codes::ReasonCode;
use rust_mqtt::utils::rng_generator::CountingRng;
use static_cell::ConstStaticCell;
use embassy_sync::blocking_mutex::raw::CriticalSectionRawMutex;
use embassy_sync::channel::{Channel, Receiver};
use heapless::{String as HString, Vec as HVec};
use crate::mqtt::config::mqtt_broker_endpoint;
const RECONNECT_DELAY_SECS: u64 = 5;
const KEEPALIVE_SECS: u64 = 60;
const PING_PERIOD: Duration = Duration::from_secs(KEEPALIVE_SECS / 2);
// Limits for small, static buffers (no heap)
pub const TOPIC_MAX: usize = 128;
pub const PAYLOAD_MAX: usize = 512;
const COMMAND_QUEUE: usize = 8;
const EVENT_QUEUE: usize = 8;
// TCP socket buffers (for embassy-net TcpSocket)
static TCP_RX_BUFFER: ConstStaticCell<[u8; 2048]> = ConstStaticCell::new([0; 2048]);
static TCP_TX_BUFFER: ConstStaticCell<[u8; 2048]> = ConstStaticCell::new([0; 2048]);
// MQTT client buffers (separate from the TcpSocket's buffers)
static MQTT_TX_BUF: ConstStaticCell<[u8; 1024]> = ConstStaticCell::new([0; 1024]);
static MQTT_RX_BUF: ConstStaticCell<[u8; 1024]> = ConstStaticCell::new([0; 1024]);
// Tie TcpSocket lifetime to session
type Client<'a, 'net> = MqttClient<'a, TcpSocket<'net>, 8, CountingRng>;
#[derive(Clone)]
pub struct IncomingMsg {
pub topic: HString<TOPIC_MAX>,
pub payload: HVec<u8, PAYLOAD_MAX>,
}
#[derive(Clone)]
struct PublishMsg {
topic: HString<TOPIC_MAX>,
payload: HVec<u8, PAYLOAD_MAX>,
qos: QualityOfService,
retain: bool,
}
#[derive(Clone)]
enum Command {
Publish(PublishMsg),
Subscribe(HString<TOPIC_MAX>),
}
static CMD_CHAN: Channel<CriticalSectionRawMutex, Command, COMMAND_QUEUE> = Channel::new();
static EVT_CHAN: Channel<CriticalSectionRawMutex, IncomingMsg, EVENT_QUEUE> = Channel::new();
// Public API
pub async fn mqtt_publish(topic: &str, payload: &[u8], qos: QualityOfService, retain: bool) {
CMD_CHAN
.send(Command::Publish(PublishMsg {
topic: truncate_str::<TOPIC_MAX>(topic),
payload: truncate_payload(payload),
qos,
retain,
}))
.await;
}
pub async fn mqtt_subscribe(topic: &str) {
CMD_CHAN.send(Command::Subscribe(truncate_str::<TOPIC_MAX>(topic))).await;
}
pub fn mqtt_events(
) -> Receiver<'static, CriticalSectionRawMutex, IncomingMsg, EVENT_QUEUE> {
EVT_CHAN.receiver()
}
// Helper functions for memory-safe truncation
fn truncate_str<const N: usize>(s: &str) -> HString<N> {
let mut h = HString::new();
let _ = h.push_str(&s[..s.len().min(N)]);
h
}
fn truncate_payload(data: &[u8]) -> HVec<u8, PAYLOAD_MAX> {
let mut v = HVec::new();
let _ = v.extend_from_slice(&data[..data.len().min(PAYLOAD_MAX)]);
v
}
// MQTT configuration and client setup
fn build_client_config() -> ClientConfig<'static, 8, CountingRng> {
let mut cfg = ClientConfig::new(MqttVersion::MQTTv5, CountingRng(0));
cfg.keep_alive = KEEPALIVE_SECS as u16;
cfg.add_client_id("esp32-client");
cfg
}
fn build_client<'a, 'net>(
socket: TcpSocket<'net>,
mqtt_tx: &'a mut [u8],
mqtt_rx: &'a mut [u8],
) -> Client<'a, 'net> {
let mqtt_tx_len = mqtt_tx.len();
let mqtt_rx_len = mqtt_rx.len();
MqttClient::new(socket, mqtt_tx, mqtt_tx_len, mqtt_rx, mqtt_rx_len, build_client_config())
}
// Connection lifecycle and main session loop
async fn connect_tcp<'net>(socket: &mut TcpSocket<'net>) -> Result<(), ()> {
match socket.connect(mqtt_broker_endpoint()).await {
Ok(_) => {
info!("Connected TCP to MQTT broker");
Ok(())
}
Err(e) => {
info!("TCP connect failed: {:?}", e);
Err(())
}
}
}
async fn connect_mqtt(client: &mut Client<'_, '_>) -> Result<(), ReasonCode> {
client.connect_to_broker().await
}
async fn run_loop(client: &mut Client<'_, '_>) -> Result<(), ReasonCode> {
let default_topic = "esp32/topic";
match client.subscribe_to_topic(default_topic).await {
Ok(_) => info!("Subscribed to '{}'", default_topic),
Err(e) => info!("Default subscribe failed: {:?}", e),
};
loop {
let net_or_ping = select(client.receive_message(), Timer::after(PING_PERIOD));
match select(CMD_CHAN.receive(), net_or_ping).await {
Either::First(cmd) => handle_command(client, cmd).await?,
Either::Second(Either::First(result)) => handle_incoming(result).await?,
Either::Second(Either::Second(_)) => client.send_ping().await?,
}
}
}
async fn handle_command(client: &mut Client<'_, '_>, cmd: Command) -> Result<(), ReasonCode> {
match cmd {
Command::Publish(msg) => {
client
.send_message(msg.topic.as_str(), &msg.payload, msg.qos, msg.retain)
.await
}
Command::Subscribe(topic) => {
client.subscribe_to_topic(topic.as_str()).await?;
info!("Subscribed to '{}'", topic);
Ok(())
}
}
}
async fn handle_incoming(result: Result<(&str, &[u8]), ReasonCode>) -> Result<(), ReasonCode> {
let (topic, payload) = result?;
EVT_CHAN
.send(IncomingMsg {
topic: truncate_str::<TOPIC_MAX>(topic),
payload: truncate_payload(payload),
})
.await;
Ok(())
}
// Session and reconnect control
async fn run_one_session(
stack: Stack<'static>,
tcp_rx: &mut [u8],
tcp_tx: &mut [u8],
mqtt_tx: &mut [u8],
mqtt_rx: &mut [u8],
) -> Result<(), ()> {
let mut socket = TcpSocket::new(stack, tcp_rx, tcp_tx);
if connect_tcp(&mut socket).await.is_err() {
return Err(());
}
let mut client = build_client(socket, mqtt_tx, mqtt_rx);
match connect_mqtt(&mut client).await {
Ok(_) => info!("MQTT CONNACK received"),
Err(reason) => {
info!("MQTT connect failed: {:?}", reason);
return Err(());
}
}
run_loop(&mut client).await.map_err(|_| ())
}
// Main MQTT embassy task
#[embassy_executor::task]
pub async fn mqtt_task(stack: Stack<'static>) {
info!("MQTT task starting...");
let tcp_rx = TCP_RX_BUFFER.take();
let tcp_tx = TCP_TX_BUFFER.take();
let mqtt_tx = MQTT_TX_BUF.take();
let mqtt_rx = MQTT_RX_BUF.take();
loop {
let _ = run_one_session(
stack,
&mut tcp_rx[..],
&mut tcp_tx[..],
&mut mqtt_tx[..],
&mut mqtt_rx[..],
)
.await;
info!(
"Reconnecting in {}s after session end/failure",
RECONNECT_DELAY_SECS
);
Timer::after(Duration::from_secs(RECONNECT_DELAY_SECS)).await;
}
}

122
mqtt_display/src/mqtt/config.rs Normal file
View File

@@ -0,0 +1,122 @@
// src/mqtt/config.rs
#![allow(dead_code)]
use embassy_net::{IpAddress, Ipv4Address, Ipv6Address};
// Compile-time values injected by build.rs
const BROKER_IP: &str = env!("BROKER_IP");
const BROKER_PORT: &str = env!("BROKER_PORT");
pub fn mqtt_broker_endpoint() -> (IpAddress, u16) {
(parse_ip(BROKER_IP), parse_port(BROKER_PORT))
}
fn parse_port(s: &str) -> u16 {
let p: u16 = s
.parse()
.unwrap_or_else(|_| panic!("BROKER_PORT must be a valid u16 (1..=65535)"));
assert!(p != 0, "BROKER_PORT cannot be 0");
p
}
fn parse_ip(s: &str) -> IpAddress {
if s.contains(':') {
IpAddress::Ipv6(parse_ipv6(s))
} else {
IpAddress::Ipv4(parse_ipv4(s))
}
}
fn parse_ipv4(s: &str) -> Ipv4Address {
let mut it = s.split('.');
let a = parse_octet(it.next(), 1);
let b = parse_octet(it.next(), 2);
let c = parse_octet(it.next(), 3);
let d = parse_octet(it.next(), 4);
assert!(it.next().is_none(), "Too many IPv4 octets");
Ipv4Address::new(a, b, c, d)
}
fn parse_octet(part: Option<&str>, idx: usize) -> u8 {
let p = part.unwrap_or_else(|| panic!("IPv4 missing octet {}", idx));
let v: u16 = p
.parse()
.unwrap_or_else(|_| panic!("Invalid IPv4 octet {}: {}", idx, p));
assert!(v <= 255, "IPv4 octet {} out of range: {}", idx, v);
v as u8
}
// Minimal IPv6 parser with '::' compression. Does not handle IPv4-embedded IPv6.
fn parse_ipv6(s: &str) -> Ipv6Address {
assert!(
!s.contains('.'),
"IPv4-embedded IPv6 like ::ffff:192.0.2.1 not supported; \
use pure hex IPv6"
);
let has_double = s.contains("::");
let (left_s, right_s) = if has_double {
let mut sp = s.splitn(2, "::");
(sp.next().unwrap_or(""), sp.next().unwrap_or(""))
} else {
(s, "")
};
let mut left = [0u16; 8];
let mut right = [0u16; 8];
let mut ll = 0usize;
let mut rl = 0usize;
if !left_s.is_empty() {
for part in left_s.split(':') {
left[ll] = parse_group(part);
ll += 1;
assert!(ll <= 8, "Too many IPv6 groups on the left");
}
}
if !right_s.is_empty() {
for part in right_s.split(':') {
right[rl] = parse_group(part);
rl += 1;
assert!(rl <= 8, "Too many IPv6 groups on the right");
}
}
let zeros = if has_double {
assert!(ll + rl < 8, "Invalid IPv6 '::' usage");
8 - (ll + rl)
} else {
assert!(ll == 8, "IPv6 must have 8 groups without '::'");
0
};
let mut g = [0u16; 8];
let mut idx = 0usize;
for i in 0..ll {
g[idx] = left[i];
idx += 1;
}
for _ in 0..zeros {
g[idx] = 0;
idx += 1;
}
for i in 0..rl {
g[idx] = right[i];
idx += 1;
}
assert!(idx == 8, "IPv6 did not resolve to 8 groups");
Ipv6Address::new(g[0], g[1], g[2], g[3], g[4], g[5], g[6], g[7])
}
fn parse_group(part: &str) -> u16 {
assert!(
!part.is_empty(),
"Empty IPv6 group (use '::' instead for compression)"
);
assert!(part.len() <= 4, "IPv6 group too long: {}", part);
u16::from_str_radix(part, 16)
.unwrap_or_else(|_| panic!("Invalid IPv6 hex group: {}", part))
}

4
mqtt_display/src/mqtt/mod.rs Normal file
View File

@@ -0,0 +1,4 @@
// src/mqtt/mod.rs
pub mod client;
pub mod config;