Daniel Frentzel

Hand build 20x10 LED display with Tetris

2018-08-02T00:00:00+00:00

As part of an embedded systems class, we were instructed to create a project powered by an Arduino or Raspberry Pi, using various electrical components, to display competence in the class material. A classmate, Brendan, and I decided to create a display using individual LEDs with the goal to implement a game of Tetris. In order to power the classical 20x10 Tetris display, we needed a way to wire and control 200 LEDs with less than 30 general-purpose input/output, GPIO, pins on the Raspberry Pi. Little did we know that the final project would employ 4 breadboards and 350 hand cut wires.

Project Design

After discussing ideas, we realized that by connecting LEDs across the rows and LEDs down the columns together, that a coordinate-like system could be achieved. Since LEDs need a voltage differential to flow, by supplying 0v to column, x, and 5v to row, y, the LED at coordinate x, y can be illuminated. This method works great as long as only a single LED is illuminated at a time. A list of LEDs that need to be illuminated will be iterated through, flashing every LED on, then off, to appear as multiple LEDs are on at the same time. This idea alone requires only 30 GPIO pins, but that number still needs to be reduced.

Demultiplexers

Our professor, Dr. Andy Keck, introduced the idea of multiplexer chips. Demultiplexers can be used to take n, number of inputs, to power 2ⁿ output chips. Using demultiplexers allows us to use 5 GPIO pins to control the 20 rows and 4 pins to account for the 10 columns. Due to our particular situation, we chose to use 5 pins to control the columns to prevent the first led from defaulting to the on position while keeping zero based indexing in the software. Ultimately, this reduced the number of required GPIO pins from 30 to a very manageable 10.

Getting It Done

As it turns out, 5 to 32 pin demultiplexers are not readily available, but a 2 to 4 used with three 3 to 8 demultiplexers can be used together to achieve 32 output pins. This works by using the highest two binary inputs to supply the 2 to 4 chip to enable a single 3 to 8 chip, while the lowest three binary inputs supply input to every 3 to 8 chip. Below, on the left, is a diagram of how to columns are controlled with one 2 to 4 chip and two 3 to 8 chips. The same logic is used for the rows. It is worth mentioning that our demultiplexers send low to the selected output pin and high to the rest. While this is ideal for controlling the columns, it means that the demultiplexer outputs going to the 3 to 8 chips and to the rows need to be inverted. While we didn’t have inverters on hand, we were able to make them using transistors. This can be seen in the top right quadrant of the project, inverting the voltage from the demultiplexers to the rows, and above the 2 to 4 chip at the bottom of the third breadboard. It is also worth noting that our 2 to 4 chip is actually two 2 to 4 chips in one, so it’s output is wired, through inverters, to the enable pins on the 3 to 8 chips for both the rows and columns.

LED Wiring

In order to connect the rows and columns in series, a lot of individual wires needed to be cut. Luckily, we were able to plug in 2x3 grids of LEDs to share appropriate power and grounds. Wires were then cut to jump each grid, connecting the whole display, detailed in the wiring diagram above on the right. The forest of wires responsible for this is hidden underneath the LEDs.

Code

The library, driver.py, is responsible for communication between the Raspberry Pi and the display board. It’s responsible for setting up the GPIO pins, changing the illumination state of LEDs, and cleaning up the GPIO ports. The game, tetris.py, is responsible for running the Tetris game, responding to the buttons, and telling driver.py which LEDs to illuminate.

Here is Brendan playing Tetris, with the controller, and the rest of the project assembled.

Closing Thoughts

Although this project involved a lot more time and effort than we had expected, it was an extremely rewarding and fun project that I will never forget. We joked about this being our prototype, as we thought about improvements like building the demultiplexers ourselves. With that being said, I believe we were close to the limits with this project. We noticed a small amount of ghosting, stray LEDs faintly being lit, on the display, which we believe were caused by the hand built inverters. Also, when the display starts to fill up, the flashing of the LEDs becomes noticeable to the viewer. Of course this project could have been accomplished with a custom circuit board, LED strips or even a LCD display, but we fancied the idea of building everything that we could, embracing the retro design and spending countless hours sticking over 1300 wires into breadboards.

Thanks for checking out our project!

Project Links

Check out the GitHub repository

Boids Flocking Simulation

2018-07-11T00:00:00+00:00

This project consists of independent bodies, boids, acting on certain characteristics to simulate the nature of a flying flock of birds. A world is created and boids are given three desires to fly based on Craig W. Reynolds paper, “Flocks, Herds, and Schools: A Distributed Behavior Model.”

Collision Avoidance: The desire to avoid collisions with nearby boids
Velocity Matching: The desire to fly at the same speed as nearby boids
Flock Centering: The desire to stay towards the center of the flock

The desires are accomplished with object oriented programming, creating objects for boids, flocks, and behaviors. Each boid belongs to a flock that knows every boid within the flock and computes a distance matrix between the boids of the flock. Although boids could do this on their own, it is more efficient for the flock to calculate this each tick. Boids are also given a behavior that uses algorithms to tell the boid where to move based on its three desires. A point class is used for 3-D coordinates to hold locations and vectors. The point class overrides operators so point objects can be added, scaled, etc. and contains functions to calculate distance, magnitude and to normalize vectors. Each tick, the flock is told to update, telling every boid to move, which asks its behavior where to move and moves the boid, and then flock updates the distance between all the boids.

Realistic Animation:

Parameters are used to weigh the importance of all three desires of the boids. After trial and error, parameters were found to create a decent flying simulation of a flock of birds.

Your browser does not support the video tag.

