denko 0.14.0 → 0.15.0

data/lib/denko/fonts.rb

@@ -1,106 +0,0 @@
-module Denko
-  module Fonts
-    #
-    # Adapted from:
-    # https://github.com/lexus2k/ssd1306/blob/master/src/ssd1306_fonts.c
-    #
-    FONT_6x8 = [
-      [0x00, 0x00, 0x00, 0x00, 0x00, 0x00], # sp
-      [0x00, 0x00, 0x00, 0x2f, 0x00, 0x00], # !
-      [0x00, 0x00, 0x07, 0x00, 0x07, 0x00], # "
-      [0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14], # #
-      [0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12], # $
-      [0x00, 0x23, 0x13, 0x08, 0x64, 0x62], # %
-      [0x00, 0x36, 0x49, 0x55, 0x22, 0x50], # &
-      [0x00, 0x00, 0x05, 0x03, 0x00, 0x00], # '
-      [0x00, 0x00, 0x1c, 0x22, 0x41, 0x00], # (
-      [0x00, 0x00, 0x41, 0x22, 0x1c, 0x00], # )
-      [0x00, 0x14, 0x08, 0x3E, 0x08, 0x14], # *
-      [0x00, 0x08, 0x08, 0x3E, 0x08, 0x08], # +
-      [0x00, 0x00, 0x00, 0xA0, 0x60, 0x00], # ,
-      [0x00, 0x08, 0x08, 0x08, 0x08, 0x08], # -
-      [0x00, 0x00, 0x60, 0x60, 0x00, 0x00], # .
-      [0x00, 0x20, 0x10, 0x08, 0x04, 0x02], # /
-      [0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E], # 0
-      [0x00, 0x00, 0x42, 0x7F, 0x40, 0x00], # 1
-      [0x00, 0x42, 0x61, 0x51, 0x49, 0x46], # 2
-      [0x00, 0x21, 0x41, 0x45, 0x4B, 0x31], # 3
-      [0x00, 0x18, 0x14, 0x12, 0x7F, 0x10], # 4
-      [0x00, 0x27, 0x45, 0x45, 0x45, 0x39], # 5
-      [0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30], # 6
-      [0x00, 0x01, 0x71, 0x09, 0x05, 0x03], # 7
-      [0x00, 0x36, 0x49, 0x49, 0x49, 0x36], # 8
-      [0x00, 0x06, 0x49, 0x49, 0x29, 0x1E], # 9
-      [0x00, 0x00, 0x36, 0x36, 0x00, 0x00], # :
-      [0x00, 0x00, 0x56, 0x36, 0x00, 0x00], # ;
-      [0x00, 0x08, 0x14, 0x22, 0x41, 0x00], # <
-      [0x00, 0x14, 0x14, 0x14, 0x14, 0x14], # =
-      [0x00, 0x00, 0x41, 0x22, 0x14, 0x08], # >
-      [0x00, 0x02, 0x01, 0x51, 0x09, 0x06], # ?
-      [0x00, 0x32, 0x49, 0x59, 0x51, 0x3E], # @
-      [0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C], # A
-      [0x00, 0x7F, 0x49, 0x49, 0x49, 0x36], # B
-      [0x00, 0x3E, 0x41, 0x41, 0x41, 0x22], # C
-      [0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C], # D
-      [0x00, 0x7F, 0x49, 0x49, 0x49, 0x41], # E
-      [0x00, 0x7F, 0x09, 0x09, 0x09, 0x01], # F
-      [0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A], # G
-      [0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F], # H
-      [0x00, 0x00, 0x41, 0x7F, 0x41, 0x00], # I
-      [0x00, 0x20, 0x40, 0x41, 0x3F, 0x01], # J
-      [0x00, 0x7F, 0x08, 0x14, 0x22, 0x41], # K
-      [0x00, 0x7F, 0x40, 0x40, 0x40, 0x40], # L
-      [0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F], # M
-      [0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F], # N
-      [0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E], # O
-      [0x00, 0x7F, 0x09, 0x09, 0x09, 0x06], # P
-      [0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E], # Q
-      [0x00, 0x7F, 0x09, 0x19, 0x29, 0x46], # R
-      [0x00, 0x46, 0x49, 0x49, 0x49, 0x31], # S
-      [0x00, 0x01, 0x01, 0x7F, 0x01, 0x01], # T
-      [0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F], # U
-      [0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F], # V
-      [0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F], # W
-      [0x00, 0x63, 0x14, 0x08, 0x14, 0x63], # X
-      [0x00, 0x07, 0x08, 0x70, 0x08, 0x07], # Y
-      [0x00, 0x61, 0x51, 0x49, 0x45, 0x43], # Z
-      [0x00, 0x00, 0x7F, 0x41, 0x41, 0x00], # [
-      [0x00, 0x02, 0x04, 0x08, 0x10, 0x20], # \
-      [0x00, 0x00, 0x41, 0x41, 0x7F, 0x00], # ]
-      [0x00, 0x04, 0x02, 0x01, 0x02, 0x04], # ^
-      [0x00, 0x40, 0x40, 0x40, 0x40, 0x40], # _
-      [0x00, 0x00, 0x01, 0x02, 0x04, 0x00], # '
-      [0x00, 0x20, 0x54, 0x54, 0x54, 0x78], # a
-      [0x00, 0x7F, 0x48, 0x44, 0x44, 0x38], # b
-      [0x00, 0x38, 0x44, 0x44, 0x44, 0x20], # c
-      [0x00, 0x38, 0x44, 0x44, 0x48, 0x7F], # d
-      [0x00, 0x38, 0x54, 0x54, 0x54, 0x18], # e
-      [0x00, 0x08, 0x7E, 0x09, 0x01, 0x02], # f
-      [0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C], # g
-      [0x00, 0x7F, 0x08, 0x04, 0x04, 0x78], # h
-      [0x00, 0x00, 0x44, 0x7D, 0x40, 0x00], # i
-      [0x00, 0x40, 0x80, 0x84, 0x7D, 0x00], # j
-      [0x00, 0x7F, 0x10, 0x28, 0x44, 0x00], # k
-      [0x00, 0x00, 0x41, 0x7F, 0x40, 0x00], # l
-      [0x00, 0x7C, 0x04, 0x18, 0x04, 0x78], # m
-      [0x00, 0x7C, 0x08, 0x04, 0x04, 0x78], # n
-      [0x00, 0x38, 0x44, 0x44, 0x44, 0x38], # o
-      [0x00, 0xFC, 0x24, 0x24, 0x24, 0x18], # p
-      [0x00, 0x18, 0x24, 0x24, 0x18, 0xFC], # q
-      [0x00, 0x7C, 0x08, 0x04, 0x04, 0x08], # r
-      [0x00, 0x48, 0x54, 0x54, 0x54, 0x20], # s
-      [0x00, 0x04, 0x3F, 0x44, 0x40, 0x20], # t
-      [0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C], # u
-      [0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C], # v
-      [0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C], # w
-      [0x00, 0x44, 0x28, 0x10, 0x28, 0x44], # x
-      [0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C], # y
-      [0x00, 0x44, 0x64, 0x54, 0x4C, 0x44], # z
-      [0x00, 0x00, 0x08, 0x77, 0x00, 0x00], # {
-      [0x00, 0x00, 0x00, 0x7F, 0x00, 0x00], # |
-      [0x00, 0x00, 0x77, 0x08, 0x00, 0x00], # }
-      [0x00, 0x10, 0x08, 0x10, 0x08, 0x00], # ~
-      [0x14, 0x14, 0x14, 0x14, 0x14, 0x14], # horiz lines # DEL
-    ]
-  end
-end

