Exploring Arduino: An Open-Source Platform for Creative Electronics Prototyping

Introduction

Arduino represents an open-source electronics prototyping platform built upon versatile and user-friendly hardware and software components. Its purpose is to cater to artists, designers, hobbyists, and individuals keen on crafting interactive objects or environments.

Getting Started with Arduino UNO

The Arduino platform offers a variety of board options to choose from. For beginners, you can acquire a basic “Arduino UNO” board for under $5 through numerous online retailers. I recommend considering an “Arduino Starter Kit,” which includes an Arduino UNO board along with an assortment of electronic components such as LEDs, resistors, transistors, motors, a breadboard, wires, and more.

#define BUILTIN_LED_PIN 13    // A Built-in LED connected to digital Pin 13
 
/* 
 * Setup() runs only once for initialization 
 */
void setup() {
   pinMode(BUILTIN_LED_PIN, OUTPUT);    // Set Pin 13 (digital) to OUTPUT mode
}

/* 
 * loop() repeats forever after setup() completed
 */
void loop() {
   digitalWrite(BUILTIN_LED_PIN, HIGH);  // Set Pin 13 to HIGH (5V) to turn ON its built-in LED
   delay(1000);                  // Delay in msec
 
   digitalWrite(BUILTIN_LED_PIN, LOW);   // Set Pin 13 to LOW (0V) to turn OFF its built-in LED
   delay(1000);                  // Delay in msec
}

/*
 * Blink: Turns ON an LED on for one second, then turn OFF for one second, repeatedly.
 */
#define LED_PIN 13   // Give it a name for easy referencing

/* 
 * setup() run once for initialization
 */
void setup() {
   pinMode(LED_PIN, OUTPUT);  // initialize the digital pin as output
}

/*
 * loop() repeats forever after setup() completes
 */
void loop() {
   digitalWrite(LED_PIN, HIGH);  // turn the LED ON by making the voltage HIGH (5V)
   delay(1000);                  // wait for the given millisecond
 
   digitalWrite(LED_PIN, LOW);   // turn the LED OFF by making the voltage LOW (0V)
   delay(1000);                  // wait for the given millisecond
}

#define LED_PIN 9       // LED connected to digital PWM pin 9
#define DUTY_CYCLE 192  // Duty cycle for the PWM over [0,255]
 
/* Setup() runs only once */
void setup() {
   pinMode(LED_PIN, OUTPUT);  // Set to OUTPUT mode
}

/* loop() repeats forever */
void loop() {
   analogWrite(LED_PIN, DUTY_CYCLE);  // Try other values from 0 to 255
   delay(1000);                       // time delay in msec before repeat

   // Fade in from min to max in increments of 5
   for (int fadeValue = 0 ; fadeValue <= 255; fadeValue += 5) {
      analogWrite(ledPin, fadeValue);
      delay(30); // small delay to see the effect
   }

   // Fade out from max to min in decrements of 5
   for (int fadeValue = 255 ; fadeValue >= 0; fadeValue -= 5) {
      analogWrite(ledPin, fadeValue);
      delay(30);
   }
}

The LED’s luminance corresponds to the duty cycle, with the ON duration determining its brightness. For instance, if the duty cycle is set to 64, the LED will shine at 25% of its maximum brightness

LED Basics

#include <Adafruit_NeoPixel.h>
#define DATA_PIN 6       // Data-In (DI) connects to this pin
#define NUM_LEDS 60
Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUM_LEDS, DATA_PIN, NEO_GRB + NEO_KHZ800);

In setup():

void setup() {
   strip.begin();  // initialize strip's buffer to all zeros (off)
   strip.show();   // Update all LEDs
}

You can then play with the color in loop():

// Set the color of a particular LED via setPixelColor()
uint32_t color = strip.Color(255, 0, 0);  // Set R, G and B of a color
strip.setPixelColor(8, color);            // Set LED 8's color
strip.show();                             // Update ALL LEDs
delay(1000);

// You can retrieve the color of a LED via getPixelColor()
strip.setPixelColor(9, strip.getPixelColor(8));
strip.show();                             // Update ALL LEDs
delay(1000);

