denko 0.13.5 → 0.14.0

data/examples/advanced/{m5_env.rb → m5_env3.rb}

@@ -4,28 +4,26 @@
 #
 require 'bundler/setup'
 require 'denko'
+require_relative '../sensor/neat_tph_readings'
+
+# How many degrees C the two temperature values can differ by before a warning.
+TOLERANCE = 0.50
 
 board = Denko::Board.new(Denko::Connection::Serial.new)
-bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
-sht = Denko::Sensor::SHT3X.new(bus: bus) # address: 0x44 default
-qmp = Denko::Sensor::QMP6988.new(bus: bus) # address: 0x70 default
+bus   = Denko::I2C::Bus.new(board: board)
+sht   = Denko::Sensor::SHT3X.new(bus: bus)   # address: 0x44 default
+qmp   = Denko::Sensor::QMP6988.new(bus: bus) # address: 0x70 default
 
 # Configure for higher accuracy.
-sht.repeatability = :high
+sht.repeatability       = :high
 qmp.temperature_samples = 2
-qmp.pressure_samples = 16
-qmp.iir_coefficient = 2
+qmp.pressure_samples    = 16
+qmp.iir_coefficient     = 2
 
 # Buggy on ESP32-S3 in forced mode. Data registers return zeroes on all but first read.
 # Can't recreate on ESP32 V1, AVR or SAMD21. Put it in contiuous mode just in case.
 qmp.continuous_mode
 
-# Get the shared #print_tph_reading method to print readings neatly.
-require_relative '../sensor/neat_tph_readings'
-
-# How many degrees C the two temperature values can differ by before a warning.
-TOLERANCE = 0.50
-
 loop do
   # Read both sensors.
   qmp_reading = qmp.read
@@ -33,11 +31,11 @@ loop do
 
   # Retry immediately if either failed.
   next unless (sht_reading && qmp_reading)
-  
+
   # Warn if large gap between temperature readings.
   difference = (qmp_reading[:temperature] - sht_reading[:temperature]).abs
   if (difference > TOLERANCE)
-    puts "WARNING: temperature values differed by more than #{TOLERANCE}\xC2\xB0C (#{difference.round(4)} \xC2\xB0C actual)"
+    puts "WARNING: temperature values differed by more than #{TOLERANCE}\xC2\xB0C (#{difference.round(4)} \xC2\xB0C)"
   end
 
   # Combine values from both sensors, averaging their temperatures.

data/examples/advanced/rotary_encoder_mac_volume.rb

@@ -1,14 +1,15 @@
 #
-# Example using a rotary encoder to control audio output volume on a Mac.
+# Example using a KY-040 (30 detent) rotary encoder as a mac volume control.
 #
 require 'bundler/setup'
 require 'denko'
 
-board = Denko::Board.new(Denko::Connection::Serial.new)
+PIN_A = 4
+PIN_B = 5
+
+board   = Denko::Board.new(Denko::Connection::Serial.new)
 encoder = Denko::DigitalIO::RotaryEncoder.new  board: board,
-                                              pins:{ clock: 4, data: 5 },
-                                              divider: 1,                # (default) read approx every divider ms
-                                              steps_per_revolution: 30   # (default)
+                                               pins:  { a: PIN_A, b: PIN_B }
 
 # Set up a pseudo terminal with osascript (AppleScript) in interactive mode.
 # Calling a separate script each update is too slow.
@@ -32,16 +33,20 @@ class AppleVolumeWrapper
   end
 end
 
-volume = AppleVolumeWrapper.new
-puts "Current volume: #{volume.get}%"
+volumeWrapper= AppleVolumeWrapper.new
+# volumeWrapper.get can return imprecise values.
+# Display those, but keep exact value in this variable.
+volume = volumeWrapper.get
+puts "Current volume: #{volume}%"
 
 encoder.add_callback do |update|
-  # Increase by 2% for every step so it responds faster.
-  value = (volume.get + (update[:change] * 2))
-  value = 0 if value < 0
-  value = 100 if value > 100
-  volume.set(value)
-  current_volume = volume.get
+  # update[:change] is always either +1 or -1.
+  volume = volume += update[:change]
+  volume = 0 if volume < 0
+  volume = 100 if volume > 100
+
+  volumeWrapper.set(volume)
+  current_volume = volumeWrapper.get
   puts "Current volume: #{current_volume}%"
 end
 

