Today I want to show you a project really very simple but effective that can be used for various applications.
This is a high resistance continuty sensor (current gain approximately 30000 times), based on the interesting Darlington NPN BC517, and very low cost.
The basic design published here simply allows you to turn on an LED by touching or immersing in water two metallic elements (cables, plates or whatever), but “cloning” the circuit and putting more transistors and more LEDs, we can get a gauge with 2, 3, 4 or 30 sectors.
It goes without saying nothing forbids to replace the LED with a relay in order to drive loads the most important.
But let’s see in detail the circuit:
The operation is quite trivial: by touching the two contacts of the sensor “SENS” with hands for example, the weak current flowing through the body is sufficient to excite the transistor via the resistor R1 which serves as protection if we join directly the two contacts. The BC517 is able to amplify this current approximately 30,000 times, for which a current of 10 uA, is able to slide up to 300 mA through the transistor. The resistor R2 serves to prevent accidental starting by grounding the base of the transistor, while R3 is simply the resistor to limit the current flowing through the LED.
Although simple, I believe that this project will be a starting point for other applications.
Also sometimes the simple things are the most functional and a little ‘analog electronics’ sometimes … is not bad …
Greetings and see you soon!
Update – 03/10/2012 Schema corrected: obviously one of the two leads did not go to mass but on the positive … I apologize for the mistake and thanx who rightly corrected me with his comments.
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!
In the previous post we saw how to program the Arduino bootloader on a standalone Atmega328, while in another post we saw how to upload the sketch to the microcontroller with Arduino bootloader on board.
In this post I want to highlight what I believe is the ultimate goal of the projects prototyped with Arduino: program the ATmega328 without a bootloader, so that our programs can completely override the flash of the microcontroller.
But why do we do it? The main advantages are the immediate execution of our program when the Atmega power on, and more space for our programs in the memory of the microcontroller. The disadvantage is the fact that it is no longer possible to program via simple serial (less than reload the bootloader), but we must use a dedicated programmer (or a ArduinoISP) and the time to upload the sketch is a lot longer. I advise you to use this mode only on finished project, while using the Arduino bootloader when we are debugging our programs (with continuous uploads).
But we come to practice. The programming is implemented in the same way as the previous post, with a slight modification. We need to edit the usual file “boards.txt”, and add the line xxxxxxx.upload.using = arduino: arduinoisp in the configuration of the board that we are interested in programming, where xxxxxxx is the name of the board. We make a practical example, lets take the configuration to be included in boards.txt we saw the last time for the Atmega at 8MHz: with this new addition would thus become:
With this addition, we specify that the upload of the sketch does not have to end up on our Arduino UNO, but on the Atmega we want to program.
Also note the change (optional) atmega328bb.upload.maximum_size whose value becomes 32768. Basically it is the maximum space in bytes available to load our sketch. There is no longer the bootloader so the freed space is available to us.
1 – We upload by the IDE (version 0022) the example sketch ArduinoISP on our Arduino UNO
2 – We turn off everything and then connect a 22uF capacitor between RESET and GND of the Arduino UNO
3 – We Connect pin 10 of Arduino UNO to the RESET pin of the Atmega and pins 11,12,13 to pins 17,18,19 of the microcontroller (or pins 11,12,13 of another Arduino board) as shown in Figure :
4 – We do upload the sketch using the traditional command File -> Upload to I / O board
And that’s it … We programmed the microcontroller to work standalone without Arduino bootloader and without (or almost) external components.
As you can see it is very simple and allows us not only to program the ATmega328 standalone, but also a full Arduino board.
For example I use this system with the Arduino Mini Pro. These are budget boards, which have nearly all the features of the Arduino UNO, but they are very small. Usually, instead of using a standalone Atmega328 within a well-defined project, I use these small boards, and once everything is ready to be canned, I upload the sketch bypassing the bootloader, in particular to make faster ignition.
The Arduino Pro Mini is produced by Sparkfun and is available in 3.3V or 5V and with ATmega168 or ATmega328. I would recommend if the sketch does not exceed 16kB to use the ATmega168 and the 8Mhz version at 3.3V especially if your project is running on battery because it consumes a lot less.
Obviously during programming we have to select the corresponding tab from the list of boards, for example Arduino Pro or Pro Mini (5V, 16 MHz) w / ATmega168.
But the fun does not stop there …
With this system we can also program the ATtiny, the younger brothers of the Atmega. There are several versions but the most interesting are the 8-pin ATtiny85 and the 20-pin ATtiny2313. They have the advantage that consume very little power, are smaller and cheaper.
The ATtiny85 has only 5 I/O, but for many projects is just fine, considering the cost of about € 2.50 in Italy.
Moreover working with internal clock to 1Mhz consumption is really very low, and the size is like that of a NE555.
Can u think how many projects we can simplify using the ATtiny. Even only for example a PWM control of a LED strip, which would usually require operational, capacitors, NE555, and so on, with a simple ATtiny85, a potentiometer, a transistor, a few other components and 2 lines of code, the game is done…
In the next post then!
