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:
    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,


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


Communication Established

This weekend we worked on establishing communication both between units as well as between chips within each unit. With this, we designed voltage stepdowns as well as stepups to have 3.3V chips (Xbees) communicate with 5V chips (the Arduino).

Naturally, we tested them by sending the string “Hello world” over and over from one to the other, which projected the results on screen.

Success. We also got it to send the output of an A/D converter, allowing sensor readings to be sent. Next up will be connecting to our screen and writing a call and response pattern for the module.


Protoday in the Lab

Today we worked on prototyping our hardware. To do this, we put a relay on a breadboard along with a 7404, a 2n2222a, a red LED, green LED and required resistors and isolation. The idea is that one pin can control all of these elements- When the pin goes high the relay is turned on (allowing mains power to flow) and the green LED turns on to signify the circuit being on, and when the pin is low the red LED turns on to signify that the relay is off.

We even got this working with the PIR motion sensor, shown below by Elie and Brian waving at it.

The ACS712 current sensors we ordered came in a SOIC package, which makes it difficult to prototype with them. Additionally, even if you could prototype with them the mains power going through a breadboard could fry it. So, we decided to etch our own breakout board, shown below.

More pictures after the etch.


First Stages of Prototyping

We got in our first ACS712 current sensor yesterday and gave it a spin in the lab. We plugged in a laptop charger and wound up getting a nice display on the oscilloscope, and decided that this would be the chip we used for current sensing.

Since this was the last component we needed for prototyping, we have made the parts orders today. The last component we need for the initial socket/console pairing is the screen, which we should be ordering soon.