10 releases (6 breaking)

new 0.7.1 Nov 6, 2024
0.7.0 Oct 26, 2024
0.6.1 Oct 18, 2024
0.5.0 Sep 11, 2024
0.1.0 Nov 4, 2023

#242 in Network programming

Download history 5/week @ 2024-08-05 369/week @ 2024-09-09 14/week @ 2024-09-16 7/week @ 2024-09-23 21/week @ 2024-09-30 264/week @ 2024-10-14 127/week @ 2024-10-21 30/week @ 2024-10-28

421 downloads per month

MIT/Apache

1MB
21K SLoC

SunSpec Rust Implementation

Latest Version CI Unsafe forbidden Rust 1.75+

This Rust crate contains code for accessing SunSpec compliant devices in a safe and convenient way.

Highlights

  • Pure Rust library
  • No unsafe code
  • Panic free
  • All communication is abstracted via traits making it runtime agnostic
  • Supports Modbus TCP and RTU (via tokio-modbus).
  • Implements "Device Information Model Discovery" as defined in the SunSpec specification.
  • Fully typed models generated from the JSON files contained in the SunSpec models repository
  • Fully typed enums
  • Fully typed bitfields
  • Fully documented. Even the generated models.
  • Reading of complete models in a single request.
⚠️ Nested and repeating groups are not supported, yet.

Features

Feature Description Extra dependencies Default
tokio Enable tokio_modbus support tokio-modbus, tokio/time yes
serde Enable serde support serde, bitflags/serde yes

Examples

The examples directory in the code repository contains the unabridged code.

Example code for accessing data from a three phase inverter using the model 103

use std::{error::Error, net::SocketAddr, time::Duration};

use clap::Parser;
use itertools::Itertools;
use sunspec::{
    client::{AsyncClient, Config},
    models::{model1::Model1, model103::Model103},
};
use tokio::time::sleep;
use tokio_modbus::{client::tcp::connect_slave, Slave};

#[derive(Parser)]
struct Args {
    addr: SocketAddr,
    device_id: u8,
}

#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
    let args = Args::parse();

    let mut client = AsyncClient::new(
        connect_slave(args.addr, Slave(args.device_id)).await?,
        Config::default(),
    ).await?;

    let m1: Model1 = client.read_model().await?;

    println!("Manufacturer: {}", m1.mn);
    println!("Model: {}", m1.md);
    println!("Version: {}", m1.vr.as_deref().unwrap_or("(unspecified)"));
    println!("Serial Number: {}", m1.sn);

    println!(
        "Supported models: {}",
        client
            .models
            .supported_model_ids()
            .iter()
            .map(|id| id.to_string())
            .join(", ")
    );

    loop {
        let m103: Model103 = client.read_model().await?;
        let w = m103.w as f32 * 10f32.powf(m103.w_sf.into());
        let wh = m103.wh as f32 * 10f32.powf(m103.wh_sf.into());
        println!("{:12.3} kWh {:9.3} kW", wh / 1000.0, w / 1000.0,);
        sleep(Duration::from_secs(1)).await;
    }
}

FAQ

How does this crate differ from crates like tokio-sunspec, sunspec-models, sunspec_rs?

  • This crate generates all code using Rust code via the official SunSpec models repository with a code generator that was written in Rust, too.

  • All generated models are plain Rust structs. A single Modbus call can return the complete data for a model rather than having to fetch points individually.

  • All public types are documented. Even the generated models.

License

Licensed under either of

at your option.

Dependencies

~2.8–8.5MB
~78K SLoC