Showing posts with label Arduino Mini Course. Show all posts
Showing posts with label Arduino Mini Course. Show all posts

Friday, October 1, 2021

Arduino: Lesson 6 - How to use Analog Output to fade an LED

Fig. 1 - Arduino: Lesson 6 - How to use analog output to fade an LED

Welcome to Lesson 6 - Basic Arduino Course

In today's lesson, we will learn how to use an analog output to increase and decrease the brightness of a LED. In this example, we will use the analogWrite() function, which triggers a PWM wave on an Arduino pin.

We will use PWM to vary the brightness of a LED as an example, but nothing prevents us from also using it to drive a motor and control its speed, the concept is the same.

The analogWrite() function triggers a square wave at the specified duty cycle until the next analogWrite() call.

The frequency of the PWM signal is around 490 Hz on most Arduinos, however on Arduino Uno and some similar boards, pins 5 and 6 use a frequency of about 980 Hz.

On most Arduino boards with ATmega168 or ATmega328 chips, this function works on pins 3, 5, 6, 9, 10 and 11. On the Arduino Mega this function works on pins 2 to 13 and 44 to 46.

Hardware Required

  • Arduino Board
  • LED
  • 200 ohms resistor
  • Jumper Wires
  • Protoboard (optional)

The Circuit

The circuit is quite simple, we connect a LED in series with a 220 ohm resistor used to limit the current in the LED as we learned in the previous lessons, and we connect the PWM 9 port of the Arduino UNO as shown in Figure 2 below.
Fig. 2 - Using an analog output to fade an LED - tinkercad.com

We use a Protoboard to facilitate the connections, but you can also connect the wires directly to the Arduino.

The Code

The analogWrite() function writes an analog value to the Arduino pin. It is important to remember that this output is not a pure analog output that we can use to generate a pure sine wave, but this output is a PWM wave control.

When we execute the call to the analogWrite() function, the pin will generate a constant square wave with the specified duty cycle until the next function call.

After building the circuit, connect your Arduino board to your computer, launch Arduino Software (IDE), copy the code below and paste it into your Arduino IDE. But first let us understand the code line by line. 

  • In Line 3, we declared ledPin to digital Pin 9 where we connect the LED to the digital Pin 9
  • In Line 5we enter the void setup() function. This function is read only once when the Arduino is started.
  • In Line 6, we define Port 9 as the output, using the pinMode(); function;

01
02
03
04
05
06
07
08
//Arduino: Lesson 6 - How to use Analog Output to fade an LED

int ledPin = 9;                                // LED connected to digital pin 9

void setup() {                                // This function is called once when the program starts
pinMode(ledPin, OUTPUT);        // Set the digital pin as output:

}
  • In Line 09, we enter in the loop() function does precisely what its name suggests, and loops consecutively.
  • In Line 11, the control structure For, is used to repeat a block of statements enclosed in curly braces. An increment counter is usually used to increment and terminate the loop.

  • In Line 12, we run the analogWrite() function, this function writes an analog value (PWM wave) to pin 9, in this case we are increasing the PWM value from 5 to 5, to increase the LED brightness up to the maximum value of 255.
  • In Line 13, we use the function delay(); to wait for 30 milliseconds to see the dimming effect.

1
...
09
10
11
12
13
14
15
// Arduino: Lesson 6 - How to use Analog Output to fade an LED