data/test/eeprom/built_in_test.rb

@@ -1,61 +0,0 @@
-require_relative '../test_helper'
-
-class BoardMock < Denko::Board
-  attr_reader :eeprom_stub
-
-  def eeprom_read(start_address, length)
-    # Initialize a fake EEPROM
-    @eeprom_stub ||= Array.new(eeprom_length){255}
-
-    # Pack it up like a string coming from the board.
-    string = @eeprom_stub[start_address, length].map{ |x| x.to_s }.join(",")
-
-    # Update ourselves with it.
-    self.update("254:#{start_address}-#{string}\n")
-  end
-
-  def eeprom_write(start_address, bytes)
-    @eeprom_stub[start_address, bytes.length] = bytes
-  end
-end
-
-class BuiltInEEPROMTest < Minitest::Test
-  def board
-    @board ||= BoardMock.new
-  end
-
-  def part
-    @part ||= board.eeprom
-  end
-
-  def test_pin_ee
-    assert_equal part.pin, 254
-  end
-
-  def test_loads_on_initialize_and_updates_correctly
-    assert_equal part.state, Array.new(board.eeprom_length){255}
-  end
-
-  def test_delegates_to_state_array
-    mock = Minitest::Mock.new
-    mock.expect(:[], 255, [0])
-    mock.expect(:[]=, 128, [1, 128])
-    mock.expect(:each, nil)
-    mock.expect(:each_with_index, nil)
-
-    part.stub(:state, mock) do
-      part[0]
-      part[1] = 128
-      part.each { |el| el }
-      part.each_with_index { |el| el }
-    end
-  end
-
-  def test_saves_to_the_board
-    part[0] = 128
-    part[part.length] = 127
-    part.save
-    assert_equal 128, board.eeprom_stub[0]
-    assert_equal 127, board.eeprom_stub[board.eeprom_length]
-  end
-end

