denko-piboard 0.13.2 → 0.14.0

data/board_maps/raspberry_pi.yml

@@ -0,0 +1,95 @@
+#
+# Tested on:
+#   - Raspberry Pi 4B with Raspberry Pi OS, Kernel 6.6.47
+#   - Raspberry Pi Zero W, with Raspberry Pi OS, Kernel 6.6.51
+#
+# Should work for all 40-pin Raspberry Pi models on this OS,
+# EXCEPT Raspberry Pi 5.
+#
+---
+pins:
+  # Left side (odd numbered physical pins)
+  # PIN 1 is 3V3
+  2: { phy: 3, chip: 0, line: 2 }
+  3: { phy: 5, chip: 0, line: 3 }
+  4: { phy: 7, chip: 0, line: 4 }
+  # PIN 9 is GND
+  17: { phy: 11, chip: 0, line: 17 }
+  27: { phy: 13, chip: 0, line: 27 }
+  22: { phy: 15, chip: 0, line: 22 }
+  # PIN 17 is 3V3
+  10: { phy: 19, chip: 0, line: 10 }
+  9: { phy: 21, chip: 0, line: 9 }
+  11: { phy: 23, chip: 0, line: 11 }
+  # PIN 25 is GND
+  0: { phy: 27, chip: 0, line: 0 }
+  5: { phy: 29, chip: 0, line: 5 }
+  6: { phy: 31, chip: 0, line: 6 }
+  13: { phy: 33, chip: 0, line: 13 }
+  19: { phy: 35, chip: 0, line: 19 }
+  26: { phy: 37, chip: 0, line: 26 }
+  # PIN 39 is GND
+
+  # Right side (even numbered physical pins)
+  # PIN 2 is 5V
+  # PIN 4 is 5V
+  # PIN 6 is GND
+  14: { phy: 8, chip: 0, line: 14 }
+  15: { phy: 10, chip: 0, line: 15 }
+  18: { phy: 12, chip: 0, line: 18 }
+  # PIN 14 is GND
+  23: { phy: 16, chip: 0, line: 23 }
+  24: { phy: 18, chip: 0, line: 24 }
+  # PIN 20 is GND
+  25: { phy: 22, chip: 0, line: 25 }
+  8: { phy: 24, chip: 0, line: 8 }
+  7: { phy: 6, chip: 0, line: 7 }
+  1: { phy: 28, chip: 0, line: 1 }
+  # PIN 30 is GND
+  12: { phy: 32, chip: 0, line: 12 }
+  # PIN 34 is GND
+  16: { phy: 36, chip: 0, line: 16 }
+  20: { phy: 38, chip: 0, line: 20 }
+  21: { phy: 40, chip: 0, line: 21 }
+
+pwms:
+  #
+  # To enable in /boot/config.txt:
+  #   dtoverlay=pwm-2chan,pin=12,func=4,pin2=13,func2=4
+  12:
+    pwmchip: 0
+    channel: 0
+  13:
+    pwmchip: 0
+    channel: 1
+
+i2cs:
+  #
+  # To enable in /boot/config.txt:
+  #   dtparam=i2c_arm=on
+  #   dtparam=i2c_arm_baudrate=400000
+  1:
+    scl: 3
+    sda: 2
+
+spis:
+  #
+  # To enable in /boot/config.txt:
+  #   dtoverlay=spi0-0cs
+  0:
+    clk: 11
+    mosi: 10
+    miso: 9
+    cs0: 8
+    # cs1: 7
+
+  #
+  # To enable in /boot/config.txt:
+  #   dtoverlay=spi1-1cs
+  # 1:
+    # clk: 21
+    # mosi: 20
+    # miso: 19
+    # cs0: 18
+    ## cs1: 17
+    ## cs2: 16

data/denko_piboard.gemspec

@@ -4,18 +4,17 @@ Gem::Specification.new do |s|
   s.name        = 'denko-piboard'
   s.version     = Denko::PiBoard::VERSION
   s.licenses    = ['MIT']
