DEV Community: x

How to control addressable RGB lights with a ESP8266. Part 3 of 3. Episode 1 of 2.

Sun, 11 Apr 2021 01:33:23 +0000

This blog will cover setting up the API response from the ESP8266. The final blog on this topic will cover the website to interact with the controller. This was too much to cover in one blog, so it needed to be split again.

boot.py

Micropython has two files that are run automatically without having to invoke them. boot.py and main.py are run in that order with main beginning after boot finishes. Another notable feature is both files share the same namespace. Everything that is boot.py is available in main.py as if they are the same file. There isn't a particular reason to favor one over the other. You can place all of your code in either file and it will execute. Unlike Arduino main loops, main.py is not looped and is only called once. If your program requires a loop, you will have to create it yourself.

The way I use the files is to place configuration and functions in boot.py and place timer instantiation or loops in main.py. The best use I've found is to start WiFi connections in boot.py since you can be confident that the network connection will be done by the time the main program is called, and if your program depends on connectivity, your code can sleep and reboot before calling your program to try again if the network isn't available.

The following is the boot.py we are using.

from machine import Pin
from micropython import const
import gc
from neopixel import NeoPixel
from network import WLAN, STA_IF
import ESP8266WebServer as ws

station = WLAN(STA_IF)
ssid = <your SSID>
psk = <your password>

class LightController:
  def __init__(self, *args, **kwargs):
    self.ledData = {
      'color':'white',
      'status':'off'
    }
    self.light_len = const(5)
    self.pixel = NeoPixel(Pin(2), self.light_len)
    self.all_off()

  def all_off(self):
    for i in range(self.light_len):
      self.pixel[i] = (0, 0, 0)
    self.pixel.write()
    self.ledData['status'] = 'off'

  def all_on(self, color = 'white'):
    for i in range(self.light_len):
      if color == 'white':
        self.pixel[i] = (200, 200, 200)
      if color == 'red':
        self.pixel[i] = (200, 0, 0)
    self.pixel.write()
    self.ledData['color'] = color
    self.ledData['status'] = 'on'

lights = LightController()

def handleOff(socket, args):
  lights.all_off()
  ws.ok(socket, '200')

def handleWhite(socket, args):
  lights.all_on(color='white')
  ws.ok(socket, '200')

def handleRed(socket, args):
  lights.all_on(color='red')
  ws.ok(socket, '200')

if not station.isconnected():
  station.active(1)
  station.connect(ssid, psk)
  while not station.isconnected():
    pass
  print(station.ifconfig())

ws.onPath('/off', handleOff)
ws.onPath('/red', handleRed)
ws.onPath('/white', handleWhite)

ws.setDocPath('/')
ws.setTplData(lights.ledData)

ws.begin()

This gets almost everything going that we need. The ESP8266WebServer that we imported will respond to the routes we set up and invoke the functions that wrote. This is a work in progress and can certainly be improved, but this should cover the basic functionality of what I'm trying to accomplish. The only thing left is to invoke the server and start responding to clients. We put this in main.py

main.py

try:
  while 1:
    ws.handleClient()
except:
  ws.close()

That's it. This should not block REPL access over serial if you connect to the board after loading this. I prefer rshell for file copy, there are plenty of tutorials. If you follow this guide and use rshell, the board contents are available via /pyboard from the rshell prompt. You can copy your boot.py and main.py using rshell or you can copy them into the /modules subfolder in the ESP8266 directory of the microypthon repo. Just follow the guides available for "freezing micropython modules" or build the firmware as in step on of this guide, but placing your created files in the /modules folder before building.

The final part of this blog, we will create a simple reactjs app to talk to the ESP8266 and turn the lights on and off for us via a web interface.

What's new in Python 3.10

Sun, 04 Apr 2021 02:49:22 +0000

Python 3.10 will be here later this year and I wanted to go over some of the new features that will make our lives a little easier.

Multi line context managers.

This allows you to have multiple context managers in one with statement. Instead of nesting context managers and the associated complexity, you can open everything at once in one expression. One use case would be having multiple files open. Now all the needed files can be opened and closed in the same context without nesting.

with (open('source_a.txt') as source_a,
      open('source_b.txt') as source_b,
      open('out.txt', 'w') as out):
    <perform some logic to use the contents of all the files>

Error messages point to the fault and not to where the interpreter failed

