lobo/ssd1306_oled_display_cli
1
0
Fork 0
Code Issues 3 Pull requests Projects Releases Packages Wiki Activity Actions
ssd1306_oled_display_cli/src/main.zig

546 lines
21 KiB
Zig
Raw Blame History

const std = @import("std");
const display = @import("display.zig");
const chars = @import("images/images.zig").chars;
// The package manager will install headers from our dependency in zig's build
// cache and include the cache directory as a "-I" option on the build command
// automatically.
const c = @cImport({
@cInclude("MagickWand/MagickWand.h");
@cInclude("i2cdriver.h");
});
var lines: [display.LINES]*[:0]u8 = undefined;
fn usage(args: [][]u8) !void {
const writer = std.io.getStdErr().writer();
try writer.print("usage: {s} <device> [-bg <image file>] [-<num> text]...\n", .{args[0]});
try writer.print("\t-<num> text: line number and text to display\n", .{});
try writer.print("\te.g. \"-1 'hello world'\" will display \"hello world\" on line 1\n", .{});
std.os.exit(1);
}
const Options = struct {
background_filename: [:0]u8,
device_file: [:0]u8,
};
pub fn main() !void {
const alloc = std.heap.c_allocator;
//defer alloc.deinit();
const args = try std.process.argsAlloc(alloc);
defer std.process.argsFree(alloc, args);
const stdout_file = std.io.getStdOut().writer();
var bw = std.io.bufferedWriter(stdout_file);
const stdout = bw.writer();
defer bw.flush() catch unreachable; // don't forget to flush!
// If we have stdin redirected, we want to process that before
// we take command line options. So cli will overwrite any lines specified
// from the file
const stdin_file = std.io.getStdIn();
var stdin_data: [display.WIDTH * display.HEIGHT + 1]u8 = undefined;
// Need this to support deallocation of memory
var line_inx: usize = 0;
var stdin_lines: [display.LINES][:0]u8 = undefined;
defer {
for (0..line_inx) |i| {
alloc.free(stdin_lines[i]);
}
}
var nothing: [:0]u8 = @constCast("");
for (lines, 0..) |_, i| {
lines[i] = &nothing;
}
if (!stdin_file.isTty()) {
const read = try stdin_file.readAll(&stdin_data);
if (read == stdin_data.len) {
try std.io.getStdErr().writer().print("ERROR: data provided exceeds what can be sent to device!\n", .{});
try usage(args);
}
var read_data = stdin_data[0..read];
var it = std.mem.split(u8, read_data, "\n");
while (it.next()) |line| {
if (line.len == 0) continue;
stdin_lines[line_inx] = try alloc.dupeZ(u8, line);
lines[line_inx] = &stdin_lines[line_inx];
line_inx += 1;
}
}
std.debug.print("delme: {s}\n", .{lines[0].*});
const opts = try processArgs(alloc, args, &lines);
defer alloc.destroy(opts);
if (opts.background_filename.len > 0) try stdout.print("Converting {s}\n", .{opts.background_filename});
var pixels: [display.WIDTH * display.HEIGHT]u8 = undefined;
try convertImage(opts.background_filename, &pixels, textForLine);
try bw.flush();
// We should take the linux device file here, then inspect for ttyUSB vs
// i2c whatever and do the right thing from there...
try sendPixels(&pixels, opts.device_file, 0x3c);
// try stdout.print("Run `zig build test` to run the tests.\n", .{});
}
fn processArgs(allocator: std.mem.Allocator, args: [][:0]u8, line_array: *[display.LINES]*const [:0]u8) !*Options {
if (args.len < 2) try usage(args);
const prefix = "/dev/ttyUSB";
var opts = try allocator.create(Options);
opts.device_file = args[1];
if (!std.mem.eql(u8, opts.device_file, "-") and !std.mem.startsWith(u8, opts.device_file, prefix)) try usage(args);
opts.background_filename = @constCast("");
var is_filename = false;
var line_number: ?usize = null;
for (args[1..], 1..) |arg, i| {
if (std.mem.eql(u8, "-bg", arg)) {
is_filename = true;
continue;
}
if (is_filename) {
opts.background_filename = args[i]; // arg capture changes value...
break;
}
if ((arg[0] == '-' and arg.len > 1) and areDigits(arg[1..])) {
line_number = try std.fmt.parseInt(usize, arg[1..], 10);
continue;
}
if (line_number) |line| {
if (arg.len > display.CHARS_PER_LINE) {
try std.io.getStdErr().writer().print(
"ERROR: text for line {d} has {d} chars, exceeding maximum length {d}\n",
.{ line, arg.len, display.CHARS_PER_LINE },
);
std.os.exit(1);
}
std.log.debug("line {d} text: \"{s}\"\n", .{ line, arg });
line_array.*[line] = &args[i];
line_number = null;
continue;
}
}
return opts;
}
fn areDigits(bytes: []u8) bool {
for (bytes) |byte| {
if (!std.ascii.isDigit(byte)) return false;
}
return true;
}
fn sendPixels(pixels: []const u8, file: [:0]const u8, device_id: u8) !void {
if (std.mem.eql(u8, file, "-"))
return sendPixelsToStdOut(pixels);
if (@import("builtin").os.tag != .linux)
@compileError("Linux only please!");
const is_i2cdriver = std.mem.startsWith(u8, file, "/dev/ttyUSB");
if (is_i2cdriver)
return sendPixelsThroughI2CDriver(pixels, file, device_id);
// Send through linux i2c native
return error.LinuxNativeNotImplemented;
}
fn sendPixelsToStdOut(pixels: []const u8) !void {
const stdout_file = std.io.getStdOut().writer();
var bw = std.io.bufferedWriter(stdout_file);
const stdout = bw.writer();
defer bw.flush() catch unreachable; // don't forget to flush!
for (0..display.HEIGHT) |i| {
try stdout.print(
"{d:0>2}: {s}\n",
.{ i, fmtSliceGreyscaleImage(pixels[(i * display.WIDTH)..((i + 1) * display.WIDTH)]) },
);
}
}
fn sendPixelsThroughI2CDriver(pixels: []const u8, file: [*:0]const u8, device_id: u8) !void {
var pixels_write_command = [_]u8{0x00} ** ((display.WIDTH * display.PAGES) + 1);
pixels_write_command[0] = 0x40;
packPixelsToDeviceFormat(pixels, pixels_write_command[1..]);
var i2c = c.I2CDriver{
.connected = 0,
.port = 0,
.model = [_]u8{0} ** 16,
.serial = [_]u8{0} ** 9,
.uptime = 0.0,
.voltage_v = 0.0,
.current_ma = 0.0,
.temp_celsius = 0.0,
.mode = 0,
.sda = 0,
.scl = 0,
.speed = 0,
.pullups = 0,
.ccitt_crc = 0,
.e_ccitt_crc = 0,
};
const c_file = @ptrCast([*c]const u8, file);
const stdout_file = std.io.getStdOut().writer();
var bw = std.io.bufferedWriter(stdout_file);
const stdout = bw.writer();
defer bw.flush() catch unreachable; // don't forget to flush!
try stdout.print("Connecting to I2CDriver on {s}. If progress stalls, unplug device and re-insert.\n", .{c_file});
try bw.flush();
try stdout.print("Sending pixels to display...", .{});
c.i2c_connect(&i2c, c_file);
try stdout.print("Device connected\n", .{});
if (i2c.connected != 1) return error.I2CConnectionFailed;
// Initialize the device
if (c.i2c_start(&i2c, device_id, 0) != 1) // 0 for write, 1 for read. Seems to be a mask
return error.I2CStartFailed;
try i2cWrite(&i2c, &[_]u8{ 0x00, 0x8d, 0x14 }); // Enable charge pump
// Charge pump takes a few ms so let's do some other stuff in the meantime
try i2cWrite(&i2c, &[_]u8{ 0x00, 0x20, 0x00 }); // Horizontal addressing mode
try i2cWrite(&i2c, &[_]u8{ 0x00, 0x21, 0x00, 0x7F }); // Start column 0, end column 127
try i2cWrite(&i2c, &[_]u8{ 0x00, 0x22, 0x00, 0x07 }); // Start page 0, end page 7
try i2cWrite(&i2c, &[_]u8{ 0x00, 0xaf }); // Display on (should this be after our image is written?
// We stop/start here since otherwise it seems our data goes nowhere. Not
// sure it's actually our problem but this seems to fix it
c.i2c_stop(&i2c);
if (c.i2c_start(&i2c, device_id, 0) != 1) // 0 for write, 1 for read. Seems to be a mask
return error.I2CStartFailed;
// Write data to device
try i2cWrite(&i2c, &pixels_write_command);
// Leaving this here because we'll need it later I think
// for (0..HEIGHT) |i| {
// std.log.debug("{d:0>2}: {s}\n", .{ i, fmtSliceGreyscaleImage(pixels[(i * WIDTH)..((i + 1) * WIDTH)]) });
// }
try stdout.print("done\n", .{});
}
fn packPixelsToDeviceFormat(pixels: []const u8, packed_pixels: []u8) void {
// Each u8 in pixels is a single bit. We need to pack these bits
for (packed_pixels, 0..) |*b, i| {
const column = i % display.WIDTH;
const page = i / display.WIDTH;
// if (column == 0) std.debug.print("{d}: ", .{page});
// pixel array will be 8x as "high" as the data array we are sending to
// the device. So the device column above is only our starter
// Display has 8 pages, which is a set of 8 pixels with LSB at top of page
//
// To convert from the pixel array above, we need to:
// 1. convert from device page to a base "row" in the pixel array
const row = page * display.PAGES;
// 2. We will have 8 rows for each base row
// 3. Multiple each row by the width to get the index of the start of
// the row
// 4. Add our current column index for the final pixel location in
// the pixel array.
//
// Now that we have the proper index in the pixel array, we need to
// convert that into our destination byte. Each index will be a u8, either
// 0xff for on or 0x00 for off. So...
//
// 1. We will take the value and bitwise and with 0x01 so we get one bit
// per source byte
// 2. Shift that bit into the proper position in our destination byte
b.* = (pixels[(0 + row) * display.WIDTH + column] & 0x01) << 0 |
(pixels[(1 + row) * display.WIDTH + column] & 0x01) << 1 |
(pixels[(2 + row) * display.WIDTH + column] & 0x01) << 2 |
(pixels[(3 + row) * display.WIDTH + column] & 0x01) << 3 |
(pixels[(4 + row) * display.WIDTH + column] & 0x01) << 4 |
(pixels[(5 + row) * display.WIDTH + column] & 0x01) << 5 |
(pixels[(6 + row) * display.WIDTH + column] & 0x01) << 6 |
(pixels[(7 + row) * display.WIDTH + column] & 0x01) << 7;
// std.debug.print("{s}", .{std.fmt.fmtSliceHexLower(&[_]u8{b.*})});
// if (column == 127) std.debug.print("\n", .{});
// Last 2 pages are yellow...16 pixels vertical
// if (page == 6 or page == 7) b.* = 0xff;
// b.* = 0xf0;
}
}
fn i2cWrite(i2c: *c.I2CDriver, bytes: []const u8) !void {
var rc = c.i2c_write(i2c, @ptrCast([*c]const u8, bytes), bytes.len); // nn is size of array
if (rc != 1)
return error.BadWrite;
}
fn fmtSliceGreyscaleImage(bytes: []const u8) std.fmt.Formatter(formatSliceGreyscaleImage) {
return .{ .data = bytes };
}
fn formatSliceGreyscaleImage(
bytes: []const u8,
comptime fmt: []const u8,
options: std.fmt.FormatOptions,
writer: anytype,
) !void {
_ = fmt;
_ = options;
for (bytes) |b| {
switch (b) {
0xff => try writer.writeByte('1'),
0x00 => try writer.writeByte('0'),
else => unreachable,
}
}
}
fn reportMagickError(mw: ?*c.MagickWand) !void {
var severity: c.ExceptionType = undefined;
var description = c.MagickGetException(mw, &severity);
defer description = @ptrCast([*c]u8, c.MagickRelinquishMemory(description));
try std.io.getStdErr().writer().print("{s}\n", .{description});
}
fn textForLine(line: usize) []u8 {
return lines[line].*;
}
fn convertImage(filename: [:0]u8, pixels: *[display.WIDTH * display.HEIGHT]u8, text_fn: *const fn (usize) []u8) !void {
c.MagickWandGenesis();
defer c.MagickWandTerminus();
var mw = c.NewMagickWand();
defer {
if (mw) |w| mw = c.DestroyMagickWand(w);
}
// Reading an image into ImageMagick is problematic if it isn't a bmp
// as the library needs a bunch of dependencies available
var status: c.MagickBooleanType = undefined;
if (filename.len > 0) {
status = c.MagickReadImage(mw, filename);
} else {
// TODO: if there is no background image AND
// we precompute monochrome bit patterns for our font
// we can completely avoid ImageMagick here. Even with
// a background we can do the conversion, then do our
// own text overlay after monochrome conversion.
// Faster and smaller binary (maybe multi-font support?)
const blob = @embedFile("images/blank.bmp");
status = c.MagickReadImageBlob(mw, blob, blob.len);
}
if (status == c.MagickFalse) {
if (!std.mem.eql(u8, filename[filename.len - 3 ..], "bmp"))
try std.io.getStdErr().writer().print("File is not .bmp. That is probably the problem\n", .{});
try reportMagickError(mw);
return error.CouldNotReadImage;
}
// Get height and width of the image
const w = c.MagickGetImageWidth(mw);
const h = c.MagickGetImageHeight(mw);
std.log.debug("Original dimensions: {d}x{d}\n", .{ w, h });
// This should be 48x64 with our test
// Command line resize works differently than this. Here we need to find
// new width and height based on the input aspect ratio ourselves
const resize_dimensions = getNewDimensions(w, h, display.WIDTH, display.HEIGHT);
std.log.debug("Dimensions for resize: {d}x{d}\n", .{ resize_dimensions.width, resize_dimensions.height });
status = c.MagickResizeImage(mw, resize_dimensions.width, resize_dimensions.height, c.UndefinedFilter);
if (status == c.MagickFalse)
return error.CouldNotResizeImage;
var pw = c.NewPixelWand();
defer {
if (pw) |pixw| pw = c.DestroyPixelWand(pixw);
}
status = c.PixelSetColor(pw, "white");
if (status == c.MagickFalse)
return error.CouldNotSetColor;
status = c.MagickSetImageBackgroundColor(mw, pw);
if (status == c.MagickFalse)
return error.CouldNotSetBackgroundColor;
// This centers the original image on the new canvas.
// Note that the extent's offset is relative to the
// top left corner of the *original* image, so adding an extent
// around it means that the offset will be negative
status = c.MagickExtentImage(
mw,
display.WIDTH,
display.HEIGHT,
-@intCast(isize, (display.WIDTH - resize_dimensions.width) / 2),
-@intCast(isize, (display.HEIGHT - resize_dimensions.height) / 2),
);
if (status == c.MagickFalse)
return error.CouldNotSetExtent;
for (0..display.LINES) |i| {
const text = text_fn(i);
if (text.len == 0) continue;
// We have text!
const y: isize = display.FONT_HEIGHT * @intCast(isize, i);
var x: isize = display.BORDER_LEFT;
var left_spaces: isize = 0;
for (text) |ch| {
if (ch == ' ') {
left_spaces += 1;
continue;
}
break;
}
x += (display.FONT_WIDTH * left_spaces);
mw = try drawString(mw, text[@intCast(usize, left_spaces)..], x, y);
}
// We make the image monochrome by quantizing the image with 2 colors in the
// gray colorspace. See:
// https://www.imagemagick.org/Usage/quantize/#monochrome
// and
// https://stackoverflow.com/questions/18267432/using-the-c-api-for-imagemagick-on-iphone-to-convert-to-monochrome
//
// We do this at the end so we have pure black and white. Otherwise the
// resizing oprations will generate some greyscale that we don't want
status = c.MagickQuantizeImage(mw, // MagickWand
2, // Target number colors
c.GRAYColorspace, // Colorspace
1, // Optimal depth
c.MagickTrue, // Dither
c.MagickFalse // Quantization error
);
if (status == c.MagickFalse)
return error.CouldNotQuantizeImage;
status = c.MagickExportImagePixels(mw, 0, 0, display.WIDTH, display.HEIGHT, "I", c.CharPixel, @ptrCast(*anyopaque, pixels));
if (status == c.MagickFalse)
return error.CouldNotExportImage;
for (0..display.WIDTH * display.HEIGHT) |i| {
switch (pixels[i]) {
0x00 => pixels[i] = 0xFF,
0xFF => pixels[i] = 0x00,
else => {},
}
}
}
fn drawString(mw: ?*c.MagickWand, str: []const u8, x: isize, y: isize) !?*c.MagickWand {
var rc = mw;
for (str, 0..) |ch, i| {
rc = try drawCharacter(
rc,
ch,
-(x + @intCast(isize, display.FONT_WIDTH * i)),
-y,
);
}
return rc;
}
fn drawCharacter(mw: ?*c.MagickWand, char: u8, x: isize, y: isize) !?*c.MagickWand {
// Create a second wand. Does this need to exist after the block?
var cw = c.NewMagickWand();
defer {
if (cw) |dw| cw = c.DestroyMagickWand(dw);
// if (merged) |mergeme| {
// _ = c.DestroyMagickWand(mw);
// mw = mergeme;
// }
}
const image_char = chars[char];
if (image_char.len == 0) return error.CharacterNotSupported;
var status = c.MagickReadImageBlob(cw, @ptrCast(?*const anyopaque, image_char), image_char.len);
if (status == c.MagickFalse) unreachable; // Something is terribly wrong if this fails
// For character placement, we need to set the image to the correct
// extent, and offset the image as appropriate. When we set the extent,
// we need the fill background to be transparent so we don't overwrite
// the background. This also means our font needs a transparent background
// (maybe?)
{
var pwc = c.NewPixelWand();
defer {
if (pwc) |pixwc| pwc = c.DestroyPixelWand(pixwc);
}
status = c.PixelSetColor(pwc, "transparent");
if (status == c.MagickFalse)
return error.CouldNotSetColor;
status = c.MagickSetImageBackgroundColor(cw, pwc);
if (status == c.MagickFalse)
return error.CouldNotSetBackgroundColor;
// I think our characters are offset by 6px in the x and 8 in the y
status = c.MagickExtentImage(
cw,
display.WIDTH,
display.HEIGHT,
x,
y,
);
if (status == c.MagickFalse)
return error.CouldNotSetExtent;
}
// I think I need to add the image, then flatten this
status = c.MagickAddImage(mw, cw);
if (status == c.MagickFalse) return error.CouldNotAddImage;
// This works, but idk exactly what it's doing. I get the sense
// I this only works with two images...
// c.MagickResetIterator(mw);
c.MagickSetFirstIterator(mw);
defer {
if (mw) |w| _ = c.DestroyMagickWand(w);
}
return c.MagickMergeImageLayers(mw, c.FlattenLayer);
}
const Dimensions = struct {
width: usize,
height: usize,
};
fn getNewDimensions(width: usize, height: usize, desired_width: usize, desired_height: usize) Dimensions {
// assuming we're shrinking for now.
// TODO: Handle expansion
const width_ratio = @intToFloat(f64, width) / @intToFloat(f64, desired_width);
const height_ratio = @intToFloat(f64, height) / @intToFloat(f64, desired_height);
const resize_ratio = if (width_ratio > height_ratio) width_ratio else height_ratio;
return .{
.width = @floatToInt(usize, @intToFloat(f64, width) / resize_ratio), // 48,
.height = @floatToInt(usize, @intToFloat(f64, height) / resize_ratio), // 64,
};
}
test "gets correct bytes" {
const bg_file: [:0]u8 = @constCast("logo:");
const opts = .{ .background_filename = bg_file, .device_file = "-" };
var empty: [:0]u8 = @constCast("");
for (&lines) |*line| {
line.* = &empty;
}
var line: [:0]u8 = @constCast("Hello\\!");
lines[5] = &line;
var pixels: [display.WIDTH * display.HEIGHT]u8 = undefined;
var expected_pixels: *const [display.WIDTH * display.HEIGHT]u8 = @embedFile("testExpectedBytes.bin");
// [_]u8{..,..,..}
try convertImage(opts.background_filename, &pixels, textForLine);
// try writeBytesToFile("testExpectedBytes.bin", &pixels);
try std.testing.expectEqualSlices(u8, expected_pixels, &pixels);
}
fn writeBytesToFile(filename: []const u8, bytes: []u8) !void {
const file = try std.fs.cwd().createFile(filename, .{
.read = false,
.truncate = true,
.lock = .Exclusive,
.lock_nonblocking = false,
.mode = 0o666,
.intended_io_mode = .blocking,
});
defer file.close();
const writer = file.writer();
try writer.writeAll(bytes);
// try writer.print("pub const chars = &[_][]const u8{{\n", .{});
}
test "simple test" {
var list = std.ArrayList(i32).init(std.testing.allocator);
defer list.deinit(); // try commenting this out and see if zig detects the memory leak!
try list.append(42);
try std.testing.expectEqual(@as(i32, 42), list.pop());
}
Reference in a new issue View git blame Copy permalink