Fresh Coffee at Mailchimp

via Raspberry Pi

Ben: Here’s a guest post from Steven Sloan, a developer at MailChimp.

IMG_4456

Grounds for innovation

Here at MailChimp, we’re always trying to listen hard and change fast. Turns out, this requires a good bit of coffee. Each department has its own take on how to keep the stuff flowing, mostly with the standard Bunn-O-Matic commercial machines. A few folks regularly avail themselves of our espresso setup. The developers fill two airpots—one with regular, the other double strength.

And then there’s the marketing team and our precious Chemex.

We make a pour-over pot once every hour or so, all day long, 5 days a week, 50-something weeks a year. Last December, when we were gathering data for our annual report, we got curious about how many Fresh Pots that might amount to. We tried to count it up, but begrudgingly had to accept the fact we didn’t have a good measure beyond pounds consumed. We even tried to keep track with a bean counter, but that didn’t last long.

For a while, the exact nature of our coffee consumption seemed like it would remain just another mystery of the universe. But then one day, talking to Mark while waiting on yet another Fresh Pot, I said, “Hey, I bet we could track the temperature with a Raspberry Pi and post to the group chat when there’s a fresh one.”

I wasn’t too serious, but Mark’s response was one often heard around MailChimp when ridiculous projects are proposed: “Sounds great, just let me know what you need to get it done.”

A few days later, I had a materials list drawn up from Adafruit’s thermometer tutorial, and we were off to the races.

IMG_4442

A fresh Pi

With a Raspberry Pi in hand, the first thing I did was add a script to the boot process that sent an email using Mandrill with its IP so I could find it on our network without trouble.

Then, I had to tackle the problem of detecting pot states with only a single datapoint: current temperature. I hoped that comparing the running averages of different time spans would be enough to determine the pot’s status. (The average Chemex temperature over the course of a few minutes, for instance, would tell us something different than the average temperate over the course of an hour.)

Since this was a greenfield project, I wanted to work with an unfamiliar language. I felt like the more functional nature of Clojure would be a great fit for passing along a single piece of state. This turned out to be a great decision, and I’ll explain why in a minute.

Graph it home

I hacked together a quick program that would spit out the current temperature, minute’s running average, hour’s running average, and the running average’s rate of change to a log file so I could analyze them.

...
{"current":32.062, "minute":24.8747, "hour":23.5391, "running-rate":0.039508}
{"current":32.437, "minute":25.0008, "hour":23.5635, "running-rate":0.0423943}
{"current":32.875, "minute":25.1322, "hour":23.5897, "running-rate":0.045361}
{"current":33.625, "minute":25.2738, "hour":23.6177, "running-rate":0.048569}
{"current":33.625, "minute":25.413, "hour":23.6476, "running-rate":0.05159}
{"current":33.625, "minute":25.55, "hour":23.6793, "running-rate":0.054437}
...

Log files in hand, I temporarily turned back to Ruby using the wonderful Gruff charting library to visualize things and make patterns easier to spot.

A few batches of hot water gave me a decent idea what things should look like, so I moved our coffee equipment to my desk to get some live data. This let me check in with the actual running state of the program and compare it with the status of the pot (and led to some coworker laughs and a wonderful smell at my workspace all day).

07-c

A brewing or fresh pot is easy to recognize, but figuring out when the pot is empty turned out to be a little tricky. It takes a while for the Chemex to completely cool off, which means it could be empty and still warm, which I’m sure would lead to more than a few disappointing trips to the kitchen. Luckily, the rate a pot cools tells us if it is empty or not—for instance, a half-full pot stays warm longer than an empty one simply because of the coffee still in it. Always nice to have physics on your side.

Watchers for the win

Armed with the collection of datapoints (running averages, rate of change, etc.) for each of the pot’s states, I moved on to figuring out how to notify our department’s group chat room when a pot was brewing, ready, empty, or stale. This is where some of the built-in features of Clojure came in handy.

I already had a program that logged the current state of itself every second. By switching the actual state to an agent, I could apply watchers to it. These watchers get called whenever the agent changes, which is perfect for analyzing changes in state.

Another agent added was the pot itself. The watcher for the temperature would look for the above mentioned boundaries, and update the pot’s state, leaving another watcher to track the pot and notify our chat room. When it came time to pick an alias to deliver the notifications, Dave Grohl was the natural choice.