Error messages have been improved so that if you are missing a bracket, the error handler will highlight the portion of code it thinks is missing the bracket instead of the first assignment that failed due to a missing bracket.

Previous implementations would report where the interpreter quit working, which was after the part of code that was missing the bracket. This should make troubleshooting code much easier.

Structural pattern matching, a.k.a. switch statements

Python is getting a feature that seems like a switch statement and can be used that way, but is actually more flexible that simple equality checks.

From the python docs "Patterns consist of sequences, mappings, primitive data types as well as class instances." This means that you can match on a broad array of criteria and can compare class instances against one another based on how the instances were created. You can also use array methods, like map and match on the output from that.

This will be a massive improvement over using imperative if clauses. This more declarative approach is easier to read and can be implemented in complex cases easier.

array

The index() method of the builtin array is getting start and stop parameters. This will make it work more like Javascript.

How to control addressable RGB lights with a ESP8266. Part 2.5 of 3. Rotary knob addendum.

Sun, 28 Mar 2021 02:19:25 +0000

Please see my previous part 1, part 2 here to catch up.

Before I set up the web server, I want local control of the LEDs, so I'm setting up a rotary knob to control the lights in addition to the web server. I'm using this library to control the rotary knob.

Any time you need to add a module to your ESP8266, you need to load it via compiling new firmware using the vagrant machine for part 1 and adding the new file to the /ports/esp8266/modules/ subdirectory before compiling new firmware. The boot.py file I show below is far too large to copy paste in one shot to the REPL. The best thing is to copy the file into the modules directory and burn new firmware. This seems tedious, but the files run much faster and I don't think micropython gets a file system on esp8266 to copy files onto. I have ordered some RP2040 boards, but those will take some time to arrive.

The rotary knob uses two pins which are out of phase with one another to determine which direction the know is going. Since this is handled by the library, we just need to detect the change and apply it to the string of lights. Later, the knob will be able to be moved to its own controller and the lights will work from the remote knob.

from machine import Pin, I2C, unique_id, reset, Timer
from micropython import const
import gc
import math
from ssd1306 import SSD1306_I2C
from neopixel import NeoPixel
from network import WLAN, STA_IF
from rotary_irq_esp import RotaryIRQ

rotary = RotaryIRQ(pin_num_clk=12, 
              pin_num_dt=13, 
              min_val=0, 
              max_val=7, 
              reverse=False, 
              range_mode=RotaryIRQ.RANGE_BOUNDED)
station = WLAN(STA_IF)
ssid = 'your ssid'
psk = 'your password'
light_len = const(144)
pixel = NeoPixel(Pin(2), light_len)

def rotary_knob(val=0):
  if val == 0:
    all_off()
  elif val == 1:
    white_low()
  elif val == 2:
    white_med()
  elif val == 3:
    white_high()
  elif val == 4:
    red_low()
  elif val == 5:
    red_medium()
  elif val == 6:
    red_high()
  elif val == 7:
    rainbow_one()


def white_low():
  for i in range(light_len):
    pixel[i] = (10, 10, 10)
  pixel.write()
def white_med():
  for i in range(light_len):
    pixel[i] = (100, 100, 100)
  pixel.write()
def white_high():
  for i in range(light_len):
    pixel[i] = (200, 200, 200)
  pixel.write()
def all_off():
  for i in range(light_len):
    pixel[i] = (0, 0, 0)
  pixel.write()
def red_low():
  for i in range(light_len):
    pixel[i] = (10, 0, 0)
  pixel.write()
def red_med():
  for i in range(light_len):
    pixel[i] = (100, 0, 0)
  pixel.write()
def red_high():
  for i in range(light_len):
    pixel[i] = (200, 0, 0)
  pixel.write()
def hsv2rgb(h, s, v):
    h = float(h)
    s = float(s)
    v = float(v)
    h60 = h / 60.0
    h60f = math.floor(h60)
    hi = int(h60f) % 6
    f = h60 - h60f
    p = v * (1 - s)
    q = v * (1 - f * s)
    t = v * (1 - (1 - f) * s)
    r, g, b = 0, 0, 0
    if hi == 0: r, g, b = v, t, p
    elif hi == 1: r, g, b = q, v, p
    elif hi == 2: r, g, b = p, v, t
    elif hi == 3: r, g, b = p, q, v
    elif hi == 4: r, g, b = t, p, v
    elif hi == 5: r, g, b = v, p, q
    r, g, b = int(r * 255), int(g * 255), int(b * 255)
    return r, g, b