data/examples/advanced/ssd1306_time_temp_rh.rb

@@ -8,17 +8,16 @@ require 'bundler/setup'
 require 'denko'
 
 board = Denko::Board.new(Denko::Connection::Serial.new)
-i2c = Denko::I2C::Bus.new(board: board, pin: :SDA)
+i2c   = Denko::I2C::Bus.new(board: board)
 
 # Get temperature and humidity every second.
 htu21d = Denko::Sensor::HTU21D.new(bus: i2c)
-htu21d.temperature.poll(1)
-htu21d.humidity.poll(1)
+htu21d.poll(2)
 
-oled = Denko::Display::SSD1306.new(bus: i2c, rotate: true)
+oled   = Denko::Display::SSD1306.new(bus: i2c, rotate: true)
 canvas = oled.canvas
-last_refresh = Time.now
 
+last_refresh = Time.now
 loop do
   elapsed = Time.now - last_refresh
 
@@ -29,15 +28,11 @@ loop do
     canvas.text_cursor = [0,0]
     canvas.print "Time:  #{Time.now.strftime("%H:%M:%S.%L")}"
 
-    if htu21d[:temperature]
-      canvas.text_cursor = [0,8]
-      canvas.print "Temp:     " + ('%.3f' % htu21d[:temperature]).rjust(7, " ") + " C"
-    end
+    canvas.text_cursor = [0,8]
+    canvas.print "Temp:     " + ('%.3f' % htu21d.temperature).rjust(7, " ") + " C"
 
-    if htu21d[:humidity]
-      canvas.text_cursor = [0,16]
-      canvas.print "Humidity: " + ('%.3f' % htu21d[:humidity]).rjust(7, " ") + " %"
-    end
+    canvas.text_cursor = [0,16]
+    canvas.print "Humidity: " + ('%.3f' % htu21d.humidity).rjust(7, " ") + " %"
 
     # Only refresh the area in use.
     oled.draw(0, 127, 0, 24)

data/examples/analog_io/ads1100.rb

@@ -0,0 +1,48 @@
+#
+# Example using an ADS1100 ADC over the I2C bus.
+#
+require 'bundler/setup'
+require 'denko'
+
+# Helper method so readings look nice.
+def print_reading(name, raw, voltage)
+  print "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - "
+  print "#{name.rjust(9, " ")} | "
+  print "Raw: #{raw.to_s.rjust(6, " ")} | "
+  print "Voltage: "
+  print ("%.10f" % voltage).rjust(13, " ")
+  puts " V"
+end
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+bus   = Denko::I2C::Bus.new(board: board)
+
+# Unlike the ADS1115/1118, full-scale voltage depends on Vdd. Give during setup.
+# This works for my M5Stack ADC unit (0-12V) when checked against a multimeter.
+ads = Denko::AnalogIO::ADS1100.new  bus: bus,
+                                    full_scale_voltage: 26.408,
+                                    sample_rate: 16,
+                                    gain: 2
+                                    # address: 0x48 default
+
+#
+# Configure gain and sample rate. See datasheet for more info.
+# Valid values:
+#   Gain:         1 (default), 2,  4,  8
+#   Sample Rate:  8 (default), 16, 32, 128
+#
+ads.gain        = 1
+ads.sample_rate = 8
+
+# Configure smoothing.
+ads.smoothing       = true
+ads.smoothing_size  = 8
+
+# Poll and print indefinitely.
+ads.poll(0.25) do |reading|
+  # volts_per_bit calculated from full-scale voltage, gain and sample rate.
+  voltage = reading * ads.volts_per_bit
+  print_reading("ADS1100:", reading, voltage)
+end
+
+sleep

data/examples/analog_io/ads1115.rb

@@ -5,8 +5,8 @@ require 'bundler/setup'
 require 'denko'
 
 board = Denko::Board.new(Denko::Connection::Serial.new)
-bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
-ads = Denko::AnalogIO::ADS1115.new(bus: bus)
+bus   = Denko::I2C::Bus.new(board: board)
+ads   = Denko::AnalogIO::ADS1115.new(bus: bus)
 
 # Helper method so readings look nice.
 def print_reading(name, raw, voltage)

data/examples/analog_io/ads1118.rb

@@ -5,16 +5,8 @@ require 'bundler/setup'
 require 'denko'
 
 board = Denko::Board.new(Denko::Connection::Serial.new)
-
-# Connect the ADS1118 pins to the board's default SPI pins.
-bus = Denko::SPI::Bus.new(board: board)
-
-# Or use a 2-way bit-bang SPI bus on any pins.
-# SPI_BIT_BANG_PINS   = { clock: 13, input: 12, output: 11 }
-# bus = Denko::SPI::BitBang.new(board: board, pins: SPI_BIT_BANG_PINS)
-
-# Connect chip select/enable pin of the ADS1118 to pin 9.
-ads = Denko::AnalogIO::ADS1118.new(bus: bus, pin: 9)
+bus   = Denko::SPI::Bus.new(board: board)
+ads   = Denko::AnalogIO::ADS1118.new(bus: bus, pin: 10)
 
 # Helper method so readings look nice.
 def print_reading(name, raw, voltage)
@@ -29,7 +21,7 @@ end
 #
 # Read the ADS1118 internal temperature sensor.
 # This always uses the 128 SPS mode, and there is no polling method for it.
-# 
+#
 temperature = ads.temperature_read
 puts "ADS1118 Temperature: #{temperature} \xC2\xB0C"
 puts

data/examples/analog_io/input.rb

@@ -1,32 +1,31 @@
 #
-# This example shows how to use your board's analog-to-digital-converter(ADC) pins,
-# through the AnalogIO::Input class. ADC inputs can be connected to sensors
-# which produce a variable output voltage, such as light dependent resistors,
-# or a simple temperature sensor like the TMP36.
+# Use your board's analog-to-digital-converter(ADC) pins with AnalogIO::Input.
+# ADC inputs can be connected to sensors that produce variable output voltage,
+# such as light dependent resistors, or a temperature sensor like the TMP36.
 #
 require 'bundler/setup'
 require 'denko'
 
+PIN = :A0
+
 board = Denko::Board.new(Denko::Connection::Serial.new)
-input = Denko::AnalogIO::Input.new(pin: :A0, board: board)
+input = Denko::AnalogIO::Input.new(pin: PIN, board: board)
 
-# Single read that blocks the main thread. When a value is received, the given
-# code block runs only once, and then the main thread continues.
+# Single read. Blocks main thread during read, then runs given block with the value.
 input.read { |value| puts "#{Time.now} Single read #1: #{value}" }
 
-# Read (poll) the input every half second. This happens in a separate thread, 
-# so sleep the main thread for a while to get some values.
-# Given code block is added as a callback, and runs every time a value is received.
+# Poll repeatedly does single reads, in a separate thread, with an interval in seconds.
+# Given block is saved as a callback, and runs each time a value is received.
 input.poll(0.5) { |value| puts "#{Time.now} Polling: #{value}" }
-sleep 3
 
-# Stop polling. Automatically removes the #poll callback.
+# Does not block main thread, so wait for some values.
+sleep 3
+# Stop polling, automatically removing callback from #poll.
 input.stop
 
-# Listening is similar to polling. The board reads the input and sends the value
-# every time interval, except it's keeping time. We only send the initial command,
-# not one for each read. Smaller intervals like 32 milliseconds are possible.
-# Powers of 2 from 1 to 128 are supported for listener intervals.
+# "Listening" is where the Board keeps time, reading the ADC at a small interval
+# and continuously sends values, until #stop is called.
+# Powers of 2 from 1 to 128 (in milliseconds) are supported for listener intervals.
 input.listen(32) { |value| puts "#{Time.now} Listening: #{value}" }
 sleep 0.5
 
@@ -53,3 +52,5 @@ input.remove_callbacks(:test)
 
 # Remove all callbacks.
 input.remove_callbacks
+
+board.finish_write

data/examples/analog_io/input_smoothing.rb

