Skip navigation

Arduino

11 Posts authored by: Christopher Stanton element14 Team

graphic.PNGThe Internet of Holiday Lights RoadTest+ is running from December 8th to January 23rd 2015

Previous Activity:

Blog Summary #000 : Internet of Holiday Lights RoadTest Plus 2014

Blog Summary #001 : Internet of Holiday Lights RoadTest Plus 2014

Blog Summary #002 : Internet of Holiday Lights RoadTest Plus 2014

NameSuper Awesome Blog Time
Viorel M. AlexeNo Updates
Stephen Baird

IoT Christmas Ornaments - The Software, Part 1

IoT Christmas Ornaments - The Wrapup

The Internet of Holiday Lights RoadTest Plus - Review

Jan Cumps

Compare the Infineon RGB libraries that spawned from the Internet of Holiday Lights

Internet of Holiday Lights: Road Test Plus review

[Christmas Wreath of Things] Internet of Holiday Lights - Bonus kicker: the IoT talks (a spoken tribute to Science Fair kits)

Massimiliano Dibitonto

Social Xmas Tree 2

Jack Franklin

Internet of Holiday Lights - Houston, we have a problem

Internet of Holiday Lights - Mr Oakes to the rescue!

Matteo Furlan

Publish data with MQTT - The smart entrance - Internet of Holiday Lights RoadTest

Get a working webcam on Arduino Yun - The smart entrance - Internet of Holiday Lights RoadTest

The Internet of HOliday Lights RoadTest Plus - Review

Send email with photo on movement - The smart entrance - Internet of Holiday Lights RoadTest

Gurinder Singh GillNo Updates
Saurabh Gohe

Blog Post #2 : Smartphone Controlled Lighting System - Sending Commands Via Bluetooth,  For Internet of Holiday Lights RoadTest Plus 2014...

Introduction to the Arduino Yun #1

Introduction to the Arduino Yun #2

Blog Post #3 : Smartphone Controlled Lighting System - Sending Commands Via IR Remote  For Internet of Holiday Lights RoadTest Plus 2014...

Smartphone Controlled Lighting System - Sending Commands Via Bluetooth

Blog Post #4 : Smartphone Controlled Lighting System - Sending Commands Via A Web Browser,  For Internet of Holiday Lights RoadTest Plus 2014...

The Internet of Holiday Lights RoadTest Plus - Review

Blog Post #5 : Smartphone Controlled Lighting System - Final Sum-up of My Project,  For Internet of Holiday Lights RoadTest Plus 2014...

Lukas Hornby

No Updates

Jordan Lui

The Internet of Holiday Lights RoadTest Plus - Review

RoadTest Internet of Holiday Lights: Apartment Lighting Extravaganza Post 4

Jordan's Holiday Lights Roadtest entry

Clem Martins

[IoT Christmas Sparkle Ball] The mirror works finally

[IoT Christmas Sparkle Ball] Trying to Connect  Lights

The Internet of Holiday Lights RoadTest Plus - Review

Peter Oakes

BYOB Party #11 - Stars for the tree. From Re-flow to Wow, how to make a tree topper fit for any tree

BYOB Party #12, "Creating a control page to add remote ability for your IoT of Holiday Lights"

BYOB Party #13, "Announcing guest callers from around the world "

BYOB Party #14, "Welcome Texas... Instruments that is"

The Internet of Holiday Lights RoadTest Plus - Review

BYOB Party #15, News year resolution in coding practices. Infineon, UNO the NRF24L01 coding walk through.

BYOB Party #16 - The BIG Event finally arrives

Mohan PalanisamyNo Updates
Aby Raj

No Updates

Inderpreet Singh

[Dynamic Living-room Lights] Building the Mood Lights

[Dynamic Living Room Lights] The XMAS Tree

[Dynamic Living-Room Lights] IoT Holiday Lights Minions

[Dynamic Living-Room Lights] The Big Picture - The Final Build

[Dynamic Living-Room Lights] Paho For Python - Writing better code

[Dynamic Living-Room Lights] The Tree Code explained - Write a protocol with interrupts.

[Dynamic Living-Room Lights] The project Summary and Demo Video

The Internet of Holiday Lights RoadTest Plus - Review

[Dynamic Living-room Lights] Converting a wireless router into a YUN

Francesco Truzzi

[Arduino Light Spots] Client building and coding + 3W RGB LED + Infineon shield!

The Internet of Holiday Lights RoadTest Plus - Review

Eric TsaiNo Updates
Madhuri Vaghasia

My IoT Holiday Lightings...#4: Final Build 1

The Internet of HOliday Lights RoadTest Plus - Review

My IoT Holiday Lighting...#5: Final Build 2

Frederick Vandenbosch

[Christmas Tree] Internet of Holiday Lights - Song-based Lighting

[Christmas Tree] Internet of Holiday Lights - Finished Build

The Internet of Holiday Lights RoadTest Plus - Review

Darcy WalkerNo Updates
Robert WatersNo Updates