if not station.isconnected():
  station.active(1)
  station.connect(ssid, psk)
  while not station.isconnected():
    pass
  print(station.ifconfig())
def rainbow_map(v=.1):
  map = {}
  for i in range(360):
    map[i] = hsv2rgb(i, 1, v)
  return map

def rainbow_one():
  color = rainbow_map()
  for i in range(360):
    for j in range(144):
      pixel[j] = color[i]
    pixel.write()
  gc.collect()

val_old = rotary.value()
while True:
  val_new = rotary.value()
  if not val_old == val_new:
    val_old = val_new
    rotary_knob(val=val_old)

For the "high" setting, I use a value of 200. The maximum the LED can go is 255, but I found that just results in excessive current draw for not very much light. 80% of the maximum is 204, so 200 was a good spot for the max value.

The final part of this blog will cover setting up some basic routes and controlling these same functions from a web page. I will be using a web server library for ESP8266.

How to control addressable RGB lights with a ESP8266. Part 2 of 3.

Sun, 21 Mar 2021 01:31:35 +0000

Please see my previous blog here to get up to speed. You should have serial access to the micropython prompt at this point. Connect to your board and run the following code in the REPL to setup our string of lights. For this example, I'm using a 1 meter long string with 144 lights.

from machine import Pin
from neopixel import NeoPixel
lights = NeoPixel(Pin(5), 144)

Now we have an instance of NeoPixel we can manipulate. Run the following to make sure your lights work. Warning. If you have too many lights connected, this is where you will start to have problems. Turning all the lights on at full brightness will draw the most current. Be careful

lights[0] = (50,50,50)
lights.write()

This turns the first light on and you should see a white light. The syntax is the same for the rest of the lights. lights[index of the light you want] = (red, green, blue) intensity

Now, let's light all the lights in the string. The max value for each color is 256, but the color intensity is inverse to the intensity. Numbers less than 50 will give good results most of the time.

for i in range(144):
    lights[i] = (20,20,20) # not too bright
    lights.write()

This will draw each light as the loop progresses and you can watch the string of lights fill in, or you can wait until the loop is done and then call lights.write() to draw the string all at once. The latter is much faster.

Time to get some random color involved. Try this.

from random import getrandbits
for i in range(144):
    lights[i] = (getrandbits(3), getrandbits(3), getrandbits(3)) # numbers higher than 4 lead to lots of white lights
    lights.write()

Similar to before, but every light should be a random color now.

Sticking with the random color theme this will assign a random color to the string and update the entire row 10 times a second. Simple and easy effect.

from utime import sleep
try:
    while 1:
        for i in range(144):
            lights[i] = (getrandbits(3), getrandbits(3), getrandbits(3))
        lights.write()
        sleep(.1)
except KeyboardInterrupt:
    print('Done')

You can also move the lights.write() command into the loop for a slightly different effect.

try:
    while 1:
        for i in range(144):
            lights[i] = (getrandbits(3), getrandbits(3), getrandbits(3))
            lights.write()
        sleep(.1)
except KeyboardInterrupt:
    print('Done')

This will sweep new colors down the string for an interesting effect. Moving the sleep(.1) method and changing its duration will have interesting effects as well.

What to expect in part 3

In the final chapter, we are going to make a simple web application to control the lights from anywhere. The WiFi stack on the ESP8266 will make this pretty easy. We will also be making custom firmware with the environment we set up in the first chapter. Once it's complete, the ESP8266 will allow control of the lights over WiFi. Stay Tuned.

How to control addressable RGB lights with a ESP8266. Part 1 of 3.

Sun, 14 Mar 2021 05:59:25 +0000

This will be a multi-part blog covering the steps needed to setup a micro web server on a ESP8266 microcontroller and use that to control a string of addressable RGB lights. The first part will cover the environment set-up, part two will be about controlling the RGB led lights, and part three will be implementing a basic web server to allow the lights to be controlled from a page served by the ESP8266.

If you wish to follow along, you will need the following items:

