LED Maze, The Schematic and Shift registers

LED maze schematic

This is the schematic of the LED maze. The implementation of the shift registers can be seen here. 3 inputs are passed to each shift register: clock, clear, and serial data in. Serial data in is used to decide which LED to activate, by using a binary representation of which LED to light. To light the 2nd and 5th led, for example, 01001000 will be passed to the serial in. Then, the clock is used to shift the serial data to it’s required position on each clock pulse. This is what results in the very dim LEDs showing up, as they are actually turning on for an extremely small amount of time compared to the LEDs that are meant to be on.  Then finally, clear is used to make LEDs turn off again. This cycle repeats fast enough so that the LEDs meant to be on appear constantly on, and the other LEDs appear off (or are actually off).

This combination of inputs allows the control of each individual LED within the maze.

LED Candle Light Show – Schematic

We planned to use the I2C interface to serve as a means of communication for each candle. Two data lines are used: a clock line and and data line. These two line are shared with every device including the master and slave boards. The master board can request to write or read data to each slave board. The signal consists of multiple sets of two bytes of date. The first seven bits in the first byte is the address of the slave board that is being addressed. The last bit is signaling whether it is requesting for the following data to be written or read. The second byte is the data the master is trying send. If the slave successfully received the data bit then it will send an acknowledgment bit to the master board.

We ran in to difficulties trying to simultaneously interface with P and PB variant boards because they require different address name schemes.

Optical Theremin – SCHEMATIC

As for the technical components, the hardware was very similar to previous lab work in which we modified to obtain our project. For instance, the corresponding lab (#4) had the output be delivered to an LCD, which ours was adjusted to go to an external speakers. In addition, the major component was a “Guwoops” light sensor which helped to make the conversion.

Optical Theremin – Code Snippet

From our project, the interesting thing about our code is how the output signals are converted into realistic musical notes. The original approach we were going to use the received signals as a corresponding output using a speakers. But, we actually decided to create a realistic version which takes in the signal and translates them into real-world musical notes; therefore that is the most interesting portion of our code. The above photo only portray the first few conversion because including more would just be repetitive. Also, all the code is a series of if statements which tells certain signals to convert to particular musical notes.

Optical Theremin – BIG PICTURE

The proposed idea was to create a Theremin, an electronic musical instrument which is used with only gestures and no physical contact. The goal of the project was to successfully implement the idea while only using the knowledge from the previous lab work and creating a successful product. Therefore, the equipment necessary to complete the project was Atmel Studio and certain hardware components such as wiring, resistors, and amplifiers. As for the software aspect, the concepts of a previous lab were used to implement the proposed idea due to the similarities of the two. As a result of the effort into the project, the goal was accomplished as the Theremin was fully implemented. It was successful because of the way each gesture creates specific musical notes.

LED maze, The Code

Code for ray tracing for the LED maze

One interesting aspect of the code is the implementation of ray tracing. Ray tracing is basically casting a “ray” from a point outwards, gathering data about when the ray encounters an object, and using that data to interact with the surroundings. In this project, Ray tracing is used to find out where the visible walls will be. A ray is cast from the user’s current position, and when it encounters a wall in the maze, it instructs the program to activate the led at that position. It repeats this all the way around the user, until the entire view of the maze that the user would have while within the maze is constructed. This is referred to as the “frame” and is how the program decides which LEDs to have on after each move made by the user. This does result in a small delay between each move until the next frame is displayed, but also gets the desired result of only showing the parts of the maze wold be visible in the maze to a user.

Catapult – Code Snippets

One interesting thing about our design was that we were able to code the different angles we wanted the motor to turn. We had different cases based off user input that selected which angle to use. We then had a variable in each of those cases to store the degrees chosen, so that the return motor function would know how far to come back so that the catapult could be shot again.

Catapult – Schematics

 

As you can see in the image above, the red arrow is pointing to our motor, which is being used to pull back the catapult’s arm. The yellow arrow is pointing to our Atmega328PB which is sending out our signals to the solenoid and the Big Easy Driver. The blue arrow is pointing to the Big Easy Driver which is controlling the motor. The green arrow is pointing to the solenoid which is acting as the release mechanism. Below is the schematic to make it all work.

Catapult – Project Ideas

<iframe width=”560″ height=”315″ src=”https://www.youtube.com/embed/0A-gTYmDuN4″ frameborder=”0″ allow=”accelerometer; autoplay; encrypted-media; gyroscope; picture-in-picture” allowfullscreen></iframe>

The goal of performing this project was to encompass learning objectives acquired throughout the duration of this course. We wanted to use a motor to pull back the arm of a catapult and have a solenoid be the release mechanism. The project was successful. When we pressed the appropriate key, the motor would pull back the arm and the solenoid would retract.

LED Maze, The Big Picture

the initial LED layout
LED layout in casing

 

The goal of this project is to create an 8×8 LED maze. The user should be able to use buttons to navigate up, down, left, and right through the maze. Instead of simply showing the entire maze at once, the only parts of the maze that should be visible would be the parts of the maze a person inside would be able to see, assuming the walls are taller than the person. I.E. the only maze walls visible would be the walls in the line of site of the user, and no walls behind another wall would be visible. A “Fog of War” type of effect. The goal is to accomplish this using transistors, shift registers, ray tracing, resistors, buttons, and of course LEDs. A jewelry holder is used as the physical “casing” for the Maze. Images above are the initial LED layout, and the casing used.