|Product Performed to Expectations:||10|
|Specifications were sufficient to design with:||8|
|Demo Software was of good quality:||10|
|Product was easy to use:||10|
|Support materials were available:||8|
|The price to performance ratio was good:||10|
|TotalScore:||56 / 60|
I received my PiFace in the mail a few weeks ago. Unfortunately, life has kept me from spending proper time with it until recently. I'm only a hobby programmer, but a unix/linux system admin by trade, so it was pretty easy for me to get going.
The PiFace has 8 digital inputs and 8 digital outputs. There are also +5v terminals, grounds, and relays for switching higher voltages. 4 of the inputs can be triggered by onboard buttons. All 8 of the outputs have led indicators showing whether the output is engaged or not. When looking down on the board, the PiFace obsures the RPi's onboard LED's, but I rarely find those informational when everything is working as designed. There are also jumpers allowing you to interface multiple PiFace boards, yet the hardware does not provide an easy way to attach multiple boards.
I started with a default raspbian install, and installed the software using the documentation found on github: https://github.com/thomasmacpherson/piface
Other piface documentation can be found here: https://drive.google.com/?pli=1&authuser=0#folders/0B-UAZ9CyJCLGQjJ3RDlqa2pqaDg
Next came fitting the board on top of the raspberry pi. It was super simple. The PiFace fits within the standard Raspberry Pi footprint. It only adds some height.
Top view. I've attached infrared proximity sensors.
Side view. I've seen everybody else mention the rubber pad. It's attached to the bottom of the board allowing the piface to rest level. I thought this was a really nice touch.
Other Side view. Here you see the io ports.
Programming via Python is riddiculously easy. You need to know 4 lines of code, and that's it.
import piface.pfio as pfio
pfio.init() - initiates the pfio class
pfio.digital_write(<pin>,<on/off>) - pins numbered 0-7, 1 for on, 0 for off.
pfio.digital_read(<pin>) - again, pins are numbered 0-7.
So, I'm running! First task was to make the pretty lights dance:
The Code: http://pastebin.com/MGj64qUQ
The Result: http://www.youtube.com/watch?v=rbRk7Xj7ztc
You hear the relays clicking, but they can be disabled by pulling a jumper.
I'm curently working on a project to monitor my garage doors using the infrared sensors pictured above, a few led's, and a couple other swiches. This PiFace would also be great for projects such as monitoring an alarm system. I will try to complete this and edit the review when I am not chasing after an infant.
While in monitoring garage doors, you don't have to worry about an incredibly fast polling speed, I did some brief experimentation with the code below. If I sleep for .01 seconds between loops, it consumes about 25% cpu. If I sleep .05 seconds between loops, it only comsumes about 5%. That should likely be good for most applications.
Overall, the PiFace is an excellent way to get into physical programming. It doesn't get any easier. The wires can hook right up, and you can begin to make progress in less than 5 minutes. The PiFace lacks some features, such as an analog to digital coverter or serial connection, but the i2c inputs on the RPi can be wired to interface with multiple devices. The main strength of the PiFace is the easy of use. It simplistic, easy to use, and hard to screw up.
In future versions, I would like to see a header soldered on top of the PiFace, so another PiFace can be stacked right on top, or the pins may be accessed by another peripheral as if you plugging directly into the RPi itself.
I would also like to see a more minimal python library that could be installed without the gui components, as I prefer a stripped down linux install. Even documentation showing how to interface using only the i2c libraries would go a long way.