EPS8266 - These can be ordered from several places but shouldn't be more than a few dollars. Amazon has unreasonably high prices for these and you should shop around if you can. If you want a name brand item for the consistency, I recommend Adafruit, although the Feather HUZZAH is the most expensive board. You get what you pay for, mostly. You can save a few dollars sometimes if you order the board without the headers soldered and do it yourself. In part two, we are going to be soldering sockets to the prototyping board to plug the modules into so you will need to order headers with your sockets if the board you choose does not include them.
3.3v-5v level shifter. This is not actually required since the leds will usually work correctly at 3.3v, but this will allow longer strings of lights to work without error. It's best to buy a few of these at a time since they are so cheap. You could also do a single transistor to convert the signal, but a level shifter on a pre-made board is easiest to implement.
5VDC power supply. This heavily depends on how many lights you want to run. For the purposes of this demo, I'm using a 1500mA power supply obtained from a wall transformer. These are very common and anything 1000mA or more should be fine. If you are only doing 1-3 lights, you can use the pin on your ESP8266 that connects to the USB plug and get your 5v there. This pin will not be connected if you are using an external power supply.
Addressable RGB leds. These come in two main varieties and the main distinction is the order of the light's color message information. There are RGB and RBG and they are basically identical, except the order in which the messages are set, which will be covered later. Either one is fine, as long as they are 5 volt.
Electronics prototyping supplies. I won't go into too much detail here, but the basics are some breadboard, sockets for the ESP8266 and level shifter (so they can be reused in another project), screw terminals, and a bit of 24ga wire. Some basic searching should put you on track to get everything you need pretty easy.

Environment set-up

The first thing to do is get the required software to build micropython. This is needed over using a pre-built image because there is limited memory available on the ESP8266. In order to run more complex programs and not run out of memory, it is required to precompile your program when the firmware is built. This will place the your program in a different part of memory which will free up ram, which is very limited. I followed the guide available here with one extra step. The dependencies were broken for me, so after running vagrant ssh for the first time, run sudo apt -y install git autoconf gperf bison flex texinfo help2man libtool libncurses-dev build-essential python-dev inside the vagrant machine before trying to compile the toolchain.

Once you have the toolchain built, continue to follow the guide until you are able to connect to the board over serial and you get a REPL. Once you know that you can connect and the firmware you flashed is working, then you are ready to start working on connecting to the leds, which is covered in the next blog.

Rails 6 ActionCable basics with React

Tue, 05 Jan 2021 19:57:36 +0000

What you need to know to get ActionCable working with React.

This will walk through the steps to get basic ActionCable functionality in Rails 6, using React. I will use the most basic scenario that isn't a chat room, two player matchmaking. There is a link to the repo at the bottom of the page.

First let's make a demo project.

rails new ActionCable-demo -T webpack=react

Then, we will need a User model with a name

rails g scaffold User name

Next we need a Game model only. We won't use any views or controllers for this.

rails g model Game red_user_id:integer blue_user_id:integer

The last part needed is the channel for ActionCable. Just generating the channel will do most of the work for you so all you need to do is generate the channel.

rails g channel MatchMaking

Now we need to set up the relation for the Game and User models.

class User < ApplicationRecord
  has_many :blue_games, class_name: 'Game', foreign_key: 'blue_user'
  has_many :red_games, class_name: 'Game', foreign_key: 'red_user'

  def games
    [blue_games, red_games]
  end
end

class Game < ApplicationRecord
  belongs_to :red_user, class_name: 'User'
  belongs_to :blue_user, class_name: 'User'

  def users
    [red_user, blue_user]
  end
end

Now when we create a Game, using two Users, we will get the red_user_id and blue_user_id attributes automagically. The helper methods just emulate the regular belongs_to and has_many relationship.

Time to set up the MatchMaking channel

class MatchMakingChannel < ApplicationCable::Channel
  @@matches = []

  def subscribed
    stream_from 'MatchMakingChannel'
  end

  def joined(username)
    @@matches.length == 2 ? @@matches.clear : nil
    user = User.find_by(name: username['user'])
    # add the user to the array unless they already joined
    puts '*' * 30
    puts @@matches
    @@matches << user unless @@matches.include?(user)
    if @@matches.length == 2
      game = Game.create!(red_user: @@matches.first, blue_user: @@matches.last)
      ActionCable.server.broadcast 'MatchMakingChannel', game: game
    else
      ActionCable.server.broadcast 'MatchMakingChannel', message: 'waiting for game'
      ActionCable.server.broadcast 'MatchMakingChannel', 'waiting for game'
    end
  end

  def unsubscribed
    # Any cleanup needed when channel is unsubscribed
  end
end

This is everything needed to get connected. Now to the frontend to see it.

First step is to tweak the User show form to suit our purposes. In /app/views/users/show.html.erb. Add the id tag to the

block for use later.

<p id="notice"><%= notice %></p>

<p id='name'>
  <%= @user.name %>
</p>

<%= link_to 'Edit', edit_user_path(@user) %>
<%= link_to 'Back', users_path %>

Now we need to add the React elements. In

/app/views/layouts.application.html.erb

add

<%= javascript_pack_tag 'index' %>

to the header and create index.js in /app/javascript/packs/

import React from 'react';
import ReactDOM from 'react-dom';
import actioncable from 'actioncable';
import App from '../App'

const CableApp = {}
CableApp.cable = actioncable.createConsumer('ws://localhost:3000/cable')

document.addEventListener('DOMContentLoaded', () => {
  ReactDOM.render(
    <App cable={CableApp.cable}/>,
  document.body.appendChild(document.createElement('div')),
)
})

Now, the App component one directory up.

import React, { Component } from 'react'

export default class App extends Component {

  constructor(props) {
    super(props)
    this.state = {
      message: 'not joined',
      name: ''
    }
    this.matchMakingChannel = {}
  }



  componentDidMount = () => {
    this.setState({name: document.getElementById('name').textContent.trim()})
    this.matchMakingChannel = this.props.cable.subscriptions.create('MatchMakingChannel', {
      connected: () => {
        this.setState({message: 'joined MatchMaking'})
      },
      received: (data) => {
        if (data.message){
          this.setState({message: data.message})
        }
        if (data.game){
          this.setState({message: 'Game # ' + data.game.id + ' Red user id ' + data.game.red_user_id + ' Blue user id ' + data.game.blue_user_id + '.'})
        }
      },
      joined: (name) => {
        this.matchMakingChannel.perform('joined', {user: name})
      }
    })

  }
  handleJoined = (name) => {
    this.matchMakingChannel.joined(name)
  }
  render() {
    return (
      <div>
        <div>{this.state.message}</div>
        <button type="button" onClick={() => this.handleJoined(this.state.name)} >Join Game</button>
      </div>
    )
  }
}

Start the rails server and go to http://localhost:3000/users and create a new user. Repeat this in the second window and see the status update for both users when the second user clicks join game. If this were a real game, then there would be a game object that action cable would stream from that would serve as a private room for the players. Once they were both connected to the Game channel, you could disconnect them from MatchMaking.

Clone this repo here.

How to script a digital clock in Blender using Python

Wed, 02 Dec 2020 07:42:53 +0000

This tutorial will use Blender 2.91

Available here

Set up the scene.

This won't cover the basics. I highly suggest Andrew Price's excellent tutorial videos on YouTube to get you started. However, everything needed to duplicate this scene exactly is listed below.

Everything for this scene is default except for removing the default cube, repositioning the camera, and adding the text with the settings shown.

The material for the plane and the text is the default principled shader, in this case the plane is black and the text is white.

This is what we start with. Take note that the text object has the name "Text". We will use that to reference this object later. Also, do not convert the text to mesh. Some fonts require you to convert them to a static mesh to render correctly because of artifacts when you give them 3d geometry as text objects. You just have to choose compatible fonts to do it this way. Smooth corners and edges are best.

Release the Python

Everything that I have done to set this scene up using the UI can be scripted with Python as well. To learn the API, simply use Blender and look at the output from the Python console. In this case, I used the UI to make the scene and left Python to code the interesting part, but if you duplicated the commands from the Python console in a script as well, you would get the same scene. In fact, you don't need the UI at all and can construct an entire scene from the Python shown if you want a challenge.

How it works

The following will break down the data structure, generator, and callback that makes the clock work.

Data structure.

This total_frames in the following section is being calculated for a full motion display. This example doesn't need to render all these frames if none of the scene elements move and the way to do that is covered later.

minute, second = '10', '01' # variable assignment
total_frames = ((int(minute) * 60) + int(second)) * 30 # 30fps video times the total seconds
scene.frame_end = total_frames # let Blender know how long the scene is.

seconds = ['%02d'% (i,) for i in reversed(range(60))] # list comprehension to create all the seconds in a minute

seconds_arr = [seconds] * int(minute) # this is what we give to our generator

if not second == '00': # if the timer is not a whole minute, we need a partial list to add to the front.
    seconds_arr[:0] = [seconds[(60 - int(second)):]]