Here’s a simple example of the pot watcher looking for a brewing pot:

(def pot-status
  (agent {:status "empty"}))

(defn pot-watcher [watcher status old_status new_status]
  (if (= (:status new_status) "brewing")
    (notify/is_brewing)))

(add-watch pot-status :pot-watcher pot-watcher)

The great thing is the watcher only gets called when the status changes, not on each tick of the temperature. Using agents felt great to me in this case as they provided a clean way to watch state (without callbacks or a ton of boilerplate) and maintain separation of concern between different parts of the program.

hipchat1

Freshness into the future

I’m still working out a few kinks, tuning in the bounds, and keeping a log of pots. It’s been a fun experience and I learned a ton. Something tells me this won’t be the last time we work with Raspberry Pi on a project. What’s next, Fresh Pots in space? Luckily, we’ve got plenty of coffee to propel us.

tumblr_n9kwt5IBUt1ri8rtfo1_1280

Ben: Thanks to Steven and MailChimp for permission to use the post – we’re very pleased to see the Pi used as the tool of choice of coffee-hungry developers around the world! Coffee is important to us here at Pi Towers…

Trojan Room Coffee Pot

Blast from the past – remember this coffee pot? Click to read more

MailChimp is what I use to power Pi Weekly – my weekly Raspberry Pi news & projects email newsletter – check it out at piweekly.net!

The internet of trees makes smart birdhouses using Arduino Yùn

via Arduino Blog

tumblr_inline_nbjvwkqaDW1rxqn91

The connected birdhouse is a project prototyped during a workshop ran by Massimo Banzi at Boisbuchet, last August in France. It was developed using Arduino Yùn, by Valentina Chinnici, who shared with us the project, and two other students taking part to  the week of learning-by-doing around the theme of  the Internet of Trees.

They redesigned a traditional object, a wooden birdhouse to be placed outdoor, and connected it to a lamp shaped like a nest, to be placed indoor:

The connected birdhouse was in fact an interactive object able to communicate to the nest/lamp the presence of a bird inside the house, and accordingly to a color coded signal was giving also some informations about the size of the bird itself. In the event of a bird entering into the house, the nest/lamp remotely controlled via WiFi by an Arduino Yùn, was turned on. The nest/lamp received the notification from the birdhouse translating it firstly with a rainbow effect. After few seconds the light changed according to the weight of the bird (green, yellow or red).

The LED strip used for the nest lamp was an Adafruit Neopixel strip controlled by an Arduino Yún.

On this blog you can find the sketch to make it work and create one yourself.

Afroman Demonstrates Boost Converters

via Hackaday » » hardware

boosIf you need to regulate your power input down to a reasonable voltage for a project, you reach for a switching regulator, or failing that, an inefficient linear regulator. What if you need to boost the voltage inside a project? It’s boost converter time, and Afrotechmods is here to show you how they work.

In its simplest form, a boost converter can be built from only an inductor, a diode, a capacitor, and a transistor. By switching the transistor on and off with varying duty cycles, energy is stored in the inductor, and then sent straight to the capacitor. Calculating the values for the duty cycle, frequency, inductor, and the other various parts of a boost converter means a whole bunch of math, but following the recommended layout in the datasheets for boost and switching converters is generally good enough.

boostconverter

[Afroman]‘s example circuit for this tutorial is a simple boost converter built around an LT1370 switching regulator. In addition to that there’s also a small regulator, diode, a few big caps and resistors, and a pot for the feedback pin. This is all you need to build a simple boost converter, and the pot tied to the feedback pin varies the duty cycle of the regulator, changing the output voltage.

It’s an extremely efficient way to boost voltage, measured by [Afroman] at over 80%. It’s also exceptionally easy to build, with just a handful of parts soldered directly onto a piece of perfboard.

Video below.


Filed under: hardware, parts

Electricute – Conductive Velcro-Style Hook and Loop

via SparkFun Electronics Blog Posts

Today we have another episode of “ElectriCute' - our video series focusing on the wonderful world of e-textiles. In today’s video, our resident wearables guru Dia and Creative Technologist Nick explore ”conductive hook and loop“ (think Velcro) material.

As always, feel free to leave any questions or comments below. You can check out all the videos from the ElectriCute series here.

comments | comment feed

New Raspbian and NOOBS releases

via Raspberry Pi

If you head over to the downloads page, you’ll find new versions of our Raspbian image and NOOBS installer. Alongside the usual firmware and kernel improvements, major changes to the Raspbian image include:

  • Java updated to JDK 8
  • Mathematica updated to version 10
  • Sonic Pi updated to version 2
  • Minecraft Pi pre-installed

Following its release last week, of our port of Epiphany has replaced Midori as the default browser, bringing with it hardware-accelerated video support and better standards compliance.

Epiphany is now the default browser

Epiphany is now the default browser

Our Raspbian image now includes driver support for the BCM43143 802.11n WiFi chip. Last week Broadcom released a rather neat USB hub and WiFi adapter combo based on this chip, which should now work out of the box. More info is available here.

BCM43143 802.11n wireless dongle

BCM43143 802.11n USB hub and WiFi adapter

Finally, to free up SD card space, the offline NOOBS package now only contains the Raspbian archive. To install Arch, Pidora, OpenELEC, RaspBMC or RISC OS you will require a network connection.

Join the SparkFun Faire Game!

via SparkFun Electronics Blog Posts

Hey folks! Today we are excited to announce a new contest we’re hosting. The contest is entirely online, at your own pace, and you can earn discounts off SparkFun gear! It’s called the SparkFun Faire Game!

alt text

Here is how it will work:

  • Below you will find a list of challenges you can complete at home over the next week (12:01 a.m. MT on September 14th - 11:59 p.m. MT September 21, 2014)
  • When you’ve completed a challenge, simply tweet @sparkfun with a photo or video of your project, which challenge it fulfulls (the “color” of the challenge) and the hashtag “#myfairegame.” We will be using this hashtag to tally your complete challenges SO DON"T FORGET! For example you would tweet “Hey @sparkfun - I just completed the red challenge! #myfairegame - [attached picture].” You will need a Twitter account to participate in this competition - but it only takes a few minutes to set one up!
  • Once the competition has ended, we will tally the results and send you a discount code based on how many challenges you completed. Complete all 10 challenges = 25% off, 5-9 challenges = 20% off, 1-4 challenges = 10% off.
  • Lastly, you must register using the EventBrite form below. It’s completely free and this will give us a way to contact you after the competition has ended so we can get you your prize!

That’s it! Here is the list of challenges and a link with an example tweet:

  • Navy Blue – RoboGames: Play a game. With a robot. Tweet This!

  • Sky Blue – Wide World of Science: Do a science experiment at home. Tweet This!

  • Red – Build Something Beautiful. Tweet This!

  • Yellow – Coding is Love: Learn how to do something with code. Program an Arudino, build a website, make a Javascript game–up to you! Tweet This!

  • Forest Green – Agrihack for Justice!: Learn about farm hacking and Smart Citizen Tweet This!

  • Lime Green – Craft your heart out: Make a gift for someone. Tweet This!

  • Purple – You can build it: Visit your local hackerspace, makerspace, or hacker/maker meetup. If none of those exist, start a meetup yourself! Tweet This!

  • White – Pssh Doors: Learn how to lockpick. Tweet This!

  • Orange – Share the geekery: Do something geeky with someone who’s never done it before. Tweet This!

  • Pink – Tinker, tailor, solder, spy: Solder something! Tweet This!

We hope you enjoy the SparkFun Faire Game - and maybe learn an awesome new skill while you’re at it!

comments | comment feed

A Breakout Board for a Flir Lepton

via Hackaday » » hardware

leptonThermal imaging cameras are all the rage now, and one of the best IR cameras out there is Flir’s Lepton module. It’s the sensor in the FLIR ONE, a thermal imaging camera add-on for an iPhone. Somewhat surprisingly, Flir is allowing anyone to purchase this module, and that means a whole bunch of robotics and other various electronics projects. Here’s a breakout board for Flir’s Lepton.

Electron artisan [Mike] recently got his hands on a FLIR ONE, and doing what he does best, ripped the thing apart and built the world’s smallest thermal imaging camera. Compared to professional models, the resolution isn’t that great, but this module only costs about $250. Just try to find a higher resolution thermal imager that’s cheaper.