graphic.PNGThe Internet of Holiday Lights RoadTest+ is running from December 8th to January 23rd 2015

Previous Activity:

Blog Summary #000 : Internet of Holiday Lights RoadTest Plus 2014

Blog Summary #001 : Internet of Holiday Lights RoadTest Plus 2014

Current Activity:

Blog Summary #003 : Internet of Holiday Lights RoadTest Plus 2014 - Post Final Day

NameSuper Awesome Blog Time
Viorel M. Alexe

The Santa monitor & lights - (T.I.O.H.L.)part-1

The Santa monitor & lights - (T.I.O.H.L.)part-2

Stephen BairdIoT Christmas Ornaments - The Hardware!
Jan Cumps

[Christmas Wreath of Things] Internet of Holiday Lights: part 2 - paper prototype

[Christmas Wreath of Things] Internet of Holiday Lights: part 3 - set up the Arduino Yún

[Christmas Wreath of Things] Internet of Holiday Lights: part 4 - I need Date and Time

[Christmas Wreath of Things] Internet of Holiday Lights: part 5 - Found a Stepper Motor

[Christmas Wreath of Things] Internet of Holiday Lights: part 6 - Stepper Motor works

[Christmas Wreath of Things] Internet of Holiday Lights: part 7 - Infineon LED shield works

[Christmas Wreath of Things] Internet of Holiday Lights: software side note - dodgy advent logic

[Christmas Wreath of Things] Internet of Holiday Lights: part 8 - Arts & Crafts

[Christmas Wreath of Things] Internet of Holiday Lights: part 9 - Time and Event Management

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

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

[Christmas Wreath of Things] Internet of Holiday Lights - summary

[Christmas Wreath of Things] Internet of Holiday Lights : post Christmas blues

Massimiliano Dibitonto

No Updates

Jack Franklin

Internet of Holiday Lights - We meet at Last

Matteo Furlan

The smart entrance - My project for Internet of Holiday Lights RoadTest

Gurinder Singh GillNo Updates
Saurabh Gohe

Blog Post #1 : Introduction To My Project "Smartphone Controlled Lighting System" For Internet of Holiday Lights RoadTest Plus 2014...

Lukas Hornby

No Updates

Jordan Lui

RoadTest Internet of Holiday Lights: Apartment Lighting Extravaganza Post 2

RoadTest Internet of Holiday Lights: Apartment Lighting Extravaganza 3: LCD Screen Learning

Clem Martins

[IoT Christmas Sparkle Ball] The plans so far

Peter Oakes

BYOB Party #5, Mrs Yun gets her MQTT on

BYOB Party #6, Introducing Baby Trinket... Shhh she is sleeping

BYOB Party #7 - Mrs YUN gets chatty with iot.eclipse.org and NRF24L01

BYOB Party #8 - PI Matrix - Behind the scenes at the PI camp

BYOB Party #9 - Meet Minion Baby Bob, Trinket Evolves over night and learns a few tricks

BYOB Party #10 - Re-flow Soldering for Custom Neopixel displays

Mohan Palanisamy

Part X.3 Arduino Yun Extending the RAM with swap file

Part 2.3 Touche Minions

Part 3.1: Introducing Ponte, a M2M bridge for MQTT, CoAP and HTTP

Part 3.2: Reading a MQTT topic with HttpClient On Arduino Yun

Part 3.3: Arduino Uno + ESP8266 + Eclipse Ponte HTTP Bridge = MQTT Magic

Part 3.4 Behold the Color Catcher and Thrower

Aby Raj

No Updates

Inderpreet Singh

[Dynamic Living-Room Lights] The YUN review - When the Penguin Met The Arduino.

[Dynamic Living-Room Lights] The Infineon RGB LED Shield Review

[Dynamic Living-Room Lights] The Infineon RGB LED Shield -Library!

[Dynamic Living-Room Lights] The Lights Teaser Video

[Dynamic Living-Room Lights] Build Blog - Setting the stage

[Dynamic Living-room Lights] The YUN talks to OpenHAB

Francesco Truzzi

[Arduino light spots] Updates and WebUI preview!

Eric TsaiVoice controlled holiday lights w/ OpenHAB & Tasker
Madhuri Vaghasia

My IoT Holiday Lightings...#2: First prototype

My IoT Holiday Lightings...#3: Second prototype with Music Controlled lightings and more options..

My IoT Holiday Lightings...#3 some more options Added

Frederick Vandenbosch

[Christmas Tree] Internet of Holiday Lights - Getting Started

[Christmas Tree] Internet of Holiday Lights - Control from openHAB

[Christmas Tree] Internet of Holiday Lights - Special Feature

[Christmas Tree] Internet of Holiday Lights - NeoPixel Star

Darcy WalkerNo Updates
Robert WatersLight Shield Review Part 1

DayofMaking_logo-2.png


Congrats to Tomas Polisensky who was chosen to win the Arduino Starter Kit !



Kickstart your Project and start making with an Arduino Starter Kit! Enter the contest and win!


starter-kit.png