This will create the correct order for our clock to count down to zero. To count up, omit

reversed()

and add the partial seconds to the end

[seconds[:(60 - int(second))]]

Generator

There are several ways to iterate over the structure we just made. The method I chose was to create a generator because I knew the frame change callback would be the perfect time to call a next iteration function.

# this function will count through the seconds_arr and give us the correct clock face string each time it is called.
@persistent # this decorator keeps the generator from being refreshed during the render.
def time_remaining(seconds_arr):
    while seconds_arr:
        current_minute = seconds_arr.pop(0)
        for sec in current_minute:
            yield (str(len(seconds_arr)) + ':' + str(sec))


clock = time_remaining(seconds_arr) # now we have the generator, we just need a way to call it

Complications

Skip this if you just want the countdown. I wanted the clock to move gently around the scene and I didn't want to set all those keyframes by hand. You can use other methods you may remember from geometry to draw circles or figure 8 patterns. I just wanted random movement in all axis within a small range.

text.location = (0,0,.2) # set the starting location x, y, z
text.keyframe_insert('location', frame=1) # first keyframe
text.keyframe_insert('location', frame=scene.frame_end) # last keyframe

for frame in range(total_frames):
    if frame % 300 == 0: # every 10 seconds
        text.location = (random.uniform(-2,2),random.uniform(-1.2,1.2),random.uniform(.2, 1.0)) # pick a random number for all three axis
        text.keyframe_insert('location', frame=frame) # add keyframe

text.location = (0,0,.2) # move the text back to the start before the render starts (for a test render)

Callback

Time to tie it all together and automate our scene. Blender provides several powerful events that you can trigger callbacks with.

# this is the callback function that will fire on each frame change. The callback passes the current scene as its first argument.
def draw_clock(scene):
    global clock # global variable
    text = scene.objects['Text'] # grab the text object
    current_frame = scene.frame_current
    if current_frame % 30 == 0: # every second at the project fps
        text.data.body = next(clock) # invoke the generator

bpy.app.handlers.frame_change_pre.append(draw_clock) # attach callback to the frame change event.

The method of choice for this example is frame_change_pre. This will fire on each frame change, before the frame is drawn. If the frame number on change is divisible by the frame rate, then it will decrement the second count until it reaches zero just before the last rendered frame.

Time to render

You only need to run the script one time. In the above screenshot, I left the commented code for using this script from the command line. Once the script has run, you should have the following first frame if you render the image.

If it all looks good, check your output directory, change the project fps to 30, and hit Render Animation. A 10:01 animation is 18030 frames, so expect this render to take a long time if the clock is moving around the screen with the optional code! If you are rendering without motion, you can start on frame 0 and skip 30 frames each sequence since the light source is not moving and there is no reason to render the exact same frame repeatedly.

And &, per se.

Thu, 12 Nov 2020 06:12:35 +0000

This blog will cover three common uses that will help clarify the purpose and application of the & operator.

Convert a variable into a proc
Shorten array enumerables
Safe Navigation Operator

All of these things that you can do rely on the underlying magic that Ruby provides with the & operator

& just works, ok?

The first use we will explore is using & to allow us to pass a block to a method and do something useful with it.

def pretty_print(&block)
puts '**' << block.call.to_s << '**'
end

pretty_print {'hello world'}

That looks just like a regular method, only with braces, right? Not exactly. What would happen if you passed an enumerable? Suppose "('a'..'j').to_a" was our array of characters to be converted to uppercase before showing the entire array.

pretty_print { ('a'..'j').to_a.map do |letter| letter.upcase end }

You can't do this with a method parameter. The following doesn't work since it can't convert the Array to a String implicitly.

def test_print(t)
  puts '**' << t << '**'
end

test(('a'..'j').to_a.map do |letter| letter.upcase end )

Shortening enumerables

What was happening in our example above was & represented the block that we passed to it. In fact & converts what you pass to it into either a block or proc, depending on how it is used. A common use is with #map and other enumerable methods that return a new array.

If you are using #map to create a new array from an existing object, you can likely cut down on some typing. Refactoring the example above would look like this.

pretty_print { ('a'..'j').to_a.map(&:upcase) }

Since we passed a block to &, Ruby converted this to a proc for us and the symbol :upcase refers to the method upcase which is available to the enumerable item. This could be useful with models that have a single attribute that you want an array of. For example, we could create an instance variable in one of our models.