With this breakout board, you’ll obviously need a Lepton module. There’s a group buy going on right now, with each module costing just under $260.

The Lepton module is controlled over I2C, but the process of actually grabbing images happens over SPI. The images are a bit too large to be processed with all but the beefiest Arduinos, but if you’re thinking of making Predator vision with a Raspi, BeagleBone, or a larger ARM board, this is just the ticket.

You can check out some video made with the Lepton module below.

This is also project number 3000 on hackaday.io. That’s pretty cool and worthy of mention.


Filed under: hardware

VEX + Arduino Control — Best of both worlds!

via SparkFun Electronics Blog Posts

There are thousands of schools using VEX in the classroom. VEX started with a simple PIC microcontroller system and recently upgraded their platform to a Cortex based system. These are fantastic, high-powered, fast systems that work well in many classrooms. There are a variety of programming environments for VEX from easyC, robotC, to ModKit and Flowol. However, there is also a fast growing population of schools using Arduino to teach basic microcontroller programming and electronics. How can we combine these two realms?

VEX has a fantastic building platform. If you are looking at expanding your robotics, mechatronics, or general structures program – I encourage you to look into VEX. Their structural and mechanics system is fully modular and works with a minimum number of unique parts and pieces. One of the struggles I have heard from teachers is how can we integrate Arduino with what we do with VEX. Here’s a quick summary of what we got working. A more in depth tutorial is in the works.

alt text

Human Control

Using Arduino as an autonomous controller for VEX motors is a pretty easy problem to solve. The bigger problem to tackle is replicating the “tele-operated” human-control that VEX provides.

VEX offers a slick WiFi Joystick control and default firmware on their Cortex controller that allows a quick “plug-and-play” experience. I wanted to re-create the same experience with as few custom parts as possible.

alt text

A quick search for USB joystcks on-line came up quite a few different options. I tried this low-cost controller, but settled with the Logitech F310 instead. It’s currently availble on Amazon for $18.99 and features nearly all of the same buttons and controls as the traditional VEXnet joystick.

alt text

Hardware Used

Aside from the joystick and the Clawbot kit from VEX, here is a wishlist of all the parts I used on this build. With the battery, the total retail cost is about $200. What I really like about this solution is that it opens up the controller to all sorts of other interfaces, sensors, and peripherals that you can build and hack on.

If you want to try this, you will need to pair your XBee Radios. You can check out this tutorial if you’ve never done this before:

Exploring XBees and XCTU

June 5, 2014

How to set up an XBee using your computer, the X-CTU software, and an XBee Explorer interface board.

Control Programming

alt text

Now I had a comparable controller, I needed an interface to the Arduino. Naturally, I looked into Processing. The GameControlPlus library in Processing handles a lot of the back-end I/O for the joystick. Here is a rough DriverStation program example in Processing. You will need to install both the VSync and the GameControlPlus libraries to use this example. You can add both of these directly in Processing from the Sketch –> Add Library menu.

The code is pretty well commented. In general, what it does is interface a joystick controller and read in all of the inputs from the joystick and it sends this to the Arduino through the serial COM port associated with the XBee Radio. Alternatively, you can use a USB cable tether directly to the Arduino and for-go the wireless Xbee part - just make sure that you specify the correct COM port.

// DriverStation.pde
//
// This example uses two community supported libraries - gamecontrolplus and vsync
// you need to install both of these libraries before running this example.
//
// gamecontrolplus handles the interface with any standard USB controller
// vsync is a great library for passing data between processing and arduino
//
// Written by: B. Huang, Sparkfun Electronics -- 
// rev. September 12, 2014
//
import processing.serial.*;
import org.gamecontrolplus.*;
import vsync.*;

Serial myXbee;          // The serial port interface -- connected to an XBee for wireless serial to Arduino

/***************************************************************************************
// vsync objects
// Create a sender and a receiver for incoming and outgoing synchronization.
****************************************************************************************/
ValueReceiver receiver;
ValueSender sender;

// vsync public variables for passing to Arduino
public int leftX;
public int leftY;
public int rightX;
public int rightY;
public int hatPosition;

public int b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12;

// variables for receiving debug data back from Arduino
public int debugVar0, debugVar1, debugVar2, debugVar3;

/***************************************************************************************
// gamecontrolplus objects 
// Objects for managing and hangling interface to the joystick controller
****************************************************************************************/
ControlIO control;
ControlDevice device;

ControlButton[] button; // Array of buttons - one for each button control on joystick
ControlHat hat;         // The 'hat' is the up/down/left/right control on joystick

Stick rightStick;       // We are using a custom Stick class which combines two ControlSliders for each analog "stick"
Stick leftStick;        // each ControlSlider returns a single axis. In the constructor for the Stick object,
                        // define the X and Y ControlSlider.
int controllerID; 
String controllerName;

int numDevices;         // number of 'gamecontrol' devices connected. This includes any I/O including mouse, keyboard, touchscreen...
int numButtons;         // number of buttons on joystick
int numRumblers;        // number of rumblers on joystick
int numSliders;         // number of 'sliders' or analog joystick axes

String[] hatPositionNames = {
  "Center", "Northwest", "North", "Northeast", "East", "Southeast", "South", "Southwest", "West"
};
/********************************************************
/ Misc variables for displaying text to graphics window.
/********************************************************/
int xPos = 10;
int yPos = 20;
int txtLineSpace = 20;

public class Stick {
  float x;
  float y;
  public ControlSlider sliderX; 
  public ControlSlider sliderY; 

  public Stick(ControlDevice controldevice, int sliderXnum, int sliderYnum) {
    sliderX = controldevice.getSlider(sliderXnum);
    sliderY = controldevice.getSlider(sliderYnum);
  }

  public float getX() {
    return sliderX.getValue();
  };

  public float getY() {
    return sliderY.getValue();
  };
}
/********************************************************
/ setup function 
/********************************************************/
public void setup() {
  size(800, 600);  // Define the window size.

  // List out and setup the Serial com port interface
  print("Serial Com Ports Available: ");
  println(Serial.list());
  println();

  // myXbee = new Serial(this, "COM6", 9600);   // COM port can be specified explicitly or by index. On most PCs, it is index [0]
  myXbee = new Serial(this, Serial.list()[0], 9600);

  // Setup the gamecontrol device object
  control = ControlIO.getInstance(this);      // instantiated the controlIO object
  numDevices = control.getNumberOfDevices();  // find the number of connected controllers

  // Search for the "Joystick" controller on USB
  for (int x = 0; x < numDevices; x++) {
    println("[" + x + "] " + control.getDevice(x).getName() + " - Type: " + control.getDevice(x).getTypeName());
    if (control.getDevice(x).getTypeName() == "Stick")  // Tested using the Logitech GamePad F310
      controllerID = x;                                 // It enumerates as a type "Stick"
  }
  println();

  device = control.getDevice(controllerID);   // device object points to the joystick controller
  controllerName = device.getName();  

  numButtons = device.getNumberOfButtons();
  numSliders = device.getNumberOfSliders();
  numRumblers = device.getNumberOfRumblers();

  hat = device.getHat(0); // 8 position directional control

  // define the right and left paddles on the controller.
  // Stick class combines both the up/down and left/right sliders into one object
  rightStick = new Stick(device, 1, 0); // Analog joysticks
  leftStick = new Stick(device, 3, 2);  // Analog joysticks

  button = new ControlButton[numButtons]; // creates an array of button objects for all buttons on device.
  for (int x = 0; x < numButtons; x++)
    button[x] = device.getButton(x);

  // setup for vSync control. Receiver object takes in data from Arduino. Sender object sends data to Arduino
  // the number of objects and the order of these must match between Processing and Arduino.
  receiver = new ValueReceiver(this, myXbee).observe("debugVar0").observe("debugVar1").observe("debugVar2").observe("debugVar3");
  sender = new ValueSender(this, myXbee).observe("hatPosition").observe("leftX").observe("leftY").observe("rightX").observe("rightY").observe("b0").observe("b1").observe("b2").observe("b3").observe("b4").observe("b5").observe("b6").observe("b7").observe("b8").observe("b9").observe("b10").observe("b11").observe("b12");
}

/********************************************************
/ draw function 
/********************************************************/