@@ -0,0 +1,27 @@
+#
+# This example shows how to smooth the input of an AnalogIO::Input.
+#
+require 'bundler/setup'
+require 'denko'
+
+PIN = :A0
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+input = Denko::AnalogIO::Input.new(pin: PIN, board: board)
+
+# Enable smoothing on the input using the last 16 values.
+input.smoothing = true
+input.smoothing_size = 16
+
+# Use the slowest listener possible.
+input.listen(128)
+
+#
+# With these settings, the input's state should gradually change (~2 seconds),
+# if you switch its supply from Vcc to Ground (or vice versa), instead of instantaneously.
+#
+# Print the state every 1/4 second. Change the voltage being input to the pin to see results.
+loop do
+  puts input.state
+  sleep(0.25)
+end

data/examples/analog_io/potentiometer.rb

@@ -0,0 +1,31 @@
+#
+# Example for a potentiometer.
+#
+require 'bundler/setup'
+require 'denko'
+
+PIN = :A0
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+pot = Denko::AnalogIO::Potentiometer.new(pin: PIN, board: board)
+
+last_percent = nil
+pot.on_data do |reading|
+  # Map reading to a decimal between 0 and 1.
+  fraction = reading / board.adc_high.to_f
+
+  # Linearization hack for audio taper potentiometers.
+  # Adjust k for different tapers. This was an A500K.
+  k = 5
+  linearized = (fraction * (k + 1)) / ((k * fraction) + 1)
+  # Use this for linear potentiometers instead.
+  # linearized = fraction
+
+  percent = (linearized * 100).round
+  unless percent == last_percent
+    puts "Potentiometer: #{percent.to_s.rjust(3, " ")}%"
+    last_percent = percent
+  end
+end
+
+sleep

data/examples/connection/binary_echo.rb

@@ -0,0 +1,34 @@
+#
+# Diagnostic to confirm board is receiving binary data
+# (in aux message) properly.
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+echo  = Denko::Connection::BinaryEcho.new(board: board, pin: 253)
+
+min_byte = 0
+max_byte = 255
+
+expected_result = (min_byte..max_byte).to_a.join(',') << ','
+
+waiting    = false
+wait_mutex = Mutex.new
+
+echo.on_data do |data|
+  if data == expected_result
+    puts "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - Echo received"
+    wait_mutex.synchronize { waiting = false }
+  end
+end
+
+loop do
+  wait_mutex.synchronize do
+    unless waiting
+      echo.test_range(min: min_byte, max: max_byte)
+      waiting = true
+    end
+  end
+  sleep 0.001
+end

data/examples/connection/tcp.rb

@@ -1,34 +1,19 @@
-require 'bundler/setup'
-require 'denko'
 #
-# This example shows how to use denko when connecting to a board via TCP.
-# This applies to the WiFi and Ethernet sketches, or serial sketch + ser2net.
-# Port number defaults to 3466 (denko), but may be given as a second argument.
-# It must correspond to the listening port set when the board was flashed.
+# Connect to a Board via TCP. This works for WiFi and Ethernet sketches.
+# Default port is 3466, and must match the port the Board was flashed to listen on.
 #
-connection = Denko::Connection::TCP.new("192.168.0.77", 3466)
-# connection = Denko::Connection::TCP.new("127.0.0.1")
-# connection =  Denko::Connection::TCP.new("192.168.1.2", 3466)
-#
-board = Denko::Board.new(connection)
-led = Denko::LED.new(board: board, pin: :LED_BUILTIN)
+require 'bundler/setup'
+require 'denko'
+
+IP_ADDRESS  = "192.168.0.52"
+PORT        = 3466
+PIN         = :LED_BUILTIN
+
+connection  = Denko::Connection::TCP.new(IP_ADDRESS, PORT)
+board       = Denko::Board.new(connection)
+led         = Denko::LED.new(board: board, pin: PIN)
 
 [:on, :off].cycle do |switch|
   led.send(switch)
   sleep 0.5
 end
