move frame buffer cursor using tv remote controller

Author: markfirmware

README.md

@@ -1,5 +1,20 @@
 zig logo is displayed
 
+The frame buffer cursor moves around the screen in response to the tv remote controller buttons. This requires a Cosumer Electronics Control (CEC) on the tv.
+
 Successfully tested on rpi3b, rpi3b+
 
 Not yet working on armv6 raspberry pi models
+
+Building
+--------
+
+Requires the following patch to lib/zig/std/fmt.zig:
+
+replace
+
+    const digit = a % base;
+
+with
+    const digit = a - base * (a / base);
+

build.zig

@@ -4,8 +4,8 @@ const builtin = @import("builtin");
 
 pub fn build(b: *Builder) void {
     const mode = b.standardReleaseOptions();
-    const want_armv6 = b.option(bool, "armv6", "Build armv6 instead of armv7 (armv7 is default)") orelse false;
-    const want_armv7 = b.option(bool, "armv7", "Build armv7 instead of armv6 (armv7 is default)") orelse false;
+    const want_armv6 = b.option(bool, "armv6", "Build armv6") orelse false;
+    const want_armv7 = b.option(bool, "armv7", "Build armv7 (default)") orelse false;
 
     const exec_name = "zig-bare-metal-raspberry-pi";
     const exe = b.addExecutable(exec_name, "src/main.zig");
@@ -26,11 +26,9 @@ pub fn build(b: *Builder) void {
     }
     const os = builtin.Os.freestanding;
     const environ = builtin.Abi.eabihf;
-    exe.setTarget(arch, builtin.Os.freestanding, environ);
+    exe.setTarget(arch, os, environ);
     exe.addBuildOption(u32, "subarch", subarch);
-
-    const linker_script = "src/linker.ld";
-    exe.setLinkerScriptPath(linker_script);
+    exe.setLinkerScriptPath("src/linker.ld");
 
     const run_objcopy = b.addSystemCommand([_][]const u8{
         "llvm-objcopy-6.0", exe.getOutputPath(),

release-message.md

@@ -14,4 +14,5 @@
 * connect the pi to the tv using the hdmi cable
 * turn on the tv
 * apply power to the pi
-* you should see the zig logo displayed along a changing banner of colored lines
+* you should see the zig logo displayed along with a changing banner of colored lines
+* if your tv has CEC (Consumer Electronics Control) then the frame buffer cursor will move in response to tv remote controller buttons

src/arm_assembly_code.zig

@@ -8,15 +8,11 @@ pub fn panicf(comptime fmt: []const u8, args: ...) noreturn {
     }
     already_panicking = true;
 
-    serial.log("panic: " ++ fmt, args);
+    serial.log("\npanic: " ++ fmt, args);
     hang("panic completed");
 }
 
-pub fn io(offset: u32) *volatile u32 {
-    return @intToPtr(*volatile u32, PERIPHERAL_BASE + offset);
-}
-
-pub fn ioStruct(comptime StructType: type, offset: u32) *volatile StructType {
+pub fn io(comptime StructType: type, offset: u32) *volatile StructType {
     return @intToPtr(*volatile StructType, PERIPHERAL_BASE + offset);
 }
 
@@ -97,6 +93,25 @@ pub fn setVectorBaseAddressRegister(address: u32) void {
     );
 }
 
+pub fn cntpct32() u32 {
+    return asm("mrrc p15, 0, %[cntpct_low], r1, c14"
+        : [cntpct_low] "=r" (-> usize)
+        :
+        : "r1");
+}
+
+var last_low: u32 = 0;
+var overflow: u32 = 0;
+pub fn seconds() u32 {
+    const frequency = 1*1000*1000;
+    const low = cntpct32();
+    if (low < last_low) {
+        overflow += 0xffffffff / frequency;
+    }
+    last_low = low;
+    return low / frequency + overflow;
+}
+
 // The linker will make the address of these global variables equal
 // to the value we are interested in. The memory at the address
 // could alias any uninitialized global variable in the kernel.

src/gpio.zig

@@ -1,4 +1,4 @@
-pub fn setAlt5(pin_number: u32) void {
+pub fn useAsAlt5(pin_number: u32) void {
       setPinPull(pin_number, Pull.None);
       setPinFunction(pin_number, GPIO_FUNCTION_ALT5);
 }
@@ -65,7 +65,7 @@ const GPIO_MAX_PIN = 53;
 const GPFSEL0 = PERIPHERAL_BASE + 0x200000;
 const GPSET0 = PERIPHERAL_BASE + 0x20001C;
 const GPCLR0 = PERIPHERAL_BASE + 0x200028;
-const GPPUD = arm.io(0x200094);
+const GPPUD = arm.io(u32, 0x200094);
 const GPPUDCLK0 = PERIPHERAL_BASE + 0x200098;
 
 const Pull = enum {

src/linker.ld

@@ -6,7 +6,7 @@ SECTIONS {
     .text : ALIGN(4K) {
         KEEP(*(.text.boot))
         . = 0x1000;
-        KEEP(*(.text.exception_vector_table_at_0x1000))
+        KEEP(*(.text.exception_vector_table))
         __end_init = .;
         *(.text)
     }

src/main.zig

@@ -17,33 +17,26 @@ export fn kernelMain() noreturn {
     arm.setBssToZero();
 
     serial.init();
-    serial.log("\n{} {} ...", name, release_tag);
+    log("\n{} {} ...", name, release_tag);
 
     fb.init();
-    serial.log("drawing logo ...");
+    log("drawing logo ...");
     var logo: Bitmap = undefined;
     var logo_bmp_file align(@alignOf(u32)) = @embedFile("../assets/zig-logo.bmp");
     logo.init(&fb, &logo_bmp_file);
     logo.drawRect(logo.width, logo.height, 0, 0, 0, 0);
 
     screen_activity.init(logo.width, logo.height);
     serial_activity.init();
+    vchi_activity.init();
 
     while (true) {
         screen_activity.update();
         serial_activity.update();
+        vchi_activity.update();
     }
 }
 
-fn hex(message :[] const u8, x: u32) void {
-    var buf: [8]u8 = undefined;
-    for (buf) |_, i| {
-        const digit: u8 = @intCast(u8, (x >> @intCast(u5, (buf.len - 1 - i) * 4)) & 0xF);
-        buf[i] = if (digit < 9) digit + '0' else digit - 10 + 'A';
-    }
-    serial.log("0x{} {}", buf, message);
-}
-
 const ScreenActivity = struct {
     width: u32,
     height: u32,
@@ -64,8 +57,11 @@ const ScreenActivity = struct {
     }
 
     fn update (self: *ScreenActivity) void {
-        fb.drawPixel32(self.x, self.y, self.color32);
-        self.x += 1;
+        var batch: u32 = 0;
+        while (batch < 20 and self.x < self.width) : (batch += 1) {
+            fb.drawPixel32(self.x, self.y, self.color32);
+            self.x += 1;
+        }
         if (self.x == self.width) {
             self.x = 0;
             self.y += 1;
@@ -87,7 +83,7 @@ const ScreenActivity = struct {
 
 const SerialActivity = struct {
     fn init(self: *SerialActivity) void {
-        serial.log("now echoing input on uart1 ...");
+        log("now echoing input on uart1 ...");
     }
 
     fn update(self: *SerialActivity) void {
@@ -98,11 +94,60 @@ const SerialActivity = struct {
         switch (byte) {
             '!' => {
                 var x = @intToPtr(*u32, 2).*;
+                log("ok {x}", x);
             },
             '\r' => {
                 serial.writeText("\n");
             },
-            else => serial.writeByte(byte),
+            else => serial.writeByteBlocking(byte),
+        }
+    }
+};
+
+const VchiActivity = struct {
+    vchi: Vchi,
+    cursor_x: u32,
+    cursor_y: u32,
+
+    fn init(self: *VchiActivity) void {
+        self.vchi.init();
+        self.cursor_x = fb.physical_width / 2;
+        self.cursor_y = fb.physical_height / 2;
+        fb.moveCursor(self.cursor_x, self.cursor_y);
+        self.vchi.cecOpenNotificationService();
+    }
+
+    fn update(self: *VchiActivity) void {
+        while (self.vchi.wasButtonPressedReceived()) {
+            const button_code = self.vchi.receiveButtonPressedBlocking();
+            var dx: i32 = 0;
+            var dy: i32 = 0;
+            const delta = switch (button_code) {
+                0x01 => {
+                    dy = -1;
+                },
+                0x02 => {
+                    dy = 1;
+                },
+                0x03 => {
+                    dx = -1;
+                },
+                0x04 => {
+                    dx = 1;
+                },
+                else => {
+                },
+            };
+            const scale = 64;
+            const x = @intCast(i32, self.cursor_x) + dx * scale;
+            if (x > 0 and x < @intCast(i32, fb.physical_width) - 1) {
+                self.cursor_x = @intCast(u32, x);
+            }
+            const y = @intCast(i32, self.cursor_y) + dy * scale;
+            if (y > 0 and y < @intCast(i32, fb.physical_height) - 1) {
+                self.cursor_y = @intCast(u32, y);
+            }
+            fb.moveCursor(self.cursor_x, self.cursor_y);
         }
     }
 };
@@ -133,10 +178,8 @@ comptime {
         \\ cps #0x1f // enter system mode
         \\ mov sp,#0x08000000
         \\ bl kernelMain
-    );
-
-    asm(
-        \\.section .text.exception_vector_table_at_0x1000
+        \\
+        \\.section .text.exception_vector_table
         \\.balign 0x80
         \\exception_vector_table:
         \\ b exceptionEntry0x00
@@ -183,23 +226,23 @@ export fn exceptionEntry0x07() noreturn {
 }
 
 fn exceptionHandler(entry: u32) noreturn {
-    serial.log("arm exception taken");
-    hex("vector", entry);
-    hex("spsr", arm.spsr());
-    hex("cpsr", arm.cpsr());
-    hex("scr", arm.scr());
-    hex("sp", arm.sp());
-    hex("sctlr", arm.sctlr());
+    log("arm exception taken");
+    log("entry {}", entry);
+    log("spsr  0x{x}", arm.spsr());
+    log("cpsr  0x{x}", arm.cpsr());
+    log("sp    0x{x}", arm.sp());
+    log("sctlr 0x{x}", arm.sctlr());
     arm.hang("execution is now stopped in arm exception handler");
 }
 
 pub fn panic(message: []const u8, trace: ?*builtin.StackTrace) noreturn {
     panicf("main.zig pub fn panic(): {}", message);
 }
 
+var fb: FrameBuffer = undefined;
 var screen_activity: ScreenActivity = undefined;
 var serial_activity: SerialActivity = undefined;
-var fb: FrameBuffer = undefined;
+var vchi_activity: VchiActivity = undefined;
 
 const margin = 10;
 
@@ -210,15 +253,16 @@ const color_yellow = Color{ .red = 255, .green = 255, .blue = 0, .alpha = 255 };
 const color_white = Color{ .red = 255, .green = 255, .blue = 255, .alpha = 255 };
 
 const name = "zig-bare-metal-raspberry-pi";
-const release_tag = "0.1";
+const release_tag = "0.2";
 
 const arm = @import("arm_assembly_code.zig");
 const build_options = @import("build_options");
 const builtin = @import("builtin");
 const Bitmap = @import("video_core_frame_buffer.zig").Bitmap;
 const Color = @import("video_core_frame_buffer.zig").Color;
 const FrameBuffer = @import("video_core_frame_buffer.zig").FrameBuffer;
-const gpio2 = @import("gpio2.zig");
+const log = serial.log;
 const panicf = arm.panicf;
 const serial = @import("serial.zig");
 const std = @import("std");
+const Vchi = @import("video_core_vchi.zig").Vchi;