This is Team 5.2 explaining how our graphing calculator works. Our design is an USART based, interrupt driven device that generates mathematical input into a graphical output on the A3BU’s LCD screen.
In simple terms, it’s a calculator. That graphs. (Our team had a lot of trouble coming up with a name. Graphulator, The Graph Master, and Graphtastic Graphing Machine were all considered.)
Various interrupt methods were incorporated into the design through user character input and push buttons on the A3BU board. The input from the PC is parsed using our own developed parsing code, which gathers all possible outputs for a given range of inputs. The software then plots those on the LCD screen. The push buttons include various scaling and scrolling methods that allow the user to interrupt the program in order to horizontally and vertically scroll and/or scale, along with re-centering capabilities.
The hardware design is very similar to that of Lab 3, using a MAX232 chip to bridge communication between the PC and the LCD on the A3BU’s on-board USART. This is done in conjunction with a serial connection via RS-232 signals.
For our final project, we have chosen to create a stoplight using the ATxmega256A3BU microcontroller. This project idea is based off of a similar project done by a team member in Arduino. The circuit includes two stoplights (with a red, yellow, and green LED each), as well as two sets of lights for a crosswalk. The user can initiate the crosswalk sequence by clicking a small button within the circuit. This will interrupt the stoplight cycle and, theoretically, give a pedestrian a walk sign. We found this to be an interesting, and challenging project; however, it is very practical.
Below is a link to a YouTube video showing a complete cycle of the stoplight circuit.
In the beginning we were thinking about doing a binary calculator, but after brooding over that idea for about a week we changed it to the LED cube. At first we wanted to have the LED cube attach to a different project that was developed by one of our team members, Tayce Lassiter, which is apart of her teaching assistant class. However, seeing as how long it was taking to complete the LED cube, and to program it, we decided to just leave the project to just the LED cube.
The purpose of this project was to use the problem solving skills and the knowledge that we gained throughout the semester to create some type of interface with our A3BU. We chose to build a device that would turn a motor at different speeds depending on various colors that the device would be sensing.
The project was broken down into 3 different parts. The first part of the project was communicating with the color senor. This was accomplished by communicating via I2C (Inter-Integrated Circuit) to an Arduino Uno. I2C is a protocol intended to allow multiple slave digital integrated circuits to communicate with one or more master chips. Like SPI (Serial Peripheral Interface), it is only intended for short distance communications within a single device. However, it is also like Asynchronous Serial Interfaces (such as RS-232 or UARTs); it only requires two signal wires to exchange information. These two signals are SCL (the clock signal) and SDA (the data signal). SCL is a particular type of signal that oscillates between a high and low state and is used to coordinate the actions of a circuit. SDA is the physical transfer of data (a digital bit stream) from point-to-point. The second part of the project dealt with sending data from the Arduino to the A3BU. We chose to do this through a single line; TXD from the Arunino to RXD on the A3BU. However, in order to accomplish this we needed to create a voltage divider circuit to step down the 5V from the Arduino to 3.3V (the maximum voltage for the A3BU). The third part of this lab dealt with driving a DC motor. After the color sensor detects either a blue, red, yellow, or green card, the data is sent from the color sensor to the Arduino and then to the A3BU via TXD/RXD. We wanted to control the motor’s speed based on which color is detected. This was accomplished by using Pulse Width Modulation (PWM). In the code, when green is sensed by the color sensor, there is an 80% duty cycle of 3.3V applied to the motor circuit, which causes the motor to spin at a high speed. When yellow is sensed there is a 60% duty cycle, which causes the motor to spin at a lower speed. When red is detected, there is a 0% duty cycle, which stops the motor. Blue is used as an initialization.
At the end of the lab we were able to create a device that would turn a fan at different speeds based on what color is detected. By doing this we were able to gain a much better understanding of I2C, how to communicate amongst microcontrollers, and how to create and implement a circuit to drive a motor.
When we first started discussing a final project idea, a lot of wild concepts were thrown around. We discussed the idea of a making a bluetooth connected scoreboard for our heated summer volleyball games. The scoreboard would be made up of several 7-segment displays and have a communication bridge via bluetooth to a fitness wearable device. The wearable device would then act as the remote to the scoreboard to increase or decrease the score wirelessly. We began to wrap our heads around the project and soon realized that unfortunately the project was too far off our budget to pull off.
The second and final idea we took of the whiteboard was to make a music box and visualizer. The idea of this project was to have a knob or tone control to change the tone and pitch of a speaker. This tone would then have a corresponding visual element that was undecided at the start of the project. We wanted a way to house the project so it had an aesthetic appeal along with impressive technical abilities. This is when the group looked to 3D printing a case.
The above image was made in a free 3D modeling software, 123D Design on a Macbook Pro. The square hole on the top was designed to house the speaker and LED array. Its width and length were designed to be 0.1mm smaller than the LED array so that it could be press fit into place. The square whole to the right of the team name was designed to house all of the microcontroller and wiring components. There is a wall separating the two square holes inside the housing with a small channel to allow wires to connect between the openings. The circular opening on the top of the design was to allow a variable resistor to stick out, giving the user control over the tone and visuals. There is also an array of square holes on the face of the design. This was originally intended to be the speaker grill to allow the audio from the speaker to travel outside the housing.
In the following blog posts, it will become clear why the words “originally intended” were used.
So what exactly are we up to? After project v1.0 crashed and burned (figuratively) all efforts have been moved v2.0. Our current project is to construct a cute little binary clock!
Just look at the little guy 😀
Here’s a close up of all that heart-pounding binary counting action!
The big idea here, is that in addition displaying the time in the best way possible, it also blinks the on-board LED’s like the second hand of an analogue (deprecated) clock. It also plays a little *boop* every quarter second (for demo purposes. No self respecting clock should *boop* that often)
In our project we are creating a makeshift Thereman device, which sounds like vid related >>> https://www.youtube.com/watch?v=w5qf9O6c20o
We decided to create one of these because we knew we wanted to work with input modulation and sound, so naturally we thought of the crazy electronic sounds of the Theremen device!
Input modulation is very interesting to us because of how much you can do with it; your imagination is the only thing that limits you. Our association with music in our project is a byproduct of our collective backgrounds with it since we all know how to play a musical instrument!
Here we are troubleshooting our Theremin project! Currently at the time of this post we are having the most problems with sound clarity and getting a sweet spot for our voltage running through the circuit! Further information is in the pipes!
The idea for the Wireless Motion Sensor projects was to display an alert on the A3BU controller when a distant motion sensor was tripped. In order to achieve this, we used Xbee wireless modules to communicate between two A3BU controllers. The first controller would simply detect when the motion sensor was being tripped. The second A3BU controller would display an alert message on its LCD when the first controller detected movement. There were four distinct parts to this project. The first was to get an A3BU to communicate with the motion sensor. The second was to set up the Xbee modules to allow communication between the two A3BUs. The third was to use the communication from the receiving Xbee in order to make the second A3BU display an alert message. Then the last part was to create a couple of mobile power sources for the two A3BU controllers.
This project is a calculator made with two series of LEDs (a yellow series representing input, and a red series representing output); a blue LED for feedback; a potentiometer, used for input; and the A3BU. Interrupts receive input from the pot, and are also tied to a pushbutton switch on the A3BU; the pushbutton is utilized to ‘advance’ the program logic to subsequent operations. It’s a fine example of a project where there’s some hardware, but most of the focus is on software. This addition-only calculator has the user turn a knob to cycle through a series of integers in binary (1-7 in decimal). When the desired number is reached, a push-button is pressed, the A3BU stores the current addend, and the potentiometer knob is again rotated. Once the second addend is reached, the push-button is again pressed, the A3BU sums the two addends, and then outputs the generated value to the red row of LEDs. When the push-button is pressed a third time, the values are cleared from memory, and the program is ready to start over. It’s important for the program to ‘know where it is’ within its flow of execution; otherwise, it executes operations out-of-sequence, leading to unexpected behavior. To this end, a series of flags are used. These flags prevent the program from advancing to its next state until the user indicates (by pressing the push-button) that he or she is ready to advance.