-#
-# ser2net can be used to simulate a TCP interface from a board running denko serial.
-# It serves the serial interface over a TCP port from the machine running ser2net.
-#
-# Example ser2net command for an Arduino UNO connected to a Mac:
-# ser2net -u -C "3466:raw:0:/dev/cu.usbmodem621:115200"
-#
-# Tell denko to connect to the IP address of the Mac, at port 3466.
-# Note: ser2net should be used in raw TCP mode, not telnet mode (more common).
-#
-# Replace /dev/cu.usbmodem621 with your denko serial device.
-# Arduino UNOs should be something like /dev/ttyACM0 under Linux.
-#
-# http://sourceforge.net/projects/ser2net/ for more info on installing and configuring ser2net.
-#

data/examples/digital_io/button.rb

@@ -4,10 +4,14 @@
 require 'bundler/setup'
 require 'denko'
 
+PIN = 3
+
 board = Denko::Board.new(Denko::Connection::Serial.new)
-button = Denko::DigitalIO::Button.new(board: board, pin: 5, pullup: true)
+button = Denko::DigitalIO::Button.new board: board,
+                                      pin:   PIN,
+                                      mode:  :input_pullup
 
-button.up   { puts "Button released!" } 
-button.down { puts "Button pressed!" }
+button.up   { puts "Button released at #{Time.now.strftime '%H:%M:%S'}" }
+button.down { puts "Button pressed  at #{Time.now.strftime '%H:%M:%S'}" }
 
 sleep

data/examples/digital_io/relay.rb

@@ -0,0 +1,17 @@
+#
+# Use Relays to work with higher voltage circuits. This example
+# closes and opens a relay to send a 500ms pulse on a 12V control circuit.
+#
+require 'bundler/setup'
+require 'denko'
+
+PIN = 6
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+relay = Denko::DigitalIO::Relay.new(board: board, pin: PIN)
+
+relay.close
+sleep(0.500)
+relay.open
+
+board.finish_write

data/examples/digital_io/rotary_encoder.rb

@@ -1,26 +1,36 @@
 #
-# Example of a smiple rotary encoder polling at ~1ms.
+# KY-040 (30 detent) rotary encoder on a microcontroller, listener at 1ms.
 #
-# WARNING: This method is not precise at all. Please do not use it for anything
-# that requires all steps to be read for precise positioning or high speed.
+# WARNING: This method is not precise and may miss steps. Don't use for anything
+# that requires all steps to be read for exact positioning or high speed.
 #
 require 'bundler/setup'
 require 'denko'
 
+PIN_A = 4
+PIN_B = 5
+
 board = Denko::Board.new(Denko::Connection::Serial.new)
-encoder = Denko::DigitalIO::RotaryEncoder.new  board: board,
-                                              pins: { clock: 4, data: 5 },
-                                              divider: 1,                 # default, reads each pin every 1ms
-                                              steps_per_revolution: 30    # default
 
-# Reverse direction if needed.
+# Other options and their default values:
+#
+# divider: 1                 # read every divider milliseconds (Board only)
+# debounce_time: 1           # software debounce in microseconds (PiBoard only)
+# counts_per_revolution: 60  # for generic 30 detent rotary encoders
+#
+encoder = Denko::DigitalIO::RotaryEncoder.new board: board,
+                                              pins:  { a: PIN_A, b: PIN_B }
+
+# Reverse direction.
 # encoder.reverse
 
-# Reset angle and steps to 0.
-encoder.reset
+# Reset count and angle to 0.
+# encoder.reset
 
 encoder.add_callback do |state|
-  puts "Encoder moved #{state[:change]} steps | CW step count: #{state[:steps]} | Current angle: #{state[:angle]}\xC2\xB0"
+  change_printable = state[:change].to_s
+  change_printable = "+#{change_printable}" if state[:change] > 0
+  puts "Encoder Change: #{change_printable} | Count: #{state[:count]} | Angle: #{state[:angle]}\xC2\xB0"
 end
 
 sleep

data/examples/display/hd44780.rb

@@ -4,11 +4,19 @@
 require 'bundler/setup'
 require 'denko'
 
+# These pins match the SainSmart LCD Keypad Shield for Arduino boards.
+RS = 8
+EN = 9
+D4 = 4
+D5 = 5
+D6 = 6
+D7 = 7
+
 board = Denko::Board.new(Denko::Connection::Serial.new)