// To switch an LED off use the color BLACK (0,0,0)
strip.setPixelColor(8, strip.Color(0,0,0));  // Set LED color
strip.show();                                // Update all LEDs
delay(1000);

// Set all LEDs to green
color = strip.Color(0, 255, 0);
for (int i = 0; i < strip.numPixels(); ++i) {
   strip.setPixelColor(i, color);
}
strip.show();    // Update all LEDs
delay(1000);

Execute and examine the remaining examples.

NeoPixel utilizes a display buffer that corresponds to all the LEDs within the strip. To configure this buffer, you are required to invoke strip.begin(). You can modify the color within the buffer using strip.setPixelColor(index, color), and when you are ready to update the strip’s LEDs, you can activate strip.show() to transmit all the values from the buffer to the strip.

Color is expressed as a uint32_t, encompassing the red, green, and blue components.

• strip.Color(R, G, B): translate the R, G and B into a color value in a uint32_t.
• strip.setPixelColor(pixelIndex, color): set the color of a particular pixel.
• strip.getPixelColor(pixelIndex): returns a 32-bit color value of a particular pixel.
• strip.numPixels(): returns the number of pixel declared during initialization.
• strip.setBrightness(level): adjust the brightness of all the LEDs with level ranges from 0 (off) to 255 (max brightness). setBrightness() was intended to be called once, in setup(), to limit the current/brightness of the LEDs throughout the life of the sketch. It is not intended as an animation effect itself!

 FastLED 3.1

FastLED is compatible with both 4-wire and 3-wire chipsets, whether or not they include a Clock-In (CI). You are required to tailor these connections:

#include "FastLED.h"
#define NUM_LEDS 60    // Number of LEDs in your LED strip
#define DATA_PIN 6     // Data-In (DI) connecting to this pin

// For four-wire chipsets with a Clock-In (CI) only
//#define CLOCK_PIN 7    // Clcok-In (CI) connecting to this pin

// Define an array of LEDs to keep the RGB values of each LED 
CRGB leds[NUM_LEDS];

In setup():

void setup() {
   // For 3-wire chipsets without Clock-In (CI)
   FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);  // or set to WS2812 or WS2811
   ....
   // For 4-wire chipsets with a Clock-In (CI)
   //FastLED.addLeds<LPD8806, DATA_PIN, CLOCK_PIN>(leds, NUM_LEDS);
}

You can then play with the color in loop():

// To switch an LED Off, set the color to Black for that particular LED and call the show() function:
leds[8] = CRGB::Black;  // Array index begins at 0, up to NUM_LEDs - 1
                        // Set color to black via pre-defined constant CRGB::Black
FastLED.show();         // Show changes

// Set an LED to a specific color
leds[8] = CRGB::Red;    // Set LED 8 to red via pre-defined constant CRGB::Red
FastLED.show();         // Show changes
delay(1000);

// You can set each of the RGB components individually
leds[18].r = 255;     // Set red component, value between 0 and 255
leds[18].g = 125;     // Set green
leds[18].b = 0;       // Set blue
FastLED.show();       // Show changes, no change in leds[8]
delay(1000);

// Set all LEDs to pre-defined constant ForestGreen (0x228B22)
for (i = 0; i < NUM_LEDS; ++i) {
   leds[i] = CRGB::ForestGreen;
}
FastLED.show();       // Show changes
delay(1000);

 Motors

Circuit Diagram

Dissecting the Circuit

In the circuit described above, we employ a P2N2222AG NPN BJT transistor with a maximum rating of 40V and 200mA (as detailed in the datasheet) as an electronic switch. This transistor turns on when pin 9, connected to its base (b), produces a HIGH signal at 5V. The base current (IB) is calculated as (5V – 0.8V) / 330Ω, resulting in 13mA. When turned on, there is a voltage drop of 0.2V across the collector (c) and emitter (e) of the transistor. Conversely, the transistor is in the OFF state when pin 9 outputs a LOW signal (0V).

In this setup, a transistor is essential because the output from pin 9, with a maximum current of 40mA, is inadequate to directly power the DC motor. However, only a small amount of current (2mA) is required to activate the transistor.

The rotation speed of a DC motor is directly proportional to the applied voltage when there is no load. As a load is introduced, the speed decreases, and the current drawn by the motor also correlates with the torque it produces.