data/test/spi/peripheral_single_pin_test.rb

@@ -1,48 +0,0 @@
-require_relative '../test_helper'
-
-class SPITester
-  include Denko::SPI::Peripheral::SinglePin
-
-  def some_callback(data)
-  end
-end
-
-class SPIPeripheralSinglePinTest < Minitest::Test
-  def board
-    @board ||= BoardMock.new
-  end
-
-  def bus
-    @bus ||= Denko::SPI::Bus.new(board: board)
-  end
-
-  def options
-    { bus: bus, pin: 9, spi_frequency: 800000, spi_mode: 2, spi_bit_order: :lsbfirst}
-  end
-
-  def part
-    @part ||= SPITester.new(options)
-  end
-
-  def test_string_data_converts_to_bytes_for_callbacks
-    part.on_data do |bytes|
-      part.some_callback(bytes)
-    end
-    mock = Minitest::Mock.new.expect :call, nil, [[127,255]]
-    part.stub(:some_callback, mock) do
-      board.update("#{part.pin}:127,255")
-    end
-    mock.verify
-  end
-
-  def test_array_data_reaches_callbacks
-    part.on_data do |bytes|
-      part.some_callback(bytes)
-    end
-    mock = Minitest::Mock.new.expect :call, nil, [[127,255]]
-    part.stub(:some_callback, mock) do
-      part.update([127,255])
-    end
-    mock.verify
-  end
-end

data/tutorial/01-led/led.rb

@@ -1,73 +0,0 @@
-#
-# Example 1: Controlling an LED
-#
-require 'bundler/setup'
-require 'denko'
-
-# If the board is plugged into a USB port, we can connect with serial over USB.
-connection = Denko::Connection::Serial.new
-
-# Create a new board object, giving the connection.
-board = Denko::Board.new(connection)
-
-#
-# Create an LED object, giving the board, and the pin that the positive
-# leg of the LED is connected to. The longer leg is usually positive.
-#
-# See led.pdf in this folder for a hook-up diagram.
-# Use a current limiting resistor with external LEDs to protect them.
-#
-# The on-board LED can also be used. It is connected to pin 13 on most Arduinos,
-# but can vary for other boards. The symbol :LED_BUILTIN should map to the right pin.
-# If it doesn't, change it to the pin number from your board's documentation.
-#
-# Note: Some boards use an addressable LED on-board. In those cases, connect an external
-# LED and use its pin for this example instead.
-#
-led = Denko::LED.new(board: board, pin: :LED_BUILTIN)
-
-# Now we can make it blink.
-puts "Blinking every half second..."
-
-#
-# A digital output can only have one of two states:
-# 1 / high / on
-# 0 / low / off
-# We can use led.digital_write to set it directly, or named convenience methods.
-# These 3 lines all do the same thing: turn on, wait half a second, turn off.
-#
-led.digital_write(1); sleep 0.5; led.digital_write(0)
-led.high;             sleep 0.5; led.low
-led.on;               sleep 0.5; led.off
-
-#
-# led.toggle will set it to the opposite state each time it's called.
-# Keep it blinking for 3 more seconds using #toggle.
-#
-6.times do
-  led.toggle
-  sleep 0.5
-end
-
-#
-# What if we want to blink in the background?
-#
-# led.blink runs in a separate thread, managed by the led, and doesn't block the
-# main thread. Give it the blink interval in seconds.
-#
-led.blink 0.5
-puts "Blinking in the background... Hello from the main thread!"
-sleep 3
-
-#
-# Calling a method that sets the state (#digital_write, #high, #low, #on, #off)
-# automatically stops the blink thread.
-#
-puts "Turning off for 2 seconds..."
-led.off
-sleep 2
-
-# Blink faster indefinitely.
-puts "Blinking faster forever... (Press Ctrl+C to exit)"
-led.blink 0.1
-sleep