-lcd = Denko::Display::HD44780.new  board: board,
-                                   pins: { rs: 8, enable: 9, d4: 4, d5: 5, d6: 6, d7: 7 },
-                                   cols: 16,
-                                   rows: 2
+lcd   = Denko::Display::HD44780.new  board: board,
+                                     pins: { rs: RS, enable: EN, d4: D4, d5: D5, d6: D6, d7: D7 },
+                                     cols: 16,
+                                     rows: 2
 
 # Bitmap for a custom character. 5 bits wide x 8 high.
 # Useful for generating these: https://omerk.github.io/lcdchargen/
@@ -20,7 +28,7 @@ heart = [	0b00000,
         	0b01110,
         	0b00100,
         	0b00000 ]
-                  
+
 # Define the character in CGRAM address 2. 0-7 are usable.
 lcd.create_char(2, heart)
 

data/examples/display/ssd1306.rb

@@ -6,26 +6,29 @@ require 'denko'
 
 board = Denko::Board.new(Denko::Connection::Serial.new)
 
+# The SSD1306 OLED connects to either an I2C or SPI bus, depending on the model you have.
+# Bus setup exampels in order:
+#   I2C Hardware
+#   I2C Bit-Bang
+#   SPI Hardware
+#   SPI Bit-Bang
 #
-# Default pins for the I2C0 (first) interface on most chips:
-#
-# ATmega 328p:       SDA = 'A4'  SCL = 'A5' - Arduino Uno, Nano
-# ATmega 32u4:       SDA =   2   SCL =   3  - Arduino Leonardo, Pro Micro
-# ATmega1280 / 2560: SDA =  20   SCL =  21  - Arduino Mega
-# SAM3X8E:           SDA =  20   SCL =  21  - Arduino Due
-# SAMD21G18:         SDA =  20   SCL =  21  - Arduino Zero, M0, M0 Pro
-# ESP8266:           SDA =   4   SCL =   5
-# ESP32:             SDA =  21   SCL =  22
-# RP2040:            SDA =   4   SCL =   5  - Raspberry Pi Pico (W)
-#
-# Only give the SDA pin of the I2C bus. SCL (clock) pin must be 
-# connected for it to work, but we don't need to control it.
-#
-bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
-oled = Denko::Display::SSD1306.new(bus: bus, rotate: true)
-canvas = oled.canvas
+bus = Denko::I2C::Bus.new(board: board)
+# bus = Denko::I2C::BitBang.new(board: board, pins: {scl: 4, sda: 5})
+# bus = Denko::SPI::Bus.new(board: board)
+# bus = Denko::SPI::BitBang.new(board: board, pins: {clock: 13, output: 11})
+
+# I2C OLED, connected to I2C SDA and SCL.
+oled = Denko::Display::SSD1306.new(bus: bus, rotate: true) # address: 0x3C is default
+# oled = Denko::Display::SH1106.new(bus: bus,rotate: true) # address: 0x3C is default
+
+# SPI OLED, connected to SPI CLK and MOSI pins.
+# select: and dc: pins must be given. reset is optional (can be pulled high instead).
+# oled = Denko::Display::SSD1306.new(bus: bus, pins: { select: 10, dc: 7, reset: 8 }, rotate: true)
+# oled = Denko::Display::SH1106.new(bus: bus, pins: { select: 10, dc: 7, reset: 8}, rotate: true)
 
 # Draw some text on the OLED's canvas (a Ruby memory buffer).
+canvas = oled.canvas
 canvas.text_cursor = [27,60]
 canvas.print("Hello World!")
 

data/examples/display/ssd1306_s2_pico.rb

@@ -10,8 +10,8 @@ board = Denko::Board.new(Denko::Connection::Serial.new)
 reset = Denko::DigitalIO::Output.new(board: board, pin: 18)
 reset.high
 
-bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
-oled = Denko::Display::SSD1306.new(bus: bus, width: 128, height: 32)
+bus    = Denko::I2C::Bus.new(board: board, pin: :SDA)
+oled   = Denko::Display::SSD1306.new(bus: bus, width: 128, height: 32)
 canvas = oled.canvas
 
 # Draw some text on the OLED's canvas (a Ruby memory buffer).