DC motors come in a variety of specifications. For instance, one toy DC motor is designed to operate within a voltage range of 1.5V to 4.5V, and under no load, it can reach a speed of 23,000 RPM when powered at 4.5VDC, drawing a current of 70mA (as per the datasheet). Another toy DC motor is suitable for operation in a voltage range of 1.0V to 3.0V and achieves a no-load speed of 6,600 RPM when supplied with 1.0V DC, consuming a current of 110mA (according to the datasheet).

In general, DC motors like these typically require around 100mA of current to function correctly, a current level that cannot be provided directly from an output pin on devices like the Arduino, which has a maximum current output of 40mA. The transistor used in this setup has a rating of 200mA, which comfortably accommodates the motor’s current requirements.

DC motors come in a variety of specifications. For instance, one toy DC motor is designed to operate within a voltage range of 1.5V to 4.5V, and under no load, it can reach a speed of 23,000 RPM when powered at 4.5VDC, drawing a current of 70mA (as per the datasheet). Another toy DC motor is suitable for operation in a voltage range of 1.0V to 3.0V and achieves a no-load speed of 6,600 RPM when supplied with 1.0V DC, consuming a current of 110mA (according to the datasheet).

In general, DC motors like these typically require around 100mA of current to function correctly, a current level that cannot be provided directly from an output pin on devices like the Arduino, which has a maximum current output of 40mA. The transistor used in this setup has a rating of 200mA, which comfortably accommodates the motor’s current requirements.

Practice

Connect the DC motor directly to 5V. Measure the no load current.

Set pin 9 to HIGH (to turn on the transistor):

1. Using a digital multimeter, measure the voltage at pin 9, the voltage across the base and emitter V_BE. Compute the base current I_B (through the base resistor).
2. Measure the voltage across the collector and emitter V_CE.
3. Measure the collector current I_C

Arduino Mega 2560

The Arduino UNO has its constraints, such as its ability to drive approximately 300-400 LED pixels due to its 2KB of SRAM and its limited number of available I/O pins. Many of your projects might demand the capabilities of a more robust microcontroller, such as the Arduino Mega 2560, which has superseded the original Arduino Mega model.

Arduino Mega 2560 has:

• 54 digital I/O pins, of which 15 can be used as PWM outputs (pins 2-13, 44-46). Each pin could provide 20mA current. (Compared with Arduino UNO: 14 digital pins, 6 PWMs.)
  Use function pinMode(0-53, INPUT|OUTPUT) to configure the pin for input or output; and digitalRead(0-53) or digitalWrite(0-53, HIGH|LOW) to read or write.
  For PWM pins, you can use function analogWrite(2-13|44-46, dutyCycle) with duty cycle of between 0 (off) to 255 (on) to output PWM signal.
• 16 analog input pins. (Compared with Arduino UNO: 6)
  Use function pinMode(A0-A13, INPUT) (optional but nice to have) and analogRead(A0-A13) to read the 10-bit analog input [0,1023].
  These analog input pins can also be used for digital input/output like the digital I/O pins, with pin number for A0-A13.
• 4 Serial ports (USART) (Compared with Arduino UNO: 1).
• ATmega2560 microcontroller @ 16MHz, with 256KB of Flash memory for program, 8KB of SRAM for data, and 4KB of EEPROM for non-volatile data.

More on Arduino

Microcontroller

The Arduino UNO is powered by the ATmega328P microcontroller, boasting the following attributes:

• A low-power CMOS 8-bit microcontroller founded on the AVR enhanced RISC architecture.
• Utilizes an advanced RISC Architecture featuring 131 instructions, with most executing in a single clock cycle.
• Equipped with 32×8 general-purpose registers.
• Offers up to 20 MIPS throughput at 20MHz.
• Provides 32 KBytes of Flash memory for program storage with 10,000 write/erase cycles.
• Includes 1 KBytes of EEPROM memory capable of 100,000 write/erase cycles.
• Contains 2 KBytes of SRAM.
• Features six PWM channels.
• Equipped with a 6-channel 10-bit ADC.
• Offers one programmable Serial USART.
• Provides two Master/Slave SPI Serial Interfaces.
• Includes one Byte-oriented 2-wire Series Interface (I2C compatible).
• Features two 8-bit Timer/Counters with separate prescalers and compare modes.
• Includes one 16-bit Timer/Counter with separate prescalar, compare mode, and capture mode.
• Supports interrupt and wake-up on pin change.
• Has an operating voltage range of 1.8V to 5.5V.
• Exhibits a power consumption of 0.2mA in Active Mode @ 1MHz, 1.8V, 25°C.