@all_cats = Owners.all.map(&:cat)

Nice and simple.

Safe Navigation Marker

Another use for & is when you want to check a value, but just want nil back if it doesn't exist instead of the dreaded NoMethodError. This allows you to presume and not worry if something doesn't exist, you are prepared to get nil back.

@owner&.cat&.name

This is shorter an much easier to read than its counterpart

if @owner.cat
  @owner.cat.name
else
  nil
end

It is even better than the ternary version.

@owner.cat ? @owner.cat.name : nil

In this case, & is still converting what you pass to it as a block, but since the action occurs inside &'s block, if @owner doesn't have a cat and therefore the method for getting the cat's name doesn't exist, the block will evaluate to nil instead of throwing an error.

A powerful place to use this last example would be in a view page. You can lazily assume that parameters exist and just expect a nil output when that parameter or method doesn't exist.

And then?

There is also the bitwise use of & which wasn't covered in this blog. Stay tuned for more. & is an enigmatic symbol that produces interesting and useful ways to create flexible methods that wrap around other methods. Thank you for reading my blog and helping me understand these issues better with you.

Recursion in Ruby

Mon, 19 Oct 2020 02:06:50 +0000

What does recursion mean?

Merriam Webster provides the following definition:

"a computer programming technique involving the use of a procedure, subroutine, function, or algorithm that calls itself one or more times until a specified condition is met at which time the rest of each repetition is processed from the last one called to the first"

Recursively solving a problem means that you create a method that calls itself until it reaches a base problem and then exits. There are two important things to be aware of when deciding if a problem can be solved recursively. The first thing is that there must be a way out of the recursive loop, or it will loop indefinitely. The second thing to look for is a problem that has a basic solution and another equally difficult solution that can eventually solve the basic solution.

What does recursion look like in Ruby?

Recursion is typically shown with mathematical problems that express the equivalence of the basic solution to the recursive solution but don't appear to be practical outside of those uses. This article will look at solving two problems, factorial and another example that isn't solving a math problem.

Factorial

def fact n   
  return 1 if n < 2
  n * fact(n - 1)
end

Why does this work?

Ruby makes understanding the two key concepts for recursion easy with each of these lines.

return 1 if n < 2

This is our escape from the recursion. You will see from the second line that n decrements each time through the recursion, so we will eventually escape the loop as long as we start with a positive number. (No, I'm not going to handle errors, this is about recursion)

n * fact(n - 1)

This is where the recursion actually begins. What happens on this line is Ruby stays here and continues to call #fact until it hits the escape point. To understand this better, comment out the first line and then call puts fact(10) to see what happens.

It's not terribly important to understand all of the inner workings of how this happens for you, just know that Ruby will unwrap the entire recursive loop until the basic problem and then return the entire result. The final line returns our result so this is where Ruby starts the recursion and returns its result. It knows to return a result because it will eventually call 1 * fact(2 - 1) and get 1 as a return and there will be no more loops to go. The next step for Ruby is to return the result of the recursive loop.

Math hurts, do something else.

Recursion is not limited to math problems, let's build a recursive CLI menu and see a more practical use.

def menu selection=nil
  system 'clear' #clears the screen
  puts 'Menu'
  puts '-----'
  puts '1. Email'
  puts '2. Chat'
  puts '3. Account'
  puts '4. Quit'
  puts "You chose #{selection}" unless selection.nil? 
  selection = gets.chomp
  return 'You selected quit' if selection == '4' # this is the escape. Note '4' is a string.
  menu selection # this is the recursion
end

Although the menu doesn't actually do anything useful, it illustrates how a method can call itself and pass new information to itself each time. Let's say you were making a call to an API that provided a random trivia fact, only you wanted a new random fact each time and the API would sometimes send you a fact you had seen before. Recursion would be a simple solution since you only need to check if the fact you received is in your list of known facts and if it is, call the method to retrieve the fact again. If it isn't, then present the fact. It would be prudent to provide an additional break so that you will stop if the API only sends you facts you have already seen.

Hopefully this sheds some light on recursion and how it can be practically applied in your use case. If your problem is a "Do this until..." and there is an escape condition that will occur either through user input or by your method passing a new variable to itself that will eventually match the escape condition, then recursion may be right for you.

Please share if this was helpful and thanks for reading.