void loop() { // The loop function runs over and over again forever
  
  for (int fadeValue = 0; fadeValue <= 255; fadeValue += 5 { // fade in from min to max in increments of 5 points:
   analogWrite(ledPin, fadeValue);          // sets the value (range from 0 to 255)
   delay(30);                                             // wait for 30 milliseconds to see the dimming effect
  } 
//------------------------------------- www.elcircuits.com --------------------------------------------
  • In Line 16, the control structure For, is used to repeat a block of statements enclosed in curly braces. An increment counter is usually used to increment and terminate the loop.
  • In Line 17, we run the analogWrite() function, this function writes an analog value (PWM wave) to pin 9, in this case, we are decreasing the PWM value from 5 to 5, to decrease the LED brightness to the minimum value of 0.
  • In Line 18, we use the function delay(); to wait for 30 milliseconds to see the dimming effect.
1
...
16
17
18
19
20
21
// Arduino: Lesson 6 - How to use Analog Output to fade an LED

for (int fadeValue = 255; fadeValue >= 0; fadeValue -=5){ //fade out from max to min in increments of 5 points
   analogWrite(ledPin, fadeValue);           // sets the value (range from 255 to 0)
   delay(30);                                              // wait for 30 milliseconds to see the dimming effect
  }
}
//------------------------------------- www.elcircuits.com --------------------------------------------
Below you can see the full code, which we can be copying and pasting into your Arduino IDE, and uploading to Arduino.

The complete code is showed in the sketch below!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
// Arduino: Lesson 6 - How to use Analog Output to fade an LED

int ledPin = 9;                                          // LED connected to digital pin 9

void setup() {                                           // This function is called once when the program starts
  pinMode(ledPin, OUTPUT);                 // Set the digital pin as output:

}
void loop() { // The loop function runs over and over again forever
  
  for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 5) {  // fade in from min to max in increments of 5 points:
   analogWrite(ledPin, fadeValue);           // sets the value (range from 0 to 255)
   delay(30);                                              // wait for 30 milliseconds to see the dimming effect
  } 

    for (int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5) {  // fade out from max to min in increments of 5 points:
   analogWrite(ledPin, fadeValue);           // sets the value (range from 0 to 255)
   delay(30);                                              // wait for 30 milliseconds to see the dimming effect
  }
}
//------------------------------------- www.elcircuits.com --------------------------------------------

Next Lesson

Previous Lesson

If you have any questions, suggestions or corrections, please leave them in the comments and we will answer them soon.

Subscribe to our blog!!! Click here - elcircuits.com!!!

My Best Regards!!!

Sunday, September 19, 2021

Arduino: Lesson 5 - Reading Potentiometer and Showing Values On Serial Monitor

Fig. 1 - Arduino Lesson 5 - Reading Potentiometer and Showing Values On Serial Monitor

Welcome to Lesson 5 - Basic Arduino Course

Today we are going to learn how to read a Potentiometer end showing the Values on Serial Monitor.
In this example, we will use a potentiometer, however, this same concept is used for most analog sensors. 

What will differentiate will be the type of calculation used, with reference to each sensor.

We will use the analogRead() function, to read A0 PIN, in Arduino we have 6 Analog Ports, which goes from A0 to A5, so we can make readings from up to 6 sensors simultaneously without having to use external hardware.

Hardware Required

  • Arduino Board
  • A 10K Potentiometer
  • Wires
  • Protoboard (optional)

The Circuit

The potentiometer works like a voltage divider. When you turn the shaft of the potentiometer, you change the resistance on either side of the center pin (or wiper) of the potentiometer. 

This changes the relative resistances between the center pin and the two outer pins, so you get a different voltage at the analog input. 

When the shaft is fully rotated in one direction, there is no resistance between the center pin and the pin connected to ground.
The middle pin varies from 0Kohms to 10Kohms, which is the value of the potentiometer we will use.

This resistance is sensed by the voltages at the ends of the potentiometer, causing the center pin to vary between 0V and 5V

And the voltage variation that comes from the Center Pin of the potentiometer goes to the A0 Analog Port.

In Figure 2, you can see the schematic of the potentiometer and the Arduino. We use a breadboard to make the connections easier, but you can also connect the wires directly from the A0 terminal in the middle of the potentiometer, connecting the outer pin to 5V positive and the outer pin to the negative GND of the Arduino.

Fig. 2 - Reading Potentiometer and Showing Values On Serial Monitor - tinkercad.com

The Code

