00:24 <badrb[m]> Hi! Does any one have some recommendation for a modbus no_std crate?

00:24 <JamesMunns[m]> quick question, are you being a modbus master or slave in no_std mode?

00:26 <JamesMunns[m]> There's https://github.com/slowtec/modbus-core, but IIRC it only supported being a slave in no_std, which doesn't help if you want to talk to an external meter or something

00:26 <badrb[m]> Master

00:27 <badrb[m]> modbus-rtu

00:27 <vollbrecht[m]> are you wanting modbus-rtu or modbus-tcp :D

00:27 <JamesMunns[m]> Yeah that's a good question too, I was assuming rti

00:27 <JamesMunns[m]> s/rti/rtu/

00:27 <JamesMunns[m]> yeah, modbus-core::rtu only provides slave/server, not master/client

00:28 <JamesMunns[m]> I found that in a project recently, I think I ended up hacking together a basic master/client library by using some of the bits from tokio-modbus and modbus-core, but it wasn't a general solution, I basically implemented enough to talk to the three slave/server nodes I needed for that project

00:29 <JamesMunns[m]> maybe someone else knows of a better solution

00:30 <diondokter[m]> I've used this one with good success: https://github.com/alttch/rmodbus

00:30 <vollbrecht[m]> rmodbus claims no_std support but just from reading

00:30 <badrb[m]> I was surprised to not find much in the no_std realm, Modbus is fairly common.

00:31 <diondokter[m]> I've used it as both a server and a client

00:31 <JamesMunns[m]> tokio-modbus I've seen at a couple customers, but they are all on PCs talking to external sensors/actuators

00:31 <badrb[m]> JamesMunns[m]: Do you have sources published? It might be a good inspiration

00:31 <JamesMunns[m]> badrb[m]: no, sorry, that was a private customer project

00:33 <badrb[m]> Thanks guys, I’ll take a look at rmodbus!

00:34 <diondokter[m]> Here's my server code for rmodbus. It's flexible enough that I could put an async layer on top of it. Though, that's not really required to use, it was more to challenge myself 😬

00:34 <diondokter[m]> https://github.com/diondokter/induction-heater/blob/master/software/ih-controller-firmware/src/modbus.rs

00:35 <diondokter[m]> But the core of it is pretty much what they've written in the docs. So that's the best starting point

07:10 <AnandGedam[m]> Hello all,

07:10 <AnandGedam[m]> I am beginning to explore rust for my FPGA board.

07:10 <AnandGedam[m]> Any leads or documentations to write startup code in rust for riscv architecture?

07:20 <FlixtheNewbie[m]> Hello, I want to shrink my firmware size as much as possible, and I wonder if in this code, both constants have the same size or not:... (full message at <https://catircservices.org/_matrix/media/v3/download/catircservices.org/suyPHLKtkHUyXlxDpQiWTWTp>)

07:20 <FlixtheNewbie[m]> * Hello, I want to shrink my firmware size as much as possible, and I wonder if in this code, both constants data use the same size or not:... (full message at <https://catircservices.org/_matrix/media/v3/download/catircservices.org/KpOqMSSfCkDozCsBlPTSvNAq>)

07:21 <FlixtheNewbie[m]> I know that if we take only the array into account, the first one is bigger, but if I use a reference to Foo::Nothing, what space does it take? A full Foo size, or just one byte?

07:23 <FlixtheNewbie[m]> If the latter takes less space, how costly is such a series of indirections when I iterate over the array?

07:27 <FlixtheNewbie[m]> * the array on the FLASH?

08:00 <burrbull[m]> <FlixtheNewbie[m]> "I know that if we take only..." <- `size_of<ref> == size_of<usize>` 4 bytes for 32bit system

08:00 <burrbull[m]> https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=5dd41b816263584faa49dc00e5903d60

08:31 <vollbrecht[m]> dirbaio: didn't you want to release embedded-hal on gh? its still missing the gh release

08:52 <thejpster[m]> consts take zero space - they are pasted into the usage site at compile time.

08:54 <thejpster[m]> But Foo is 132 bytes and &Foo is 4 or 8 bytes (depending on platform). I suspect you’d get a single static Foo with the value Nothing and all the references would point to it.

08:56 <thejpster[m]> Indirections are low cost unless you have cache. You’d have to benchmark your application, but personally I wouldn’t worry about it until performance had been proven to be outside acceptable limits.

14:07 <dav1d> If I want to pass messages between embassy tasks, is the way to do it with a 'static Channel?

14:18 <diondokter[m]> <dav1d> "If I want to pass messages..." <- yes indeed! If you look at e.g. embassy-sync, then you'll see multiple flavours of channels. One of those will surely work for you

14:19 <dav1d> diondokter[m], cool thanks, wasnt sure if I have to make them static or if I can pass references

14:20 <diondokter[m]> To pass something to an embassy task, it needs to be 'static, so yes

15:14 <FlixtheNewbie[m]> <thejpster[m]> "Indirections are low cost unless..." <- Thanks a lot, that's clear. I'll use the reference mechanism, then, I will be able to save a lot of space.

20:54 <dav1d> is there something like FuturesUnordered for embedded?

20:54 <dav1d> (aka no_std)

20:56 <dav1d> basically embassy-futures but with alloc