Unrealistic Animation:

The following is an example of an animation where the parameter on the flock centering is too high. Notice that the boids lose their sense of direction and all repeatedly fly towards the center.

Your browser does not support the video tag.

Other

While this was part of a group project, I was not involved in the development on the world, graphics, or GUI anymore than to make sure flock objects were being initialized and called correctly. The goal for this project was to create object avoidance and multiple behavior algorithms before running out of time.

Check out the GitHub repository

Song Year Prediction on the Million Song Dataset

2018-07-01T00:00:00+00:00

The sound of music has changed throughout the past century and continues to change. The Million Song Dataset collects song features from popular contemporary songs ranging from 1922 to 2010. By using the sound characteristics of songs, this project applies linear regression models, namely ordinary least squares and ridge regression, to the segments pitches and segments timbre features found in the dataset. These features are used to build a model matrix of predictors and to predict song release years using residual sum of squares and leave-one-out cross-validation.

Technologies

The project is programmed in Python using various libraries. NumPy is used to store data in narrays, compute covariance matrices for song data and for general computing. Pandas is used to create data frame structures for analysis, which are pickled as fast, serialized files that can easily be reloaded. Scikit-learn does the heavy lifting by supplying the machine learning models while Matplotlib graphs the results.

Song Year Predictions

The correct year is predicted for songs more often than any other year. The model is able to predict 75% of songs within a decade and 45% of songs within 5 years of their actual release year. The histogram is skewed right, representing more over predictions by the model. If the model is trusted, these over predictions contain songs that are futuristic. Further work can be done to analyze futuristic song patterns to shed light on future music trends and the characteristics that make future throwback songs.

Project Links

View my full research paper

Check out the GitHub repository

Dynamic Virtual Tour of Crested Butte

2018-06-14T00:00:00+00:00

This project consists of a Flask website running off of an Sqlite server. The tour consists of pins on a map to mark locations and pictures that are uploaded corresponding to the pin. Pins have already been placed on the tour so users can visit and interact with the website. Everything is stored in a database and dynamically loaded so users can add their locations and pictures to the virtual tour.

Information on how to use the website and understand the underlying technologies can be found in the documentation link below.

Project Links

Visit the full website

Documentation for using the website

Check out the GitHub repository

StartPy Game Object Library

2018-04-23T00:00:00+00:00

For this project I was asked to maintain a pygame library for a fun, introductory class to game programming. The objective of the StartPy library is to create an easy to use interface for first time programmers to create simple games such as pong. I was responsible for developing, maintaining, and testing compound objects (multiple objects being added together as one object), labels, buttons, backgrounds and more, mostly dealing with the GObj.py file.

An example of a basic demonstration using various game objects is shown below. The code is basic and straight-forward to read, as intended by the StaryPy library. A video is also shown of the script being run.

Example Code

from StartPy import *

start()
run = True

cir = Circle(100, BLUE)
img = Image('img.jpg', 350, 0)
btn = Button('Click to start', 50, GRAY, BLACK, 135, 250)
lab = Label(50, BLACK, 'Demo is running...', 20, 20)

add(cir)
add(img)
add(btn)
add(lab)
sendToBack(lab)

waitForClick()
remove(btn)
while run:
    cir.move(1, 1)
    img.move(-1, 1)
    pause(2)
    if collides(cir, img):
        comp = img + cir
        add(comp)
        img.setVisible(False)
        while run:
            comp.move(0, 1)
            pause(2)
            if comp.getY() > 400:
                run = False
                lab.setText('Demo is completed!')

stop()

Running the Example Code

Your browser does not support the video tag.

Check out the GitHub repository

Sum of Even Fibinici Terms

2017-12-22T00:00:00+00:00

The Fibinici sequence is renowned for its golden ratio that is found throughout our world. It starts with the first two terms as 1 and is formed with each subsequent term being the sum of the two previous terms (1, 1, 2, 3, 5, 8, 13,…). Suppose one wanted to know the sum of every even term less than 4 million. While the solution is straight forward, a little cleverness can be used to improve efficiency.

Since the first two terms of the sequence are given, we can start the sequence as a list and build the rest of the terms less than 4 million

f = [1, 1]

while f[-1] + f[-2] < 4000000:
    f.append(f[-2] + f[-1])  # add the next term, the sum of the previous two terms

At this point our list, f, holds all the Fibinici terms less than 4 million. Finding the sum of the even terms is easy enough. A comprehension can be used to get the even terms and the built in sum operator can sum the list

print(sum([term for term in f if term % 2 == 0]))

We have answered the question, but do we really need to append each term and hold onto the entire sequence? After all, we are just summing the even terms.

Let’s try to do this on the fly by only holding two values, starting with our initial list. When we compute the next term, we will update the held values so that the second value is the current term and the first value is our previous term. The two terms in our list always tell us how to compute the next term in the Fibinici sequence. You can think of the two held values as your view of the whole sequence, through a window only two terms wide. Every update to our held values, shifts our view, once, down the sequence.

Notice, since we aren’t holding the entire sequence, we can’t use the sum operator. Instead, the sum is held in sum2

f = [1, 1]
sum2 = 0

while f[0] + f[1] < 4000000:
    f[0], f[1] = f[1], f[0] + f[1]  # update the held values
    if f[1] % 2 == 0:
        sum2 += f[1]

print(sum2)

Notice the subtlety in python’s ability to return multiple values. Since f[0] and f[1] are both computed before being assigned, there is no need for a place holder variable.

Admittetly, the computational difference in this example is negliable, but as the size of the list grows, avoiding the append operator becomes more important.