data/tutorial/02-button/button.rb

@@ -1,65 +0,0 @@
-#
-# Example 2: Using a Button
-#
-require 'bundler/setup'
-require 'denko'
-
-# Set up the board, connecting with serial over USB.
-board = Denko::Board.new(Denko::Connection::Serial.new)
-
-#
-# Create an object for a momentary button, giving the board, and the pin that
-# the ungrounded side of the button is connected to.
-#
-# `mode: :input_pullup` keeps the input pin high (logical 1) when the
-# button is not pressed. Without this (or an external pullup resistor), the pin
-# might float between 0 and 1, giving incorrect readings. When the button is
-# pressed, it pulls the input pin down to ground (0).
-#
-# See button.pdf in this folder for a hook-up diagram.
-#
-button = Denko::DigitalIO::Button.new(board: board, pin: 7, mode: :input_pullup)
-
-#
-# As soon as a Button (or any DigitalInput) is created, the board starts
-# listening for changes to the physical button. When that happens, our button
-# object is notified. To catch these notifications, we have to use a callback.
-# button.add_callback saves a block of code to run each time the button state changes.
-#
-# The callback below checks if the state is 0 (the button went from up to down),
-# then counts and prints the number of times pressed.
-#
-presses = 0
-button.add_callback(:count_presses) do |state|
-  if state == 0
-    presses = presses + 1
-    puts "Button press ##{presses}"
-  end
-end
-
-# Wait for the button to be pressed 3 times.
-puts "Press button 3 times to continue..."
-sleep 0.005 while presses < 3
-
-# Button keeps its callbacks in a Hash. We can be specific and use keys to add and remove.
-button.remove_callback(:count_presses)
-
-# Or remove them all. Either way, the block above won't run anymore.
-button.remove_callbacks
-
-#
-# button.down and button.up add callbacks that automatically check state for you.
-#
-# #down runs only when state goes from high (1) to low (0).
-# #up runs only when state goes from low (0) to high (1).
-#
-# We can use them to control the internal LED from example 1.
-#
-led = Denko::LED.new(board: board, pin: 13)
-
-button.up   { led.off }
-button.down { led.on }
-
-puts "Press the button to turn on the LED... (Ctrl+C to exit)"
-
-sleep

data/tutorial/03-potentiometer/potentiometer.rb