-  s.summary     = "Use Raspberry Pi built-in GPIO as a Board class with the denko gem"
-  s.description = "Denko::PiBoard is a drop-in replacement for Denko::Board. Use denko features and component classes to be used directly on a Raspberry Pi."
+  s.summary     = "Linux SBC GPIO in Ruby"
+  s.description = "Use Linux single-board-computer GPIO, I2C, SPI and PWM in Ruby"
 
   s.authors     = ["vickash"]
   s.email       = 'mail@vickash.com'
   s.files       =  Dir['**/*'].reject { |f| f.match /.gem\z/}
   s.homepage    = 'https://github.com/denko-rb/denko-piboard'
   s.metadata    = { "source_code_uri" => "https://github.com/denko-rb/denko-piboard" }
-  
-  # libgpio C extension
-  s.extensions = %w[ext/gpiod/extconf.rb]
 
-  s.add_dependency 'pigpio', '~> 0.1.12'
-  s.add_dependency 'denko',  '~> 0.13'
+  s.required_ruby_version = '>=3'
+
+  s.add_dependency 'lgpio',  '~> 0.1'
+  s.add_dependency 'denko',  '~> 0.14'
 end

data/examples/digital_io/bench_out.rb

@@ -0,0 +1,22 @@
+require 'denko/piboard'
+
+PIN       = 272
+COUNT     = 1000000
+
+board = Denko::PiBoard.new
+output = Denko::DigitalIO::Output.new(board: board, pin: PIN)
+
+t1 = Time.now
+COUNT.times do
+  # If bit-banging in Ruby, this is the level to work at.
+  board.digital_write(PIN, 1)
+  board.digital_write(PIN, 0)
+
+  # These methods set output.state on every call (slower).
+  # output.high
+  # output.low
+end
+t2 = Time.now
+board.finish_write
+
+puts "Toggles per second: #{COUNT.to_f / (t2 - t1).to_f}"

data/examples/digital_io/rotary_encoder.rb

@@ -0,0 +1,31 @@
+#
+# WARNING: This performs significantly better when used with a PiBoard instance
+# (Linux SBC), compared to a Board instance (attached microcontroller),
+# but still might not be perfect.
+#
+require 'denko/piboard'
+
+PIN_A     = 260
+PIN_B     = 76
+
+board = Denko::PiBoard.new
+encoder = Denko::DigitalIO::RotaryEncoder.new board: board,
+                                              pins: { a: PIN_A, b: PIN_B },
+                                              divider: 1,                 # Default. Applies only to Board. Read pin every 1ms.
+                                              debounce_time: 1,           # Default. Applies only to PiBoard. Debounce filter set to 1 microsecond.
+                                              counts_per_revolution: 60   # Default
+
+# Reverse direction if needed.
+# encoder.reverse
+
+# Reset angle and count to 0.
+encoder.reset
+
+encoder.add_callback do |state|
+  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/ssd1306.rb

@@ -0,0 +1,43 @@
+#
+# Use SSD1306 OLED, over I2C or SPI.
+#
+require 'denko/piboard'
+
+board = Denko::PiBoard.new
+
+# Use the first hardware I2C interface.
+i2c_index = board.map[:i2cs].keys.first
+bus       = Denko::I2C::Bus.new(board: board, index: i2c_index)
+#
+# Or a bit-bang I2C interface.
+# bus = Denko::I2C::BitBang.new(board: board, pins: {scl: 228, sda: 270})
+
+# Use the first hardware SPI interface, and its defined :cs0 pin.
+# spi_index   = board.map[:spis].keys.first
+# chip_select = board.map[:spis][spi_index][:cs0]
+# bus         = Denko::SPI::Bus.new(board: board, index: spi_index)
+#
+# Or a bit-bang SPI interface.
+# bus = Denko::SPI::BitBang.new(board: board, pins: {clock: 228, output: 270})
+
+# I2C OLED, connected to I2C SDA and SCL.
+oled = Denko::Display::SSD1306.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: {reset: 259, dc: 260, select: chip_select}, 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!")
+
+# Add some shapes to the canvas.
+baseline = 40
+canvas.rectangle(10, baseline, 30, -30)
+canvas.circle(66, baseline - 15, 15)
+canvas.triangle(87, baseline, 117, baseline, 102, baseline - 30)
+
+# Send the canvas to the OLED's graphics RAM so it shows.
+oled.draw
+board.finish_write