The analogRead() function converts the input voltage range, 0 to 5 volts, to a digital value between 0 and 1023. This is done by a circuit within the microcontroller called analog-to-digital converter, or ADC.

Then, if the voltage at the center pin is 0 volts, analogRead() returns 0. When the shaft is turned all the way the other way, there is no resistance between the middle pin and the pin connected to 5 volts

If the voltage on the middle pin is then 5 voltsanalogRead() returns 1023. In between, analogRead() returns a number between 0 and 1023 that is proportional to the voltage applied to the pin.

After building the circuit, connect your Arduino board to your computer, launch Arduino Software (IDE), copy the code below and paste it into your Arduino IDE. But first let us understand the code line by line. 

  • In Line 3, we declared variable sensorPin which is set to Analog Pin A0 where we receive the value of the connected potentiometer. 
  • In Line 4, we create a variable senorPin that stores the value of the sensor that we also use for the potentiometer.

01
02
03
04
05
// Arduino: Lesson 5 -  Reading Potentiometer and Showing Values On Serial Monitor

int sensorPin = A0           // Read the Analogic Pin A0 Values  into a variable
int sensorValue = 0;          // Variable to store the value coming from the sensor "Potentiometer"

  • In Line 6, we enter the void setup() function. This function is read only once when the Arduino is started.

  • In Line 7, we begin serial communication by declaring the Serial.begin() function. At 9600 bits of data per second, this is the speed at which your computer will communicate with your Arduino Serial.
01
...
06
07
08
09
// Arduino: Lesson 5 -  Reading Potentiometer and Showing Values On Serial Monitor

void setup() {                      // This function is called once when the program starts
Serial.begin(9600);  // Begin the Serial Monitor with bounce rate in 115200
}

  • After setting the initializations, in Line 10 we will enter the void loop() function.

  • In Line 11, we use the variable sensorValue to store the resistance value, which is between 0 and 10K (read by the Arduino as a value between 0 and 1023) and controlled by the potentiometer.

  • In Line 13, we use the command Serial.println(), it is print out the value controlled by the potentiometer, this value will read with value between 0 and 1023 in your Serial Monitor.

  • In Line 14, we run the delay() function, for greater system stability.

1
...
10
11
12
13
14
15
16
17
// Arduino: Lesson 5 -  Reading Potentiometer and Showing Values On Serial Monitor

void loop() { // The loop function runs over and over again forever
sensorValue = analogRead (sensorPin);      // Read the input on analog pin A0

 Serial.println(sensorValue);                       // Print out the value you read
   delay(1);                                                   // delay in between reads for stability
}

//------------------------------------- www.elcircuits.com --------------------------------------------
Now you can copy the code and upload it to your Arduino. After that, if you open your Serial Monitor in Arduino Software (IDE) (by clicking on the icon that looks like a lens on the right side of the green top bar or using the keyboard shortcut Ctrl+Shift+M), you should see a steady stream of numbers in the range 0-1023 that correlate with the position of the pot. When you turn your potentiometer, these numbers respond almost instantly.

The complete code is showed in the sketch below!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Arduino: Lesson 5 -  Reading Potentiometer and Showing Values On Serial Monitor

int sensorPin = A0       // Read the Analogic Pin A0 Values  into a variable
int sensorValue = 0;       // Variable to store the value coming from the sensor "Potentiometer"

void setup() {                     // This function is called once when the program starts
Serial.begin(9600); // Start serial connection
}
 
void loop() { // The loop function runs over and over again forever
sensorValue = analogRead (sensorPin);      // Read the input on analog pin A0
 
   Serial.println(sensorValue);                     // Print out the value you read
   delay(1);                                                   // delay in between reads for stability
}
//------------------------------------- www.elcircuits.com --------------------------------------------

Next Lesson

Previous Lesson

If you have any questions, suggestions or corrections, please leave them in the comments and we will answer them soon.

Subscribe to our blog!!! Click here - elcircuits.com!!!

My Best Regards!!!