@@ -1,66 +0,0 @@
-#
-# Example 3: Potentiometer and Analog Inputs
-#
-require 'bundler/setup'
-require 'denko'
-
-# Set up the board, connecting with serial over USB.
-board = Denko::Board.new(Denko::Connection::Serial.new)
-
-#
-# Connect the potentiometer's outer 2 pins to Ground and Vcc respectively.
-# The center is the wiper, and should be connected to one of the board's analog
-# pins. On most boards these pins start with 'A' and can be given as strings.
-#
-# See potentiometer.pdf in this folder for a hook-up diagram.
-#
-potentiometer = Denko::AnalogIO::Potentiometer.new(pin: 'A0', board: board)
-
-#
-# Like with Button, the Board starts reading the Potentiometer value immediately,
-# but we need to add a callback to do something with it.
-#
-potentiometer.on_change do |value|
-  print "Potentiometer value: #{value} \r"
-end
-puts "Turn the potentiometer to change value. Press Enter to continue..."
-
-# Stop the callback.
-gets; puts
-potentiometer.remove_callbacks
-
-#
-# The default resolution for Analog Input is 10-bits, so you should have seen
-# values from 0 - 1023. We can use the value to control the blinking
-# speed of the LED from the earlier example.
-#
-led = Denko::LED.new(board: board, pin: 13)
-
-# Helper method to calculate the blink time.
-def map_pot_value(value)
-  # Map 10 bit value into 0 to 1 range.
-  fraction = value / 1023.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
-
-  # Map to the 0.1 to 0.5 seconds range in reverse. Clockwise = faster.
-  0.5 - (linearized * 0.4)
-end
-
-# Start blinking with interval of 0.3
-led.blink(0.3)
-
-# Callback that calculates the blink interval and tells the LED.
-potentiometer.on_change do |value|
-  interval = map_pot_value(value)
-  print "LED blink interval: #{interval.round(4)} seconds    \r"
-  # Update the LED's blink interval without stopping the blink.
-  led.blink_interval = interval
-end
-puts "Turn potentiometer to control the LED blink. Press Ctrl+C to exit..."
-sleep

data/tutorial/04-pwm_led/pwm_led.rb

@@ -1,64 +0,0 @@
-#
-# Example 4: LED Brightness and PWM
-#
-require 'bundler/setup'
-require 'denko'
-
-# Set up the board, connecting with serial over USB
-board = Denko::Board.new(Denko::Connection::Serial.new)
-
-#
-# LEDs don't change brightness much with voltage, but we can vary it with a
-# technique called PWM. PWM sets up a fast (500Hz+) wave on the LED pin. Then we
-# set a duty cycle, telling the LED what fraction of those cycles to be on for.
-#
-# Eg. 1 cycle on, 4 cycles off = 20% duty cycle.
-# This happens so fast that it looks like 20% brightness to the naked eye.
-#
-# Depending on your board, some pins may not be PWM capable. Pin 13 on Arduinos
-# isn't, so the earlier example was limited to on/off. There might be a wave
-# symbol printed next to the pin number, but check your documentation.
-#
-# Note: If you have pins labeled "DAC", do not use them here. DACs generate steady
-# analog voltages, not pulses.
-#
-# Set up LED on a PWM pin. See pwm_led.pdf in this folder for hook-up diagram.
-#
-led = Denko::LED.new(board: board, pin: 11)
-
-# led.duty= sets duty cycle from 0 to 100, in percentage.
-[0, 20, 40, 60, 80, 100].each do |duty|
-  led.duty = duty
-  print "LED at #{duty}% duty cycle. Press Enter..."; gets
-end
-puts
-
-# Now let's add the potentiometer from the previous example to control it.
-potentiometer = Denko::AnalogIO::Potentiometer.new(pin: 'A0', board: board)
-
-# Helper method to calculate brightness.
-def map_pot_value(value)
-  # Map 10 bit value into 0 to 1 range.
-  fraction = value / 1023.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
-
-  # x100 to get percentage out of 100.
-  (linearized * 100).round
-end
-
-# Callback to change brightness.
-potentiometer.on_change do |value|
-  duty     = map_pot_value(value)
-  led.duty = duty
-  print "LED brightness: #{duty}%  \r"
-end
-
-puts "Turn potentiometer to control the LED brightness. Press Ctrl+C to exit..."
-sleep

data/tutorial/05-rgb_led/rgb_led.rb

@@ -1,58 +0,0 @@
-#
-# Example 5: RGB LED
-#
-require 'bundler/setup'
-require 'denko'
-
-# Set up the board, connecting with serial over USB
-board = Denko::Board.new(Denko::Connection::Serial.new)
-
-#
-# To set up an RGB LED, connect its cathode leg to ground, and each of its 3 color
-# anodes to PWM-capable pin on your board, through a current limiting resistor. Make
-# the green resistor much larger. Since green is usually brighter, we want to limit
-# its current more than the others. See rgb_led.pdf for a hook-up diagram.
-# The values used are 4.7k Ohm for green, 220 Ohm for red and blue.
-#
-# An RGB LED is really 3 individual LEDS in one, sharing a cathode (sometimes anode).
-# We could initailize them separately, or use the RGBLed class, which takes all 3 pins.
-#
-rgb_led = Denko::LED::RGB.new(pins: {red: 11, green: 10, blue: 9}, board: board)
-
-#
-# We can call methods on the RGBLed as a whole. For example, these 8 defined colors.
-#
-print "Press Enter to cycle through RGBLed defined colors..."; gets
-[:red, :green, :blue, :cyan, :yellow, :magenta, :white, :off].each do |color|
-  rgb_led.color = color
-  sleep 0.5
-end
-
-#
-# Or we can access the individual Leds through the #red, #green and #blue methods.
-# This makes an orange color with them.
-#
-rgb_led.red.duty = 100
-rgb_led.green.duty = 40
-rgb_led.blue.off
-print "Done. Changed to orange. Press Enter to continue..."; gets
-
-# Let's bring the potentiometer back from the previous examples.
-potentiometer = Denko::AnalogIO::Potentiometer.new(pin: 'A0', board: board)
-
-#
-# In a separate file (rgb_mapping.rb), there are methods to map the 0-1023 values
-# received from the potentiometer into RGB values that create a rough color spectrum.
-#
-require_relative 'rgb_mapping'
-potentiometer.on_change do |pot_value|
-  # Use the mapping methods to calculate values and write them.
-  rgb_led.red.duty   = map_red(pot_value)
-  rgb_led.green.duty = map_green(pot_value)
-  rgb_led.blue.duty  = map_blue(pot_value)
-
-  print "Potentiometer value: #{pot_value}   \r"
-end
-
-puts "Turn potentiometer to change the RGB LED color. Press Ctrl+C to exit..."
-sleep

data/tutorial/05-rgb_led/rgb_mapping.rb

@@ -1,76 +0,0 @@
-# Maximum and minimum PWM values.
-OUT_MAX = 100
-OUT_MIN = 0
-
-def map_value(value, input_steps, reverse=false)
-  # Map it to a 0-1 range first.
-  fraction = value / input_steps.to_f
-
-  # Reverse if needed.
-  fraction = 1 - fraction if reverse
-
-  # Map to the output range
-  value = (fraction * OUT_MAX).floor
-
-  # Clamp within the range just in case.
-  value = OUT_MAX if value > OUT_MAX
-  value = OUT_MIN if value < OUT_MIN
-  value
-end
-
-def map_red(pot_value)
-  # Red full on at low end.
-  return OUT_MAX if pot_value < 171
-
-  # Red fades out from 171-341
-  if (171..341).include? pot_value
-    return map_value(pot_value - 171, 170, true)
-  end
-
-  # Red full off in the middle third.
-  return OUT_MIN if (342..682).include? pot_value
-
-  # Red fades in from 683-853
-  if (683..853).include? pot_value
-    return map_value(pot_value - 683, 170, false)
-  end
-
-  # Red full on at high end.
-  return OUT_MAX if pot_value > 853
-end
-
-def map_green(pot_value)
-  # Green fades in from 0-171
-  if (0..170).include? pot_value
-    return map_value(pot_value, 170, false)
-  end
-
-  # Green full on from 1/6 to 1/2.
-  return OUT_MAX if (171..511).include? pot_value
-
-  # Green fades out from 512-682
-  if (512..682).include? pot_value
-    return map_value(pot_value - 512, 170, true)
-  end
-
-  # Geen full off above 2/3.
-  return OUT_MIN if pot_value > 682
-end
-
-def map_blue(pot_value)
-  # Blue full off until 1/3
-  return OUT_MIN if pot_value < 342
-
-  # Blue fades in from 342-512 (170 steps)
-  if (342..542).include? pot_value
-    return map_value(pot_value - 342, 170, false)
-  end
-
-  # Blue full on from 513 to 852
-  return OUT_MAX if (513..852).include? pot_value
-
-  # Blue fades out from 853-1023 (170 steps)
-  if (853..1023).include? pot_value
-    return map_value(pot_value - 853, 170, true)
-  end
-end