DivoomCli is a command-line tool built on top of Divoom APIs designed to control Divoom devices such as Pixoo-64. This versatile utility allows users to interact with their Divoom devices through a terminal interface, enabling precise and efficient management of device settings and functionalities.
Key Features:
Offering control over system/device settings, running batch commands, sending raw API requests, and managing tools like countdowns, noise meters, scoreboards, and stopwatches. The tool also supports advanced operations such as setting device brightness, rotation angles, mirror modes, and more. Built on a robust Rust SDK, DivoomCli ensures reliability and performance.
Audience & Benefit:
Ideal for developers, tinkerers, and users seeking precise control over their Divoom devices. With DivoomCli, users can customize device behavior, integrate commands into scripts, and automate tasks, providing unparalleled flexibility and efficiency in managing Divoom hardware.
DivoomCli can be installed via winget, making it easy to incorporate into your workflow.
README
Divoom
Rust Library for controlling divoom devices that support REST APIs, such as pixoo-64 (and from how divoom's api/doc organizes, maybe more in the future).
// Get current channel
use divoom::*;
println!(
"{}",
PixooClient::new("192.168.0.123").get_current_channel().await?
);
// Output: clock
Besides the SDK, a few more tools are provided to help people enjoy the device as well as serving as demo!
A command line tool divoom-cli for controlling the device: .
# Check current channel
> divoom-cli 192.168.0.123 channel get
---
clock
A REST gateway divoom-gateway with Swagger UI and OpenAPI spec json provided, so we can control the device, build cron-like schedule, render customized animation and play it on the device: .
How to use
To use this library, please add the following into the dependencies in the Cargo.toml file:
[dependencies]
divoom = "0.1"
The library contains 2 major parts:
Divoom service APIs, that is used for talking to Divoom's backend service for device discovery etc.
Pixoo device APIs, that is used for talking to a specific device via its REST APIs.
Divoom service APIs
To discover all devices in your LAN, we can use the get_same_lan_devices API to get all devices from Divoom's backend service.
use divoom::*;
let divoom = DivoomServiceClient::new();
let devices = divoom.get_same_lan_devices().await?;
devices.iter().for_each(|x| println!("{:?}", x));
Once we get the Device Address, we can use it to create a pixoo client and start talking to it:
use divoom::*;
let pixoo = PixooClient::new("192.168.0.123");
let result = pixoo.get_current_channel().await?;
println!("{:?}", result);
This will output:
Clock
Currently, we have these APIs supported:
Channel APIs
Select channel
Get current channel
Select clock
Get selected clock info
Select cloud channel
Select visualizer
Select custom page
System/Device APIs
Get device settings
Get device time
Set device brightness
Set device time
Set device high light mode
Set device hour mode
Set device mirror mode
Set device rotation angle
Set device screen power state
Set device temperature unit
Set device time zone
Set device weather area
Set device white balance
Tools APIs
Set countdown tool
Set noise tool
Set scoreboard tool
Set stopwatch tool
Animation APIs
Play gif from file
Get next animation id
Reset next animation id
Send image animation
Send text animation
Clear all text area
Play buzzer
Batch APIs
Batching commands
Execute commands from url
Image Animation
Devices like Pixoo-64 supports play GIF file from file or even Internet directly, all we need is to specify a URL as below:
use divoom::*;
let pixoo = PixooClient::new("192.168.0.123");
pixoo.play_gif_file(DivoomFileAnimationSourceType::Url, "").await?;
However, this device API is not quite stable (by 07/2022) and the most reliable way to play a GIF is to create an animation and draw
all the GIF frames into it one by one. To help with this process, we created a resource loader and an animation builder to help.
use divoom::*;
// Load the resource.
let frames = DivoomAnimationResourceLoader::gif_file("test_data/animation_builder_tests/logo-16-rotate-4-frames.gif").unwrap();
// Build animation with 16 pixel canvas and 100ms frame play speed.
let builder = DivoomAnimationBuilder::new(16, Duration::from_millis(100)).unwrap();
let animation = builder.draw_frames(&frames, 0).build();
// Send to device here.
let pixoo = PixooClient::new("192.168.0.123");
pixoo.send_image_animation(animation).await
Or even simpler:
use divoom::*;
let pixoo = PixooClient::new("192.168.0.123");
pixoo.render_gif_as_animation(16, Duration::from_millis(100), "test_data/animation_builder_tests/logo-16-rotate-4-frames.gif").await
Besides gif, we also support png and jpeg format. And besides reading from file, we also support loading resource from any Read trait. For more on how to use it, feel free to check our doc here: .
And for any reason, if you don't want the builtin animation builder, we can exclude it by specifying the features with:
[dependencies]
divoom = { version = "0.1", features = [] }
Text Animation
To create a text animation, we can use DivoomTextAnimation structure and send_text_animation API to help us:
use divoom::*;
let pixoo = PixooClient::new("192.168.0.123");
let animation = DivoomTextAnimation::default();
animation.text_string = "Foo".to_string();
pixoo.send_text_animation(animation).await?;
Command batching
In certain cases, we might want to run a lot of commands at the same time, such as initialize the settings. Pixoo devices supports batching all commands into a single request, but with only 1 single result being returned for indicating if everything succeeded or not.
Here is an example that we batch executed multiple commands to update the device settings:
use divoom::*;
let pixoo = PixooClient::new("192.168.0.123");
pixoo.start_batch()
.set_device_rotation_angle(DivoomDeviceRotationAngle::Rotate90)
.set_device_mirror_mode(DivoomDeviceMirrorMode::On)
.set_device_brightness(30)
.execute().await.expect("Request should succeed.");
Sending raw requests
In case new API is released and we haven't support it yet, or we need to do some experimental things by sending the raw payload, we can use the following API to send raw request directly, which works for both single request and batch mode.
Single request mode:
use divoom::*;
let pixoo = PixooClient::new("192.168.0.123");
pixoo.send_raw_request("{ \"Command\": \"Device/SetHighLightMode\", \"Mode\": 0 }").await?.expect("Request should succeed.");
Batch mode:
use divoom::*;
let pixoo = PixooClient::new("192.168.0.123");
pixoo.start_batch()
.send_raw_request("{ \"Command\": \"Device/SetHighLightMode\", \"Mode\": 0 }".into())
.execute_with_raw_response().await.expect("Request should succeed.");
Debugging
The debug logs are logged at debug level. Once we set the log level to debug, we will be able to start see it:
> $env:RUST_LOG="warn"; .\divoom-cli.exe 192.168.0.123 channel get
---
customPage
Acknowledgements
Thanks to @farique1 for allowing me to bundle the classic 8-bits fonts, that generated via his nice project
Chartotype, as part of the Divoom Gateway, which
helps generate text animations.