The Arduino Mega2560, on the other hand, is powered by the ATmega2560 microcontroller, which is an 8-bit microcontroller.

Memory

Types of Memory

The Arduino board comprises three distinct memory pools:

1. **Flash Memory:** This space is dedicated to storing the program, often referred to as program space. Both Flash and EEPROM memory are non-volatile, meaning the data remains intact even when the power is turned off.

2. **SRAM (Static RAM):** SRAM is utilized for storing program data and variables. Unlike Flash and EEPROM, SRAM is volatile, which means the data stored in it is lost when the power is turned off.

3. **EEPROM (Electrical Erasable Programmable Read-Only Memory):** This memory is designed for retaining long-term data.

The Arduino UNO, which employs the ATmega328 microcontroller, offers the following memory specifications:

– 32KB of Flash (approximately 0.5KB is allocated for the bootloader).
– 2KB of SRAM.
– 1KB of EEPROM.

On the other hand, the Arduino Mega2560, featuring the ATmega2560 microcontroller, possesses:

– 256KB of Flash (with around 8KB used for the bootloader).
– 8KB of SRAM.
– 4KB of EEPROM.

It’s crucial to note that SRAM in the Arduino UNO is quite limited. For instance, each LED in an LED strip necessitates 3 bytes of SRAM. With 2KB of SRAM, the UNO can only support approximately 682 LEDs, assuming all available SRAM is allocated. If you exceed the SRAM’s capacity, your program may appear to load successfully but may not run correctly or exhibit unexpected behavior. To conserve SRAM, consider these strategies:

– Utilize smaller data types, such as using a byte or uint8_t instead of an int to reduce memory usage.
– If data doesn’t need to be modified, store it in Flash memory to free up SRAM.

Programming EEPROM

• EEPROM.length(): return total number of bytes of EEPROM.
• EEPROM.write(address, value): write a byte with value of 0 to 255 to the EEPROM at address. For example, to initialize and clear the EEPROM:

  for (int i = 0 ; i < EEPROM.length() ; i++) {
     EEPROM.write(i, 0);  // write 0 to all the addresses
  }

  An EEPROM write takes 3.3ms to complete. The EEPROM memory has a specified life of 100,000 write/erase cycles, so you may need to be careful about how often you write to it.

• EEPROM.read(address): read the value (in byte) from the EEPROM address.
• EEPROM.put(address, data): write any data type or object (struct) to the EEPROM starting from address. The data could be multi-byte, you can use sizeof(type) to check the size of data type in bytes.
• EEPROM.update(address, data): Similar to EEPROM.put(), but does not rewrite the value if it didn’t change (Recall that EEPROM has a certain write/erase life).
• EEPROM.get(address, data): read any data type or object from EEPROM starting from address into data

Serial Communication

Every Arduino board is equipped with at least one serial port, also known as UART or USART. This serial communication takes place through digital pin 0 (RX) and pin 1 (TX), as well as via USB when connected to a computer through a USB-to-Serial adapter. The Serial object represents this serial port. If you activate serial communication, you cannot use pins 0 and 1 for other purposes. You can make use of the Arduino IDE’s Serial Monitor to interact with the Arduino board.

In the case of the Arduino Mega2560, it boasts three extra serial ports:

– Serial1, accessible through pins 18 (TX) and 19 (RX).
– Serial2, which can be utilized via pins 16 (TX) and 17 (RX).
– Serial3, available on pins 14 (TX) and 15 (RX).

Notably, these additional serial ports are not connected to the built-in USB-to-Serial adapter, and if you wish to employ them, you’ll need an additional USB-to-Serial adapter.

void setup() {
   // open serial port, set baud rate to 57600
   Serial.begin(57600);
   // Arduino board writes to computer via serial port
   Serial.println("Serial port started at baud rate of 57600");
}

The Serial‘s functions are:

