Arduino Foundations


Published on

Based on the Arduino foundations tutorial at

Published in: Technology, Business
  • Be the first to comment

No Downloads
Total views
On SlideShare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide

Arduino Foundations

  1. 1. Arduino foundations: sketchbasics, what’s on board, more programming tions
  2. 2. BasicsWhat’s a sketch and how does it work?
  3. 3. Sketch: comments and variables• A sketch is the name Arduino uses for a program• Comments are used to explain what the program does: – Use /* blah */ to comment out an area of code – Use // to add a comment to the end of a line of code• A variable is a place for storing data: – type name = value; – int ledPin = 13; – Every time ledPin is referred to in code, value is retrieved – Can also change variable value in code
  4. 4. Sketch: functions• Functions are named pieces of code that can be used from elsewhere in a sketch: – setup(), loop(), pinMode()• First line of a function provides info about it, like its name (e.g. setup), and the text before / after the name specify its return type and parameters: void setup() { [body of function] }
  5. 5. Sketch: functions (2)• Can call a pre-defined function as part of the Arduino language or functions defined in your sketch: – e.g. pinMode(ledPin, OUTPUT); calls pinMode() with the parameters ledPin and OUTPUT• We’ll now describe some sample functions that you may have seen already
  6. 6. Function: pinmode()• The pinMode() function configures a pin as either an input or an output• To use it, you pass it the number of the pin to configure and the constant INPUT or OUTPUT• When configured as an input, a pin can detect the state of a sensor like a pushbutton• As an output, it can drive a device like an LED
  7. 7. Functions: digitalWrite(), delay()• digitalWrite() outputs a value on a pin• For example, the line: – digitalWrite(ledPin, HIGH); sets the ledPin (pin 13) to HIGH, or 5 volts• Writing a LOW to the pin connects it to ground, or 0 volts• delay() causes the Arduino to wait for the specified number of milliseconds before continuing on to the next line• There are 1000 milliseconds in a second, so the line: – delay(1000); creates a one second delay
  8. 8. Special functions: setup(), loop()• There are two special functions that are a part of everyArduino sketch: setup() and loop(): – setup() is called once, when the sketch starts • Its a good place to do setup tasks like setting pin modes or initializing libraries – The loop() function is called over and over and is heart of most sketches• You need to include both functions in your sketch, even if you dont need them for anything
  9. 9. Exercises, based on ‘blink’ code1. Change the code so that the LED is on for 100 milliseconds and off for 10002. Change the code so that the LED turns on when the sketch starts and stays on
  10. 10. Problem• Write a sketch that turns on and off the onboard LED (pin 13) in the Morse code-style SOS sequence ‘· · · — — — · · ·’, assuming that a unit is of one second duration, and Morse code is composed of the following five elements: – short mark, dot or dit (·) — dot duration is one unit long; – longer mark, dash or dah (–) — three units long; – inter-element gap between the dots and dashes within a character — one unit long; – short gap (between letters) — three units long; – medium gap (between words) — seven units long. – 2C_timing_and_speeds
  11. 11. Morse code codeint pin = 13;void setup(){pinMode(pin, OUTPUT);}void loop(){ dot(); dot(); dot(); delay(2000); // plus last one second delay from the dot function = 3 dash(); dash(); dash(); delay(2000); // plus last one second delay from the dash function = 3 dot(); dot(); dot(); delay(6000); // plus last one second delay from the dot function = 7}
  12. 12. Morse code code (2)void dot(){digitalWrite(pin, HIGH); delay(1000);digitalWrite(pin, LOW); delay(1000);}void dash(){digitalWrite(pin, HIGH); delay(3000);digitalWrite(pin, LOW); delay(1000);}
  13. 13. Overview• First, we have the dot() and dash() functions that do the actual blinking• Second, theres the pin variable which the functions use to determine which pin to use• Finally, theres the call to pinMode() that initialises the pin as an output
  14. 14. On the microcontroller Pins and memory
  15. 15. Configuring digital pins• Note: the vast majority of Arduino (Atmega) analog pins may be configured, and used, in exactly the same manner as digital pins• We’ll look at: – Properties of pins configured as INPUT – Pull-up resistors – Properties of pins configured as OUTPUT
  16. 16. Properties of pins configured as INPUT• Arduino pins default to INPUT: – Don’t need to be explicitly defined as INPUT-type using pinMode()• Input pins are high impedance (order of M ): – Will draw little current (order of A) – Suitable for low current apps like capacitive touch sensors, FSRs, phototransistors / photodiodes, etc.• But with nothing connected, become sensitive to external noise from the environment
  17. 17. Pull-up resistors• Used to steer an input to a particular (default) state if no input is present• Could add a pull-up resistor to +5 volts or a pull- down resistor to 0 volts, e.g. using a 10 kΩ value• There are built-in 20 kΩ pull-up resistors on the Atmega chips, which can be enabled via software: – pinMode(pinX, INPUT); // set pin to input – digitalWrite(pinX, HIGH); // turn on pull-up resistors
  18. 18. Pull-up resistors (2)• Pull-ups will provide enough current to dimly light LEDs on a pin configured (by default) in INPUT mode: – So if an LED lights dimly, the pin probably hasn’t been set to OUTPUT mode
  19. 19. Switching from INPUT to OUTPUT• Note also that the pull-up resistors are controlled by the same registers (internal chip memory locations) that control whether a pin is HIGH or LOW• Consequently, a pin that is configured to have pull-up resistors turned on when the pin is an INPUT will have the pin configured as HIGH if the pin is then switched to an OUTPUT with pinMode()• This works in the other direction as well, and an output pin that is left in a HIGH state will have the pull-up resistors set if switched to an input with pinMode()
  20. 20. Special case: digital input pin 13• Digital pin 13 is harder to use as a digital input than the other pins because it has an LED and resistor attached to it thats soldered to the board on most Arduinos• If you enable its internal 20 kΩ pull-up resistor, it will hang at around 1.7 V instead of the expected 5 V because the onboard LED and series resistor pull the voltage level down, meaning it always returns LOW• If you must use pin 13 as a digital input, use an external pull down resistor…
  21. 21. Properties of pins configured as OUTPUT• Pins configured as OUTPUT with pinMode() are said to be in a low-impedance state: – Can provide a substantial current to other circuits, up to 40 mA – Enough to brightly light up an LED (via a series resistor), or run many types of sensors, but not a motor, for example
  22. 22. Properties of pins configured as OUTPUT (2)• Short circuits on Arduino pins, or attempting to run high current devices, can damage or destroy the output transistors in the pin, or damage the entire Atmega chip: – Often this will result in a "dead" pin but the remaining chip will still function• It is a good idea to connect OUTPUT pins to other devices with 470 Ω or 1kΩ resistors, unless maximum current draw from pins is required for a particular app
  23. 23. Analog input pins / ADC• The Atmega controllers used for the Arduino contain an onboard 6-channel analog-to-digital (A/D) converter: – The converter has 10 bit resolution, returning integers from 0 to 1023• While the main function of the analog pins is to read analog sensors, the analog pins also have all the functionality of general purpose input/output (GPIO) pins (the same as digital pins 0 – 13)
  24. 24. Pin mapping• The analog pins can be used identically to the digital pins, using the aliases A0 (for analog input 0), A1, etc.• For example, the code would look like this to set analog pin 0 to an output, and to set it HIGH: – pinMode(A0, OUTPUT); – digitalWrite(A0, HIGH);
  25. 25. Pull-up resistors for analog pins• The analog pins also have pull-up resistors, which work identically to pull-up resistors on the digital pins• They are enabled by issuing a command such as: – digitalWrite(A0, HIGH); // set pull-up on analog pin 0 while the pin is an input• Be aware however that turning on a pull-up will affect the values reported by analogRead()• Note that the same issue as for digital pins applies to analog pins when switching from INPUT to OUTPUT as regards the pull-up settings
  26. 26. Pulse width modulation
  27. 27. Memory on the Arduino• Three pools of memory in the microcontroller used on Arduino boards (ATmega168): – Flash memory (program space) is where the sketch is stored [16 kbytes non-volatile, 2k used for bootloader] – SRAM (static random access memory) is where the sketch creates and manipulates variables when it runs [1 kbyte volatile] – EEPROM is memory space that programmers can use to store long-term information [512 bytes non- volatile]
  28. 28. SRAM limits• Not much SRAM available, so can be used up quite quickly by defining strings, etc.: – char message[] = "I support the Arduino project.";• If program not running successfully, it may be that you’ve run out of SRAM: – Try commenting out string definitions, lookup tables, large arrays to see if it works without them – If interfacing with a PC, move data and/or calculations to the PC instead if possible – Store strings or data in flash memory instead with PROGMEM
  29. 29. Programming techniquesVariables, functions and libraries
  30. 30. Variables• As mentioned, a variable is a place to store a piece of data• A variable has other advantages over a value like a number, once it’s declared (int pin = 13;)• Most importantly, you can change the value of a variable using an assignment (indicated by an equals sign), for example: – pin = 12;• The name of the variable is permanently associated with a type; only its value changes
  31. 31. Assigning a variable to another• When you assign one variable to another, youre making a copy of its value and storing that copy in the location in memory associated with the other variable• Changing one has no effect on the other• For example, after: – int pin = 13; – int pin2 = pin; – pin = 12; only pin has the value 12; pin2 is still 13
  32. 32. Scope: global• If you want to be able to use a variable anywhere in your program, declare it at top of your code (a global variable): int pin = 13; void setup() { pin = 12; pinMode(pin, OUTPUT); } void loop() { digitalWrite(pin, HIGH); }• Both functions are using pin and referring to the same variable, so that changing in one will affect value in the other• Here, the digitalWrite() function called from loop() will be passed a value of 12, since that was assigned in setup()
  33. 33. Scope: local• If you only need to use a variable in a single function, you can declare it there, in which case its scope will be limited to that function• For example: void setup() { int pin = 13; pinMode(pin, OUTPUT); digitalWrite(pin, HIGH); }
  34. 34. Global vs. local scope• Local scope can make it easier to figure out what happens to a variable• If a variable is global, its value could be changed anywhere in the code, meaning that you need to understand the whole program to know what will happen to the variable• For example, if your variable has a value you didnt expect, it can be much easier to figure out where the value came from if the variable has a limited scope
  35. 35. Functions• Segmenting code into functions allows a programmer to create modular pieces of code that perform a defined task and then return to the area of code from which the function was "called”• The typical case for creating a function is when one needs to perform the same action multiple times in a program
  36. 36. Advantages of code fragments in functions• Functions help the programmer stay organised: – Often this helps to conceptualize the program• Functions codify one action in one place so that the function only has to be thought out/debugged once: – This also reduces chances for errors in modification if the code needs to be changed• Functions make a sketch smaller/more compact because code sections are reused many times• They make it easier to reuse code in other programs, and as a nice side effect, using functions also often makes the code more readable
  37. 37. Example: multiply function• Function needs to be declared outside any other function, so "myMultiplyFunction()" can go either above or below the "loop()" area
  38. 38. Calling the example function• To "call" our simple multiply function, we pass it parameters of the data-type that it is expecting: void loop{ inti = 2; intj = 3; intk; k = myMultiplyFunction(i, j); // k now contains 6 }
  39. 39. Another example: average analog readintReadSens_and_Condition(){inti;intsval = 0; for (i = 0; i< 5; i++){sval = sval + analogRead(0); // sensor on analog pin 0 }sval = sval / 5; // averagesval = sval / 4; // scale to 8 bits (0 - 255)sval = 255 - sval; // invert output return sval;}
  40. 40. Libraries• Earlier on, we had the Morse code example• Can also convert its functions into a library• This allows other people to easily use the code that youve written and to easily update it as you improve the library
  41. 41. What’s required?• You need at least two files for a library: – Header file (with the extension .h) – Source file (with the extension .cpp)• The header file has definitions for the library: basically a listing of everything thats inside; while the source file has the actual code• More at: –
  42. 42. Morse.h#ifndefMorse_h#define Morse_h#include "WProgram.h"class Morse{ public:Morse(int pin); void dot(); void dash(); private:int _pin;};#endif
  43. 43. Morse.cpp#include "WProgram.h" void Morse::dash()#include "Morse.h" { digitalWrite(_pin, HIGH);Morse::Morse(int pin) delay(1000);{ digitalWrite(_pin, LOW);pinMode(pin, OUTPUT); delay(250); _pin = pin; }}void Morse::dot(){digitalWrite(_pin, HIGH); delay(250);digitalWrite(_pin, LOW); delay(250);}