Share your Arduino project idea that you will create in 10 words or fewer with your original created pictures/diagrams/etc between June 18th and June 20th 2014!


Don't be afraid to be specific! (It's better if you are).


What's in the kit ?


  • Arduino Uno R3 and project book
  • Temperature / Tilt Sensors
  • LCDs and LEDs
  • Cables and resistors
  • Motors and potentiometers
  • Diodes and capacitors
  • Breadboard and octocouplers
  • And more!


It's Simple to Join:


  • Register or log on to the element14 Community.
  • Select "Add Your Comment" at the bottom of this post to submit your idea (only appears when you're logged in!)

 

What Happens Next?


  • The element14 Team will choose an entry after the 20th of June when the competition closes
  • One winner will be announced on the 24th of June

 

Important Note:


By submitting an entry you will automatically start receiving notifications of other responses to this post. If you do not wish to receive notifications, select "Unfollow" at the top right of this page. If you have any questions, please let us know in our Feedback & Support area.

 

Only submit one idea, if you submit more than one, it is at the discretion of the element14 Team to ignore or disqualify your entry/entries.

 

The element14 Team will have a preference for ideas which include diagrams/schematics/pictures of the proposed project idea(s); images containing wording that appears to extend the 10 word limit will be disqualified. This decision is at the discretion of the element14 Team.

 

If you are selected, you will be contacted via instant message on the element14 Community site to confirm your details.

 

Detailed Prizing Info:

 

The winner will be sent an Arduino Starter KitArduino Starter Kit. Entrants who post up to 10 words describing their project and post pictures/photographs/diagrams/schematics planning their project will be favoured to win the competition.

 

See the full Terms & Conditions: "There can only be one, let's start with 10! Kickstart your Arduino Project!"


Timeline:


During the period from 9am BST (United Kingdom British Summer Time) on June 18th 2014 until 5pm BST (United Kingdom British Summer Time) on the 20th of June 2014, any registered community member can participate in the competition.

 

whitehousebgNJ.gif

Learn More about Arduino with the New Jersey Makerspace Association!

In a glorious 8 colours. I couldn't believe this when I saw the video footage, but there's even a shot of the circuitry after it and the guy is giving away how he did it along with the code.

 

It isn't even overclocked!

 

 

Article Source: 640×480 VGA On An Arduino

Arduino_Uno.jpg

Sorting Machine - Skittles and M&Ms ?

 

I find this almost therapeutic to watch, perhaps it's a little OCPD in me but seeing an Arduino UnoArduino Uno control a machine which will sort out your sweeties by colour is great. This little video does well to demonstrate it working with the 3D printed parts, an RGB and an infra-red sensor doing the work in tune with the motors.

 

Practical wise it's a little slow and you would be forgiven for asking "why would I do this?" but for a friends birthday present, a person who loves purple sour skittles, I manually made up a whole bag of them for him from many, many large bags and this would have made it so much easier! Even though it's doing skittles and M&M I'm sure it could just as easily do smarties - and really this could be useful for maybe wedding favours or just if you have friends/children who particularly prefer a certain flavour or colour. I certainly couldn't find the ability to buy a particular colour of what I wanted from the sweet store.

 

 

You can even find a bill of materials and the 3D printed models along with instructions here.

 

$1 Photo-Theremin and more fun with reversed LEDs

 

I love this project. It's so simple yet the principle behind it isn't and I feel it shows a good understanding of electronics and how it works! Basically, an LED can work as a crude light sensor, or specifically it's a photo-diode. All this is using is a resistor an LED and an Arduino Uno - it brightens when it gets lighter and dims when it gets darker and ultimately when hooked up to a piezo buzzer - you can play a tune like a theremin!

 

 

The code, electrical diagrams and videos can be found here.

 

Plotting Time - Open Source Clock

 

There are clocks which use LEDs to tell the time, there are ones that use valves, hands, light casting and those that use e-ink. What if you could use actual ink to tell the time ? In this project, an Arduino is hooked up to a motor and mechanism where a felt pen draws out the time (though it could be anything you want) and wipes it away to correct it! I think it's a cute and out-of-the box way to show that there are always many ways to do the same task.

 

 

The original instructions for creating this project are in German, but there are links to the resources, 3D models, etc at a thingiverse page for the project.

 

MicroView: Chip-sized Arduino with built-in OLED Display!

 

It's an ATMega328PATMega328P (Arduino Uno) embedded within a small, smooth designed, display. It can standalone by itself or you can attach it to a computer or single board computer like the Raspberry PiRaspberry Pi. So you have the power of the ATMega chip and the potential of the OLED display. It's in a form factor that's really nice to play with, communicates over the USB port that's attached to it but also can plug straight into a breadboard.

7837640211ea6fb33ff3775dbfd5b50a_large.jpg

 

It began as a kickstarter and it's a product you can actually buy, there's a video and more examples on the Kickstarter page.

 

Arduino Bowel Gauge

 

This smart project I see as having medical applications, it follows one of the basic, natural needs! using the toilet! What's not to like ? You can tell if people are really telling the truth about when they've last cleaned it, if they're healthy or if the poor goldfish has gone the way of the drink.

 

 

It was actually created by request from HackaDay and more information is available from the appropriate blog post.

 

Etch-a-Sketch with Lasers

 

I didn't have an etch-a-sketch, but I had friends whom did, using it was definitely an art form and managing to do a curve was practically a nigh impossibility for a young child such as myself at the time. What was true of it though, is the inability to keep what you drew; just one shake and poof! gone! Not this time, not when the drawing field is a laser cutter!

 

 

Dom runs a company offering laser cutters to Hack/Mak(er) spaces and has more information on the blog.

 

Arduino Etch-a-Sketch Clock

 

This project is exactly what you think it is, where as we've seen an Arduino felt-tip pen clock and a laser cutter etch-a-sketch. Why not combine the two? Just shake it and draw a new time! Awesomely renewable.

 

 

Of course if you want to, you can make your own.

 

K4S, a Keyboard for Arduino to use with Scratch

 

Scratch, if you're not aware, is a programming language which I was originally introduced to with the Raspberry Pi. Scratch 4 Arduino since came along and with it, an Arduino Shield to help teach its principles - a Keyboard 4 Scratch!

 

 

Quite nicely the schematic is available!

 

Arduino Baby Robot

 

There's not a lot of information about this project that I've found. Just a thought provoking video. I think that this is a robot kit that you can get, it has been programmed to act curious and follow, be wary and I think it just acts amusingly.

 

 

Arduino Phone

 

It's old news to some, but since the Arduino GSM ShieldArduino GSM Shield came out it was inevitable that someone would convert it into a working phone. If you decide to do it yourself, make sure that you monitor or replace the tantalum capacitors else they may explode (I'm serious).

 

 