data/examples/i2c/bitbang_aht10.rb

@@ -0,0 +1,18 @@
+#
+# AHT10 sensor over bit-banged I2C.
+#
+require 'denko/piboard'
+require_relative '../sensor/neat_tph_readings'
+
+SCL   = 228
+SDA   = 270
+board = Denko::PiBoard.new
+bus   = Denko::I2C::BitBang.new(board: board, pins: {scl: SCL, sda: SDA})
+aht10 = Denko::Sensor::AHT10.new(bus: bus) # address: 0x38 default
+
+# Poll it and print readings.
+aht10.poll(5) do |reading|
+  print_tph_reading(reading)
+end
+
+sleep

data/examples/i2c/bitbang_search.rb

@@ -0,0 +1,24 @@
+#
+# Search for connected devices on a bit-bang I2C bus.
+#
+require 'denko/piboard'
+
+SCL   = 228
+SDA   = 270
+board = Denko::PiBoard.new
+bus   = Denko::I2C::BitBang.new(board: board, pins: {scl: SCL, sda: SDA})
+
+bus.search
+
+if bus.found_devices.empty?
+  puts "No devices found on I2C bus"
+else
+  puts "I2C device addresses found:"
+  bus.found_devices.each do |address|
+    # Print as hexadecimal.
+    puts "0x#{address.to_s(16).upcase}"
+  end
+end
+
+puts
+board.finish_write

data/examples/i2c/bitbang_ssd1306_bench.rb

@@ -0,0 +1,29 @@
+require 'denko/piboard'
+
+START_ARRAY = [0, 33, 0, 127, 34, 0, 7]
+PATTERN_1   = [64] + Array.new(1024) { 0b00110011 }
+PATTERN_2   = [64] + Array.new(1024) { 0b11001100 }
+
+SCL   = 228
+SDA   = 270
+board = Denko::PiBoard.new
+bus   = Denko::I2C::BitBang.new(board: board, pins: {scl: SCL, sda: SDA})
+oled  = Denko::Display::SSD1306.new(bus: bus, rotate: true)
+
+FRAME_COUNT = 400
+start = Time.now
+(FRAME_COUNT / 2).times do
+  oled.i2c_write(START_ARRAY)
+  oled.i2c_write(PATTERN_1)
+  oled.i2c_write(START_ARRAY)
+  oled.i2c_write(PATTERN_2)
+end
+board.finish_write
+finish = Time.now
+
+fps = FRAME_COUNT / (finish - start)
+# Also calculate C calls per second, using roughly 23 calls per byte written.
+cps = (START_ARRAY.length + ((PATTERN_1.length + PATTERN_2.length) / 2) + 2) * 23 * fps
+cps = (cps / 1000.0).round
+
+puts "SSD1306 benchmark result: #{fps.round(2)} fps | #{cps}k C calls/s"

data/examples/i2c/search.rb

@@ -0,0 +1,24 @@
+#
+# Search for connected devices on a hardware I2C bus.
+#
+require 'denko/piboard'
+
+board = Denko::PiBoard.new
+# Use the first hardware I2C interface.
+i2c_index = board.map[:i2cs].keys.first
+bus       = Denko::I2C::Bus.new(board: board, index: i2c_index)
+
+bus.search
+
+if bus.found_devices.empty?
+  puts "No devices found on I2C bus"
+else
+  puts "I2C device addresses found:"
+  bus.found_devices.each do |address|
+    # Print as hexadecimal.
+    puts "0x#{address.to_s(16).upcase}"
+  end
+end
+
+puts
+board.finish_write

data/examples/led/blink.rb

@@ -0,0 +1,10 @@
+require 'denko/piboard'
+
+PIN = 272
+
+board = Denko::PiBoard.new
+led = Denko::LED.new(board: board, pin: PIN)
+
+led.blink 0.5
+
+sleep

data/examples/led/fade.rb

@@ -0,0 +1,22 @@
+require 'denko/piboard'
+
+# Either a regular GPIO (uses software PWM) or a GPIO with a hardware PWM channel.
+PIN = 226
+
+board = Denko::PiBoard.new
+led = Denko::LED.new(board: board, pin: PIN)
+
+5.times do
+  led.on
+  sleep 0.2
+  led.off
+  sleep 0.2
+end
+
+# Seamless loop from 0-100 and back.
+values = (0..100).to_a + (1..99).to_a.reverse
+
+values.cycle do |v|
+  led.write(v)
+  sleep 0.020
+end

