Who has not happened to note that wonderful breathing led effect present on some electronic devices?
There are makers all over the world equipped with oscilloscope tried to do reverse engingering to find the algorithm and turn it into an Arduino sketch. The problem lies in the fact that most of the codes found in the network have two defects: the first is that such algorithms do not contain a function but a series of pre-calculated values that do not make the effect smooth, while the second resides in the fact that often these codes are blocking, making use of delay and therefore do not permit the correct execution of the remaining code inside of the sketch.
Ispired by the Sean Voisen’s post who find the function defining the PWM values to drive the LED, I made some changes and tests to make it non-blocking and to make it work in background allowing execution to other code.
The end result is the following:
The connection is obviously as for any other LEDs and the system is capable of driving even power LEDs or LED strip, through appropriate transistor or MOSFET (See: Driving a LED Strip with Arduino)
The Arduino code is the following:
/*
NonBlockingBreathingLed 0.1
by Luca Soltoggio - 2015
12 May 2015
http://www.arduinoelettronica.com/
https://arduinoelectronics.wordpress.com/
http://minibianpi.wodpress.com/
Use a exp + sin function to recreate a
non-blocking breathing led effect
Released under GPL v.2 license
*/
#include <math.h>
#define ledPin 11
int i=0;
int breathe_delay = 15; // delay between loops
unsigned long breathe_time = millis();
void setup()
{
}
void loop()
{
nonBlockingBreath(); // call the nonblocking function
// yourOtherCodeHere();
}
void nonBlockingBreath()
{
if( (breathe_time + breathe_delay) < millis() ){
breathe_time = millis();
float val = (exp(sin(i/2000.0*PI*10)) - 0.36787944)*108.0;
// this is the math function recreating the effect
analogWrite(ledPin, val); // PWM
i=i+1;
}
}
The title could not be more appropriate: Arduino Yún is in fact the first of a series of products that is already revolutionizing the world of Makers.
I will not examine here the specifications (which have already been widely discussed in various blogs and which are summarized on the official website), but I would rather analyze the mode of operation of this platform, as well as highlight the possible future implications.
The starting premise is that the Arduino environment has spread exponentially since its inception, becoming a de facto standard, fueling in a virtuous circle the worldwide Makers movement.
From Arduino have resulted in fact hundreds of projects, similar board and new ideas, so that now are very few technological innovations that have nothing to do with this board (just think of the advent of 3D printers).
Ad Arduino mancava però ancora una cosa, di importanza sempre più fondamentale per poter partecipare all’Internet dell Cose: la capacità di scambiare ed elaborare metadati complessi con il resto del mondo (utilizzando ad esempio il web semantico).
The Arduino, however, still lacked one crucial thing to be able to participate in the Internet of Things: the ability to exchange and process complex metadata with the rest of the world (using for example the Semantic Web).
This deficit the world of digital artisans tried to remedy, with more or less successful solutions usually based on the combination of Arduino with embedded linux systems, such as the Raspberry Pi, which are very web-oriented and prepared to data processing, but lack of physical connections with the real world (in my own small I also made a few attempts: see Ardudome).
The makers of Arduino have responded to this ever more pressing need with a truly unique product: Arduino Yún.
Its uniqueness is due to several new features:
– The ability to combine into a single board a low-power embedded linux and an Arduino Leonardo
– The onboard Wifi which lets you connect to the network and makes it possible to load the sketch wireless
– The interaction with the widest range API (Google, Youtube, Twitter, etc.).
– Linux System on board based on OpenWrt, light and powerful at the same time
– Web interface and REST APIs that allow direct communication between the web pages and Arduino
– The form factor compatible with previous Arduino board
But the feature that I think above all else is the hub of the whole operation, is the Bridge library, which is the software that allows these two worlds to communicate with each other in a simple and fast way.
At first glance, reading the various examples, it all seemed quite incomprehensible, but using and experimenting with the library , you quickly realize the enormous potential and brilliance of this product: the connection between the two souls of the Yún is via a serial communication that allows a direct exchange of data in a bidirectional communication using simple dedicated functions. Therefore it is possible for example to directly access Arduino sensors data from the Linux side, or vice versa to access directly the output of a linux command from the Arduino side.
This mode of communication simplifies everything and vastly expands the incredible potential of the old Arduino board, but also those of a “trivial” embedded linux board.
For example we can very easily turn on an LED when we get an email, rather than monitor the power consumption of our house and save the data on a Google Spreadsheet document, or even build an alarm clock that according to traffic conditions retrieved from the Internet, decides whether it is early or too late to wake up.
The practical implications of this technology are really futuristic and endless, and we can imagine that this library will be the engine of the next Arduino’s revolution: Arduino Tre, which promises extreme performance compared to Arduino Yún, especially with regard to the Linux side. Will in fact have more power, an HDMI output and will be based on the Beagleboard system.
During these days I’m working on my first project which will be published as soon as completed.
Subtitle: Platform and browser-independent web based Arduino bidirectional remote control & sensors. (Smartphone optizimized)
Here we are with the perhaps more interesting so far presented project.
I was looking on the internet for a way to control the Arduino via the web, but everything had to be estrememanete flexible, simple, adaptable to a smartphone but also had to have a two-way communication and automatic refresh. I have not found anything that had all of these combined, that’s why I decided to implement this project.
The majority of similar projects, have in my opinion incomplete features: those specific to automation usually have to download an application and therefore are not cross-platform, web-based ones either have a poor interface or require to refresh the page in order to update the state of outputs, or still have the opportunity to read sensors, but not change the outputs…
The requirement that I had in particular was that if I was changing the state of an output not remotely, but locally (via a button for example), the interface had to introduce almost in real time such modification exactly on the button of the interface without having to refresh anything.
To do this I need to use a bit more complex web interface than the one coming from the Arduino Ethernet Shield, so I opted to use the Raspberry Pi web side (but can be used any Linux PC, or with some modifications even Windows), connected via USB (ie serial) with Arduino.
In this way I could implement some technologies, especially PHP and jQuery, which allowed me to realize everything.
The final operation is therefore very simple:
The interface shown in the photo above is a simple web page (as you can see is optimized for smartphones). Clicking on the slide we enable or disable an output (which is operated in real time), and every 5 seconds we have the automatic refresh of the outputs and of the analogic inputs also (in the above example I enabled only four outputs and one input).
The complete interface, contains the 13 outputs of the Arduino (not including the 0 and 1, which are used for serial communication), and the 6 analog inputs.
Connections and configuration is very simple: The Raspberry Pi or our PC is connected via USB to the Arduino board on which we loaded the sketch, then load up the interface and scripting on the Raspberry Pi et voila, you’re done. IMPORTANT NOTE: In order for this to work, we need to disable the Arduino auto reset. This can be done by connecting a 10uF capacitor between RESET and GND. If this is not done the serial communication will not work properly!
Let see principle of operation: The Arduino sketch gets a command from serial port and actvite/deactvate output or send value back.
The command has to be 7 chars long and begin with *CMD and end with /.
Between “*CMD” and “/”, you have to put the pin number (02, 03, 04, …, A5, A6) followed by the action: V = value (read) – get the raw value for analog input S = status (read) – is the output status of digital pins H = high (write) – just for digital pins L = low (write) – just for digital pins T = toggle (write) – just for digital pins
This sketch is designed to work with his PHP script, but it could be integrated in other prjects using the syntax above.
The PHP script communicate with web interface and Arduino for getting and setting PIN status.
If invoked without parameters it returns a JSON string with status of digital output and value of analog input.
For example: {“02″:0,”03″:0,”04″:0,”05″:0,”06″:0,”07″:0,”08″:0,”09″:0,”10″:0,”11″:0,”12″:0,”13″:0,”14″:756,”15″:745,”16″:722,”17″:679,”18″:634,”19”:494}
If invoked with the GET method it use two parameters: “pin” (from P02 to P13) and “cmd” (0 or 1).
For example http://raspberrypi/ardudome.php?pin=P13&cmd=1, will send the following command *CMD13H/ to Arduino
putting PIN13 in HIGH status.
This script is designed to work with his web interface, but it could be integrated in other projects using the syntax above.
The web interface, based on HTML, jQuery and AJAX, will call every 5 seconds the PHP script, udpating HTML with right values got from Arduino.
If a slider would be clicked or touched, changing his value, the script will suddenly call PHP script giving
PIN to change, and VALUE to set.
As you can see is all really simply and intuitive.
Now let’s see how to install:
1 – Download files from github (https://github.com/toggio/ardudome/)
2 – Load the sketch ArduDome.ino in your Arduino UNO board
3 – Put a 10uF capacitor between GND and RESET (this will disable autoreset feature on serial open)
4 – Connect you Arduino UNO through USB port to your RaspberryPI (or any other Linux PC) with apache and php preinstalled
5 – Put all files (except for Ardudome.ino and functions.ino) in your www directory (usually /var/www)
6 – Verify the name of your USB serial port (usually /dev/ttyACM0) and change it in ardudome.php ($serial->deviceSet(“/dev/ttyACM0”);)
7 – Give the user www-data permission for dialout (usermod -a -G dialout www-data)
8 – Verify connection (php ardudome.php)
9 – Open your web browser from smartphone or PC to http://yourraspberryip/ardudome.html
In recent months I’ve been busy on a project I’m doing with some friends: launch a weather balloon into the stratosphere (over 38km of altutudine).
Although is not a new project in the world, and even in Italy (see the project Stratospera), we believe there is new compared to other similar projects.
First of all, the project is entirely open source, both for hardware than for the software: each aspect it will come out, will be published on the official website.
In secondo luogo, il “computer di bordo”, è realizzato interamente con Arduino, che si occuperà quindi della gestione della posizione, dei dati meteorologici, del datalogging, di una parte di comunicazione, e della gestione del “cut-off” di emergenza. Android si occuperà prevalentemente invece della gestione della posizione e dell’invio tramite rete cellulare dei dati in tempo reale (ovviamente quando sarà sotto copertura di rete, cioè realisticamente fino a 5-6km di altitudine).
As the tird innovation, there is in preparation, not from the first launch of course, the possibility of recovering the payload (containing all the electronic equipment), via a glider drone, which should autonomously bring everything to the point of launch…
From the point of view of the feasibility study we have finished, while now we are focusing on the Arduino software, and we are proceeding with the request of various authorizations, as well as to raise funds for various expenses …
We are also looking for people willing to contribute to the project, not only economically but also humanly to the project.
In addition, if some company wants to sponsor us with material that can be used in the project, we will be happy.
I will keep you updated!
After months of waiting, the long-awaited Arduino Two is finally here 🙂
I have not yet had the opportunity to have it in my hands, but looking around in the network and specially in the official site, in this article i want to highlight the main news of this system compared to its predecessor Arduino UNO.
Well, what to say!
On the paper, the news are actually many and all derives from the new Atmel SAM3X8E CPU Cortex M3 with 32bits ARM architecture that replaces the old 8bits AVR:
1 – CPU Clock at 84Mhz (16Mhz compared to the previous version)
2 – 96Kb of RAM (compared to 2Kb)
3 – 512Kb of Flash (UNO had 32Kb)
4 – 12bits PWM and analog inputs (compared to 8bits)
5 – Output DAC – New for Arduino
6 – Higher number of PIN
7 – USB Host
Tis means an extremely higher processing speed, accuracy greatly improved and new possibilities thanks to the DAC and the USB host.
Performances are mainly related to the clock speed coupled with the 32bits (and of course more RAM).
With 32bit we are able to perform a 4bytes operation (8 x 4 = 32) with a single CPU clock. This means in an empirical way, that Arduino TWO might be about 20 times faster than Arduino UNO.
The most accuracy is related to the 12-bits analog inputs and PWM outputs: we have 16 times the old resolution, that means we have 4096 levels of conversion from analog to digital and vice versa compared to the 256 of the previous version. This allows a higher density of input data and a greater control on the PWM output.
The new features mainly concern the DAC pin (analog outputs, that is linear from 0 to 3.3 V) allowing for example to perform a MP3 file and hear it on the speakers connected to these outputs.
The only negative notes in my opinion (you have to be really picky though!), are the lack of an ethernet port – now essential in any application, and the fact that the TTL is 3.3V and not compatible 5V; with the wrong voltage you will fry pin or microcontroller itself. This leads to an incomplete compatibility with the existing shield or with third-party hardware.
Regarding consumption theoretically should be similar Arduino Mega although I did not find anything specific about it.
The programming instead always work through our Arduino IDE, updated to version 1.5 for the occasion, which contains additional libraries for the management of the new capabilities of the board. The programming mode is very similar to the old procedure.
Obviously, in this article we talked about a version out a few days ago and still in the testing phase. Time will tell if this card will completely replace the old Arduino, or if there will be a parallel market that will adapt depending on the final application. Surely those news lead further innovation in this field, such as to suggest that now the Arduino product may encroach further from the world of “geeks home” in the electronics professional.
Certainly a product like Arduino DUE, in terms of performance and precision is a product that is well suited for applications beyond entertainment home at a very attractive price (Arduino Store official price: Euro 39).
On the other hand, with this platform, it will be difficult to create embedded designs similar to those achieved with ATtiny85 or ATmega328 in standalone mode, but you can of course continue to use the old AVRs: as I said before, depending on the final application, you will find the best solution.
And now another interesting little project.
After seeing various online projects, especially based on the PIC microcontroller, I decided to make a charger for NiMH batteries driven by an ATtiny85.
Why we need a microcontroller to manage charging a battery? The answer is very simple … The most economic charger that on the market, regulate the charge based on a timer, that is if I charge a 2500mAh battery for example, they provide a charging current of 250mAh, keeping the charge for eg 14 hours (a part of the energy will be lost, so 10 hours would not be enough).
This way of charging NiMh or NiCd batteries is not very functional. It is a slow process, and does not guarantee a 100% accurate cell charge, as well as increasing the risk of overload.
“Smart” chargers however, charge batteries correctly, but besides being quite expensive, their usually charge current is not very high, leading to charging times still quite long.
So in addition to the curiosity and the desire to create something of my own, this project was born …
But lets proceed with order, starting with a video showing the finished running project:
Let us now try to understand the operating principle.
First nickel batteries require a constant current to be charged properly. So we used a transistor-based constant current source, derived from what we saw in a previous post, and so far nothing special, but how do we know when the battery is fully charged?
We need to constantly read the voltage of the battery being charged, and when there will be a maximum peak voltage followed by a sudden drop of about 20mV, the battery may be considered charged. This phenomenon (called Negative Delta V) is related to the chemistry of this type of battery, and allows to establish precisely the right moment to terminate charging.
Thus we see the circuit diagram:
The schematic is pretty simple. The darlington transistor Q1 (TIP127), through LED1 (which must be absolutely RED) and the resistance R3 from 0.3 Ω, creates a constant current flowing in the direction of the 6-cell battery (7.2V), while the Schottky diode 1N5822, serves to protect the entire circuit in the case that is lacking the input voltage with the battery connected. The voltage divider R4-R5, serves to bring to port 7 of the ATtiny (A1) the battery voltage decreased to about 1/3, in such a way that it can operate with voltages up to 15V (the analog input of the ATtiny can not exceed 5V). The transistor Q2, driven by the port 5 of the ATtiny (D0), serves as a switch to enable or disable the LED-1 and the transistor Q1. It’s really important that LED1 is RED, and this is not a matter of aesthetics, but because the power output is given by the ratio between the voltage of the LED (the red LED is about 1.8 to 2.2 V) and resistance R3. Using a green LED, the reference voltage is raised, and consequently also the current rises (and not just a little bit).
The circuit above, can deliver about 1.5-2.5 A: you may have to do some testing with various types of red LED, or vary the resistance, which must be at least 2W. If you can not find resistance with so low values, you can use 3 or 4 1Ω resistors in parallel.
Another thing to remember, is the power dissipated by the TIP127, which can be up to 20 watt (depending on the current and the voltage difference between the input and the battery), then a heat sink need to be mounted properly. In my case was enough to use the aluminum enclosure.
Last note is the input voltage, which must not be too high otherwise you risk to burn the transistor, but must not be even too low, because otherwise the dropout induced by the various components makes too low the charging current. Can fit approximately a difference of about 5V between the input voltage and the nominal value of the battery. For example, with 6-cell a voltage of 12.2 V is recommended (maybe 12). Of course you can also charge less cells, by suitably adjusting the input voltage. For a cell, we should feed the device with a voltage of about 1.2 + 5 = 6.2 V (maybe 6 or 7).
Let us consider now the printed circuit board:
Note the two gems that were not visible in the schematic. The ICSP connector (ie the ability to update the firmware on the ATtiny – via UsbTinyISP programmer for example – and the debug connector, to be connected to a TTL converter in order to read the battery voltage during charging.
The J1 connector is a jumper that must be closed at all times, except when updating the firmware of Attiny85.
About firmware … The source code is as follows:
/*
NiMh Charger 0.9
with AtTiny85 @ 1Mhz
by Luca Soltoggio
10/03/2012 - 20/04/2012
Use negative deltaV to determine end of charge.
Suitable for NiMh and NiCD battery pack.
Default is for 6 cells 2500mAh.
Need some hardware/software adjustment for changing current / cells number
See http://arduinoelettronica.wordpress.com/
*/
const int inputPin = A1;
const int outputPin = 0;
const int numReadings = 30; // number of analog read before checking battery status
const int multi = 1614; // multi coefficent for obtaining millivolts from analogread
long interval = 1000; // interval for pulse charging and analog read - don't change this
long interval2 = 250; // pulse off interval - you can adjust power with this. Use 100 for 2-4Ah battery packs, 500 for 1-2Ah battery pack
long interval2b=interval2;
long previousMillis,currentMillis,currentMillis2,trickleMillis = 0;
unsigned int readingtemp;
unsigned int total = 0;
unsigned int average,medium,maxmedium = 0;
boolean executed,endcharge,trickle=false; // booleans for controlling various activities (for example "end of charge")
unsigned int myarray [7]; // array for keeping last 7 readings
int index,i = 0;
void setup()
{
Serial.begin(9600);
pinMode(0,OUTPUT);
// Some readings for initial check
for (i=0;i<10;i++) {
readingtemp = analogRead(inputPin);
total=total+readingtemp;
}
average = (((float)total / 1023.0) * (float)multi) / 10.0 + 0.5;
if (average<=70) endcharge=true; // If there is no battery, end charge
Serial.println(average);
total=0;
average=0;
}
void pusharray() {
// push the array
for (i=0;i<=5;++i) {
myarray[i]=myarray[i+1];
}
myarray[6]=average;
}
void voltread() {
readingtemp = analogRead(inputPin); // read analog input
total= total + readingtemp;
index++;
// if numReadings reached, calculate the average
if (index==numReadings) {
index=0;
average = (((float)total / 1023.0) * (float)multi) / numReadings + 0.5;
if (average<=70) endcharge=true; // stop charge if battery is detached
total=0;
pusharray(); // insert new average in array
medium=(float)(myarray[6]+myarray[5]+myarray[4]+myarray[3]+myarray[2]+myarray[1]+myarray[0])/7.0+0.5; // calculate the average of the last 7 readings
if (medium>maxmedium) maxmedium=medium; // save the value of highest medium in "maxmedium"
Serial.print(medium);
Serial.print(",");
Serial.print(maxmedium);
Serial.print(",");
Serial.println(myarray[6]);
if ( ((medium+1) < maxmedium) && ((millis()/60000)>=11) ) { // if battery charged (average voltage is dropped 0.02v), but not in the firsts 11 mintues
if (!trickle) trickleMillis=millis(); // start trickle timer
trickle=true; // enter final trickle charging mode
if ((millis()/60000)<=15) endcharge=true; // if battery is charged in the firts 15 minutes, don't apply trickle charge (maybe was yet charged)
}
}
}
void loop() {
currentMillis = millis();
// executed every "interval" millis
if(currentMillis - previousMillis > interval) {
voltread(); // call reading and check volts function
digitalWrite(outputPin,LOW); // temporaly stop charging
previousMillis = currentMillis;
executed=false; // boolean for setting and checking if has been yet turned ON charge
// in the firsts 10 minutes and in the endings 15 minutes do a trickle charge (change OFF interval)
if ( ( (trickle) && (((millis()-trickleMillis)/60000)<15) ) || ((millis()/60000)<10) ) {
interval2=(interval-(interval-interval2b)/5);
} else if ((millis()/60000)>=10) interval2=interval2b; // after initial trickle charghe set back right time
if ( (trickle) && (((millis()-trickleMillis)/60000)>=15) ) endcharge=true; // if final trickle charge end, end charge
}
currentMillis2 = millis();
// executed "interval2" millis after turning OFF charge
if ((currentMillis2 - previousMillis > interval2) && (!executed)) {
executed=true;
if (!endcharge) {
digitalWrite(outputPin,HIGH); // if battery is not charged, re-enable charging
}
}
}
The code is pretty simple and self-explanatory.
I conclude with a few pictures of the finished project:
Some of my previous post that talked about LED Driver, have generated a bit of confusion in someone … So I wanted to do a bit of clarity.
In particular, in a comment, I was asked if the driver did well to drive the LED strips.
The answer is: NO WAY!
Nothing to do. We have to consider LED strips as if they were bulbs or motors at 12V: they do not require special drivers to be controlled, but we simply have to feed them with a proper voltage (usually just 12V).
This is because LED strips are not simple LED, but within them ther is a circuit of series-parallel LED equipped with suitable resistances, and are then handled as a normal 12V equipment.
In the case of single LED, which has no real operating voltage, we need instead oconstant current in order to operate.
The correct circuit for driving an LED strip with Arduino is therefore as follows:
Where VCC is obviously the Arduino output (digital or analog) and X1 represents my LED strip (or motor or any other dimmable equipment at 12V).
Q1 is a TIP120, but any NPN or darlington NPN is fine, as long as is adequate to the load power.
I hope this article could have done a little ‘clarity.
See you soon!
Finally after a long absence, in which I was immersed in the final realization of this project, I did it!
After months of planning, studies, research and other obstacles, the RGB LED Lamp 1.0 by Toggio is reality.
Here’s the video showing the final result obtained:
And now a brief history.
One of the things that attracted me the most when I first heard of Arduino, was light, and in particular I have always dreamed of achieving an LED lamp RGB.
Nothing difficult, you might think … Except that along this route I found several obstacles.
First of all, I did not find complete projects on the net … There is something, but, in my opinion, with bad algorithms, with little explanation or with complicated methods.
I wanted a simple present to give to the person who I love and that gave me a beautiful daughter …
I wanted something that had a powerful enough light, without too much heat. I wanted something that had a chance to choose the color and not a simple “color cycler.” I wanted something that would serve also as a standard lamp. And finally, I wanted something that was modular and upgradeable in the future.
After these reflections, I began to study the hardware first. I did not want to use the Arduino UNO because it seemed too big for my project. So I decided (and this could open up a huge parentheses) to use a board not so common, but in my opinion awesome (so much that I bought 4 or 5 piece): The Arduino Mini Pro.
(It is understood that in the project of this post, it can easily be replaced by an Arduino UNO or any other board.)
It ‘a very small board (18mm x 33mm), 100% compatible with Arduino Dumilanove, and low power consumption. It is available in four versions: with Atmega328 or with ATmega168, both with 3.3V or 5V.
So I opted in this project for the 5V version with ATmega168. In short it is a very economic solution (it costs about half of the Arduino UNO), very compact and beautiful to see.
I then thought of using the useful LED RGB strips, which offer many advantages over using 1W or 3W power LEDs: they do not heat up, they are powered with 12V and they offer a power up to 13-14W per meter.
Each channel can be powered by a PWM output of the Arduino using a simple transistor (in my case I used the BC337, but for higher power you can use other transistor, or even the MOSFET).
I then proceeded to build a kind of shield for my board. Practically I made a circuit in which the Arduino Pro Mini would fit with strip connectors and with the ability to be removed to upgrade the firmware. Everything has been designed with Fritzing and built by Fritzing Fab.
The final result of the printed circuit is as follows:
You can see the two rows of holes where the Mini Pro will be mounted… Basically, it’s the opposite of a shield 🙂
But let’s step back and see the circuit schematic:
I hope it is clear enough even if I have not drawn just fine!
In any case, the operation principle is as follows: The two 10k potentiometers connected between +5 V and ground, are the two analog inputs that allow to adjust the brightness and other parameters set by the software. The 3-position switch SW2 allows you to select three different functions for the lamp. The digital outputs 3,5,6 go through a resistor to drive the 3 BC337 transistors that will give negative voltage to the 3 channels (R, G, B) of the LED strip. The common positive goes to +12 V, while the Arduino is powered by RAW port (input from 7V to 13V) via a diode that in addition to providing reverse polarity protection, slightly lowers the voltage. SW1 is simply the bridge where will be connected a standard power switch.
Once soldered the components, connectors, potentiometers, mounted the circuit, encapsulated the Arduino board, and assembled it all in a electrician box, the result is as in the following picture:
The size of the box is approximately 10cmx10cmx7cm.
For the top, I used about 70cm of RGB led strip, for a total power of about 10W. To fit the whole strip I rolled it around the support of a “50 CD-R set”. I cut with a utility knife and I glued all with spacers on the box. I then glued with hot glue the wrapping strip led… In short, the job is a little rough but the end result is as follows:
The glass you see on the desk, is the final piece: the glass cover of a IKEA lamp, properly cut by a local glazier, so that it remains empty on both sides. This coverage will finally resting on the box and glued, obtaining the following results:
Not bad right?
Of course there is still the icing on the cake, a not less important part: the software.
The self-explanatory code is as follows:
/*
RGB Led Lamp 1.0a
by Luca Soltoggio
15/03/2012
http://arduinoelettronica.wordpress.com/
*/
int rpin = 3; // red pin
int gpin = 5; // green pin
int bpin = 6; // blue pin
unsigned int r=0, g=0, b=0,bm=0; // r,g,b, value and blue coefficient
unsigned int valh=0, vals=0, valv=0; // hue, saturation, value
unsigned int sensorValue; // analog sensor value
const int analogInPin = A0; // potentiometer pins
const int analogInPin2 = A1;
const int digitalInPin = 10; // switch pins
const int digitalInPin2= 11;
int red[]={255,255,135}; // predefined arrays for RGB / White
int green[]={157,255,158};
int blue[]={51,255,255};
boolean DIG1, DIG2;
long previousMillis = 0;
int i=0,j=0;
int dl=0; // delay
void setup()
{
pinMode(digitalInPin,INPUT);
pinMode(digitalInPin2,INPUT);
}
void loop()
{
DIG1=digitalRead(digitalInPin);
DIG2=digitalRead(digitalInPin2);
if (DIG1) {
bm=1.1;
HSV_Game();
}
else if (DIG2) {
bm=1.9;
RAINBOW_Game();
}
else {
bm=2.4;
LIGHT_Game();
}
analogWrite(rpin, r/1.09); // write RED PIN
analogWrite(gpin, g/1); // write GREEN PIN
analogWrite(bpin, b/bm); // write BLUE PIN
}
// analog input smoothing function
int SensorSmooth (int pin) {
sensorValue=0;
for (int i = 0; i<10; i++) {
sensorValue+= analogRead(pin);
}
return int ((float)sensorValue/10+0.5);
}
// first light game: modify HUE and VALUE with potentiometer
void HSV_Game() {
valh = SensorSmooth(analogInPin);
vals = 255;
valv = SensorSmooth(analogInPin2);
valh = map(valh,0,1023,0,359);
valv = map(valv,0,1023,32,255);
hsv2rgb(valh,vals,valv,r,g,b);
}
// second light game: three positions for Warm White, White and Cold White
void LIGHT_Game() {
valv = SensorSmooth(analogInPin2);
valv = map(valv,0,1023,16,255);
valh = SensorSmooth(analogInPin);
if (valh<=281) valh=0;
if (valh>=742) valh=2;
if (valh>2) valh=1;
r=red[valh]*valv/255;
g=green[valh]*valv/255;
b=blue[valh]*valv/255;
}
// color cycler
void RAINBOW_Game() {
dl = SensorSmooth(analogInPin); // delay time
dl = map(dl,0,1023,1,100);
valv = SensorSmooth(analogInPin2);
valv = map(valv,0,1023,64,255);
unsigned long currentMillis = millis();
switch (j) {
case 0:
r=255*valv/255;
g=i*valv/255;
b=0*valv/255;
break;
case 1:
r=(255-i)*valv/255;
g=255*valv/255;
b=0*valv/255;
break;
case 2:
r=0*valv/255;
g=255*valv/255;
b=i*valv/255;
break;
case 3:
r=0*valv/255;
g=(255-i)*valv/255;
b=255*valv/255;
break;
case 4:
r=i*valv/255;
g=0*valv/255;
b=255*valv/255;
break;
case 5:
r=255*valv/255;
g=0*valv/255;
b=(255-i)*valv/255;
}
if (currentMillis-previousMillis > (long)(100-dl)) { // use millis instead of delay
previousMillis=currentMillis;
i=i+1;
if (i==256) {
i=1;
j=j+1;
if (j==6) j=0;
}
}
}
/* HSV2RGB function
(c) Elco Jacobs, E-atelier Industrial Design TU/e, July 2011
http://code.google.com/p/shiftpwm/source/browse/trunk/examples/ShiftPWM_Example1/hsv2rgb.cpp?r=3
*/
void hsv2rgb(int hue, int sat, int val, unsigned int& r, unsigned int& g, unsigned int& b)
{
int H_accent = hue/60;
int bottom = ((255 - sat) * val)>>8;
int top = val;
int rising = ((top-bottom) *(hue%60 ) ) / 60 + bottom;
int falling = ((top-bottom) *(60-hue%60) ) / 60 + bottom;
switch(H_accent) {
case 0:
r = top;
g = rising;
b = bottom;
break;
case 1:
r = falling;
g = top;
b = bottom;
break;
case 2:
r = bottom;
g = top;
b = rising;
break;
case 3:
r = bottom;
g = falling;
b = top;
break;
case 4:
r = rising;
g = bottom;
b = top;
break;
case 5:
r = top;
g = bottom;
b = falling;
break;
}
}
Here is a simple solar tracker, made with Arduino …
It ‘s just a draft, a starting point to be improved for building new projects.
The idea is very simple. Using two photoresistors (LDRs), one pointing slightly to the right and the other slightly to the left, let’s read the values and move a continuous rotation servo in the direction of the photoresistor receiving more light, until the brightness is about the same on both LDRs.
The end result is what we see in the following video:
As you can see I used Arduino Mini Pro, but nothing change using Arduino UNO. The only difference is that feeding the Arduino Pro Mini I had to use an external regulator, because the inside is not enough to drive the servo.
But let’s get to the list of materials needed:
1 – An Arduino UNO board (or any other compatible)
2 – Two 20K LDR photoresistors (with a few adjustments may also fit other values)
3 – Two 4.7K resistors (with different lighting conditions you can use different values)
4 – A continuous rotation servo. (Difficult and/or expensive to find, so I modified a standard servo following the directions found at this link
5 – One 9V battery, a breadboard, plastic holders and little else
The components must be connected to Arduino as follows:
/*
ISArduino 0.1
Arduino Solar Tracker
by Luca Soltoggio - 2012
http://arduinoelettronica.wordpress.com
*/
#include <Servo.h>
#include <Narcoleptic.h>
/*
A library that allows to put the microcontroller in standby
while in idle (delay), saving lot of energy.
You can safely remove it (but in this case you have to replace
the last staement Narcoleptic.delay(15) with delay(15).
*/
Servo myservo;
int Value;
int Center=105;
/*
The variable Center represents the centering value of the servo.
In my case it is 105, while usually it is 90.
With this value, the servo must stop running.
*/
void setup() {
Serial.begin(9600);
myservo.attach(9); // Attach servo to PIN 9
}
void loop() {
int sensorValue = analogRead(A0); // Read left LDR value
int sensorValue2 = analogRead(A1); // Read left LDR value
Value=(sensorValue-sensorValue2)/10;
/*
Compute the differnce between the two sensors
*/
if (Value==0) myservo.detach(); else myservo.attach(9);
/*
Detach servo if idle (for energy saving)
*/
if (Value>10) Value=10;
if (Value<-10) Value=-10;
/*
Limits the maximum difference between -10 and + 10
(in order to avoid an excessive speed)
*/
Serial.println(Value); // Debug
myservo.write(Center+Value);
/*
If "Value" is positive, move the servo to right, else to left
The speed is directly proportional to the absolute value of "Value"
*/
Narcoleptic.delay(15);
/*
Rather than using a simple delay, we use this to save energy
You can eventually replace with delay(15)
*/
}
So here you have this long-awaited post.
In this article we will see how to program some of the Atmel ATtiny family, particularly those highlighted in the title, using Arduino libraries and Arduino Uno as ISP. Obviously, everything can be done using a dedicated programmer, but here we will not talk about this subject because the differences are minimal.
Let’s start with a premise: on the ATtiny we will not upload the bootloader, but we will proceed to load our sketch directly into the memory of the microcontroller. So this is a first difference with the ATmega328. There are perhaps some ATtiny bootlaoders, but it doesn’t make sense to load them for several reasons. The first is the small memory of this microcontroller (ATtiny85 has 8Kb compared to 32Kb of the Atmega328). Secondly, most of the ATtiny do not have serial hardware, so it would make not sense to install a bootloader if it doesn’t help to do uploads via serial port.
Let us now see the advantages of the ATtiny85 compared to Atmega328:
1 – lower power consumption (and therefore suitable for projects with battery)
2 – smaller size (the ATmega328 has 28 pins while the ATtiny85 has only 8 pins)
3 – lower cost
Obviously with fewer pins we have a limited number of I/O compared to big brothers.
As regards the programming is very similar to that seen in the previous post and the one before that.
Let’s see the pinout of ATtiny85 that we will use as starting example in this article:
So if I want to use the PIN6 as a digital output I will use pinMode (1, output) and if I want to read the analog input from PIN3 I will use analogRead (A2).
Of course, as in Arduino, we can use analog inputs as digital outputs.
The serial hardware does not exist as we said, but we can use the appropriate PIN2 (PB3) as unidirectional software serial. Practically using the standard Arduino command Serial.begin (9600), on PIN2 we have a TX signal that can connect to RX pin of an USB-SERIAL converter, in order to communicate from the ATtiny to the PC, so it’s like having a “read-only serial”.
But let’s get to the point: compared to the programming of the Atmega328, the programming of the ATtiny requires some changes and the adding of some libraries to the IDE. I recommend using the 0023 version of the IDE, which can be downloaded from the website of Arduino (with other versions it was unsuccessful), and create a separate special folder to be used only ATtiny programming.
So if we already have Arduino (for example in the c:\Arduino folder), we will create a new folder called for example c:\Arduino-Tiny.
After this we have to download the core arduino-tiny-0022-0009.zip, from here, then we have to download the library PinChangeInterrupt-0001.zip from here and finally the library TinyTuner-0003.zip found here. The first file needs to be unzipped in hardware folder (eg: c:\Arduino-Tiny\hardware). It will ask you to overwrite some files. Answer yes without problems. The other two libraries need to be unpacked under the libraries folder (eg c:\Arduino-Tiny\libraries). At this point it should be alright. You can either upload your examples using the following scheme:
Basically, it’s like the ATmega328. The pin 10 need to be connected to RESET, and pins 11, 12, 13 to pin MOSI, MISO, SCK (ie in this case 5, 6, 7), and of course the power supply. Remember as always to insert the 22uF capacitor between GND and RESET on Arduino UNO otherwise the board will reset and the upload will not work giving you an sync error!!!
At this point, opening our IDE, and an example sketch, we can select Tools -> Boards -> ATtiny85 @ 1Mhz, then File -> Upload to I / O Board.
It will give you an error of type “PAGEL,” but you can safely ignore it. You will then see the message “Done Uploading” that will warn you that everything was successful.
As you can see it is very simple.
The ATtiny by default have fuse set in a way that the microcontroller uses its internal oscillator at 1MHz. And this is the best option for most projects, but if you need more speed, you can program the ATtiny in such a way that it uses its internal oscillator at 8MHz or by using an external oscillator at 16Mhz (see previous posts) . If we want change our ATtiny speed, for example at 8MHz, we need to set the fuse, doing an upload of a empty bootloader, containing only the settings that interest us. To do this, simply select from Tools -> Boards the setting of interest (eg ATtiny85 @ 8MHz), and then Tools -> Burn Bootloader —> w/Arduino as ISP.
At this point you will probably get the following error:
avr_read(): error reading address 0x0000
read operation not supported for memory "lock"
avrdude: failed to read all of lock memory, rc=-2
This error is due to the fact that the is missing the line that concerns the operation memory lock in file c:\Arduino-Tiny\hardware\tools\avr\etc\avrdude.conf the line that concerns the operation memory lock.
So we are going to edit this file and add the following line:
read = "0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0",
"0 0 0 0 0 0 0 0 o o o o o o o o";
Under ATtiny85 section, below the line memory “lock” that should look like so after the change:
# ATtiny85 has Signature Bytes: 0x1E 0x93 0x08.
memory "signature"
size = 3;
read = "0 0 1 1 0 0 0 0 0 0 0 x x x x x",
"x x x x x x a1 a0 o o o o o o o o";
;
memory "lock"
size = 1;
write = "1 0 1 0 1 1 0 0 1 1 1 x x x x x",
"x x x x x x x x 1 1 i i i i i i";
read = "0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0",
"0 0 0 0 0 0 0 0 o o o o o o o o";
min_write_delay = 9000;
max_write_delay = 9000;
;
Now running the bootloader operation should go.
If we want to we can fix also the problem of the message “PAGEL” by adding the following lines:
pagel = 0xB3;
bs2 = 0xB4;
Below the line chip_erase_delay = 4500 in the Attiny85 section. This should look like so after the changes:
#------------------------------------------------------------
# ATtiny85
#------------------------------------------------------------
part
id = "t85";
desc = "ATtiny85";
has_debugwire = yes;
flash_instr = 0xB4, 0x02, 0x12;
eeprom_instr = 0xBB, 0xFF, 0xBB, 0xEE, 0xBB, 0xCC, 0xB2, 0x0D,
0xBC, 0x02, 0xB4, 0x02, 0xBA, 0x0D, 0xBB, 0xBC,
0x99, 0xE1, 0xBB, 0xAC;
## no STK500 devcode in XML file, use the ATtiny45 one
stk500_devcode = 0x14;
## avr910_devcode = ?;
## Try the AT90S2313 devcode:
avr910_devcode = 0x20;
signature = 0x1e 0x93 0x0b;
reset = io;
chip_erase_delay = 4500;
pagel = 0xB3;
bs2 = 0xB4;
pgm_enable = "1 0 1 0 1 1 0 0 0 1 0 1 0 0 1 1",
"x x x x x x x x x x x x x x x x";
In this way, the error is corrected but only on Attiny85. To solve the problem for other microcontrollers, here I have given you a starting point. If you do a search on google with the error appearing during the bootloader upload you will find the solution.
There may be an additional error (I can not remember the message) when you upload very large sketchs.
In this case, I remember it was related to a AVR-gcc bug, and in order to resolve it, I needed to download the WinAVR tools, install them, and copy the contents of the folder c:\WinAvrtools in c:\Arduino-Tiny\hardware\tools replacing all files (except previously edited file avrdude.conf).
This last part is a bit more complicated, but you will see that if you will follow everything it will not be difficult.
At the next post then!