I'd be interested in seeing after following the original guide, how cheaply this could be made.

 

728x90__arduino_tre.jpg

 

Which do you like the most ? Are you working on an Arduino project?

 

If you can't see "Add Comment" below, please sign up for an account!

This article covers hardware that is in development.

The hardware covered in this article is liable to change in features and specification.

It does not necessarily reflect the quality or build of the final product.

 

 

I hadn't heard of the Arduino Tre until a few months ago, I suspected that it might be ARM processor based, but I had no idea as to what it would look like or how it would function (obviously I had missed some clear marketing). I had heard some comment of it coming to market later in the year of 2014.

 

To my surprise I spotted that it was available to buy! However, this was a Developer Edition and there's only 50 available. You get the opportunity to get hold of pre-release hardware and optionally join in with a beta to engage conversation with the Arduino developers.

 

Buying into a Developer Edition ? Don't companies usually pay people to do the testing for them? I did not care, I wanted to support the development and get hold of a board. Over the course of the day it surprised me to see that there were still about 20 left, I assumed that the website writ this in error and that they had actually ran out of stock. I took a gamble and went to order one anyway. I had a few confusing confirmations on the order but it finally went through that it was available and on its way!

 

Living in the UK, the cost of the developer's edition ran at approximately £185 including delivery, considering it was listed as €149 + VAT that feels like quite a hike. Pretty steep in comparison to other boards on the market at the moment, though granted it is a developer version! I thought that in the post I would just get the board on its own. When it finally arrived I dashed home that day and recorded this rather over exposed video thanks to the sun finally gracing its presence within the usually overcast Britain.

 

 

Much to my surprise, the parcel didn't just contain an Arduino Tre, but I was also supplied with an 802.11n WiFi adapter and a power cable and stickers (who doesn't love stickers?) along with a 5V 5A power supply.

 

IMG_20140529_151036.jpgIMG_20140521_143246.jpg
IMG_20140529_151014.jpgIMG_20140529_150940.jpg

 

I was a little surprised that the anti-static bag wasn't used for the Arduino Tre, but the SD Card which came with it. Apparently this was a miscommunication and will be rectified for the production version. I received the standard Arduino 6 small circular stickers, though I didn't fully understand the need to include "HACKED" on the larger circular ones - it just didn't seem to fit in with any other marketing I'd seen for Arduino.

 

The box and its colour scheme has kept in line with other Arduino products and it is minimalistic. Understandably there isn't much in the way of guidance on the Arduino site for the product and there's information on the box to open a web page called TreSetup.html that is either available when you connect the board to your computer or when you boot the Arduino Tre standalone while connected to a screen.

 

Yes! this Arduino is effectively a standalone, single board computer. That's because it is a hybrid of an Arduino LeonardoArduino Leonardo (running an ATMega32u4 chip) with a BeagleBone BlackBeagleBone Black (Sitara ARM Cortex-A8) on the same board, with

IMG_20140521_154611.jpg

the addition of an audio processing chip; and to me, that is what makes it very interesting. Having come from a history of using a Sinclair Spectrum and a Commodore Amiga attached to my television, in a similar ilk to the Raspberry Pi - with