data/examples/led/ws2812_bounce.rb

@@ -0,0 +1,36 @@
+#
+# Walk a single pixel along the length of a WS2812 strip and back,
+# changing color each time it returns to position 0.
+#
+require 'denko/piboard'
+
+RED    = [255, 0, 0]
+GREEN  = [0, 255, 0]
+BLUE   = [0, 0, 255]
+WHITE  = [255, 255, 255]
+COLORS = [RED, GREEN, BLUE, WHITE]
+
+PIXELS = 8
+
+# Move along the strip and back, one pixel at a time.
+positions = (0..PIXELS-1).to_a + (1..PIXELS-2).to_a.reverse
+
+board = Denko::PiBoard.new
+
+# On PiBoard, WS2812 must use a hardware Denko::SPI instance as its "board",
+# and always outputs on its MOSI pin. Use the first hardware SPI interface.
+spi_index = board.map[:spis].keys.first
+mosi      = board.map[:spis][spi_index][:mosi]
+bus       = Denko::SPI::Bus.new(board: board, index: spi_index)
+strip     = Denko::LED::WS2812.new(board: bus, pin: mosi, length: PIXELS)
+
+loop do
+  COLORS.each do |color|
+    positions.each do |index|
+      strip.clear
+      strip[index] = color
+      strip.show
+      sleep 0.05
+    end
+  end
+end

data/examples/motor/servo.rb

@@ -0,0 +1,16 @@
+#
+# Use a servo motor on a hardware PWM pin. Should raise an error
+# if the GPIO given does not have a hardware PWM channel multiplexed.
+#
+require 'denko/piboard'
+
+# Must be assigned to a hardware PWM channel in your board map.
+PIN = 226
+
+board = Denko::PiBoard.new
+servo = Denko::Motor::Servo.new(board: board, pin: PIN)
+
+[0, 90, 180, 90].cycle do |angle|
+  servo.position = angle
+  sleep 0.5
+end

data/examples/pi_system_monitor.rb

@@ -1,7 +1,7 @@
 #
 # This example uses an SSD1306 OLED display, connected to the Pi's I2C1 interface.
 # I2C1 pins are GPIO2 (SDA) and GPIO3 (SCL).
-# 
+#
 # CPU usage is measured using `mpstat`. To install it:
 #     sudo apt install sysstat
 #
@@ -16,7 +16,9 @@ require 'denko/piboard'
 BAR_ELEMENT = [0x00, 0x7E, 0x7E, 0x7E, 0x00]
 
 board = Denko::PiBoard.new
-i2c = Denko::I2C::Bus.new(board: board, pin: :SDA)
+# Use the first hardware I2C interface.
+i2c_index = board.map[:i2cs].keys.first
+i2c       = Denko::I2C::Bus.new(board: board, index: i2c_index)
 
 oled = Denko::Display::SSD1306.new(bus: i2c, rotate: true)
 canvas = oled.canvas
@@ -39,14 +41,14 @@ loop do
   # CPU Usage (automatically delays for 1 second)
   mpstat_result = `mpstat -P ALL 1 1 | awk '/^Average:/ && ++count == 2 {print 100 - $12"%"}'`
   cpu_percent = mpstat_result.chop.to_f
-  
+
   canvas.clear
   canvas.text_cursor = [0, 16]
   canvas.print "CPU Usage:  #{('%.3f' % cpu_percent).rjust(8, ' ')}%"
-  
+
   canvas.text_cursor = [0, 24]
   (cpu_percent / 4).ceil.times { canvas.raw_char(BAR_ELEMENT) }
-  
+
   # RAM Usage
   ram_string = `free -h | awk 'NR==2 {print $3}'`
   ram_usage = ram_string.to_i
@@ -54,14 +56,14 @@ loop do
   canvas.text_cursor = [0, 40]
   ram_string = "#{ram_usage}/#{total_ram}M"
   canvas.print "RAM Usage:#{ram_string.rjust(11, ' ')}"
-  
+
   canvas.text_cursor = [0, 48]
   (ram_usage / ram_bar_factor).ceil.times { canvas.raw_char(BAR_ELEMENT) }
-  
+
   # Date and time just before write.
   canvas.text_cursor = [0,0]
   canvas.print(Time.now.strftime('%a %b %d %-l:%M %p'))
-  
+
   # Only refresh the area in use.
   oled.draw(0, 127, 0, 56)
 end

data/examples/pulse_io/buzzer.rb

@@ -0,0 +1,34 @@
+#
+# Play a melody on a piezoelectric buzzer using (hardware) PWM.
+# Will use software PWM if given a regular GPIO, but not as good as good.
+#
+require 'denko/piboard'
+
+PIN = 227
+
+board = Denko::PiBoard.new
+buzzer = Denko::PulseIO::Buzzer.new(board: board, pin: PIN)
+
+C4 = 262
+D4 = 294
+E4 = 330
+
+notes = [
+        [E4, 1], [D4, 1], [C4, 1], [D4, 1], [E4, 1], [E4, 1], [E4, 2],
+        [D4, 1], [D4, 1], [D4, 2],          [E4, 1], [E4, 1], [E4, 2],
+        [E4, 1], [D4, 1], [C4, 1], [D4, 1], [E4, 1], [E4, 1], [E4, 1], [E4, 1],
+        [D4, 1], [D4, 1], [E4, 1], [D4, 1], [C4, 4],
+        ]
+
+bpm = 240
+beat_time = 60.to_f / bpm
+
+notes.each do |note|
+  buzzer.tone(note[0], (note[1] * beat_time))
+end
+
+# Only works for PiBoard.
+sleep 0.100 while (board.tone_busy(PIN) == 1)
+
+buzzer.stop
+board.finish_write

data/examples/pulse_io/infrared.rb

@@ -0,0 +1,25 @@
+#
+# Send remote control infrared signals on a hardware PWM pin.
+#
+require 'denko/piboard'
+
+# Must be assigned to a hardware PWM channel in your board map.
+PIN = 226
+
+board = Denko::PiBoard.new
+ir = Denko::PulseIO::IRTransmitter.new(board: board, pin: PIN)
+
+# NEC Raw-Data=0xF708FB04. LSBFIRST, so the binary for each hex digit below is backward.
+code =  [ 9000, 4500,                                 # Start bit
+          560, 560, 560, 560, 560, 1690, 560, 560,    # 0010 0x4 command
+          560, 560, 560, 560, 560, 560, 560, 560,     # 0000 0x0 command
+          560, 1690, 560, 1690, 560,560, 560, 1690,   # 1101 0xB command inverted
+          560, 1690, 560, 1690, 560, 1690, 560, 1690, # 1111 0xF command inverted
+          560, 560, 560, 560, 560, 560, 560, 1690,    # 0001 0x8 address
+          560, 560, 560, 560, 560, 560, 560, 560,     # 0000 0x0 address
+          560, 1690, 560, 1690, 560, 1690, 560, 560,  # 1110 0x7 address inverted
+          560, 1690, 560, 1690, 560, 1690, 560, 1690, # 1111 0xF address inverted
+          560]                                        # Stop bit
+
+ir.emit(code)
+board.finish_write

data/examples/sensor/aht10.rb

@@ -0,0 +1,17 @@
+#
+# AHT10 sensor over I2C, for temperature and humidity.
+#
+require 'denko/piboard'
+require_relative 'neat_tph_readings'
+
+board = Denko::PiBoard.new
+# Use the first hardware I2C interface.
+i2c_index = board.map[:i2cs].keys.first
+bus       = Denko::I2C::Bus.new(board: board, index: i2c_index)
+
+# Poll it and print readings.
+sensor.poll(5) do |reading|
+  print_tph_reading(reading)
+end
+
+sleep

data/examples/sensor/dht.rb

@@ -0,0 +1,24 @@
+#
+# Use a DHT class (DHT-11 / DHT-22) sensor for temperature and humidity.
+#
+require 'denko/piboard'
+require_relative 'neat_tph_readings'
+
+DHT_PIN = 267
+
+board = Denko::PiBoard.new
+sensor = Denko::Sensor::DHT.new(board: board, pin: DHT_PIN)
+
+sensor.read
+puts "Temperature unit helpers: #{sensor.temperature} \xC2\xB0C | #{sensor.temperature_f} \xC2\xB0F | #{sensor.temperature_k} K"
+puts
+
+# Don't try to read it again too quickly.
+sleep(1)
+
+# Poll it and print readings.
+sensor.poll(5) do |reading|
+  print_tph_reading(reading)
+end
+
+sleep

data/examples/sensor/ds18b20.rb

@@ -0,0 +1,59 @@
+#
+# Use a Dallas DS18B20 temperature sensor on a 1-Wire bus.
+#
+require 'denko/piboard'
+
+PIN = 256
+
+board = Denko::PiBoard.new
+bus = Denko::OneWire::Bus.new(board: board, pin: PIN)
+
+# The bus detects parasite power automatically when initialized.
+# It can tell that parasite power is in use, but not by WHICH devices.
+if bus.parasite_power
+  puts "Parasite power detected..."; puts
+end
+
+# Call #device_present to reset the bus and return presence pulse as a boolean.
+if bus.device_present?
+  puts "Devices present on bus..."; puts
+else
+  puts "No devices present on bus... Quitting..."
+  return
+end
+
+# Calling #search finds connected devices and stores them in #found_devices.
+# Each hash contains a device's ROM address and matching Ruby class if one exists.
+bus.search
+count = bus.found_devices.count
+puts "Found #{count} device#{'s' if count > 1} on the bus:"
+puts bus.found_devices.inspect; puts
+
+# We can use the search results to setup instances of the device classes.
+ds18b20s = []
+bus.found_devices.each do |d|
+  if d[:class] == Denko::Sensor::DS18B20
+    ds18b20s << d[:class].new(bus: bus, address: d[:address])
+  end
+end
+
+#  Format a reading for printing on a line.
+def print_reading(reading, sensor)
+  print "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - "
+  print "Serial(HEX): #{sensor.serial_number} | Res: #{sensor.resolution} bits | "
+
+  if reading[:crc_error]
+    puts "CRC check failed for this reading!"
+  else
+    fahrenheit = (reading[:temperature] * 1.8 + 32).round(1)
+    puts "#{reading[:temperature]} \xC2\xB0C | #{fahrenheit} \xC2\xB0F"
+  end
+end
+
+ds18b20s.each do |sensor|
+  sensor.poll(5) do |reading|
+    print_reading(reading, sensor)
+  end
+end
+
+sleep

data/examples/sensor/hcsr04.rb

@@ -0,0 +1,16 @@
+#
+# Use an HC-SR04 ultrasonic distance sensor.
+#
+require 'denko/piboard'
+
+ECHO_PIN    = 228
+TRIGGER_PIN = 270
+
+board = Denko::PiBoard.new
+hcsr04 = Denko::Sensor::HCSR04.new(board: board, pins: {trigger: TRIGGER_PIN, echo: ECHO_PIN})
+
+hcsr04.poll(1) do |distance|
+  puts "Distance: #{distance} mm"
+end
+
+sleep

data/examples/sensor/neat_tph_readings.rb

@@ -0,0 +1,32 @@
+#
+# This helper method can be used in temp/pressure/humidity sensor examples.
+# Give a hash with readings as float values and it prints them neatly.
+#
+def print_tph_reading(reading)
+  elements = []
+
+  # Temperature
+  if reading[:temperature]
+    formatted_temp = reading[:temperature].to_f.round(2).to_s.ljust(5, '0')
+    elements << "Temperature: #{formatted_temp} \xC2\xB0C"
+  end
+
+  # Pressure
+  if reading[:pressure]
+    formatted_pressure = reading[:pressure].round(2).to_s.ljust(7, '0')
+    elements << "Pressure: #{formatted_pressure} Pa"
+  end
+
+  # Humidity
+  if reading[:humidity]
+    formatted_humidity = reading[:humidity].round(2).to_s.ljust(5, '0')
+    elements << "Humidity: #{formatted_humidity} %"
+  end
+
+  return if elements.empty?
+
+  # Time
+  print "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - "
+
+  puts elements.join(" | ")
+end