public void draw() {
  xPos = 20;  // starting text position
  yPos = 20;   
  refreshLocalVariables();  // fetches the state of the button presses and joystick to local Variables -- used with vSync Library
  background(255);
  fill(255, 0, 0); // red for LEFT stick (slider)

  ellipse(map(leftStick.getX(), -1, 1, 20, 780) - 20, map(leftStick.getY(), -1, 1, 0, 600), 20, 20);

  fill(0, 0, 255); // blue for RIGHT stick (slider)
  ellipse(map(rightStick.getX(), -1, 1, 20, 780) + 20, map(rightStick.getY(), -1, 1, 0, 600), 20, 20);

  text("Joystick Controller: " + device.getName(), xPos, yPos);
  yPos += txtLineSpace;
  text("NumButtons: " + numButtons, xPos, yPos);
  yPos += txtLineSpace;
  text("NumSliders: " + numSliders, xPos, yPos);
  yPos += txtLineSpace;
  text("NumRumblers: " + numRumblers, xPos, yPos);
  yPos += 2*txtLineSpace; // double-space

  text("*********Dashboard*********", xPos, yPos);
  yPos += txtLineSpace;
  text("Left Analog Stick: (" + leftX + ", " + leftY + ")", xPos, yPos);
  yPos += txtLineSpace;
  text("Right Analog Stick: (" + rightX + ", " + rightY + ")", xPos, yPos);
  yPos += txtLineSpace;

  for (int x = 0; x < numButtons; x++) {
    text("Button [" + x + "]: " + (int)(button[x].pressed() ? 1 : 0), xPos, yPos);
    yPos += txtLineSpace;
  }

  text("Hat Position: " + hatPositionNames[hatPosition], xPos, yPos);
  yPos += 20;
}

void refreshLocalVariables()
{
  // type casts the boolean .pressed() to an integer type.
  b0 = button[0].pressed() ? 1 : 0;
  b1 = button[1].pressed() ? 1 : 0; 
  b2 = button[2].pressed() ? 1 : 0; 
  b3 = button[3].pressed() ? 1 : 0; 
  b4 = button[4].pressed() ? 1 : 0; 
  b5 = button[5].pressed() ? 1 : 0; 
  b6 = button[6].pressed() ? 1 : 0; 
  b7 = button[7].pressed() ? 1 : 0; 
  b8 = button[8].pressed() ? 1 : 0; 
  b9 = button[9].pressed() ? 1 : 0; 
  b10 = button[10].pressed() ? 1 : 0; 
  b11 = button[11].pressed() ? 1 : 0; 
  b12 = button[12].pressed() ? 1 : 0;

  // scales the -1 to +1 state of the slider to -255 to +255
  leftX = (int) map(leftStick.getX(), -1, 1, -255, 255);
  leftY = (int) map(leftStick.getY(), -1, 1, -255, 255);

  rightX = (int) map(rightStick.getX(), -1, 1, -255, 255); 
  rightY = (int) map(rightStick.getY(), -1, 1, -255, 255);

  hatPosition = hat.getPos();
}

Arduino Code

I learned a few things as I wrote this example. Interfacing the H-Bridge controller on the ArduMoto Shield was easy. The ArduMoto Shield is perfect for driving and controlling the VEX motors. However, the ArduMoto Shield only has two channels. Additional motors require an external motor controller. Thankfully, VEX includes these in their Clawbot kit. The VEX Motor Controller 29 has a small PIC microcontroller embedded inside it. It responds to a 50 Hz pulse-width modulation (PWM) signal with a pulse width that varies from 1000 uS to 2000 uS. 1000 uS corresponds to full speed reverse and 2000 uS corresponds to full speed forward. 1500 uS, logically, causes the motor to stop.

Using the Servo library, I wrote a small function vexMotorWrite(Servo motorObj, int speed) that scales a speed value (-255 to +255) to a Servo pulse from 1000 uS to 2000 uS. You must pass this function the Servo motorObject tied to the VEX Motor Controller.

What’s next?

Look for an in-depth tutorial around this. A lot of tips around using Xbees, the Servo library, and integrating all of these things together. In the meantime, let us know if you end up trying this in your own class! Happy hacking!

comments | comment feed

Pololu Carrier with Sharp GP2Y0D815Z0F Digital Distance Sensor 15cm

via Pololu - New Products

This small digital distance sensor detects objects between 0.5 cm and 15 cm (0.2″ and 6″) away. With its quick response time, small size, low current draw, and short minimum sensing distance, this sensor is a good choice for non-contact, close-proximity object detection, and our compact carrier PCB makes it easy to integrate into your project.

New Product Friday: Live MOSS!

via SparkFun Electronics Blog Posts

This was a pretty big week SparkFun. Not only did we have the big Intel Edison announcement earlier this week, but this was the first week we started occupying our new building. We still managed to throw together a New Product Post Video, even though we don’t have a studio setup yet. If you want a sneak peak at the new digs, check out the video below.

In the next few (several?) weeks when we get more settled, I’m sure we’ll have a formal walkthrough video of the new building. It’s still a bit of a work in progress and it’s only about half-occupied, we still need to move stock and production over. Plus, we need to setup the new studio, what will it look like?

alt text

Earlier this week we did a mid-week product post, announcing not only the new Intel Edison, but also the ‘Blocks’ that we are making to accompany the module. Blocks are a lot like shields are for Arduino. They connect to the Edison module to not only expand functionality, but also to gain access to the hardware contained in the tiny module. Want to know more? Check out the video below.

alt text

This is the HackRF One, a Software Defined Radio (SDR) peripheral capable of transmission or reception of radio signals from 10MHz to 6GHz. Designed to enable test and development of modern and next generation radio technologies, HackRF One is an open source hardware platform that can be used as a USB peripheral or programmed for stand-alone operation. Be sure to check out the wiki for more information!

alt text

If you’re going to get a HackRF One, you’re going to need an antenna. The ANT500 is a telescoping antenna made specifically for the HackRF. It has an SMA connector, telescopes from 20cm to 88cm and is designed for operation between 75 MHz to 1 GHz. You can also act like Zorro with one if you’re bored.

alt text

We have another MOSS robotics kit this week. The Exofabulatronixx 5200 is not only hard to type, it’s got a LOT of pieces. Whereas the Zombonitron is 1600, the Exofabulatronixx is a whopping 5200! But seriously, it has a lot more MOSS blocks and spheres to build more stuff. It also includes a ‘double brain’ block which uses Bluetooth to link your robot to your mobile device or computer. If you’re not familiar with MOSS, it’s a system of interconnecting robotic blocks, held together by metal spheres. The spheres not only act as a means to transmit power, but also signals between blocks.

alt text

You’ve always wanted to output analog voltages from a microcontroller, the MCP4725 is the DAC that will let you do it! The MCP4725 is an I2C controlled Digital-to-Analog converter (DAC). A DAC allows you to send analog signal, such as a sine wave, from a digital source, such as the I2C interface on the Arduino microcontroller. We have a new version this week that fixes some minor silk issues and gets a basic update.

alt text

We also cleaned up the Touch Shield a bit, fixing some minor layout issues. The Touch Shield uses an MPR121 touch IC and has 9 touch pads along with 3 extra external connections for additional pads. The shield makes touch input nice and easy for your Arduino.

alt text

Lastly, we have some panel mount nuts. You know those really thin nuts that come with panel mount buttons and switches that you end up losing and can’t find replacements for at the hardware store? We now have the most common size (M12 0.75) in packs of 25.

That’s all for this week. If you didn’t get enough new stuff between the Intel Edison products and the ones we have for today, I don’t know what to tell you. I guess you’ll just have to come back next week and see what else we have then. Thanks for reading and we’ll see you again next week.

comments | comment feed

Sharp GP2Y0D815Z0F Digital Distance Sensor 15cm

via Pololu - New Products

This small digital distance sensor detects objects between 0.5 cm and 15 cm (0.2″ and 6″) away. With its quick response time, small size, low current draw, and short minimum sensing distance, this sensor is a good choice for non-contact object detection, and its short minimum detection distance lets it see objects very close to the face of the sensor.

Sound Camera.

via coolarduino

 

device-2014-09-11-120157 device-2014-09-11-120328 device-2014-09-12-000047 edited

 

One more project, that shows breathtaking beauty of the FFT (Fast Fourier Transform). Once again, like in last 3D Ultrasonic Radar Project,    Arduino DUE was nominated to be Maestro, doing major part of the Digital Signal Processing in real time.  As you can see below, the hardware includes 4 “modules”:

  1. Sensor board
  2. Arduino DUE
  3. Bluetooth shield
  4. Android tablet.

Last two items aren’t strictly necessary. Alternative would be to connect TFT display directly to arduino, but I decided not to spend my time on re-inventing drawing-rendering software. Better to delegate all visualization stuff to the equipment that was  specifically design by big monsters in high tech industry.  I spend quite time digging into android graphics subject anyway, only hoping I can apply my knowledge somewhere else later on.

Sound_Camera

Sensor board holds 4 microphones from  SFE.  Plus a few decoupling components, capacitors and inductor in power line.

Software.

   Brief summary: Arduino sampling 4 analog inputs, close to 41 kHz,  x 4 = 164 ksps,  software library Radix4 posted on this blog was imported into project practically intact. DMA feature on Arduino DUE allows sampling rate up to 1 MSPS, and I already successfully tested its capability in 3D Radar project.  Having 2048 fft size, at the first processing stage  output there are 1024 bins 20 Hz each. Than, using arctangent LUT, phase of each bin is extracted.  Difference in phases two vertically position microphones gives Y component, and two horizontally spaced mic’s – X component. Sound source is localized with accuracy ~ 0.5 degree. Have to say, that on the lower frequency end, 100 Hz – 1 kHz , where wavelength is huge compare to spacing between two mic’s ( 3.4 meters at 100 Hz ), accuracy is deteriorating proportionally to wavelength.

Arduino is calculating data really fast, providing  X,  Y, and M  every 50 milliseconds. M – is for magnitude. Than, all this data stream flows to android over BT.  Everything else is obvious, watch the video.

Speaker outputs white noise, as for single tone (frequency) only one pixel would be visible on screen. Android software “colorized” picture based on a frequency, low range – starting from red, and up to violet on high end of the frequency band, through all 1024 color wheel possibilities.  You can see, that picture saturated with green and blue, and there is almost no red color. There are two things, first is a speaker, not performing well at low end. Second nuance is the fact, that low frequencies are not “grouped” so effectively, due to the localization error, what I tried to explain in a paragraph above. I created an option in the menu to select different types of colorization, based on a frequency or based on a magnitude. They are look pretty similar for white noise source, so there is only one video clip.

Have fun.


Let’s get Physical! New physical computing animation

via Raspberry Pi

With the success of the first two productions from Saladhouse, our animator friends in Manchester (What is a Raspberry Pi? and Setting up your Raspberry Pi), we proceeded to make plans for a third in the series. The topic we chose to cover this time is one which demonstrates the additional power of the Pi in learning – an introduction to the realm of physical computing.

Look through the amazing projects in our blog, the MagPi or Pi Weekly and you’ll see many of them use the portability of the small form factor and low powered nature of the Pi along with the extensibility the GPIO pins give you – not to mention the wealth of community produced add-on boards available making it all much easier.

B+ gpio closeup

Those pins sticking out there. General Purpose Input/Output. Did we mention there are 40 on the B+?

Here at Pi Towers we all love physical projects – from robotics and home automation to flatulence alarms and scaring the elderly – and we believe they’re a great way to introduce young people to coding, computational thinking, product development and understanding systems.

The video refers to some resources for projects you can make yourself. We featured the hamster disco on our blog in July, and you may have heard talk of some of the others on twitter – which are all brand new, constructed and tested by our education team. They are:

hamster-party-cam grandpa-scarer fart-detector robo-butler

See more in our resources section.

Huge thanks to Sam and Scott from Saladhouse for their hard work on this – and also to our voice actors Arthur (son of Pi co-founder Pete Lomas) and Maia! And yes, that’s Eben narrating.

IMG_0908 IMG_0910 IMG_0918 2014-07-04 20.01.22
A little gift I brought Dave back from Memphis...

A little gift I brought Dave back from Memphis…

Watch Makercamp hangout hosting Massimo Banzi last July

via Arduino Blog

makercamp

Maker Camp is a free summer camp from Make and Google for building, tinkering and exploring.
Back in July Massimo was invited for a live streaming interview to talk about Arduino (starting at 11’20”) together with Ayah Bdeir , founder of the littleBits electronic components. Enjoy the video!