the Arduino Tre we're semi going back to that circle of possibility where you can sit in your living room with the Tre attached via HDMI to your television, use a wireless keyboard/mouse and code away. Or maybe that's just me? Probably just me.

Not long after the confirmation of dispatch of the Tre, I received an e-mail asking if I wanted to join in with the Beta feedback for the board. When I signed up, I was greeted by a resource of getting started and communications with the Arduino team. I'm thankful that I entered the beta participation for the board, because the first thing I had to do was to update the software on the SD Card.

 

To use the Arduino Tre you need to connect it to the mains. There are connectors on the board to connect battery power, there is also a USB port to communicate with the board, but this will only power the Leonardo portion along with the on-board read only storage that is similar to pretending to being a CD-Rom drive containing drivers and documentation.

 

The Arduino Tre does not have an on-board flash chip, which is helpful to an extent. It means that I don't have to spend time waiting to program the board itself and I can just replace the operating system relatively painlessly. The SD Card runs a version of Debian for ARM hard float which has repositories from Arduino added so that a simple use of the standard package manager, apt/aptitude can be used to keep the system up to date in the future. At present both SD Card images and updates are available to developers for keeping the board software maintained.

 

The board itself is potentially in development, too. When I received it there was an obvious fix made (and this was to each one of the 50 boards sent out) as a wire was post-production soldered into place. It's not clear to me as to why or what purpose it serves.

 

Once I was all up to date with the hardware, there was nothing stopping me from tinkering with it. When connected to a Windows computer it identified itself as a multitude of serial based devices, both the Sitara ARM processor and the Arduino Leonardo, the device identifies installs itself as a USB hub which then has the Sitara and Leonardo components attached to it. So it is entirely possible to communicate and upload code directly using say, the Arduino IDE to the Atmega32u4 that's on the board.

 

However it begins to get a little tricky there, because what you actually have should identify itself more as an Arduino YUN (which is an ATMega sat behind a Linux type environment). The ATMega32u4 communicates partly via the Sitara processor. So trying to code it directly as a Leonardo doesn't work. I'm reassured this will be clarified in time.

 

Regardless of trying to upload code traditionally to the Arduino Tre this is probably not how I would go ahead with working on it, more on that in a bit. There's a major part I have entirely skipped after updating the software and that is to go through the standard setup process.

 

On the back of the box there is reference to TreSetup.html - this is a web page file that directs to a website running via the Linux operating system on the board. Ideally it can be run from whichever operating system you have your Arduino Tre plugged into; but it can also be ran from the Debian installation on the Tre itself if it's running standalone. When the Tre is connected to your computer it sets up a virtual network interface over USB on the IP address of 192.168.7.2 - so if you already have a private network which uses this address space and that IP address in particular then you're going to have a conflict. Alternatively you can connect the ethernet cable to the Tre and use whichever IP address you allocate to it via DHCP.

 

setup-initial.pngsetup-initial2.png

At the time of writing the setup steps involve changing the name of the board; which cannot be "arduinotre" and setting a password to login with. This login is for the front-end of the website, not for accessing Debian on the Tre. The default login details for Debian on the Tre are:

 

User: tre      Pass: tre

User: root    Pass:

 

Root doesn't have a password set. At the moment the steps do not get to step 3 on the page, because you will have just rebooted your Tre (there are a lot of references like that at the moment and they're obviously just left in from testing).

 

001-trelogin.png002-treblink.png

 

Once logged in to the website it presents the now intended Integrated Development Environment (IDE) for the Arduino Tre. It has the usual sketch examples that the Java IDE has, plus some more which can be uploaded to the Leonardo or ran on the Sitara processor. Yes, you can code for the Sitara from the Arduino IDE and presumably the PRUSS on the chip as well; though I haven't checked that yet. As a 'hello world' the Leonardo and the Sitara have individual LEDs that you can code for to blink. The Sitara has a three colour LED(s) which you can code for as opposed to the Leonardo's singular.

 

The web integrated IDE for the board is definitely a step in the right direction, it has has the potential to be a better IDE than the Java one and already integrates simple functionality such as auto-completion for parenthesis and quotations. From this on-board website you can also keep the packages up to date for the operating system, monitor/check the settings for your network connections and save/load sketches to compile for the board along with running a terminal and serial monitor. More features are seemingly being added as they're identified and requested and just to re-iterate, this site doesn't have to be ran from only within the operating system of the Tre. Arguably that could be a security issue down the line by default for some people but it can be trivial to lock that down if you so choose as it is only running Debian after all.

 

I decided to test one of the existing Arduino motor shields and attach it to the board, it was incredibly simple and just worked with a stepper motor I had available.

 

IMG_20140523_232930.jpgIMG_20140523_232948.jpg
003-motor.png

 

Functionality of the Sitara and ATMega "sections" of the board are also independent. There is a jumper setting on the board itself that switches between the both of the boards being powered on/off at once and allowing the Leonardo to turn the Sitara processor on/off. This means that the Arduino Tre can be sat idle, monitoring or doing numerous actions with its own shields and/or XBee connectivity and then wake up the Linux counter-part and utilise the operating system and/or the additional GPIO if required.

 

I look forward to playing with the Tre more to see what I can do with it, and I'm interested in hearing any projects that people have in mind that could be done with the Tre.

 

728x90__arduino_tre.jpg

 

Let me know your ideas! What would you do if you had a Tre ?

 

If you can't see "Add Comment" below, please sign up for an account!

 

Previous Guides:

Getting to Know Arduino : Part 1 : Hello, World!

Getting to Know Arduino : Part 2 : Hello, Again!

 

So after getting a little familiar with flashing an LED in Getting to Know Arduino : Part 1 : Hello, World! and Getting to Know Arduino : Part 2 : Hello, Again! of my Getting to Know Arduino, I have decided to throw a bit of a curve ball with my Part 3. So assuming that you already have picked up a Breadboard and some wires with your Arduino Uno. I decided that some of you may have been like I was after getting to grips with it:

 

"Where's the cool stuff? All I'm doing is flashing a light".

 

So to be topically "Internet of Things", we're going to play with a temperature sensor. It can seem daunting to start with, but once you have it plugged in then it's easy enough to get instant feedback to be reading Celsius and Fahrenheit. Honest! And what's more fun than having empirical evidence to back up a complaint of the weather?

 

So to get to know your Arduino a little more you will need the following:

 

 

Along with the Arduino IDE installed onto your computer. When you have your parts, you will want to plug them into your breadboard and there is a specific way to plug them in to complete the circuit. Here is an example of a completed setup:

 

temp_sense.jpg

 

So at the moment, this looks like a mess of wiring in a dimly lit photograph (I guess that's partly what it is). However, there are some directions that can be taken to supplement this photograph. On a typical breadboard there is a grid referencing system. As you can partly see in the photograph it is labelled A to J along the columns across the top and numbered from 1 downwards for the rows. So simply we can wire it up thus:

 

  • Insert the DS18B20 to the breadboard. Push the outer pins into row 1 and the centre pin into row 2.
  • Insert the 4.7k resistor into row 2 and into row 5. Orientation does not matter.
  • Connect a wire:
    • From Pin 10 on the Arduino onto row 2.
    • From row 1 to GND on the Arduino, it does not matter which GND this is.
    • From row 5 to 5v on the Arduino

You should now have something that looks like the diagram! Only, possibly a lot neater.

 

Now once you have your temperature sensor, resistor and wires all connected to the Arduino, you can plug it into your computer via USB. However, we cannot go about using the Arduino IDE just yet, we need to get the example code to work from.

 

The temperature sensor communicates with the Arduino via a protocol called 'OneWire' and this is a protocol (a method of communicating) that was created by Dallas Semiconductor (now Maxim Integrated Products). The DS18B20 has a datasheet which goes into all sorts of detail about how it communicates on a very low level, what its voltage and current limits are, etc. This is common for electronic components and these datasheets, while laborious to read and learn are very useful for finding out what the equipment is capable of and how you can get it working.

 

So to communicate with the temperature sensor, we need to download the OneWire library, it can be downloaded from Paul Stoffregen's site, or I have attached it to this blog post. Once you have your OneWire.zip file, you will need to extract it to your Sketchbook folder. If you open up your Arduino IDE, click the File menu and select Preferences, your Sketchbook folder will be displayed under 'Sketchbook Location'. Extract the OneWire.zip file into this location using Windows or free software such as 7-Zip (merely copying the .zip file into the sketchbook folder will not suffice).

 

When the library is in place, restart the IDE and then you can open the File menu, go to Sketchbook, then OneWire and choose DS18x20_Temperature. This will load a sketch that you can then select the Sketch menu, and select Verify/Compile which will push it to your Arduino.

 

Once the sketch has compiled and it is on your Arduino, click the Tools menu, then select Serial Monitor. You should now see some values including the temperature detected by the sensor!

 

Since the code is running on the Arduino now, you can quite happily sit back and watch it collect the temperature. However what you could also now do, is alter what it prints to the Serial Monitor so that it could be picked up by, say, Python and presented as a graph. Below is code you can compile and send to your Arduino which will only show the temperature in Celsius without the additional information. Bare in mind that the temperature might need calibrating and it could be off by a few degrees, this is correctable in software.

 

#include <OneWire.h>

OneWire  ds(10);  // on pin 10 (a 4.7K resistor is necessary)

void setup(void) {
  Serial.begin(9600);
}

void loop(void) {
  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  float celsius, fahrenheit;

  if ( !ds.search(addr)) {
    ds.reset_search();
    delay(250);
    return;
  }

  if (OneWire::crc8(addr, 7) != addr[7]) {
      Serial.println("CRC is not valid!");
      return;
  }
  Serial.println();

  // the first ROM byte indicates which chip
  switch (addr[0]) {
    case 0x10:
      type_s = 1;
      break;
    case 0x28:
      type_s = 0;
      break;
    case 0x22:
      type_s = 0;
      break;
    default:
      return;
  }

  ds.reset();
  ds.select(addr);
  ds.write(0x44, 1);        // start conversion, with parasite power on at the end

  delay(1000);     // maybe 750ms is enough, maybe not

  present = ds.reset();
  ds.select(addr);
  ds.write(0xBE);         // Read Scratchpad

  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
  }

  int16_t raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg = (data[4] & 0x60);
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
  }
  celsius = (float)raw / 16.0;
//  fahrenheit = celsius * 1.8 + 32.0;
}








 

 

If you want the Fahrenheit temperature, you can just un-comment (remove the //) on the line. Have a play about with the code, look up the functions as to what they do and see what you can make of it. If you have any troubles please leave a comment. There's also more information in the Arduino community group!

 

Next Guide:

Getting to Know Arduino : Part 3 : Taking your Temperature

 

Previous Guide:

Getting to Know Arduino : Part 1 : Hello, World!

 

In part 1 of my Getting to Know Arduino, I blogged about flashing an LED (light emitting diode) with the Arduino UnoArduino Uno and how to get started with it using an A to B USB cableA to B USB cable. However, we only flashed the LED that was on the circuit board of the Arduino and we didn't actually get to building any circuitry with it, but in the blog post we did look into the code behind the flashing of the LED.

 

Now, what we can do is the same again, only this time, a little differently. You will need the following, or a variant there of:

 

 

Along with the Arduino IDE installed onto your computer. When you have your parts, you will want to plug them into your breadboard and there is a specific way to plug them in to complete the circuit.

 

The Arduino's input/output (IO) pin sockets is where we then connect from digital pin 13 (D13) through a resistor to the LED to ground (GND). It is important to have a resistor in the circuit to prevent damage to your LED, some Arduino boards have an on board resistor in series with the IO header for pin 13 but it is safer not to take that risk else you'll let the magic blue smoke out and your LED will become an FED (fire emitting diode).

 

If you're unsure as to what resistor to use, you could take the unorthodox approach of using the highest value resistor you can find and scaling down until you find the right one, or you can calculate it. If you're uncomfortable with this, typically a 1Kohm resistor will do, but I often cheat and use an online calculator, if you do not use an online calculator then you will want to use Ohms Law to work it out. Once you've read the specifications of your LED and you know the forward voltage (or just voltage) and the forward current (or just current) in mA (milliamperes) and the source voltage (you can find out from the specifications on the Arduino, but I can easily tell you it is 5volts) then you can work out the required resistor.

 

It is important to get used to being aware of the requirements of the components and not just LEDs you're using and what resistors are required.

 

Here is an example of a completed setup:

 

arduino_part2.jpg

 

 

On a typical breadboard there is a grid referencing system. As you can partly see in the photograph it is labelled A to J along the columns across the top and numbered from 1 downwards for the rows.

 

Here we connect our LEDs positive pin to the digital IO pin socket (from row 2 on the breadboard to pin 13 on the Arduino) while we then connect a resistor (row 1 on the breadboard to row 5) and ground (GND from the Arduino to row 5 on the breadboard).

 

It is also worth to note that the LED is 'keyed' as to its orientation from positive to negative (or anode/cathode). Typically the shorter leg on the LED which also has a flat side to the plastic casing is the negative/ground/cathode side.

 

It has been known that cheap LEDs you can acquire have been manufactured incorrectly and that the casing on the LED has been rotated. So sometimes it is a lucky dip as to whether or not it will turn into a FED depending on the build quality.

Now you can connect your Arduino up to the computer and upload the example Blink program, if you still have the Blink example program uploaded to your Arduino then we will see that the LED will blink in unison with the on board LED 'L'.

 

Equally if we connect the LED to pins 1 or 0 on the Arduino, we would see it blink in unison when there is data sent to/from the Arduino.

 

Since you've now got an external LED connected to the Arduino, you can try connecting a few of them in line with one another, in series. Or, you can alter your sketch so that it will blink an LED from more than just the one pin depending on what variable values you use.

 

Have a go and experiment, if you have any problems then please leave a comment. There's also the element14 Arduino community group!

 

Next Guides:

Getting to Know Arduino : Part 2 : Hello, Again!

Getting to Know Arduino : Part 3 : Taking your Temperature

 

I recorded a video to introduce the Arduino UnoArduino Uno and how to get started with it. The premise was that you didn't need to add anything extra, except for an A to B USB cableA to B USB cable (always check the type you need for the Arduino you have) because although you can connect an external power supply it can be powered purely from the USB, and you could get code running with a few simple steps on Microsoft Windows to make an LED (Light Emitting Diode) start to flash on your board.

arduino_uno_components.jpg

The Arduino I showed in the video was a revision 3 board, there have been a few versions so far, in the image (from zenbike.co.uk) you can see an earlier version, but it nicely maps out the connectors on the board. I think in the recent version the reset button has moved, but that makes little difference overall. What it doesn't note on the image is that any socket with the ~ (tilde) symbol next to it can be used as a Pulse Width Modulation output. This is a way of having a digital signal pretend that it's analogue but typically you don't need to worry about this until you've got some hardware that you need to output to which needs it.

 

The first instruction we can make the Arduino perform is to flash an LED, which is often considered the "Hello, World!" of getting started. The example code 'Blink' will do this for you, it flashes the LED marked 'L' on the board. This LED is also linked up with the breakout pin '13' like many connections on the board, some go through components and others do not, but they ultimately connect to the ATMega328 micro-controller processor on the board, which is the brains of it all.

 

We'll need to tell the Arduino what we want it to do and for that we can use the Arduino Integrated Development Environment (IDE), this environment contains a text editor and a console window which shows you any error messages and how successful the software has been when communicating with the Arduino. You can get the IDE for more than just Microsoft Windows, there are Mac OS and Linux variants. You might want to check your package manager and software repository for whether or not there is a version pre-packaged for your version of Linux. For example you can use apt-get on Ubuntu to "apt-get install arduino" from a terminal.

 

It's often best to get the latest non-beta version of the Arduino IDE, but if you have a board that is newer then usually this isn't supported in the 'stable' builds and a beta or nightly build is required.

 

After installing the Arduino IDE in Microsoft Windows, you'll need to connect your Arduino Uno if you haven't already. It may help to reconnect it so that it re-detects the device and installs the driver. Then you can run the IDE. To be able to upload code to the device you will need to know what COM port it is running on.

 

To do this, open your Start menu, navigate to Control Panel, once the window appears, open System and then navigate around the tabs/options until you find Device Manager. With this window open, click the + symbol next to "Ports (COM & LPT)" and the Arduino should be listed along with its COM and a number.

 

In the IDE, go to the Tools menu and then expand Board and choose your Arduino, then do the same, but go to Serial Port and choose the one that it stated in Device Manager.

 

Now to get the LED flashing, choose the File menu, go to Examples and then 01.Basics, under this menu navigate to Blink. To get this running on your Arduino you can now either click on the arrow next to the tick icon or choose the Sketch menu and click Verify/Compile. Now the 'L' LED on your board should be blinking!

 

Feel free to change the code, copy and paste bits to see what works and what doesn't.

 

This will open a new window with the following code in it:

 

/*
  Blink
  Turns on an LED on for one second, then off for one second, repeatedly.

  This example code is in the public domain.
*/

// Pin 13 has an LED connected on most Arduino boards.
// give it a name:
int led = 13;

// the setup routine runs once when you press reset:
void setup() {        
  // initialize the digital pin as an output.
  pinMode(led, OUTPUT);
}

// the loop routine runs over and over again forever:
void loop() {
  digitalWrite(led, HIGH);   // turn the LED on (HIGH is the voltage level)
  delay(1000);               // wait for a second
  digitalWrite(led, LOW);    // turn the LED off by making the voltage LOW
  delay(1000);               // wait for a second
}
        

 

This is what is referred to as a 'sketch' in IDE terms, however it is actually using a low level programming language called C++ which has been around for a notable amount of time, most of the software you use is written with C++ including Microsoft Windows and parts of Linux.

 

Line 01 and 06 in the code uses text that the IDE recognises as a special arrangement so that it knows to ignore anything typed between them (it denotes that whatever is between them is a comment. On line 08 it shows the line starting with a similar arrangement that means to ignore that entire line as a comment.

 

int led = 13;
        

 

This line is literally mathematical, it could be said that programming is inherently mathematical because processors are just doing calculations and moving numbers around. So this line in particular is declaring that the english word, led is a certain type of variable (kinda like a bucket that can only contain something of a particular thing and its contents can vary) and that is called an integer, which means a whole number. As opposed to a number with a decimal (or a real number). We're then making the contents of the variable (or bucket) equal to the number 13. What then terminates the line is a semicolon and this is required by the IDE to know that we're finished putting commands on the line.

 

The IDE, or specifically the part of it that changes our near-english (sketch/programming) into a language that the Arduino can understand typically operates on a line by line basis, which is like how old typewriters used to work where by you normally couldn't go back and change what you had just created/read and had to continue (probably a bad analogy).

 

void setup() { }
       

 

The setup declaration is called a function, anything within { } is processed by the IDE, 'setup' is a reserved name for the function and it means that it is ran before anything else within the sketch. Like the variable led is of a type int, the setup function is of a type void. We don't have to worry about that for now. pinMode() is another function that is referred to and you can read up about it.

 

void loop() { }
       

 

The loop function is another reserved name that means anything within { } is ran again from the first { when it reaches the last line or instruction before the final }. The speed of this is governed by how fast the microprocessor, for example the ATMega328 can get through the instructions per second. The digitalWrite() and delay() functions can also be read up about on the Reference section of the Arduino site.

 

Hopefully you have found this useful to get started with your Arduino and it has introduced you to some new concepts for programming for micro-controllers. The best way to learn is trial and error, so don't be afraid to mess around with the code or read up about it.

 

If you have any questions, problems or otherwise please leave a comment! You can also find more information in Arduino community group!

Filter Blog

By date: By tag: