Skip navigation

This time I'm going to introduce the usage of a kind of magnetic sensors called digital magnetoresistive sensors. Magnetoresistive sensors are based on a property of several materials called magnetoresistance, consisting in the variation of their electrical resistivity when placed in a magnetic field. In practice, the current flow through a magnetoresistive wire depends on the strength and on the orientation of an external magnetic field. The adjective "digital" in the name of these sensors refers to the fact that they provide just two states: either they are sensing a magnetic field or they are not. In other words, they are not able to provide a precise and accurate measurement of the strength of any external magnetic field: they only react to magnetic fields stronger than a given threshold, providing a sort of signal that can be, in some cases, somewhat proportional to its strength. In most cases these devices are sensitive to the magnetic field only if it is oriented in a given direction (typically parallel to one of the sides of their package).

The Honeywell 2SS52MHoneywell 2SS52M is a device that belongs to the class of digital magnetoresistive sensors. It comes in a compact package with three pins (see picture): two of which are used to bias it (GND and Vcc), 2ss52m-imagewhile the third one is its "output".  The device is sensitive to magnetic fields oriented such that they are parallel to the longest side of its package (the white arrow in the figure). Being the sensor omnipolar, the orientation of the magnetic field doesn't matter: either south-north or north-south alignment triggers the device.

When the external magnetic field in the given direction is strong enough, the device works as a sink for the current. There are, in fact, two kinds of sensors: those whose output mode is source and those whose output mode is sink. A source is a point from which current flows from the device; a sink, on the contrary, is a point to which current flows. In order to operate a sink sensor, you need an external power supply to be connected to the sink through a resistor. If no magnetic field is detected, the sink works as an open switch and current does not flow from the power supply to the device. When a magnetic field is measured, instead, the sink acts as a closed switch and some current flows from the external power supply to the device.

According to the Ohm's Law, when a current I flows through a resistor R, the voltage drop across it is V=RI. In order to tell if the device is sensing a magnetic field, it is enough to measure V: if it is zero, no external magnetic field is present (apart, of course, the earth's magnetic field); if a strong enough magnetic field is placed close to the sensor you should be able to measure a voltage V.


We can use an Arduino UnoArduino Uno board to build a device that is able to tell you when a magnet is close to a given position(see the schematic above The  2SS52M2SS52M can be operated with a wide variety of input voltages(from 3.8 V up to 30 V Connecting its leftmost pin to the Arduino ground(black wire and its rightmost pin to the Arduino 5V pin(red wire is enough to make it working Then we can use the Arduino 3.3V pin as an external power supply connecting this pin to the central pin of the sensor through a resistor chain will make some current flowing from Arduino to the device when a magnetic field is sensed It is important to limit such a current that must not exceed the maximum current that the Arduino board can provide through its pins 200 mA We must then connect the  2SS52M2SS52M central pin to the 3.3V Arduino pin by means of a resistor of at least

R = V/I = 3.3/0.2=16.5 Ω

Of course, since we do not need a large current flowing, using much higher values is recommended: this way the current flowing through the resistor will be much less, reducing power consumption and heating. For example, using a 2 kΩ resistor will cause a current of I = V/R = 3.3/2000=1.65 mA from Arduino to the sensor. On the other hand, the voltage drop across the resistor will still be 3.3V, independently of the current.

In the schema shown above we illustrate a possible alternative: the resistor through which the current flows from the Arduino to the sink is made by the series of two resistors. We then measure the voltage drop across one of them (we then expect that we are going to read 3.3/2=1.65 V). There is no special reason to do that, but to show how a voltage divider works!

The tricky part comes when trying to measure the voltage drop across the resistor. Voltages can be measured using the Arduino analog pins A0-A5. They measure a voltage up to 5 V with respect to the Arduino ground. However, the voltage drop across the resistor cannot be measured relative to it. Let's try to understand why. In the figure below you can see a schematic of our circuit.


The magnetic sensor is represented as a box connected to the ground and the 5V pin of the Arduino board. The sink is in fact a transistor that conducts when a magnet is close to the sensor and does not if the magnet is far from it. It is connected through a chain of resistors to the 3.3V Arduino pin. If you try to measure the voltage between the ground and the resistor lead connected to the Arduino pin you always see 3.3 V, irrespective of the presence of a magnet close to the sensor, since such a potential is always there with respect to ground.

If, however, you measure the voltage drop across the resistor, i.e. as shown in the picture below,

2ss52mVright.pngyou would see 0 V if no current is drawn from the 3.3 V pin to the sink, while you can measure 3.3 V in the opposite case. We must then measure the voltage difference between the leads of the resistors. To do that we can measure the potentials V0 and V1 at the two leads of the resistor with respect to the Arduino ground and obtain the voltage drop as V=V1-V0. We can, then, measure the voltage V0 connecting one lead of the resistor to the Arduino A0 pin (blue wire), and the voltage V1 connecting the other resistor lead to the Arduino A1 pin (orange wire).


When no current flows through the resistor the difference between the reading of A1 and A0 will be zero (or very small, because of possible fluctuations in the measurement). If the difference exceeds a given threshold, then, a current is flowing into the resistor, then an external magnetic field has been detected by the sensor.

This device can be used as a proximity sensor Fix the  2SS52M2SS52M to something and a small magnet(see e.g the small neodymium magnets in the picture to something else when the magnet is close enough to the sensor it gives you a signal In the Arduino sketch you can tell when the magnetic field is sensed waiting for a voltage drop different from zero using a function like this

void waitUntilSensed() {
  int j = 0;
  int thr = 100 + analogRead(A0); // get the "zero" level
  while (j < thr) {
    j = analogRead(A1); // read the other lead potential

When entering into the function, the first operation is to measure the voltage at A0, that is expected to be the same of A1, using the analogRead() function We then just continuously read the A1 pin until its value exceeds those of A0 plus 100 (or any other large enough value). The function returns as soon as a magnetic field is detected.

With two such devices you can build a system with which you can measure the speed of a cart or of a falling object Fix a small magnet to the cart and two  2SS52M2SS52M sensors on a rail at a reasonable small distance x(e.g 5 cm with respect to each other

With the Arduino connected to the sensors you can measure the times of passage of the cart in front of the first and the second sensor: t0 and t1. The time needed to the cart to travel for the corresponding distance x is t=t1-t0, then its average speed is v=x/t. Look at the following sketch.

// the sensor reading for which we can consider it as triggered
#define THRESHOLD 100
// the distance between sensors (in m)
#define S10 0.05

void sense(int pin, long int &t, long int &duration, float &resolution) {
/* This method return the time at which a magnetic field was sensed by a device read on pin*/
  int j = 0;
  int thr = THRESHOLD + analogRead(A0); // get the "zero" level  
  while (j < thr) {
    j = analogRead(pin);
  // get the time at which the signal starts rising
  long int lead = micros();
  while (j > thr) {
    j = analogRead(pin);
  // get the time at which the signal fall down
  long int trail = micros();
  t = (trail + lead)/2;
  duration = trail - lead;
  resolution = duration/sqrt(12);

void loop() {
  // measures the times of passage
  int t0, w0, sigma0;
  int t1, w1, sigma1; 
  sense(A1, t0, w0, sigma0);
  sense(A2, t1, w1, sigma1);
  double v = S10/(t1-t0);


The sense() method waits until a non-zero voltage is provided from the sensor connected to the given pin. The micros() function returns the number of microseconds elapsed since the beginning of the sketch. Then, the sense() method provides a measurement of the time at which a magnet passed in front of the corresponding sensor, the duration of the pulse and its error (given by the statistical theory as the width of the pulse divided by the square root of 12). The ampersand in front of the parameters in the function tells the compiler to pass the address of the memory to the function and not its value, such that the readings are all passed to the variables used in the loop() function.

In fact we measure the time at which the voltage between A0 and another pin becomes different from zero, then we wait until it becomes zero again (in the second while loop). Measuring the time at which the signal starts to be non zero and the one at which it returns to zero, we can assume that the magnet passed in front of the sensor at a time given by the average of the two times. The duration of the passage is given by the difference of the two times.

Measuring the times of passage in front of two sensors we are then able to tell the speed of the cart as the ration between the distance traveled S0 and the time of travle t1-t0. With three or more sensors, you can then measure the speed at various positions of an object to study its motion. With such a system you can do many physics experiments, in fact. The cost of such a system can be below 40 EUR, while a professional system to make the same experiments with a comparable precision may cost from hundreds to even thousands of euros!

According to my very preliminary tests, I was able to trigger the device using a small neodymium magnet (4 mm diameter) when it was at about 2-3 cm distance from the sensor. My plan is to make a systematic measurement campaign that will be reported on my free e-book on scientific uses of Arduino boards. The e-book is in preparation and there is a very preliminary version at

Hello mates.


Here I come again...I really continue figuring out how to reach a very mall and continous speed of rotation, with a very high precission.

What I want to make is a mount to put on a camera and shoot photos of the night skies. My original idea was in the line of control the movement of my telescope, but I think this is unreacheable in my monetary conditions.


So I am here with this paint schema



The mechanism has aproximatelly 30 cm width and 30 cm height.

The structure will be made with plates of alluminium of 1,5 mm wide

You can think the camera is a small reflex camera (like Nikon D3200)


I had thought that I could reach this with an Arduino UNO board and a pair of sttepers. But when I have started to play with the Arduino board that I bought, some thoughts have come to me. I dont know how to choice the better options.

  1. Will I be able to make this mecha move with a pair of small sttepers 28BYJ-48 with ULN2003 driver?? I have not got the structure pieces yet, so I have not been able to probe this yet.
  2. What do you think will be the better way to control the movement of motors? Bluetooth, IR, RF?
  3. If I would wish to know the angle where the camera to be pointing, ¿what would be the better way? Would I need any optical sensor? or it would be enough with some variables in the code with which I control the sttepers to know this data?
  4. Whatever the choice of motor type, I need to know how to provide movement in the vertical axis. I mean: it would be better a small gear in motor axis and a big gear in the basis? or a wheel in the axis of the motor and a simple circle as basis?


Thank you in advance.

And please, escuse me if I explained it bad

The Arduino Yun is a 2 part device, half a conventional Arduino micro controller and half an embedded Linux using OpenWRT/Linino with Ethernet and Wifi connectivity.


Because there is an operating system as well as application code on the Linux side there is a need to keep that code up-to date. This guide compares the different techniques and discusses when best to use each one.


The Linux portion is made up of the software components, the boot loader (U-Boot), the Kernel and the Applications/Configuration. Reflashing the Yun will update all of these so you will loose your configuration and applications. For the applications it is possible to upgrade those independently using the package manager OPKM.


Ensure that you've copied your applications and configuration or have a way of recovering those before continuing with these processes. Note that you may need to update packages using OPKM following a reflashing.


There are various versions of the instructions for updating the flash, many of these are specific to particular companies or projects. However there are generic instructions on the Arduino site. Arduino - YunSysupgrade



Do not power off the Yun whilst doing a reflashing process!


It will take about 3 to 5 minutes so ensure that you have time and power to complete the process.

Powering off the Yun in a middle of a reflashing process may result in a device that won't boot.


Getting images


The Yun will support several different images including OpenWRT, you can even build your own images. For starting up or recovering a Yun you are probably best with the official Arduino image, an alternative that I've found to work is the Linino image.


SD Card and Web UI


This is the standard approach, you copy the image file to the SD card and use the UI to load it. It's a fairly straight forward process with the only "gotcha" being that the Wifi is reset hence you need to connect to the Arduino's access point as if you'd just started from scratch.


SSH and sysupgrade


Using the console and sysupgrade is a good approach if you are comfortable with using the shell. It would also be a good approach if you had many devices to upgrade as it could be automated. You can also use the WGET command to download the image directly onto the Yun which is a good approach if you don't have another technique for getting images onto the SD Card. The Linino site suggests that you can preserve your configuration files with this approach but I've not tried that.


Arduino - YunSysupgrade

Linino Wiki - Upgrade using SysUpgrade


U-Boot and TFTP


Following this guide will VOID the WARRANTY of your Yún


The instructions at the top of the Arduino page tell you not to do this step unless you are really certain. I've not actually managed to find out what that warranty consists of so I'm not sure what you are giving away.


However I'd recommend trying the other approaches first as this technique is a little fiddly. The key thing about this process is that it will work even if your Yun does not boot up properly. I had to try this approach as I'd unthinkingly pulled the power in the middle of a reflashing step.


This approach requires 3 different images. It's worth doing these as a set because there may be incompatibilities between the different components. I ended up at one point with a board that would boot partially and then report lots of errors.


You must use the WIRED Ethernet connector for this approach.


You also need to setup a TFTP server, I found a simple one for windows that I could use. It's worth downloading a client too so you can test your server. Note that you might need to adjust your firewall settings to be able to use the server.


As most of you know, I am doing a quadcopter from scratch project where I make almost everything from scratch. In doing so, I had to understand the dynamics behind the software/firmware and in order to explain the quadcopter, I can start by explaining a balancing robot. In this post, I explain the build and provide a video demo for the robot. Lets go!


The build

I usually build stuff from scrap and recycle what I can and this project is no different. I start with some scrap wood and made a simple box like frame. I trimmed off wood from the sides to reduce weight and to make it a little more presentable. Finally I added some paint and a quick and dirty job later, I have a robot frame.


As you can see, in the above pic, I have some motors and wheels attached as well. I bought the wheels a long time back and the motors were purchased online. These motors are 288RPM 12V rated and have optical encoders so that we can track the distance moved by each wheel. I clamped these motors in place using some sheet metal pieces I cut up from the scrap tin boxes I had. You can use soft-drink Tins etc as a source of the sheet metal and self threading screws to attach them to the wooden base.


In order to drive the motors, I am using an L293D motor driver which came from an older robot which lost it's wheels in an accident.

Since we need a place to put the control board, I used a cardboard box and cut out an H shaped plane to sit atop the motor driver floor. The control board itself if an Arduino Uno which I received as a part of the Internet Of Holiday Lights Challenge from Element14 and I made a shield for the MPU9150 breakout board. The image below shows the same shield but on the FRDM K64F board which I was using for the quadcopter.


I scraped together some libraries from the internet for the MPU9150 as well as PID control and a few hours of head scratching later, it actually worked! The video below shows the working robot in action.

I had some failures along the way but it was quite easy and only a few hours of work once you know what you are doing. In the next post, I will be sharing some more details on the code as well as things that you need to consider when making one yourself.





SMS to light an LED!

Posted by markvenn Apr 7, 2015


I have been playing with my Uno and GSM shield to try to see if I can get the real world to react to a good old fashioned SMS text. In these days of 3G and 4G data rates, I wanted to show that we don't have to have the latest toys to interact with the real world.

So, to start I am using a common cathode RGB LED with a first gen Uno with an R3 GSM shield wired up as below.


(Please imagine an Uno underneath this shield :-))

So, the idea is to react to the contents of an incoming text message and light the LED with the colour that is sent to the Arduino. (A this point the choice is red, green or blue).


At the moment I am working on IF statements to check the contents of the message as it arrives but I am probably going to change this to either a case statement or with the message passed as a parameter into a new function. Anyway, the code as it stands at the moment:



This sketch, for the Arduino GSM shield, waits for a SMS message
and displays it through the Serial port. Then returns message to sender
letting them know it has been received on Arduino.
dependent on the message certain colours will be displayed by led

* GSM shield attached to and Arduino
* SIM card that can receive SMS messages
* common cathode rgb led

created 7 Apr 2015
based on code by Javier Zorzano / TD & Tom Igoe


// include the GSM library
#include <GSM.h>

// PIN Number for the SIM (set if sim pin code protected)
#define PINNUMBER ""

// initialize the library instances
GSM gsmAccess;
GSM_SMS sms;

// Array to hold the number a SMS is retreived from
char senderNumber[20];
char outGoing[16];

// variables to define pins to be set for each colour
int redPin = 11;
int greenPin = 10;
int bluePin = 9;
// define String variable to hold incoming message
String message;

void setup()
  // configure pins to connect to led
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
  setColour(0, 0, 0); // initialise led to off

  // initialize serial communications and wait for port to open:
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  // configure and initialise GSM connection
  Serial.println("SMS Messages Receiver");

  // connection state
  boolean notConnected = true;

  // Start GSM connection
  while (notConnected)
    if (gsmAccess.begin(PINNUMBER) == GSM_READY)
      notConnected = false;
      Serial.println("Not connected");

  Serial.println("GSM initialized");
  Serial.println("Waiting for messages");

void loop()
  char c;

  // If there are any SMSs available()
  if (sms.available())
    Serial.println("Message received from:");

    // Get remote number
    sms.remoteNumber(senderNumber, 20);

    // Read message bytes and print them
    while (c =
      message += c; // build the message from the function

    Serial.println(message); // display message on serial for testing
    message.toLowerCase(); // convert to lower case to make sure the comparision works later

    Serial.println("\nEND OF MESSAGE");

    /* read the contents of message variable. see if it is blue, green or red
     light appropriate colour on LED and send message back to let sender know
     that the message has been received.
    if (message == "blue")
      Serial.println("received message to set BLUE");
      Serial.println("\nSENDING REPLY");
      sms.print("SET LED TO BLUE. (Message was blue");
      setColour(0, 0, 255);
      message = "";

    if (message == "green")
      Serial.println("received message to set GREEN");
      Serial.println("\nSENDING REPLY");
      sms.print("SET LED TO GREEN.");
      setColour(0, 255, 0);
      message = "";

    if (message == "red")
      Serial.println("received message to set RED");
      Serial.println("\nSENDING REPLY");
      sms.print("SET LED TO RED.");
      setColour(255, 0, 0);
      message = "";

    // Delete message from modem memory
    Serial.println("MESSAGE DELETED");


/* function that sets colour
takes three values to set the levels of each colour. Can be set as hex values by
prefixing with 0x. For example 0x03 = decimal 3, 0x0d = decimal 13
void setColour(int red, int green, int blue)

  analogWrite(redPin, red);
  analogWrite(greenPin, green);
  analogWrite(bluePin, blue);


So, there you go, a good old fashioned text message that says red, (or ReD due to the toLowerCase() function), will light the led a nice red colour. I will make some changes to the code, it comes in at 17,056 bytes of program storage space with 1,196 bytes of global variables so I thank that I want to tweak it a bit to see how efficient I can make it.


Shopping list



Arduino GSM ShieldArduino GSM Shield

RGB LED (such as Kingbright L154A4SURKQBDZGWRGB LED (such as Kingbright L154A4SURKQBDZGW

Arduino UnoArduino Uno

This kit is a open project I have described in detail  on, available on

Just yesterday I have published the tutorial on the assembly instructions on for who is interested. Further details on




Embrio for Arduino.

Posted by 4ringfan Apr 4, 2015

Has anyone seen or played wtih this visual, real-time development tool for Arduino programming yet?

Embrio - A visual, real time development tool for the Arduino

Program software for the Arduino in real time without writing code!


Kind of an interesting real time way to program.  Including waveform of the inputs and logic.


I just found it today.  Check it out!

25 Seconds

The first full working time-lapse shooting created with TIltPan Arduino Shield

In the following video you see an example of time-lapse video with some scene movement created with the first prototype of the TiltPan Arduino Shield. There are three main scenes: curve diagonal movement from the bottom-left side to the upper-right, then the camera moves to the left pointing to reach the middle of the rotation horizontal plane. The last is a fixed scene pointing the sky.

The entire sequence has been created with a total of 654 frames from images captured in time-lapse by the TiltPan Arduino Shield and the mechanics module with a frame interval of 4 seconds. The shield can be programmed to manage multiple sequences to create complex time-lapse sets. The total execution time of the time-lapse capture session needed about 41 minutes.


A note on the project

The TiltPan Arduino Shield is a board + mechanics to control a micro camera through Arduino. Better using Arduino UNO but works fine also with Duemilanove and Diecimila. At the actual date it is finished, a first draft of the software documentation has been published as a preview with other posts on the same argument on my blog BalearicDynamics here in Element14

In the document


Tilt-Pan Low Cost MicroCamera


under Arduino section where are shown the main prototypinng phases documented by images.

The resulting object controlled by the Arduino Shield TiltPan is shown in the image below.


Lights, Holiday and Electronics


Earlier in the year Christian and element14 sent me the kit for the IoT Xmas Lights.

I was unable to enter in the challenge due to other commitments, so when I was offered the kit I promised to add something later.




I have an idea for the lights, and require to source some High Power LED's which the Infineon Shield can drive.

Most of the existing strings are already voltage controlled (just stick them across 12 v and they are happy).

There have been some great uses, but mine will be for anytime ... providing I can sort out the LED's I want and mount them properly.

Since the intention is for outdoor use, the proper enclosure is part of the design requirement.




One of the neat ideas to come out of the Challenge was the IoT link that Jan and Frederick came up with.

[Christmas Wreath of Things] Internet of Holiday Lights: part 10 - Secret IoT Team Up

[Christmas Tree] Internet of Holiday Lights - Special Feature

They extended the invitation to anyone else

Internet of Holiday Lights: Join the secret IoT Service - open for all

I was able to join in with a few lines of code, and an ethernet plug, and while it is a simple task to light a LED or LED's, it is a waste of the Arduino YUN to just do that.

I plan to use the YUN at a central point and send the data over a RF link to an micro arduino, that will drive the display.

The YUN will also interface to the Lights and allow remote control using a wireless device from my home network.





Some time ago Shabaz produced a fantastic map showing where challengers were situated.

He did it for In The Air and again for Forget Me Not.


I thought that lighting up the location when the person is online would be a great idea.



A simple print onto A4 later, and the penny struck ... some countries are not very large ... PLUS there are two people in one small country (ignoring the wives, children, cats and minions).


Hence a 5mm RGB or NeoPixel was just not going to work.

Time for another plan.




Fibre Optic

Everyone knows this is the stuff they send the internet down. 


     Photo source

Well yes that is true, but those tend to be glass fibres and are a fixed size.


Wikipedia has a good summary of most uses here.

Optical fiber - Wikipedia, the free encyclopedia


They can be used to illuminate sensitive subjects, since they don't conduct the heat, UV or Infra red and their small size makes them very effective.

Low cost LED technology may have displaced this use in many applications.


Some people may know that fibre optics were used on some older automobiles to show the various lights were working.

For the 1968-71 Chevrolet Corvette they ran from a fitting in the light through the wiring loom to the dash and were probably a salesman's delight at the time.

Corvette questions | stevelinden


I've used Fibre Optics for Lighting effects in three of our Casino's, and some other locations.

We used 'End Glow' fibres to light up square blocks of plastic, or a device that looked like a normal light bulb. There was fascination amongst the builders when these 'light bulbs' changed colour.

We also did a few Starfield simulations complete with 2-3m long shooting stars. (that is a whole other story)


The fibre optic generally used for lighting effects is solid plastic with a coating on the outside, and comes in a range of sizes from 0.75mm to 12mm diameter.

The advantage of the plastic means you can apply heat to the end, which creates a dome or lens shape, and of course you can glue/epoxy it.


If I use fibre optics then I have the means to transmit the light to a very small hole in a very small country.



What colour should I use.

I decided that just having a LED that was ON or OFF, was not going to suffice.

An RGB or even better a NeoPixel LED was the better option.


I chose to use some 5mm diffused NeoPixels that I purchased locally from Hadley at Nicegear (

I'll simply attach the fibre onto the top with expoxy or some other method that I'll finalise later in the hardware build.


How to Light them.

As I said earlier using the Arduino YUN to drive some LED's is a bit of a waste, and with the map fitted to a deep A4 Picture frame, I might not have room.

Instead I'm going to send the data via RF from the YUN to a micro Arduino mounted inside the picture frame.

This also allows for different powering options, so it can be fitted anywhere.



Eric Tsai provided us with some very informative posts about sending data using RFM69 Transceiver modules.

Uber Multi Wireless Sensor - smoke, gas, flame, dog barking, PIR movement, light - sensor


I used this technique to send Hot Water data back to OpenHAB in the Forget Me Not challenge last year.



Data to send

As it stands there are 4 participants in this secret IoT service.

I decided on three different states

Online (Green)

Last 24hrs (Red)

Unknown (Blue)


This could be achived with a single 8 bit number ... BUT what happens if someone else joins.


During the Forget Me Not challenge, the EnOcean modules were solar powered and worked with indoor lighting as low as 100 lux.

In order to work, they needed to conserve the data transmission so it was sent efficently.

For my purpose I have power, but the display could be battery powered (I haven't decided).

If I simply send any change of state, and then send the state every 5 or 10 mins, the RF transmissions will be minimal.

Once the receiver is awake, it only takes a few seconds to process and send the information to the Neopixels, and it can go back to sleep, where it will be saving battery life.

SO I can send more than a single byte of data.

This also means I could use the YUN for other indication ideas ....

Now that I've formulated the overall concept, and decided on a few of the particulars, its time to put the bits together.

In my next blog, I hope to sort out the RF data transfer protocol and drive the NeoPixels.

I should have sorted out the picture frame, and decided how to get two fibres into this country.




And the winner was...


Craig Terris. Here is is receiving his Arduino starter kit from Zac Colley, very kindly supplied by Element14! We drew the name from a hat, an actual hat; a room full of computer nerds and we fell back on good old tradition! Thanks odion


We had a brilliant day; we had a mum and her son who had the Ardunio for Christmas and had not got much further than blink, he had a go at a few of the projects in the starter kit book and had a good time. One of the strangest projects was "Party Face"; no pics unfortunately. This was an Uno with ethernet shield, (for the SD card capability), hooked up to a speaker and mounted in a cardboard mask. The guys worked extremely hard in getting the Uno to play a wav file stored on the sd card. The point? Well, as we all know, students like to party; when the partying gets too much, pop on the mask and have a sleep. The Uno then plays the messages stored on the SD card. We heard a lot of crackling to start then suddenly "Thanks for coming!" could be heard clearly. If there was more time I think the idea was to use ultra sonic detector to tell when someone approaches and the message plays to say, well whatever is programmed.


Roll over Apple, we have the coolest smart watch prototype here, Arduino style.



As you can see, work in progress although we have working bluetooth connection and working displays. I am all for keeping it this size and having it strapped to the users forearm rather than making it smaller and watch-like but I am not sure how this will go. There is talk of making a custom PCB next although discussions were made about a 3d printed wrist mount.


We have python on Linux talking to and receiving from the serial output of the Mega, SMS powered RGB led with incoming messages changing the colour of the output and then sending back a text letting the sender know it had worked. But mostly people played and had fun; this was the whole point of the day. We will be setting up something else, hopefully on a regular basis, looking at names at the moment, Pompey Proto People seems likely!


So, that was it.

Filter Blog

By date: By tag: