Just about done.  In the last two weeks, we built our second board that we etched ourselves. Came out much better than the breakouts in the beginning of the year. We used light sensitive boards and vellum paper, as can be seen below.

We also have been tying up loose wires (no pun intended). The code is nearing completion (at nearly 2000 lines total) and the casing is all completely done. Pictures below!

The Board is Complete

So the board came in and we hooked it up, and for the first time in our undergraduate careers it worked first try. All of the current sensors measured ~512 (2.5V on the nose), the light sensor fluctuated with light, and the temp sensor showed a comfortable 79 degrees in the room. All 4 relays were individually controllable and did not heat up. Success!

 

Prototyping the Board

In order to make sure our design can fit all of the components, we printed out a to-scale replica and mounted it on cardboard. There was some good news and some bad news… all of the components fit great, but we noticed that we forgot to put the temp sensor on at all so we will be amending this and ordering this coming week.

PC Board Manufacturing

Been working hard on the board setup. Heres the current setup, if it passes DRM they should be sent out to be manufactured soon!

Voltage Peaks and Simulating Humans

We’ve been working on 3 important things so far this semester:

• Getting a current reading.
  We have been working on an amplification scheme that is based off of:
  http://ecelab.com/circuit-peak-detector.htm
  Since we have a 2.5V centered signal coming out of each ACS771, this circuit will be used to find the peaks of the 60HZ sine wave and read that into the socket module. This is shown in the video below:

• Optimizing the uGrid’s algorithm.
  There will be a ton of different applications that you can plug into uGrid, and we want to control them differently. We’ve begun categorizing all of the possible different appliances into how they can be controlled, and will be turning that into program rules this month.

• Simulating a house.
  Or rather, as the title says, simulating people. This is probably the most interesting program any of us have ever written. It is written in Python, currently around 400 lines of code, and here is how it works: 
  1. In the simulation there is a world which contains houses which contain rooms which contain appliances.
  2. There are people within the house that can do actions. An example would be if someone wants to watch TV, they could.
  3. People accurately travel throughout the house. They have personalities which dictate whether or not they will leave something on when walking around, and the house actually has a map that the people can navigate.
  4. Throughout the day, the house accumulates its power totals. There is still a fairly limited amount of appliances, but when this is done we will post what assumptions we make about the house.
  5. The simulation can be run by itself or with the uGrid system.

Semester Duex

First, a recap of everything that has been accomplished since the last post:

• Screens have been created and loaded for the main console.
• Serial events which allowed the Arduino, Rabbit, and Screen to communicate. For example, pushing the button on the screen above would cause a relay to switch.

• A request for data can be sent from the Rabbit to the Arduino.
• Relay interfacing.

From here, we will be working on automation and fabrication.

More updates as we go this semester,

-ugrid

Communication and Touch Screen Come to Fruition

Been a while since the last post, but we have been hard at work!

As far as communication goes:

We implemented a call and response technique that allows the system to make sure a module is listening before it sends a command, and to resend any commands that were misread or didn’t make it. Below, one Arduino sends the “Turn LED on” command to another Arduino, and after 5 wireless communication sends, the information is sent.

We have also made leeway on the touch screen. We will be doing all of the programming within the 4DGL language using serial communication to communicate with the Rabbit processor. Below, the touchscreen displays a button (which can be pressed to navigate to the next screen) that was created using the 4DGL language:

 

From here to the end of the semester we hope to:

• Interface the Rabbit with the Arduino instead of Arduino-Arduino communication.
• Hook up this application to the sample relay used earlier.
• Get a basic touch interface working.
• Get accurate current, temperature, and motion readings.

All of these goals will be on breadboards, since next semester we plan on fabricating boards for use. Be back with more updates this month

-ugrid