• Serial.begin(baudRate, [config]): setup serial communication.
• Serial.end(): Disable serial communication. Pins RX and TX can be used for general input/output.
• Serial.print(value, [format]) and Serial.println(value, [format]): Prints data to the serial port as human-readable ASCII text, with an optional format. Serial.println() terminates with a newline. For examples,

Serial.print(123);        // 123
Serial.print(1.23);       // 1.23
Serial.print("Hello");    // Hello
Serial.print(123, DEC);   // 123
Serial.print(123, HEX);   // 7B
Serial.print(123, OCT);   // 173
Serial.print(123, BIN);   // 01111011
Serial.print(1.2345, 2);  // 1.23  (2 decimal places)
Serial.print(1.2345, 3);  // 1.234 (3 decimal places)

Here are the functions related to serial communication:

– `Serial.write(value)`: Transmit binary data through the serial port. The data is sent as either a single byte or a sequence of bytes. For sending data in a human-readable format, you can use `print()`.

– `Serial.available()`: Retrieve the count of bytes (characters) ready for reading from the serial port.

– `Serial.read()`: Retrieve the first byte of incoming serial data as an integer (or -1 if there’s no available data to read).

void setup() {
   Serial.begin(57600);
}
void loop() {
   char inChar;
   if (Serial.available() > 0) {
      inChar = (char)Serial.read();   // Read one byte (in int)
      Serial.println(inChar);         // Format in ASCII text
      Serial.println(inChar, DEC);    // Format in DEC
   }
}

Here are some additional functions related to serial communication:

– `Serial.peek()`: This function returns the next byte of incoming serial data as an integer but doesn’t remove it from the internal serial buffer. If there’s no available data, it returns -1.

– `Serial.flush()`: When invoked, this function waits for the ongoing transmission of outgoing serial data to finish before proceeding.

– `serialEvent()`: This is a callback function that is triggered when serial data becomes available for processing. You can use `Serial.read()` within this function to read the incoming data. To understand more about this, you can refer to the “serialEvent tutorial.”

Interrupts

Polling vs. Interrupt

There are two methods for managing external inputs: polling and interrupts.

1. In the polling approach, you regularly check the status of external inputs and execute the processing routine when the input is detected.
2. In the interrupt approach, you connect an interrupt service routine (ISR) to an external input. The ISR is activated when the input is triggered.

External Interrupt Pins

Within the Arduino UNO, two pins (2 and 3) are available for external interrupts and can be assigned to INT0 and INT1. Meanwhile, in the Arduino Mega2560, you have access to six pins (2, 3, 18, 19, 20, 21) that can be utilized for external interrupts.

Interrupt Service Routine (ISR)

Interrupt Service Routines (ISRs) are specialized functions that don’t accept parameters or return any values. When multiple ISRs are present, only one can be executed at a given moment, and the remaining interrupts will be invoked sequentially once the current one has completed, following a priority order.

It’s important to note that functions like `millis()`, which relies on interrupts for timekeeping, won’t function (or increment) within an ISR. Similarly, `delay()` also depends on interrupts and will not operate correctly inside an ISR. This situation may lead to potential loss of serial data. To share data between the primary program and an ISR, global variables are employed. These variables should be declared as volatile, ensuring they are stored in RAM rather than in a register for multi-threading compatibility.

Efforts should be made to keep the ISR as concise as possible. Its primary role is to update global variables (marked as volatile) to indicate changes in state.

For example,

const byte ledPin = 13;
const byte interruptPin = 2;
volatile byte state = LOW;

void setup() {
   pinMode(ledPin, OUTPUT);
   pinMode(interruptPin, INPUT_PULLUP);
   attachInterrupt(digitalPinToInterrupt(interruptPin), toggle, CHANGE);
}

void loop() {
   digitalWrite(ledPin, state);
}

void toggle() {
   state = !state;
}

Enable/Disable Interrupts

The `noInterrupts()` function can be utilized to deactivate all interrupts, while `interrupts()` can be employed to reactivate them. This capability can be valuable in real-time applications, particularly when specific critical, time-sensitive code segments must be executed. For instance,

void loop() {
   ......
   noInterrupts();
   // critical, time-sensitive code here
   interrupts();
   ......
}