diff --git "a/Arduino/arduino.pdf.txt" "b/Arduino/arduino.pdf.txt"
new file mode 100644--- /dev/null
+++ "b/Arduino/arduino.pdf.txt"
@@ -0,0 +1,4975 @@
+arduino
+
+#arduino
+
+Table of Contents
+
+About
+
+Chapter 1: Getting started with arduino
+
+Remarks
+
+What is Arduino?
+
+Why Use Arduino?
+
+Versions
+
+Examples
+
+Bare Minimum
+
+Blink
+
+First Time Setup
+
+Setup
+
+Upload
+
+Serial monitor
+
+LED - With Button control
+
+Chapter 2: Analog Inputs
+
+Syntax
+
+Remarks
+
+Examples
+
+Print out an Analog Value
+
+Get Voltage From Analog Pin
+
+Chapter 3: Arduino IDE
+
+Examples
+
+Installing on Windows
+
+Portable app on Windows
+
+Installing on Fedora
+
+Installing on Ubuntu
+
+Installing on macOS
+
+Chapter 4: Audio Output
+
+Parameters
+
+Examples
+
+1
+
+2
+
+2
+
+2
+
+2
+
+2
+
+2
+
+2
+
+3
+
+4
+
+5
+
+7
+
+7
+
+7
+
+9
+
+9
+
+9
+
+9
+
+9
+
+9
+
+11
+
+11
+
+11
+
+11
+
+11
+
+11
+
+11
+
+12
+
+12
+
+12
+
+Basic Note Outputs
+
+Chapter 5: Bluetooth Communication
+
+Parameters
+
+Remarks
+
+Examples
+
+Basic bluetooth hello world
+
+Chapter 6: Data Storage
+
+Examples
+
+cardInfo
+
+SD card datalogger
+
+SD card file dump
+
+SD card basic file example
+
+Listfiles
+
+SD card read/write
+
+Chapter 7: Digital Inputs
+
+Syntax
+
+Parameters
+
+Remarks
+
+Examples
+
+Pushbutton reading
+
+Chapter 8: Digital Output
+
+Syntax
+
+Examples
+
+Write to pin
+
+Chapter 9: Functions
+
+Remarks
+
+Examples
+
+Create simple function
+
+Call a function
+
+Chapter 10: Hardware pins
+
+Examples
+
+12
+
+13
+
+13
+
+14
+
+14
+
+14
+
+15
+
+15
+
+15
+
+17
+
+18
+
+19
+
+20
+
+22
+
+24
+
+24
+
+24
+
+24
+
+24
+
+24
+
+26
+
+26
+
+26
+
+26
+
+27
+
+27
+
+27
+
+27
+
+27
+
+29
+
+29
+
+Arduino Uno R3
+
+Chapter 11: How Python integrates with Arduino Uno
+
+Syntax
+
+Parameters
+
+Remarks
+
+Examples
+
+First serial communication between Arduino and Python
+
+Chapter 12: How to store variables in EEPROM and use them for permanent storage
+
+Syntax
+
+Parameters
+
+Remarks
+
+Examples
+
+Store a variable in EEPROM and then retrieve it and print to screen
+
+Chapter 13: I2C Communication
+
+Introduction
+
+Examples
+
+Multiple slaves
+
+Chapter 14: Interrupts
+
+Syntax
+
+Parameters
+
+Remarks
+
+Examples
+
+Interrupt on Button Press
+
+Chapter 15: Libraries
+
+Introduction
+
+Examples
+
+Installing libraries with the Library Manager
+
+Including libraries in your sketch.
+
+Chapter 16: Liquid Crystal Library
+
+Introduction
+
+Syntax
+
+29
+
+32
+
+32
+
+32
+
+32
+
+32
+
+32
+
+34
+
+34
+
+34
+
+34
+
+34
+
+34
+
+36
+
+36
+
+36
+
+36
+
+39
+
+39
+
+39
+
+39
+
+39
+
+39
+
+41
+
+41
+
+41
+
+41
+
+42
+
+44
+
+44
+
+44
+
+Parameters
+
+Examples
+
+Basic Usage
+
+Chapter 17: Loops
+
+Syntax
+
+Remarks
+
+Examples
+
+While
+
+For
+
+Do ... While
+
+Flow Control
+
+Chapter 18: MIDI Communication
+
+Introduction
+
+Examples
+
+MIDI THRU Example
+
+MIDI Thru with Queue
+
+MIDI Clock Generation
+
+MIDI Messages Defined
+
+Chapter 19: PWM - Pulse Width Modulation
+
+Examples
+
+Control a DC motor through the Serial port using PWM
+
+The basics
+
+Bill of materials: what do you need to build this example
+
+The build
+
+The code
+
+PWM with a TLC5940
+
+Chapter 20: Random Numbers
+
+Syntax
+
+Parameters
+
+Remarks
+
+Examples
+
+44
+
+44
+
+44
+
+46
+
+46
+
+46
+
+46
+
+46
+
+47
+
+47
+
+48
+
+49
+
+49
+
+49
+
+49
+
+49
+
+51
+
+52
+
+57
+
+57
+
+57
+
+57
+
+58
+
+58
+
+58
+
+59
+
+60
+
+60
+
+60
+
+60
+
+60
+
+Generate a random number
+
+Setting a seed
+
+Chapter 21: Serial Communication
+
+Syntax
+
+Parameters
+
+Remarks
+
+Examples
+
+Simple read and write
+
+Base64 filtering for serial input data
+
+Command Handling over Serial
+
+Serial Communication with Python
+
+Arduino:
+
+Python:
+
+Chapter 22: Servo
+
+Introduction
+
+Syntax
+
+Examples
+
+Moving the servo back and forth
+
+Chapter 23: SPI Communication
+
+Remarks
+
+Chip select signals
+
+Transactions
+
+Using the SPI in Interrupt Service Routines
+
+Examples
+
+Basics: initialize the SPI and a chip select pin, and perform a 1-byte transfer
+
+Chapter 24: Time Management
+
+Syntax
+
+Remarks
+
+Blocking vs. non-blocking code
+
+Implementation details
+
+Examples
+
+60
+
+61
+
+62
+
+62
+
+62
+
+62
+
+63
+
+63
+
+63
+
+63
+
+64
+
+64
+
+65
+
+66
+
+66
+
+66
+
+66
+
+66
+
+67
+
+67
+
+67
+
+67
+
+68
+
+68
+
+68
+
+70
+
+70
+
+70
+
+70
+
+70
+
+71
+
+blocking blinky with delay()
+
+Non-blocking blinky with the elapsedMillis library (and class)
+
+Non-blocking blinky with millis()
+
+Measure how long something took, using elapsedMillis and elapsedMicros
+
+More than 1 task without delay()
+
+Chapter 25: Using Arduino with Atmel Studio 7
+
+Remarks
+
+Setup
+
+Connections
+
+Debugging considerations
+
+Software setup
+
+To include libraries in your sketch
+
+To add the terminal window
+
+Benefits
+
+Examples
+
+Atmel Studio 7 imported sketch example
+
+Chapter 26: Variables and Data Types
+
+Examples
+
+Create variable
+
+Assign value to a variable
+
+Variable types
+
+Credits
+
+71
+
+71
+
+72
+
+73
+
+73
+
+75
+
+75
+
+75
+
+75
+
+77
+
+79
+
+80
+
+80
+
+80
+
+81
+
+81
+
+82
+
+82
+
+82
+
+82
+
+82
+
+84
+
+About
+
+You can share this PDF with anyone you feel could benefit from it, downloaded the latest version 
+from: arduino
+
+It is an unofficial and free arduino ebook created for educational purposes. All the content is 
+extracted from Stack Overflow Documentation, which is written by many hardworking individuals at 
+Stack Overflow. It is neither affiliated with Stack Overflow nor official arduino.
+
+The content is released under Creative Commons BY-SA, and the list of contributors to each 
+chapter are provided in the credits section at the end of this book. Images may be copyright of 
+their respective owners unless otherwise specified. All trademarks and registered trademarks are 
+the property of their respective company owners.
+
+Use the content presented in this book at your own risk; it is not guaranteed to be correct nor 
+accurate, please send your feedback and corrections to info@zzzprojects.com
+
+https://riptutorial.com/
+
+1
+
+Chapter 1: Getting started with arduino
+
+Remarks
+
+What is Arduino?
+
+Arduino is an open-source electronics platform based on easy-to-use hardware and software.
+
+Why Use Arduino?
+
+•
+•
+•
+•
+
+Inexpensive. You can also buy clones that are even cheaper.
+Easy to use and get started with
+Huge community
+Completely Open Source
+
+Versions
+
+Version Release Date
+
+1.0.0
+
+2016-05-08
+
+Examples
+
+Bare Minimum
+
+Here's the 'bare minimum' Arduino sketch. This can be loaded into the Arduino IDE by choosing 
+File > Examples > 01. Basics > Bare Minimum.
+
+void setup() { 
+  // put your setup code here, to run once 
+} 
+
+void loop() { 
+  // put your main code here, to run repeatedly 
+}
+
+Code in the setup() function will be run once when the program starts. This is useful to set up I/O 
+pins, initialize variables, etc. Code in the loop() function will be run repeatedly until the Arduino is 
+switched off or a new program is uploaded. Effectively, the code above looks like this inside the 
+Arduino runtime library:
+
+setup(); 
+while(1) { 
+
+https://riptutorial.com/
+
+2
+
+ 
+  loop(); 
+}
+
+Unlike programs running on your computer, Arduino code can never quit. This is because the 
+microcontroller only has one program loaded into it. If this program quit there would be nothing to 
+tell the microcontroller what to do.
+
+Blink
+
+Here's a short example that demonstrates the setup() and loop() functions. This can be loaded 
+into the Arduino IDE by choosing File > Examples > 01. Basics > Blink. (Note: Most Arduino 
+boards have an LED already connected to pin 13, but you may need to add an external LED to 
+see the effects of this sketch.)
+
+// the setup function runs once when you press reset or power the board 
+void setup() { 
+  // initialize digital pin 13 as an output. 
+  pinMode(13, OUTPUT); 
+} 
+
+// the loop function runs over and over again forever 
+void loop() { 
+  digitalWrite(13, HIGH);   // turn the LED on (HIGH is the voltage level) 
+  delay(1000);              // wait for a second 
+  digitalWrite(13, LOW);    // turn the LED off by making the voltage LOW 
+  delay(1000);              // wait for a second 
+}
+
+The above snippet:
+
+1. 
+
+Defines the setup() function. The setup() function gets called first on execution in every 
+Arduino program.
+
+1. 
+
+Sets pin 13 as an output.
+
+Without this, it might be set to an input, which would make the LED not work; however 
+once it is set as an output it will stay that way so this only needs to be done once when 
+the program starts.
+
+2. 
+
+Defines the loop() function. The loop() function is called repeatedly for as long as the 
+program is running.
+
+1. 
+2. 
+3. 
+4. 
+
+digitalWrite(13, HIGH); turns the LED on.
+delay(1000); waits one second (1000 milliseconds).
+digitalWrite(13, LOW); turns the LED off.
+delay(1000); waits one second (1000 milliseconds).
+
+Because loop() is run repeatedly for as long as the program is running, the LED will flash on and 
+off with a period of 2 seconds (1 second on, 1 second off). This example is based off of the 
+Arduino Uno and any other board that already has an LED connected to Pin 13. If the board that is 
+being used does not have an on-board LED connected to that pin, one can be attached externally.
+
+https://riptutorial.com/
+
+3
+
+ 
+More on timing (for example delays and measuring time): Time Management
+
+First Time Setup
+
+Software needed: Arduino IDE
+
+https://riptutorial.com/
+
+4
+
+https://riptutorial.com/
+
+Setup
+
+5
+
+Most Arduino-compatible boards have a USB port and come with a USB cable. Plug in the Arduino
+
+Arduino IDE will start with a new sketch, typically with an emtpy setup() and loop()
+
+functions. This is enough to upload to an Arduino board, but it will do nothing at all. The "Blink" 
+example sketch works as a simple test when first using an Arduino board. Go to File → Examples 
+→ 01.Basics → Blink. This will open a new window with the Blink sketch.
+
+Select your board. Go to Tools → Board → [name of your Arduino board].
+
+Select the COM port for your board. Most Aurduino-compatible boards will create a fake COM 
+port, which is used for serial communication (debugging) and for programming the board. COM 1 
+
+https://riptutorial.com/
+
+6
+
+is usually already present, and your board will create a new one, e.g. COM 4. Select this from 
+Tools → Port → COM 4 (or other COM number).
+
+Some boards have additional settings in the Tools menu, such as clock speed. These vary from 
+board to board, but usually an acceptable set of defaults is already selected.
+
+Upload
+
+You are now ready to upload Blink. Click the Upload button or select Sketch → Upload. The 
+sketch will compile, then upload to your Arduino board. If everything worked, the on-board LED will 
+start blinking on and off every second.
+
+Serial monitor
+
+In the Arduino IDE ypu hava a serial monitor. To open it use the button serial monitor at the right 
+side of the window.
+
+Be sure that the code is uploaded before you open the monitor. The upload and monitor will not 
+run at the same time!
+
+LED - With Button control
+
+You can also use this code to setup an LED with a button switch with a pull up resistor, this could 
+preferably be with the next step after setting up the intial LED controller
+
+int buttonState = 0; // variable for reading the pushbutton status 
+
+void setup() 
+{ 
+    // initialize the LED pin as an output: 
+    pinMode(13, OUTPUT); // You can set it just using its number 
+    // initialize the pushbutton pin as an input: 
+    pinMode(2, INPUT); 
+} 
+
+void loop() 
+{ 
+    // read the state of the pushbutton value: 
+    buttonState = DigitalRead(2); 
+
+    // check if the pushbutton is pressed. 
+    // If it's not, the buttonState is HIGH : if (buttonState == HIGH) 
+    { 
+        // turn LED off: 
+
+https://riptutorial.com/
+
+7
+
+ 
+ 
+ 
+        digitalWrite(13, LOW); 
+    } 
+    else 
+    { 
+        // turn LED off: 
+        digitalWrite(13, HIGH); 
+    } 
+}
+
+Read Getting started with arduino online: https://riptutorial.com/arduino/topic/610/getting-started-
+with-arduino
+
+https://riptutorial.com/
+
+8
+
+Chapter 2: Analog Inputs
+
+Syntax
+
+•
+
+analogRead(pin) //Read from the given pin.
+
+Remarks
+
+Serial.println(val)
+
+For help with Serial communication, see: Serial Communication
+
+Examples
+
+Print out an Analog Value
+
+int val = 0;    // variable used to store the value 
+                // coming from the sensor 
+
+void setup() { 
+  Serial.begin(9600); //Begin serializer to print out value 
+
+  // Note: Analogue pins are 
+  // automatically set as inputs 
+} 
+
+void loop() { 
+
+  val = analogRead(0); // read the value from 
+                       // the sensor connected to A0. 
+
+  Serial.println(val); //Prints the value coming in from the analog sensor 
+
+  delay(10); // stop the program for 
+             // some time 
+}
+
+Get Voltage From Analog Pin
+
+Analog pins can be used to read voltages which is useful for battery monitoring or interfacing with 
+analog devices. By default the AREF pin will be the same as the operating voltage of the arduino, 
+but can be set to other values externally. If the voltage to read is larger than the input voltage, a 
+potential devider will be needed to lower the analog voltage.
+
+#define analogPin 14    //A0 (uno) 
+#define AREFValue 5        //Standard for 5V Arduinos 
+#define ADCResolution 1023    //Standard for a 10bit ADC 
+
+int ADCValue = 0; 
+
+https://riptutorial.com/
+
+9
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+float voltage = 0; 
+
+void setup() 
+{ 
+    Serial.begin(9600); 
+} 
+
+void loop() 
+{ 
+    readADC(); 
+    Serial.print(voltage); Serial.println("V"); 
+} 
+
+void readADC() 
+{ 
+    ADCValue = analogRead(analogPin); 
+    float = ( ( (float)ADCValue/ADCRange ) * AREFValue );    //Convert the ADC value to a 
+float, devide by the ADC resolution and multiply by the AREF voltage 
+}
+
+Read Analog Inputs online: https://riptutorial.com/arduino/topic/2382/analog-inputs
+
+https://riptutorial.com/
+
+10
+
+ 
+ 
+ 
+Chapter 3: Arduino IDE
+
+Examples
+
+Installing on Windows
+
+1. 
+2. 
+3. 
+
+Go to https://www.arduino.cc/en/Main/Software
+Click the "Windows Installer" link
+Follow the instructions
+
+Portable app on Windows
+
+To use the Arduino IDE on Windows without needing to install it:
+
+1. 
+2. 
+3. 
+4. 
+
+Go to https://www.arduino.cc/en/Main/Software
+Click the "Windows ZIP file for non admin install" link
+Extract the archive to a folder
+Open the folder, and double click Arduino.exe
+
+Installing on Fedora
+
+1. 
+2. 
+
+Open a terminal and run: sudo dnf install arduino
+Open the Arduino application, or type arduino into the terminal
+
+Installing on Ubuntu
+
+1. 
+2. 
+
+Open a terminal and run: sudo apt-get install arduino
+Open the Arduino application, or type arduino into the terminal
+
+Installing on macOS
+
+1. 
+2. 
+3. 
+4. 
+
+Go to https://www.arduino.cc/en/Main/Software
+Click the Mac OS X link.
+Unzip the .zipfile.
+Move the Arduino application to Applications.
+
+Read Arduino IDE online: https://riptutorial.com/arduino/topic/3790/arduino-ide
+
+https://riptutorial.com/
+
+11
+
+Chapter 4: Audio Output
+
+Parameters
+
+Parameter Details
+
+speaker
+
+Should be an output to an analog speaker
+
+Examples
+
+Basic Note Outputs
+
+#define NOTE_C4  262 //From pitches.h file defined in [Arduino Tone Tutorial][1] 
+
+int Key = 2; 
+int KeyVal = 0; 
+
+byte speaker = 12; 
+
+void setup() 
+{ 
+  pinMode(Key, INPUT);  //Declare our key (button) as input 
+  pinMode(speaker, OUTPUT); 
+} 
+
+void loop() 
+{ 
+  KeyVal = digitalRead(Key); 
+  if (KeyVal == HIGH) { 
+    tone(speaker, NOTE_C4); //Sends middle C tone out through analog speaker 
+  } else { 
+    noTone(speaker); //Ceases tone emitting from analog speaker 
+  } 
+
+  delay(100); 
+}
+
+[1]: https://www.arduino.cc/en/Tutorial/toneMelody
+
+Read Audio Output online: https://riptutorial.com/arduino/topic/2384/audio-output
+
+https://riptutorial.com/
+
+12
+
+ 
+ 
+ 
+ 
+ 
+Chapter 5: Bluetooth Communication
+
+Parameters
+
+method
+
+details
+
+SoftwareSerial.h
+
+Documentation
+
+SoftwareSerial(rxPin, 
+txPin, inverse_logic)
+
+Constructor. rxPin: Data in (receive) pin, defaults to 0. txPin: 
+Data out (transmit) pin, defaults to 1. inverse_logic: If true, treats 
+LOW as if it were HIGH and HIGH as LOW when determining bit 
+values. defaults to false.
+
+begin(speed)
+
+Sets the baud rate for serial communication. Supported baud 
+rates are 300, 600, 1200, 2400, 4800, 9600, 14400, 19200, 
+28800, 31250, 38400, 57600, and 115200.
+
+available()
+
+Check if there is some data over serial
+
+read()
+
+Reads a string from serial
+
+isListening()
+
+Checks to see if requested software serial port is actively 
+listening.
+
+overflow()
+
+peek()
+
+print(data)
+
+println(data)
+
+listen()
+
+Checks if a software serial buffer overflow has occurred. Calling 
+this function clears the overflow flag, meaning that subsequent 
+calls will return false unless another byte of data has been 
+received and discarded in the meantime. The software serial 
+buffer can hold 64 bytes.
+
+Return a character that was received on the RX pin of the 
+software serial port. Unlike read(), however, subsequent calls to 
+this function will return the same character. Note that only one 
+SoftwareSerial instance can receive incoming data at a time 
+(select which one with the listen() function).
+
+Prints data to the transmit pin of the software serial port. Works 
+the same as the Serial.print() function.
+
+Prints data to the transmit pin of the software serial port, followed 
+by a carriage return and line feed. Works the same as the 
+Serial.println() function.
+
+Enables the selected software serial port to listen. Only one 
+software serial port can listen at a time; data that arrives for other 
+ports will be discarded. Any data already received is discarded 
+during the call to listen() (unless the given instance is already 
+
+https://riptutorial.com/
+
+13
+
+method
+
+write(data)
+
+Remarks
+
+details
+
+listening).
+
+Prints data to the transmit pin of the software serial port as raw 
+bytes. Works the same as the Serial.write() function.
+
+Common Mistake : If you keep the rx and tx pins at default values (0 and 1), you cannot upload 
+new code until and unless you remove it, so it's almost always better to change the tx and rx pins 
+in the SoftwareSerial constructor.
+
+Examples
+
+Basic bluetooth hello world
+
+#include <SoftwareSerial.h> 
+// its always better to change the default tx and rx as the may interfere with other process 
+in future. 
+
+// configure tx , rx by defualt they will be 0 and 1 in arduino UNO 
+SoftwareSerial blue(3,2); 
+void setup() { 
+  // preferred baud rate/data transfer rate in general is 38400 
+     blue.begin(38400); 
+  // do initialization or put one time executing code here 
+} 
+
+void loop() { 
+
+  // put code that you want it to run every time no matter what 
+    if(blue.available()){ 
+        // put only that code which needsd to run when there is some data 
+        // This means that the their is some data sent over the bluetooth 
+        // You can do something with the data 
+
+        int n; 
+        // consider that the data received to be integer, read it by using blue.parseInt(); 
+
+        n = blue.parseInt(); 
+
+    } 
+
+}
+
+Read Bluetooth Communication online: https://riptutorial.com/arduino/topic/2543/bluetooth-
+communication
+
+https://riptutorial.com/
+
+14
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Chapter 6: Data Storage
+
+Examples
+
+cardInfo
+
+/* 
+ SD card test 
+
+ This example shows how use the utility libraries on which the' 
+ SD library is based in order to get info about your SD card. 
+ Very useful for testing a card when you're not sure whether its working or not. 
+
+ The circuit: 
+  * SD card attached to SPI bus as follows: 
+ ** MOSI - pin 11 on Arduino Uno/Duemilanove/Diecimila 
+ ** MISO - pin 12 on Arduino Uno/Duemilanove/Diecimila 
+ ** CLK -  pin 13 on Arduino Uno/Duemilanove/Diecimila 
+ ** CS -   depends on your SD card shield or module. 
+           Pin 4 used here for consistency with other Arduino examples 
+
+ created  28 Mar 2011 
+ by Limor Fried 
+ modified 9 Apr 2012 
+ by Tom Igoe 
+ */ 
+
+// include the SD library: 
+#include <SPI.h> 
+#include <SD.h> 
+
+// set up variables using the SD utility library functions: 
+Sd2Card card; 
+SdVolume volume; 
+SdFile root; 
+
+// change this to match your SD shield or module; 
+// Arduino Ethernet shield: pin 4 
+// Adafruit SD shields and modules: pin 10 
+// Sparkfun SD shield: pin 8 
+const int chipSelect = 4; 
+
+void setup() 
+{ 
+  // Open serial communications and wait for port to open: 
+  Serial.begin(9600); 
+  while (!Serial) { 
+    ; // wait for serial port to connect. Needed for Leonardo only 
+  } 
+
+  Serial.print("\nInitializing SD card..."); 
+
+  // we'll use the initialization code from the utility libraries 
+  // since we're just testing if the card is working! 
+  if (!card.init(SPI_HALF_SPEED, chipSelect)) { 
+    Serial.println("initialization failed. Things to check:"); 
+    Serial.println("* is a card inserted?"); 
+
+https://riptutorial.com/
+
+15
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+    Serial.println("* is your wiring correct?"); 
+    Serial.println("* did you change the chipSelect pin to match your shield or module?"); 
+    return; 
+  } else { 
+    Serial.println("Wiring is correct and a card is present."); 
+  } 
+
+  // print the type of card 
+  Serial.print("\nCard type: "); 
+  switch (card.type()) { 
+    case SD_CARD_TYPE_SD1: 
+      Serial.println("SD1"); 
+      break; 
+    case SD_CARD_TYPE_SD2: 
+      Serial.println("SD2"); 
+      break; 
+    case SD_CARD_TYPE_SDHC: 
+      Serial.println("SDHC"); 
+      break; 
+    default: 
+      Serial.println("Unknown"); 
+  } 
+
+  // Now we will try to open the 'volume'/'partition' - it should be FAT16 or FAT32 
+  if (!volume.init(card)) { 
+    Serial.println("Could not find FAT16/FAT32 partition.\nMake sure you've formatted the 
+card"); 
+    return; 
+  } 
+
+  // print the type and size of the first FAT-type volume 
+  uint32_t volumesize; 
+  Serial.print("\nVolume type is FAT"); 
+  Serial.println(volume.fatType(), DEC); 
+  Serial.println(); 
+
+  volumesize = volume.blocksPerCluster();    // clusters are collections of blocks 
+  volumesize *= volume.clusterCount();       // we'll have a lot of clusters 
+  volumesize *= 512;                            // SD card blocks are always 512 bytes 
+  Serial.print("Volume size (bytes): "); 
+  Serial.println(volumesize); 
+  Serial.print("Volume size (Kbytes): "); 
+  volumesize /= 1024; 
+  Serial.println(volumesize); 
+  Serial.print("Volume size (Mbytes): "); 
+  volumesize /= 1024; 
+  Serial.println(volumesize); 
+
+  Serial.println("\nFiles found on the card (name, date and size in bytes): "); 
+  root.openRoot(volume); 
+
+  // list all files in the card with date and size 
+  root.ls(LS_R | LS_DATE | LS_SIZE); 
+} 
+
+void loop(void) { 
+
+}
+
+https://riptutorial.com/
+
+16
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+SD card datalogger
+
+/* 
+  SD card datalogger 
+
+ This example shows how to log data from three analog sensors 
+ to an SD card using the SD library. 
+
+ The circuit: 
+ * analog sensors on analog ins 0, 1, and 2 
+ * SD card attached to SPI bus as follows: 
+ ** MOSI - pin 11 
+ ** MISO - pin 12 
+ ** CLK - pin 13 
+ ** CS - pin 4 
+
+ created  24 Nov 2010 
+ modified 9 Apr 2012 
+ by Tom Igoe 
+
+ This example code is in the public domain. 
+
+ */ 
+
+#include <SPI.h> 
+#include <SD.h> 
+
+const int chipSelect = 4; 
+
+void setup() 
+{ 
+  // Open serial communications and wait for port to open: 
+  Serial.begin(9600); 
+  while (!Serial) { 
+    ; // wait for serial port to connect. Needed for Leonardo only 
+  } 
+
+  Serial.print("Initializing SD card..."); 
+
+  // see if the card is present and can be initialized: 
+  if (!SD.begin(chipSelect)) { 
+    Serial.println("Card failed, or not present"); 
+    // don't do anything more: 
+    return; 
+  } 
+  Serial.println("card initialized."); 
+} 
+
+void loop() 
+{ 
+  // make a string for assembling the data to log: 
+  String dataString = ""; 
+
+  // read three sensors and append to the string: 
+  for (int analogPin = 0; analogPin < 3; analogPin++) { 
+    int sensor = analogRead(analogPin); 
+    dataString += String(sensor); 
+    if (analogPin < 2) { 
+      dataString += ","; 
+    } 
+
+https://riptutorial.com/
+
+17
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+  } 
+
+  // open the file. note that only one file can be open at a time, 
+  // so you have to close this one before opening another. 
+  File dataFile = SD.open("datalog.txt", FILE_WRITE); 
+
+  // if the file is available, write to it: 
+  if (dataFile) { 
+    dataFile.println(dataString); 
+    dataFile.close(); 
+    // print to the serial port too: 
+    Serial.println(dataString); 
+  } 
+  // if the file isn't open, pop up an error: 
+  else { 
+    Serial.println("error opening datalog.txt"); 
+  } 
+}
+
+SD card file dump
+
+/* 
+  SD card file dump 
+
+ This example shows how to read a file from the SD card using the 
+ SD library and send it over the serial port. 
+
+ The circuit: 
+ * SD card attached to SPI bus as follows: 
+ ** MOSI - pin 11 
+ ** MISO - pin 12 
+ ** CLK - pin 13 
+ ** CS - pin 4 
+
+ created  22 December 2010 
+ by Limor Fried 
+ modified 9 Apr 2012 
+ by Tom Igoe 
+
+ This example code is in the public domain. 
+
+ */ 
+
+#include <SPI.h> 
+#include <SD.h> 
+
+const int chipSelect = 4; 
+
+void setup() 
+{ 
+  // Open serial communications and wait for port to open: 
+  Serial.begin(9600); 
+  while (!Serial) { 
+    ; // wait for serial port to connect. Needed for Leonardo only 
+  } 
+
+  Serial.print("Initializing SD card..."); 
+
+https://riptutorial.com/
+
+18
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+  // see if the card is present and can be initialized: 
+  if (!SD.begin(chipSelect)) { 
+    Serial.println("Card failed, or not present"); 
+    // don't do anything more: 
+    return; 
+  } 
+  Serial.println("card initialized."); 
+
+  // open the file. note that only one file can be open at a time, 
+  // so you have to close this one before opening another. 
+  File dataFile = SD.open("datalog.txt"); 
+
+  // if the file is available, write to it: 
+  if (dataFile) { 
+    while (dataFile.available()) { 
+      Serial.write(dataFile.read()); 
+    } 
+    dataFile.close(); 
+  } 
+  // if the file isn't open, pop up an error: 
+  else { 
+    Serial.println("error opening datalog.txt"); 
+  } 
+} 
+
+void loop() 
+{ 
+
+}
+
+SD card basic file example
+
+/* 
+  SD card basic file example 
+
+ This example shows how to create and destroy an SD card file 
+ The circuit: 
+ * SD card attached to SPI bus as follows: 
+ ** MOSI - pin 11 
+ ** MISO - pin 12 
+ ** CLK - pin 13 
+ ** CS - pin 4 
+
+ created   Nov 2010 
+ by David A. Mellis 
+ modified 9 Apr 2012 
+ by Tom Igoe 
+
+ This example code is in the public domain. 
+
+ */ 
+#include <SPI.h> 
+#include <SD.h> 
+
+File myFile; 
+
+void setup() 
+{ 
+  // Open serial communications and wait for port to open: 
+
+https://riptutorial.com/
+
+19
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+  Serial.begin(9600); 
+  while (!Serial) { 
+    ; // wait for serial port to connect. Needed for Leonardo only 
+  } 
+
+  Serial.print("Initializing SD card..."); 
+
+  if (!SD.begin(4)) { 
+    Serial.println("initialization failed!"); 
+    return; 
+  } 
+  Serial.println("initialization done."); 
+
+  if (SD.exists("example.txt")) { 
+    Serial.println("example.txt exists."); 
+  } 
+  else { 
+    Serial.println("example.txt doesn't exist."); 
+  } 
+
+  // open a new file and immediately close it: 
+  Serial.println("Creating example.txt..."); 
+  myFile = SD.open("example.txt", FILE_WRITE); 
+  myFile.close(); 
+
+  // Check to see if the file exists: 
+  if (SD.exists("example.txt")) { 
+    Serial.println("example.txt exists."); 
+  } 
+  else { 
+    Serial.println("example.txt doesn't exist."); 
+  } 
+
+  // delete the file: 
+  Serial.println("Removing example.txt..."); 
+  SD.remove("example.txt"); 
+
+  if (SD.exists("example.txt")) { 
+    Serial.println("example.txt exists."); 
+  } 
+  else { 
+    Serial.println("example.txt doesn't exist."); 
+  } 
+} 
+
+void loop() 
+{ 
+  // nothing happens after setup finishes. 
+}
+
+Listfiles
+
+/* 
+ Listfiles 
+
+ This example shows how print out the files in a 
+ directory on a SD card 
+
+ The circuit: 
+
+https://riptutorial.com/
+
+20
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ * SD card attached to SPI bus as follows: 
+ ** MOSI - pin 11 
+ ** MISO - pin 12 
+ ** CLK - pin 13 
+ ** CS - pin 4 
+
+ created   Nov 2010 
+ by David A. Mellis 
+ modified 9 Apr 2012 
+ by Tom Igoe 
+ modified 2 Feb 2014 
+ by Scott Fitzgerald 
+
+ This example code is in the public domain. 
+*/ 
+
+#include <SPI.h> 
+#include <SD.h> 
+
+File root; 
+
+void setup() 
+{ 
+  // Open serial communications and wait for port to open: 
+  Serial.begin(9600); 
+  while (!Serial) { 
+    ; // wait for serial port to connect. Needed for Leonardo only 
+  } 
+
+  Serial.print("Initializing SD card..."); 
+
+  if (!SD.begin(4)) { 
+    Serial.println("initialization failed!"); 
+    return; 
+  } 
+  Serial.println("initialization done."); 
+
+  root = SD.open("/"); 
+
+  printDirectory(root, 0); 
+
+  Serial.println("done!"); 
+} 
+
+void loop() 
+{ 
+  // nothing happens after setup finishes. 
+} 
+
+void printDirectory(File dir, int numTabs) { 
+   while(true) { 
+
+     File entry =  dir.openNextFile(); 
+     if (! entry) { 
+       // no more files 
+       break; 
+     } 
+     for (uint8_t i=0; i<numTabs; i++) { 
+       Serial.print('\t'); 
+     } 
+     Serial.print(entry.name()); 
+
+https://riptutorial.com/
+
+21
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+     if (entry.isDirectory()) { 
+       Serial.println("/"); 
+       printDirectory(entry, numTabs+1); 
+     } else { 
+       // files have sizes, directories do not 
+       Serial.print("\t\t"); 
+       Serial.println(entry.size(), DEC); 
+     } 
+     entry.close(); 
+   } 
+}
+
+SD card read/write
+
+/* 
+  SD card read/write 
+
+ This example shows how to read and write data to and from an SD card file 
+ The circuit: 
+ * SD card attached to SPI bus as follows: 
+ ** MOSI - pin 11 
+ ** MISO - pin 12 
+ ** CLK - pin 13 
+ ** CS - pin 4 
+
+ created   Nov 2010 
+ by David A. Mellis 
+ modified 9 Apr 2012 
+ by Tom Igoe 
+
+ This example code is in the public domain. 
+
+ */ 
+
+#include <SPI.h> 
+#include <SD.h> 
+
+File myFile; 
+
+void setup() 
+{ 
+  // Open serial communications and wait for port to open: 
+  Serial.begin(9600); 
+  while (!Serial) { 
+    ; // wait for serial port to connect. Needed for Leonardo only 
+  } 
+
+  Serial.print("Initializing SD card..."); 
+
+  if (!SD.begin(4)) { 
+    Serial.println("initialization failed!"); 
+    return; 
+  } 
+  Serial.println("initialization done."); 
+
+  // open the file. note that only one file can be open at a time, 
+  // so you have to close this one before opening another. 
+  myFile = SD.open("test.txt", FILE_WRITE); 
+
+https://riptutorial.com/
+
+22
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+  // if the file opened okay, write to it: 
+  if (myFile) { 
+    Serial.print("Writing to test.txt..."); 
+    myFile.println("testing 1, 2, 3."); 
+    // close the file: 
+    myFile.close(); 
+    Serial.println("done."); 
+  } else { 
+    // if the file didn't open, print an error: 
+    Serial.println("error opening test.txt"); 
+  } 
+
+  // re-open the file for reading: 
+  myFile = SD.open("test.txt"); 
+  if (myFile) { 
+    Serial.println("test.txt:"); 
+
+    // read from the file until there's nothing else in it: 
+    while (myFile.available()) { 
+      Serial.write(myFile.read()); 
+    } 
+    // close the file: 
+    myFile.close(); 
+  } else { 
+    // if the file didn't open, print an error: 
+    Serial.println("error opening test.txt"); 
+  } 
+} 
+
+void loop() 
+{ 
+  // nothing happens after setup 
+}
+
+Read Data Storage online: https://riptutorial.com/arduino/topic/6584/data-storage
+
+https://riptutorial.com/
+
+23
+
+ 
+ 
+ 
+ 
+Chapter 7: Digital Inputs
+
+Syntax
+
+•
+•
+
+pinMode(pin, pinMode) // Sets the pin to the mode defined.
+digitalRead(pin); // Reads the value from a specified digital pin,
+
+Parameters
+
+Paramter Details
+
+pinmode
+
+Should be set to INPUT or INPUT_PULLUP
+
+Remarks
+
+If the input pin is not pulled LOW or HIGH, the value will float. That is, it won't be clearly a 1 or a 0, 
+but somewhere in between. For digital input, a pullup or pulldown resistor is a necessity.
+
+Examples
+
+Pushbutton reading
+
+This is an basic example on how to wire up and make an LED turn on/off when the pushbutton is 
+pressed.
+
+/* Basic Digital Read 
+ * ------------------ 
+ * 
+ * turns on and off a light emitting diode(LED) connected to digital 
+
+https://riptutorial.com/
+
+24
+
+ * pin 13, when pressing a pushbutton attached to pin 7. It illustrates the 
+ * concept of Active-Low, which consists in connecting buttons using a 
+ * 1K to 10K pull-up resistor. 
+ * 
+ * Created 1 December 2005 
+ * copyleft 2005 DojoDave <http://www.0j0.org> 
+ * http://arduino.berlios.de 
+ * 
+ */ 
+
+int ledPin = 13; // choose the pin for the LED 
+int inPin = 7;   // choose the input pin (for a pushbutton) 
+int val = 0;     // variable for reading the pin status 
+
+void setup() { 
+  pinMode(ledPin, OUTPUT);  // declare LED as output 
+  pinMode(inPin, INPUT);    // declare pushbutton as input 
+} 
+
+void loop(){ 
+  val = digitalRead(inPin);  // read input value 
+  if (val == HIGH) {         // check if the input is HIGH (button released) 
+    digitalWrite(ledPin, LOW);  // turn LED OFF 
+  } else { 
+    digitalWrite(ledPin, HIGH);  // turn LED ON 
+  } 
+}
+
+Example taken from Arduino.cc.
+
+Read Digital Inputs online: https://riptutorial.com/arduino/topic/1662/digital-inputs
+
+https://riptutorial.com/
+
+25
+
+ 
+ 
+ 
+Chapter 8: Digital Output
+
+Syntax
+
+•
+
+digitalWrite(pin, value)
+
+Examples
+
+Write to pin
+
+int ledPin = 13;                 // LED connected to digital pin 13 
+
+void setup() 
+{ 
+  pinMode(ledPin, OUTPUT);      // sets the digital pin as output 
+} 
+
+void loop() 
+{ 
+  digitalWrite(ledPin, HIGH);   // sets the LED on 
+  delay(1000);                  // waits for a second 
+  digitalWrite(ledPin, LOW);    // sets the LED off 
+  delay(1000);                  // waits for a second 
+}
+
+Example at Arduino.cc.
+
+Read Digital Output online: https://riptutorial.com/arduino/topic/2477/digital-output
+
+https://riptutorial.com/
+
+26
+
+ 
+ 
+Chapter 9: Functions
+
+Remarks
+
+Other than in ordinary C / C++ , the Arduino IDE allows to call a function before it is defined.
+
+In .cpp files, you have to define the function, or at least declare the function prototype before you 
+can use it.  
+In an .ino file, the Arduino IDE creates such a prototype behind the scenes.
+
+Arduino - function declaration - official
+
+Examples
+
+Create simple function
+
+int squareNum (int a) { 
+    return a*a; 
+}
+
+int : return type
+
+squareNum : function name
+
+int a : parameter type and name
+
+return a*a : return a value (same type as the return type defined at the beginning)
+
+Call a function
+
+If you have a function declared you can call it anywhere else in the code. Here is an example of 
+calling a function:
+
+https://riptutorial.com/
+
+27
+
+void setup(){ 
+  Serial.begin(9600); 
+} 
+
+void loop() { 
+  int i = 2; 
+
+  int k = squareNum(i); // k now contains 4 
+  Serial.println(k); 
+  delay(500); 
+} 
+
+int squareNum(int a) { 
+    return a*a; 
+}
+
+Read Functions online: https://riptutorial.com/arduino/topic/2380/functions
+
+https://riptutorial.com/
+
+28
+
+ 
+ 
+ 
+Chapter 10: Hardware pins
+
+Examples
+
+Arduino Uno R3
+
+Microcontrollers use pins to interact with the rest of the circuit. These pins will usually be one of 
+input / output pins, vin or ground. I/O pins can be simple digital I/O pins, or they can have some 
+special carachteristics like being able to vary the voltage of their output using pulse width 
+modulation. Here's a schematic of the Arduino R3 Uno and its pins.
+
+https://riptutorial.com/
+
+29
+
+(source)
+
+PWM Pins
+
+https://riptutorial.com/
+
+30
+
+ 
+PWM allows you to control the voltage of the output by switching the output between high and low 
+very very quickly. The percentage of time the pin is high is called its 'duty cycle'.
+
+PWM Pins: 3, 5, 6, 9, 10, 11
+
+Analog Inputs
+
+Just like a PWM pin can put out a range of voltages, analog pins on the Arduino Uno R3 can 
+sense a range of oinput voltages. You might use this to read the position of a potentiometer or 
+another input with a smoothly variable input. Please note that analog pins can't do analogWrite 
+output - for this you need to use PWM pins.
+
+Analog ADC Pins: A0, A1, A2, A3, A4, A5
+
+Serial, SPI and I2C
+
+The serial pins on the Arduino Uno R3 are also used by (for instance) the USB to Serial chip when 
+it communicates with a computer via the on board USB port. Serial: Tx on 0, Rx on 1
+
+SPI and I2C are communication protocols the Arduino can use to talk to shields, sensors, outputs 
+etc...:
+
+SPI Pins: MOSI on 11, MISO on 12, SCLK on 13, SS on 10
+
+I2C Pins: SCL on A5, SDA on A4
+
+On-board LED
+
+The Arduino Uno R3 has an LED with its own resistor attached to pin 13. This means that even if 
+you don't attach any LEDs to your board, if you set pin 13 to an output and set it high, you should 
+see an LED on the board come on. Use the 'Blink' example sketch to locate your onboard LED.
+
+From the Arduino Digital Pins Page
+
+NOTE: Digital pin 13 is harder to use as a digital input than the other digital pins 
+because it has an LED and resistor attached to it that's soldered to the board on most 
+boards. If you enable its internal 20k pull-up resistor, it will hang at around 1.7V instead 
+of the expected 5V 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, set its 
+pinMode() to INPUT and use an external pull down resistor.
+
+On-board LED pin: 13
+
+Read Hardware pins online: https://riptutorial.com/arduino/topic/4386/hardware-pins
+
+https://riptutorial.com/
+
+31
+
+Chapter 11: How Python integrates with 
+Arduino Uno
+
+Syntax
+
+•
+•
+
+•
+
+•
+
+Serial.begin(baudrate) // Set baud rate (bits per second) for serial data transmission
+Serial.println(value) // Print data to serial port followed by Carriage Return \r and 
+Newline character \n
+serial.Serial((port=None, baudrate=9600, bytesize=EIGHTBITS, parity=PARITY_NONE, 
+stopbits=STOPBITS_ONE, timeout=None, xonxoff=False, rtscts=False, write_timeout=None, 
+dsrdtr=False, inter_byte_timeout=None) // Initialize serial port with all parameters
+serial.readline() // Read serial data which contains Carriage Return \r and Newline 
+character \n
+
+Parameters
+
+Parameter Details
+
+serial
+
+Python package contains classes and methods to access serial port
+
+time
+
+Python package includes time-related functions
+
+Remarks
+
+I use an Arduino Uno with Arduino IDE 1.6.9 and Python 2.7.12 running in Windows 10.
+
+Examples
+
+First serial communication between Arduino and Python
+
+In this very first example, a basic serial write operation is started from an Arduino device.
+
+void setup() { 
+  // put your setup code here, to run once: 
+  Serial.begin(9600); 
+} 
+
+void loop() { 
+  // put your main code here, to run repeatedly: 
+  Serial.println("Hello World!"); 
+  delay(100); 
+}
+
+In setup(), function Serial.begin(9600) sets up the baud rate for serial data communication. In this 
+example, a baud rate of 9600 is used. Other values can be read here: Arduino Serial.begin() 
+function
+
+https://riptutorial.com/
+
+32
+
+ 
+In loop(), the first message we would like to send is "Hello World!". This message is transmitted by 
+using Serial.println("Hello World!") as it will send this string to serial port in ASCII format. At the 
+end of the message, there are Carriage Return (CR, \r) and Newline character (\n). Also, a delay 
+of 100 milliseconds is used each time program prints to serial port.
+
+Next, upload this Arduino sketch via COM port (remember this COM port number as it will be used 
+in Python program).
+
+The Python program reading serial data sent from Arduino device is shown below:
+
+import serial 
+import time 
+
+ser = serial.Serial('COM8', 9600) 
+while (1): 
+    print ser.readline() 
+    time.sleep(0.1)
+
+First, pyserial package should be imported. For more information about installing pyserial in 
+Windows environment, please check this instruction: Installing Python and pyserial. Then, we 
+initialize the serial port with COM port number and baud rate. The baud rate needs to be the same 
+as used in Arduino sketch.
+
+Received message will be printed in while loop using readline() function. A delay of 100 
+milliseconds is also used here as same as in Arduino sketch. Please notice that pyserial 
+readline() function requires a timeout when opening a serial port (pyserial documentation: 
+PySerial ReadLine).
+
+Read How Python integrates with Arduino Uno online: 
+https://riptutorial.com/arduino/topic/6722/how-python-integrates-with-arduino-uno
+
+https://riptutorial.com/
+
+33
+
+ 
+Chapter 12: How to store variables in 
+EEPROM and use them for permanent 
+storage
+
+Syntax
+
+•
+•
+
+EEPROM.write(address, value); //(Store variables in EEPROM in a particular address)
+EEPROM.read(address); //(Retrieve values from EEPROM and read data stored in 
+EEPROM)
+
+Parameters
+
+Parameters of 
+EEPROM.write
+
+Detail
+
+address
+
+The address where value is to be stored in EEPROM
+
+value
+
+Main variable to store in EEPROM. Note that this is a uint_8 (single 
+byte)—you must split multiple-byte data types into single bytes 
+yourself. Or you can use EEPROM.put to store floats or other data types.
+
+Parameters of 
+EEPROM.Read
+
+Detail
+
+address
+
+The address from which the variable is to be read
+
+Remarks
+
+The allowable addresses vary by hardware.
+
+•
+•
+•
+•
+
+ATMega328 (Uno, Pro Mini, etc.): 0–1023
+ATMega168: 0-511
+ATMega1280: 0-4095
+ATMega2560: 0-4095
+
+source
+
+Examples
+
+Store a variable in EEPROM and then retrieve it and print to screen
+
+First, add a reference to <EEPROM.h> at the start of your sketch:
+
+https://riptutorial.com/
+
+34
+
+#include <EEPROM.h>
+
+Then your other code:
+
+// Stores value in a particular address in EEPROM. There are almost 512 addresses present. 
+
+    // Store value 24 to Address 0 in EEPROM 
+    int addr = 0; 
+    int val = 24; 
+    EEPROM.write(addr, val);     // Writes 24 to address 0 
+
+    // --------- 
+    // Retrieves value from a particular address in EEPROM 
+    // Retrieve value from address 0 in EEPROM 
+    int retrievedVal = EEPROM.read(0);    // Retrieves value stored in 0 address in 
+                                          // EEPROM 
+
+    // *[NOTE: put Serial.begin(9600); at void setup()]* 
+    Serial.println(retrievedVal);        // Prints value stored in EEPROM Address 0 to 
+                                         // Serial (screen)
+
+Read How to store variables in EEPROM and use them for permanent storage online: 
+https://riptutorial.com/arduino/topic/5987/how-to-store-variables-in-eeprom-and-use-them-for-
+permanent-storage
+
+https://riptutorial.com/
+
+35
+
+ 
+ 
+ 
+Chapter 13: I2C Communication
+
+Introduction
+
+I2C is a communication protocol that can make two or more Arduino boards talk to each other. 
+The protocol uses two pins - SDA (data line) and SCL (clock line). Those pins are different from 
+one Arduino board type to another, so check the board specification. The I2C protocol set one 
+Arduino board as the master, and all the others as a slave. Each slave has a different address that 
+the programmer set hard-coded. Remark: Make sure all boards connected to the same VCC 
+source
+
+Examples
+
+Multiple slaves
+
+The following example shows how the master can receive data from multiple slaves. In this 
+example the slave sends two short numbers. The first one is for temperature, and the second one 
+is for moisture. Please notice that the temperature is a float (24.3). In order to use only two bytes 
+and not four (float is four bytes), I multiple the temperature in 10, and save it as a short. So here is 
+the master code:
+
+#include <Wire.h> 
+
+#define BUFFER_SIZE  4 
+#define MAX_NUMBER_OF_SLAVES 24 
+#define FIRST_SLAVE_ADDRESS 1 
+#define READ_CYCLE_DELAY 1000 
+
+byte buffer[BUFFER_SIZE]; 
+
+void setup() 
+{ 
+  Serial.begin(9600); 
+  Serial.println("MASTER READER"); 
+  Serial.println("*************"); 
+
+  Wire.begin();        // Activate I2C link 
+} 
+
+void loop() 
+{ 
+  for (int slaveAddress = FIRST_SLAVE_ADDRESS; 
+       slaveAddress <= MAX_NUMBER_OF_SLAVES; 
+       slaveAddress++) 
+  { 
+    Wire.requestFrom(slaveAddress, BUFFER_SIZE);    // request data from the slave 
+    if(Wire.available() == BUFFER_SIZE) 
+      {  // if the available data size is same as I'm expecting 
+        // Reads the buffer the slave sent 
+        for (int i = 0; i < BUFFER_SIZE; i++) 
+        { 
+
+https://riptutorial.com/
+
+36
+
+ 
+ 
+ 
+ 
+ 
+          buffer[i] = Wire.read();  // gets the data 
+        } 
+
+        // Parse the buffer 
+        // In order to convert the incoming bytes info short, I use union 
+        union short_tag { 
+          byte b[2]; 
+          short val; 
+        } short_cast; 
+
+        // Parse the temperature 
+        short_cast.b[0] = buffer[0]; 
+        short_cast.b[1] = buffer[1]; 
+        float temperature = ((float)(short_cast.val)) / 10; 
+
+        // Parse the moisture 
+        short_cast.b[0] = buffer[2]; 
+        short_cast.b[1] = buffer[3]; 
+        short moisture = short_cast.val; 
+
+        // Prints the income data 
+        Serial.print("Slave address "); 
+        Serial.print(slaveAddress); 
+        Serial.print(": Temprature = "); 
+        Serial.print(temprature); 
+        Serial.print("; Moisture = "); 
+        Serial.println(moisture); 
+      } 
+    } 
+    Serial.println("*************************"); 
+
+    delay(READ_CYCLE_DELAY); 
+  } 
+}
+
+And now the slave code:
+
+#include <Wire.h> 
+#include <OneWire.h> 
+#include <DallasTemperature.h> 
+
+//===================== 
+// This is the hard-coded address. Change it from one device to another 
+#define SLAVE_ADDRESS 1 
+//===================== 
+
+// I2C Variables 
+#define BUFFER_SIZE 2 
+#define READ_CYCLE_DELAY 1000 
+short data[BUFFER_SIZE]; 
+
+// Temprature Variables 
+OneWire oneWire(8); 
+DallasTemperature temperatureSensors(&oneWire); 
+float m_temperature; 
+
+// Moisture Variables 
+short m_moisture; 
+
+// General Variables 
+
+https://riptutorial.com/
+
+37
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+int m_timestamp; 
+
+void setup() 
+{ 
+  Serial.begin(9600); 
+  Serial.println("SLAVE SENDER"); 
+  Serial.print("Node address: "); 
+  Serial.println(SLAVE_ADDRESS); 
+  Serial.print("Buffer size: "); 
+  Serial.println(BUFFER_SIZE * sizeof(short)); 
+  Serial.println("***********************"); 
+
+  m_timestamp = millis(); 
+  Wire.begin(NODE_ADDRESS);  // Activate I2C network 
+  Wire.onRequest(requestEvent); // Set the request event handler 
+  temperatureSensors.begin(); 
+} 
+
+void loop() 
+{ 
+  if(millis() - m_timestamp < READ_CYCLE_DELAY) return; 
+
+  // Reads the temperature 
+  temperatureSensors.requestTemperatures(); 
+  m_temperature = temperatureSensors.getTempCByIndex(0); 
+
+  // Reads the moisture 
+  m_moisture = analogRead(A0); 
+} 
+
+void requestEvent() 
+{ 
+  data[0] = m_temperature * 10; // In order to use short, I multiple by 10 
+  data[1] = m_moisture; 
+  Wire.write((byte*)data, BUFFER_SIZE * sizeof(short)); 
+}
+
+Read I2C Communication online: https://riptutorial.com/arduino/topic/9092/i2c-communication
+
+https://riptutorial.com/
+
+38
+
+ 
+ 
+ 
+ 
+ 
+ 
+Chapter 14: Interrupts
+
+Syntax
+
+•
+
+•
+
+•
+
+•
+
+•
+
+•
+
+•
+
+digitalPinToInterrupt(pin); // converts a pin id to an interrupt id, for use with attachInterrupt() 
+and detachInterrupt().
+
+attachInterrupt(digitalPinToInterrupt(pin), ISR, mode); // recommended
+
+attachInterrupt(interrupt, ISR, mode); // not recommended
+
+detachInterrupt(digitalPinToInterrupt(pin));
+
+detachInterrupt(interrupt);
+
+noInterrupts(); // disables interrupts
+
+interrupts(); // re-enable interrupts after noInterrupts() has been called.
+
+Parameters
+
+Parameter Notes
+
+interrupt
+
+Id of the interrupt. Not to be mistaken for pin number.
+
+Interrupt Service Routine. This is the method which will be executed when the 
+interrupt occurs.
+
+What should cause the interrupt to trigger. One of LOW, CHANGE, RISING, or 
+FALLING. Due boards also allow HIGH.
+
+ISR
+
+mode
+
+Remarks
+
+Interrupt Service Routines (ISRs) should be as short as possible, since they pause main program 
+execution and can thus screw up time-dependent code. Generally this means in the ISR you set a 
+flag and exit, and in the main program loop you check the flag and do whatever that flag is 
+supposed to do.
+
+You cannot use delay() or millis() in an ISR because those methods themselves rely on 
+interrupts.
+
+Examples
+
+Interrupt on Button Press
+
+https://riptutorial.com/
+
+39
+
+This example uses a push button (tact switch) attached to digital pin 2 and GND, using an internal 
+pull-up resistor so pin 2 is HIGH when the button is not pressed.
+
+const int LED_PIN = 13; 
+const int INTERRUPT_PIN = 2; 
+volatile bool ledState = LOW; 
+
+void setup() { 
+    pinMode(LED_PIN, OUTPUT); 
+    pinMode(INTERRUPT_PIN, INPUT_PULLUP); 
+    attachInterrupt(digitalPinToInterrupt(INTERRUPT_PIN), myISR, FALLING); // trigger when 
+button pressed, but not when released. 
+} 
+
+void loop() { 
+    digitalWrite(LED_PIN, ledState); 
+} 
+
+void myISR() { 
+    ledState = !ledState; 
+    // note: LOW == false == 0, HIGH == true == 1, so inverting the boolean is the same as 
+switching between LOW and HIGH. 
+}
+
+One gotcha with this simple example is that push buttons tend to bounce, meaning that when 
+pressing or releasing, the circuit opens and closes more than once before it settles into the final 
+closed or open state. This example doesn't take that into account. As a result, sometimes pressing 
+the button will toggle the LED multiple times, instead of the expected once.
+
+Read Interrupts online: https://riptutorial.com/arduino/topic/2913/interrupts
+
+https://riptutorial.com/
+
+40
+
+ 
+ 
+ 
+Chapter 15: Libraries
+
+Introduction
+
+Here you will find documentation on:
+
+-Installing libraries into the Arduino IDE
+
+-Including libraries into a Sketch
+
+Examples
+
+Installing libraries with the Library Manager
+
+To install a new library into the Arduino IDE:
+
+•
+
+Open Sketch Menu > Include Library > Manage Libraries.
+
+Once you have opened the Library Manager you can use the menu in the top to filter 
+the results.
+
+•
+
+Click on the library you want, select a version in the drop down menu, and click 
+install.
+
+https://riptutorial.com/
+
+41
+
+Now your library is installed. In order to use it, you need to include it in your sketch.
+
+Including libraries in your sketch.
+
+Once you have installed a library, you need to include it in your sketch in order to use it.
+
+•
+
+Open the Sketch Menu > Include Library and click the Library you want to include.
+
+https://riptutorial.com/
+
+42
+
+•
+
+Now, the IDE has generated the required inclusion tags into your code.
+
+Now the Library is included in your sketch, and you can use it in your code.
+
+Read Libraries online: https://riptutorial.com/arduino/topic/8896/libraries
+
+https://riptutorial.com/
+
+43
+
+Chapter 16: Liquid Crystal Library
+
+Introduction
+
+Arduino's Liquid Crystal Library is a library for controlling LCD displays compatible the Hitachi 
+HD44780 driver, characterised by their 16 pin interface. The 16 pins might be connected via an 
+I2C interface. These displays contain a matrix of 5x7 pixel blocks used to display characters or 
+small monochromatic images. The displays are usually named according to how many rows and 
+columns they have, e.g. 16x2 or 1602 for 16 columns and 2 rows, and 20x4 or 2004 for 20 
+columns and 4 rows.
+
+Syntax
+
+•
+•
+•
+•
+•
+
+#include <LiquidCrystal.h> // Includes the library
+LiquidCrystal(rs, enable, d4, d5, d6, d7) //
+LiquidCrystal(rs, rw, enable, d4, d5, d6, d7)
+LiquidCrystal(rs, enable, d0, d1, d2, d3, d4, d5, d6, d7)
+LiquidCrystal(rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7)
+
+Parameters
+
+LiquidCrystal 
+Parameter
+
+Details
+
+the number of the Arduino pin that is connected to the RS pin on the LCD
+
+the number of the Arduino pin that is connected to the RW pin on the 
+LCD (optional)
+
+the number of the Arduino pin that is connected to the enable pin on the 
+LCD
+
+the numbers of the Arduino pins that are connected to the corresponding 
+data pins on the LCD. d0, d1, d2, and d3 are optional; if omitted, the LCD 
+will be controlled using only the four data lines (d4, d5, d6, d7).
+
+rs
+
+rw
+
+enable
+
+d0 - d7
+
+Examples
+
+Basic Usage
+
+/* 
+  Wiring: 
+   LCD pin 1 (VSS) -> Arduino Ground 
+   LCD pin 2 (VDD) -> Arduino 5V 
+
+https://riptutorial.com/
+
+44
+
+   LCD pin 3 (VO)  -> Arduino Ground 
+   LCD pin 4 (RS)  -> Arduino digital pin 12 
+   LCD pin 5 (RW)  -> Arduino Ground 
+   LCD pin 6 (E)   -> Arduino digital pin 11 
+   LCD pin 11 (D4) -> Arduino digital pin 5 
+   LCD pin 12 (D5) -> Arduino digital pin 4 
+   LCD pin 13 (D6) -> Arduino digital pin 3 
+   LCD pin 14 (D7) -> Arduino digital pin 2 
+*/ 
+
+#include <LiquidCrystal.h> // include the library 
+
+// initialize the library with the numbers of the interface pins 
+LiquidCrystal lcd(12, 11, 5, 4, 3, 2); 
+
+void setup() { 
+  // set up the LCD's number of columns and rows: 
+  lcd.begin(16, 2); 
+  // start writing on the first row and first column. 
+  lcd.setCursor(0, 0); 
+  // Print a message to the LCD. 
+  lcd.print("hello, world!"); 
+} 
+
+void loop() { 
+  // No need to do anything to keep the text on the display 
+}
+
+Read Liquid Crystal Library online: https://riptutorial.com/arduino/topic/9395/liquid-crystal-library
+
+https://riptutorial.com/
+
+45
+
+ 
+ 
+ 
+ 
+Chapter 17: Loops
+
+Syntax
+
+•
+•
+•
+
+for (declaration, condition, iteration) { }
+while (condition) { }
+do { } while (condition)
+
+Remarks
+
+General Remark If you intend to create a loop to wait for something to happen, you're probably on 
+the wrong track here. Rather remember that all code after setup() is run from a method called 
+loop(). So if you need to wait for something, it's easiest to not do anything (or only other 
+independent stuff) and come back to check for the waiting condition next time.
+
+do { } while(condition) will not evaluate the condition statement until after the first iteration. This 
+is important to keep in mind if the condition statement has side effects.
+
+Examples
+
+While
+
+A while loop will evaluate its condition, and if true, it will execute the code inside and start over. 
+That is, as long as its condition evaluates to true, the while loop will execute over and over.
+
+This loop will execute 100 times, each time adding 1 to the variable num:
+
+int num = 0; 
+while (num < 100) { 
+    // do something 
+    num++; 
+}
+
+The above loop is equivalent to a for loop:
+
+for (int i = 0; i < 100; i++) { 
+    // do something 
+}
+
+This loop will execute forever:
+
+while (true) { 
+    // do something 
+}
+
+https://riptutorial.com/
+
+46
+
+The above loop is equivalent to a for loop:
+
+for (;;) { 
+    // do something 
+}
+
+For
+
+for loops are simplified syntax for a very common loop pattern, which could be accomplished in 
+more lines with a while loop.
+
+The following is a common example of a for loop, which will execute 100 times and then stop.
+
+for (int i = 0; i < 100; i++) { 
+    // do something 
+}
+
+This is equivalent to a while loop:
+
+int num = 0; 
+while (num < 100) { 
+    // do something 
+    num++; 
+}
+
+You can create an endless loop by omitting the condition.
+
+for (;;) { 
+    // do something 
+}
+
+This is equivalent to a while loop:
+
+while (true) { 
+    // do something 
+}
+
+Do ... While
+
+A do while loop is the same as a while loop, except that it is guaranteed to execute at least one 
+time.
+
+The following loop will execute 100 times.
+
+int i = 0; 
+do { 
+    i++; 
+} while (i < 100);
+
+A similar loop, but with a different condition, will execute 1 time.
+
+https://riptutorial.com/
+
+47
+
+int i = 0; 
+do { 
+    i++; 
+} while (i < 0);
+
+If the above loop were merely a while loop, it would execute 0 times, because the condition would 
+evaluate to false before the first iteration. But since it is a do while loop, it executes once, then 
+checks its condition before executing again.
+
+Flow Control
+
+There are some ways to break or change a loop's flow.
+
+break; will exit the current loop, and will not execute any more lines within that loop.
+
+continue; will not execute any more code within the current iteration of the loop, but will remain in 
+the loop.
+
+The following loop will execute 101 times (i = 0, 1, ..., 100 ) instead of 1000, due to the break 
+statement:
+
+for (int i = 0; i < 1000; i++) { 
+    // execute this repeatedly with i = 0, 1, 2, ... 
+    if (i >= 100) { 
+        break; 
+    } 
+}
+
+The following loop will result in j's value being 50 instead of 100, because of the continue 
+statement:
+
+int j=0; 
+for (int i = 0; i < 100; i++) { 
+    if (i % 2 == 0) { // if `i` is even 
+        continue; 
+    } 
+    j++; 
+} 
+// j has the value 50 now.
+
+Read Loops online: https://riptutorial.com/arduino/topic/2802/loops
+
+https://riptutorial.com/
+
+48
+
+Chapter 18: MIDI Communication
+
+Introduction
+
+The intent of this topic to demonstrate some basic MIDI programs that show how to operate with 
+the protocol and progressively add useful features that more complex applications require.
+
+Examples
+
+MIDI THRU Example
+
+The MIDI Thru is simple and easy to test. When working properly you will be able to install your 
+Arduino project between two MIDI devices, MIDI IN to MIDI OUT and you will be able to verify that 
+the two device operate together. If you have the ability to measure latency, you will see an 
+increase due to the serial buffer capture and re-transmit instructions.
+
+// This is a simple MIDI THRU.  Everything in, goes right out. 
+// This has been validate on an Arduino UNO and a Olimex MIDI Shield 
+
+boolean byteReady; 
+unsigned char midiByte; 
+
+void setup() { 
+    // put your setup code here, to run once: 
+    //  Set MIDI baud rate: 
+    Serial.begin(31250); 
+    byteReady = false; 
+    midiByte = 0; 
+} 
+
+// The Loop that always gets called... 
+void loop() { 
+   if (byteReady) { 
+        byteReady = false; 
+        Serial.write(midiByte); 
+    } 
+} 
+
+// The little function that gets called each time loop is called. 
+// This is automated somwhere in the Arduino code. 
+void serialEvent() { 
+  if (Serial.available()) { 
+    // get the new byte: 
+    midiByte = (unsigned char)Serial.read(); 
+    byteReady = true; 
+  } 
+}
+
+MIDI Thru with Queue
+
+// This is a more complex MIDI THRU.  This version uses a queue.  Queues are important because 
+
+https://riptutorial.com/
+
+49
+
+ 
+ 
+ 
+ 
+some 
+// MIDI messages can be interrupted for real time events.  If you are generating your own 
+messages, 
+// you may need to stop your message to let a "real time" message through and then resume your 
+message. 
+
+#define QUEUE_DEPTH 128 
+
+// Queue Logic for storing messages 
+int headQ = 0; 
+int tailQ = 0; 
+unsigned char tx_queue[QUEUE_DEPTH]; 
+
+void setup() { 
+    // put your setup code here, to run once: 
+    //  Set MIDI baud rate: 
+    Serial.begin(31250); 
+} 
+
+// getQDepth checks for roll over.  Folks have told me this 
+// is not required.  Feel free to experiment. 
+int getQDepth() { 
+int depth = 0; 
+    if (headQ < tailQ) { 
+        depth = QUEUE_DEPTH - (tailQ - headQ); 
+    } else { 
+        depth = headQ - tailQ; 
+    } 
+    return depth; 
+} 
+
+void addQueue (unsigned char myByte) { 
+    int depth = 0; 
+    depth = getQDepth(); 
+
+    if (depth < (QUEUE_DEPTH-2)) { 
+        tx_queue[headQ] = myByte; 
+        headQ++; 
+        headQ = headQ % QUEUE_DEPTH; // Always keep the headQ limited between 0 and 127 
+    } 
+} 
+
+unsigned char deQueue() { 
+    unsigned char myByte; 
+    myByte = tx_queue[tailQ]; 
+    tailQ++; 
+    tailQ = tailQ % QUEUE_DEPTH;  // Keep this tailQ contained within a limit 
+    // Now that we dequeed the byte, it must be sent. 
+    return myByte; 
+} 
+
+void loop() { 
+   if (getQDepth>0) { 
+        Serial.write(deQueue()); 
+    } 
+} 
+
+// The little function that gets called each time loop is called. 
+// This is automated somwhere in the Arduino code. 
+void serialEvent() { 
+
+https://riptutorial.com/
+
+50
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+  if (Serial.available()) { 
+    // get the new byte: 
+    addQueue((unsigned char)Serial.read());; 
+  } 
+}
+
+MIDI Clock Generation
+
+// This is a MiDI clk generator.  This takes a #defined BPM and 
+// makes the appropriate clk rate.  The queue is used to let other messages 
+// through, but allows a clock to go immediately to reduce clock jitter 
+
+#define QUEUE_DEPTH 128 
+#define BPM 121 
+#define MIDI_SYSRT_CLK 0xF8 
+
+// clock tracking and calculation 
+unsigned long lastClock; 
+unsigned long captClock; 
+unsigned long clk_period_us; 
+
+// Queue Logic for storing messages 
+int headQ = 0; 
+int tailQ = 0; 
+unsigned char tx_queue[QUEUE_DEPTH]; 
+
+void setup() { 
+    //  Set MIDI baud rate: 
+    Serial.begin(31250); 
+    clk_period_us = 60000000 / (24 * BPM); 
+    lastClock = micros(); 
+} 
+
+// getQDepth checks for roll over.  Folks have told me this 
+// is not required.  Feel free to experiment. 
+int getQDepth() { 
+int depth = 0; 
+    if (headQ < tailQ) { 
+        depth = QUEUE_DEPTH - (tailQ - headQ); 
+    } else { 
+        depth = headQ - tailQ; 
+    } 
+    return depth; 
+} 
+
+void addQueue (unsigned char myByte) { 
+    int depth = 0; 
+    depth = getQDepth(); 
+
+    if (depth < (QUEUE_DEPTH-2)) { 
+        tx_queue[headQ] = myByte; 
+        headQ++; 
+        headQ = headQ % QUEUE_DEPTH; // Always keep the headQ limited between 0 and 127 
+    } 
+} 
+
+unsigned char deQueue() { 
+    unsigned char myByte; 
+    myByte = tx_queue[tailQ]; 
+
+https://riptutorial.com/
+
+51
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+    tailQ++; 
+    tailQ = tailQ % QUEUE_DEPTH;  // Keep this tailQ contained within a limit 
+    // Now that we dequeed the byte, it must be sent. 
+    return myByte; 
+} 
+
+void loop() { 
+    captClock = micros(); 
+
+    if (lastClock > captClock) { 
+        // we have a roll over condition - Again, maybe we don't need to do this. 
+        if (clk_period_us <= (4294967295 - (lastClock - captClock))) { 
+            // Add a the ideal clock period for this BPM to the last measurement value 
+            lastClock = lastClock + clk_period_us; 
+            // Send a clock, bypasing the transmit queue 
+            Serial.write(MIDI_SYSRT_CLK); 
+        } 
+    } else if (clk_period_us <= captClock-lastClock) { 
+        // Basically the same two commands above, but not within a roll over check 
+        lastClock = lastClock + clk_period_us; 
+        // Send a clock, bypasing the transmit queue 
+        Serial.write(MIDI_SYSRT_CLK); 
+    } 
+
+    if (getQDepth>0) { 
+        Serial.write(deQueue()); 
+    } 
+} 
+
+// The little function that gets called each time loop is called. 
+// This is automated somwhere in the Arduino code. 
+void serialEvent() { 
+  if (Serial.available()) { 
+    // get the new byte: 
+    addQueue((unsigned char)Serial.read());; 
+  } 
+}
+
+MIDI Messages Defined
+
+In general, MIDI protocol is broken down into "messages". There are 4 general classes of 
+messages:
+
+•
+•
+•
+•
+
+Channel Voice
+Channel Mode
+System Common
+System Real-Time Messages
+
+Messages start with a byte value above 0x80. Any value below 0x7F is considered data. 
+Effectively meaning that 127 is the maximum value that can be encoded into a single MIDI data 
+byte. To encode larger values, two or more MIDI data bytes are required.
+
+It should be pointed out that messages must be sent start to finish without interruption... 
+EXCEPT... System Real-Time messages, which are a single byte, which can be injected in the 
+middle of any message.
+
+https://riptutorial.com/
+
+52
+
+ 
+ 
+ 
+ 
+Channel Voice Messages
+
+Status 
+D7..D0
+
+Data Bytes
+
+Description
+
+1000nnnn
+
+0kkkkkkk 
+0vvvvvvv
+
+Note Off event.This message is sent when a note is released 
+(ended). (kkkkkkk) is the key (note) number. (vvvvvvv) is the 
+velocity.
+
+1001nnnn
+
+0kkkkkkk 
+0vvvvvvv
+
+Note On event. This message is sent when a note is 
+depressed (start). (kkkkkkk) is the key (note) number. 
+(vvvvvvv) is the velocity.
+
+1010nnnn
+
+0kkkkkkk 
+0vvvvvvv
+
+1011nnnn
+
+0ccccccc 
+0vvvvvvv
+
+Polyphonic Key Pressure (Aftertouch). This message is most 
+often sent by pressing down on the key after it "bottoms out". 
+(kkkkkkk) is the key (note) number. (vvvvvvv) is the pressure 
+value.
+
+Control Change. This message is sent when a controller value 
+changes. Controllers include devices such as pedals and 
+levers. Controller numbers 120-127 are reserved as "Channel 
+Mode Messages" (below). (ccccccc) is the controller number 
+(0-119). (vvvvvvv) is the controller value (0-127).
+
+1100nnnn
+
+0ppppppp
+
+Program Change. This message sent when the patch number 
+changes. (ppppppp) is the new program number.
+
+1101nnnn
+
+0vvvvvvv
+
+1110nnnn
+
+0lllllll 
+0mmmmmmm
+
+Channel Pressure (After-touch). This message is most often 
+sent by pressing down on the key after it "bottoms out". This 
+message is different from polyphonic after-touch. Use this 
+message to send the single greatest pressure value (of all the 
+current depressed keys). (vvvvvvv) is the pressure value.
+
+Pitch Bend Change. This message is sent to indicate a change 
+in the pitch bender (wheel or lever, typically). The pitch bender 
+is measured by a fourteen bit value. Center (no pitch change) 
+is 2000H. Sensitivity is a function of the receiver, but may be 
+set using RPN 0. (lllllll) are the least significant 7 bits. 
+(mmmmmmm) are the most significant 7 bits.
+
+Channel Mode Messages
+
+Status 
+D7..D0
+
+Data 
+Bytes
+
+Description
+
+1011nnnn
+
+0ccccccc 
+0vvvvvvv
+
+Channel Mode Messages. This the same code as the Control 
+Change (above), but implements Mode control and special 
+message by using reserved controller numbers 120-127. The 
+
+https://riptutorial.com/
+
+53
+
+Status 
+D7..D0
+
+Data 
+Bytes
+
+Description
+
+commands are:
+
+All Sound Off. When All Sound Off is received all oscillators will 
+turn off, and their volume envelopes are set to zero as soon as 
+possible. c = 120, v = 0: All Sound Off
+
+Reset All Controllers. When Reset All Controllers is received, all 
+controller values are reset to their default values. (See specific 
+Recommended Practices for defaults).
+
+c = 121, v = x: Value must only be zero unless otherwise allowed 
+in a specific Recommended Practice.
+
+Local Control. When Local Control is Off, all devices on a given 
+channel will respond only to data received over MIDI. Played 
+data, etc. will be ignored. Local Control On restores the functions 
+of the normal controllers.
+
+c = 122, v = 0: Local Control Off
+
+c = 122, v = 127: Local Control On
+
+All Notes Off. When an All Notes Off is received, all oscillators will 
+turn off.
+
+c = 123, v = 0: All Notes Off (See text for description of actual 
+mode commands.)
+
+c = 124, v = 0: Omni Mode Off
+
+c = 125, v = 0: Omni Mode On
+
+c = 126, v = M: Mono Mode On (Poly Off) where M is the number 
+of channels (Omni Off) or 0 (Omni On)
+
+c = 127, v = 0: Poly Mode On (Mono Off) (Note: These four 
+messages also cause All Notes Off)
+
+System Common Messages
+
+Status 
+D7..D0
+
+11110000
+
+Data Bytes
+
+Description
+
+0iiiiiii [0iiiiiii 0iiiiiii] 
+0ddddddd --- --- 
+0ddddddd 
+
+System Exclusive. This message type allows manufacturers 
+to create their own messages (such as bulk dumps, patch 
+parameters, and other non-spec data) and provides a 
+
+https://riptutorial.com/
+
+54
+
+Status 
+D7..D0
+
+Data Bytes
+
+Description
+
+11110111
+
+mechanism for creating additional MIDI Specification 
+messages. The Manufacturer's ID code (assigned by MMA or 
+AMEI) is either 1 byte (0iiiiiii) or 3 bytes (0iiiiiii 0iiiiiii 0iiiiiii). 
+Two of the 1 Byte IDs are reserved for extensions called 
+Universal Exclusive Messages, which are not manufacturer-
+specific. If a device recognizes the ID code as its own (or as 
+a supported Universal message) it will listen to the rest of the 
+message (0ddddddd). Otherwise, the message will be 
+ignored. (Note: Only Real-Time messages may be 
+interleaved with a System Exclusive.)
+
+11110001
+
+0nnndddd
+
+MIDI Time Code Quarter Frame. nnn = Message Type dddd 
+= Values
+
+11110010
+
+0lllllll 
+0mmmmmmm
+
+Song Position Pointer. This is an internal 14 bit register that 
+holds the number of MIDI beats (1 beat= six MIDI clocks) 
+since the start of the song. l is the LSB, m the MSB.
+
+11110011
+
+0sssssss
+
+Song Select. The Song Select specifies which sequence or 
+song is to be played.
+
+11110100
+
+11110101
+
+11110110
+
+11110111
+
+Undefined. (Reserved)
+
+Undefined. (Reserved)
+
+Tune Request. Upon receiving a Tune Request, all analog 
+synthesizers should tune their oscillators.
+
+End of Exclusive. Used to terminate a System Exclusive 
+dump (see above).
+
+System Real-Time Messages
+
+Status 
+D7..D0
+
+Data 
+Bytes
+
+Description
+
+11111000
+
+Timing Clock. Sent 24 times per quarter note when synchronization is 
+required (see text).
+
+11111001
+
+Undefined. (Reserved)
+
+11111010
+
+Start. Start the current sequence playing. (This message will be 
+followed with Timing Clocks).
+
+11111011
+
+Continue. Continue at the point the sequence was Stopped.
+
+https://riptutorial.com/
+
+55
+
+Status 
+D7..D0
+
+Data 
+Bytes
+
+Description
+
+11111100
+
+Stop. Stop the current sequence.
+
+11111101
+
+Undefined. (Reserved)
+
+11111110
+
+11111111
+
+Active Sensing. This message is intended to be sent repeatedly to tell 
+the receiver that a connection is alive. Use of this message is optional. 
+When initially received, the receiver will expect to receive another 
+Active Sensing message each 300ms (max), and if it does not then it 
+will assume that the connection has been terminated. At termination, 
+the receiver will turn off all voices and return to normal (non- active 
+sensing) operation.
+
+Reset. Reset all receivers in the system to power-up status. This 
+should be used sparingly, preferably under manual control. In 
+particular, it should not be sent on power-up.
+
+Read MIDI Communication online: https://riptutorial.com/arduino/topic/9406/midi-communication
+
+https://riptutorial.com/
+
+56
+
+Chapter 19: PWM - Pulse Width Modulation
+
+Examples
+
+Control a DC motor through the Serial port using PWM
+
+In this example we aim to accomplish one of the most common tasks: I have a small DC motor 
+laying around, how do I use my Arduino to control it? Easy, with PWM and serial communication, 
+using the function analogWrite() and the Serial library.
+
+The basics
+
+Pulse Width Modulation or PWM for short is a technique for mimicking analog signals using digital 
+output. How does this work? Using a pulse train whose relation D (duty cycle) between time at 
+high level (digital 1, usually 5V) and time at low level (digital 0, 0V) in each period can be modified 
+to produce an average voltage between these two levels:
+
+By using Arduino's analogWrite(pin,value) function we can vary the value of the duty cycle of pin's 
+output. Note that the pin must be put into output mode and the value must be between 0 (0V) and 
+255 (5V). Any value in between will simulate a proportional intermediate analog output.
+
+However, the purpose of analog signals is usually related to the control of mechanical systems 
+that require more voltage and current than the Arduino board alone is capable of. In this example, 
+we will learn how to amplify Arduino's PWM capabilities.
+
+For this a MOSFET diode is used. In essence, this diode acts as a switch. It allows or interrupts 
+the electric flow between its source and drain terminals. But instead of a mechanical switch, it 
+features a third terminal called gate. A very small current (<1mA) will "open" this gate and allow 
+the current to flow. This is very convenient, because we can send Arduino's PWM output to this 
+gate, thereby creating another PWM pulse train with the same duty cycle through the MOSFET, 
+
+https://riptutorial.com/
+
+57
+
+which allows voltages and currents that would destroy the Arduino.
+
+Bill of materials: what do you need to build 
+this example
+
+•
+•
+•
+•
+•
+•
+•
+•
+
+MOSFET diode: for instance, the popular BUZ11
+Protection diode for the motor: Schottky SB320
+Resistor: anything 10K ~ 1M Ohm
+Motor: A typical small motor (a typical one can be 12V)
+A power source compatible with the motor you have selected
+A breadboard
+Colorful cables!
+An Arduino, but you already knew that.
+
+The build
+
+Put everything together! Power the rails of the breadboard and place the MOSFET diode in it. 
+Connect the motor between the positive rail and the MOSFET drain. Connect the protection diode 
+in the same way: between the MOSFET drain and the positive rail. Connect the source of the 
+MOSFET to the common ground rail. Finally, connect the PWM pin (we're using pin 10 in this 
+example) to the gate of the MOSFET and also to the common ground through the resistor (we 
+need very low current!).
+
+Here's an example of how this build looks. If you prefer an scheme here's one.
+
+The code
+
+Now we can connect the Arduino to a computer, upload the code and control the motor, by 
+sending values through the serial communication. Recall that these values should be integers 
+
+https://riptutorial.com/
+
+58
+
+between 0 and 255. The actual code of this example is very simple. An explanation is provided in 
+each line.
+
+int in = 0;                   // Variable to store the desired value 
+byte pinOut = 10;             // PWM output pin 
+
+void setup() {                // This executes once 
+  Serial.begin(9600);             // Initialize serial port 
+  pinMode(pinOut, OUTPUT);        // Prepare output pin 
+} 
+
+void loop() {                 // This loops continuously 
+  if(Serial.available()){         // Check if there's data 
+    in = Serial.read();           // Read said data into the variable "in" 
+    analogWrite(pinOut, in);      // Pass the value of "in" to the pin 
+  } 
+}
+
+And that's it! Now you can use Arduino's PWM capabilities to control applications that require 
+analog signals even when the power requirements exceed the board's limits.
+
+PWM with a TLC5940
+
+The TLC5940 is a handy item to have when you run out of PWM ports on the Arduino. It has 16 
+channels, each individually controllable with 12 bits of resolution (0-4095). An existing library is 
+available at http://playground.arduino.cc/Learning/TLC5940. It is useful for controlling multiple 
+servos or RGB LEDs. Just keep in mind, the LEDs must be common anode to work. Also, the 
+chips are daisy-chainable, allowing even more PWM ports.
+
+Example:
+
+// Include the library 
+#include <Tlc5940.h> 
+
+void setup() { 
+    // Initialize 
+    Tlc.init(); 
+    Tlc.clear(); 
+} 
+
+unsigned int level = 0; 
+void loop() { 
+    // Set all 16 outputs to same value 
+    for (int i = 0; i < 16; i++) { 
+        Tlc.set(i, level); 
+    } 
+    level = (level + 1) % 4096; 
+    // Tell the library to send the values to the chip 
+    Tlc.update(); 
+    delay(10); 
+}
+
+Read PWM - Pulse Width Modulation online: https://riptutorial.com/arduino/topic/1658/pwm---
+pulse-width-modulation
+
+https://riptutorial.com/
+
+59
+
+ 
+ 
+ 
+ 
+Chapter 20: Random Numbers
+
+Syntax
+
+•
+
+•
+
+•
+
+random(max) //Returns a (long) pseudo-random number between 0 (inclusive) and max 
+(exclusive)
+
+random(min, max) //Returns a (long) pseudo-random number between min (inclusive) and 
+max (exclusive)
+
+randomSeed(seed) //Initializes de pseudo-random number generator, causing it to start at a 
+specified point in its sequence.
+
+Parameters
+
+Parameter Details
+
+min
+
+max
+
+The minimum possible value (inclusive) to be generated by the random() 
+function.
+
+The maximum possible value (exclusive) to be generated by the random() 
+function.
+
+seed
+
+The seed that will be used to shuffle the random() function.
+
+Remarks
+
+If randomSeed() is called with a fixed value (eg. randomSeed(5)), the sequence of random numbers 
+generated by the sketch will repeat each time it is run. In most cases, a random seed is preferred, 
+which can be obtained by reading an unconnected analog pin.
+
+Examples
+
+Generate a random number
+
+The random() function can be used to generate pseudo-random numbers:
+
+void setup() { 
+    Serial.begin(9600); 
+} 
+
+void loop() { 
+    long randomNumber = random(500);  // Generate a random number between 0 and 499 
+    Serial.println(randomNumber); 
+
+    randomNumber = random(100, 1000); // Generate a random number between 100 and 999 
+
+https://riptutorial.com/
+
+60
+
+ 
+ 
+    Serial.println(randomNumber); 
+
+    delay(100); 
+}
+
+Setting a seed
+
+If it is important for a sequence of numbers generated by random() to differ, it is a good idea to 
+specify a seed with randomSeed():
+
+void setup() { 
+    Serial.begin(9600); 
+
+    // If analog pin 0 is left unconnected, analogRead(0) will produce a 
+    // different random number each time the sketch is run. 
+    randomSeed(analogRead(0)); 
+} 
+
+void loop() { 
+    long randomNumber = random(500); // Generate a random number between 0 and 499 
+    Serial.println(randomNumber); 
+
+    delay(100); 
+}
+
+Read Random Numbers online: https://riptutorial.com/arduino/topic/2238/random-numbers
+
+https://riptutorial.com/
+
+61
+
+ 
+ 
+ 
+ 
+Chapter 21: Serial Communication
+
+Syntax
+
+•
+•
+•
+
+•
+
+•
+•
+•
+•
+
+Serial.begin(speed) // Opens the serial port on the given baud rate
+Serial.begin(speed, config)
+Serial[1-3].begin(speed) // Arduino Mega only! When writing 1-3 it means you can choose 
+between the numbers 1 to 3 when choosing the serial port.
+Serial[1-3].begin(speed, config) // Arduino Mega only! When writing 1-3 it means you can 
+choose between the numbers 1 to 3 when choosing the serial port.
+Serial.peek() // Reads the next byte of input without removing it from the buffer
+Serial.available() // Gets the number of bytes in the buffer
+Serial.print(text) // Writes text to the serial port
+Serial.println(text) // Same as Serial.print() but with a trailing newline
+
+Parameters
+
+Parameter Details
+
+Speed
+
+The rate of the serial port (usually 9600)
+
+Text
+
+The text to write to the serial port (any data type)
+
+Data bits
+
+Number of data bits in a packet (from 5 - 8), default is 8
+
+Parity
+
+Parity options for error detection: none (default), even, odd
+
+Stop bits
+
+Number of stop bits in a packet: one (default), two
+
+Remarks
+
+The Arduino Mega has four serial ports which there can be choosed from. They are accesed in the 
+following way
+
+  Serial.begin(9600); 
+  Serial1.begin(38400); 
+  Serial2.begin(19200); 
+  Serial3.begin(4800);
+
+The serial port on an Arduino can be set with additional parameters. The config parameter sets 
+data bits, parity, and stop bits. For example:
+
+8 data bits, even parity and 1 stop bit would be - SERIAL_8E1
+
+6 data bits, odd parity and 2 stop bit would be - SERIAL_6O2
+
+https://riptutorial.com/
+
+62
+
+7 data bits, no parity and 1 stop bit would be - SERIAL_7N1
+
+Examples
+
+Simple read and write
+
+This example listens for input coming in over the serial connection, then repeats it back out the 
+same connection.
+
+byte incomingBytes; 
+
+void setup() { 
+  Serial.begin(9600); // Opens serial port, sets data rate to 9600 bps. 
+} 
+
+void loop() { 
+  // Send data only when you receive data. 
+  if (Serial.available() > 0) { 
+    // Read the incoming bytes. 
+    incomingBytes = Serial.read(); 
+
+    // Echo the data. 
+    Serial.println(incomingBytes); 
+  } 
+}
+
+Base64 filtering for serial input data
+
+String base64="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="; 
+
+void setup() { 
+
+    Serial.begin(9600); // Turn the serial protocol ON 
+    Serial.println("Start Typing"); 
+} 
+
+void loop() { 
+
+    if (Serial.available() > 0) { // Check if data has been sent from the user 
+        char c = Serial.read();   // Gets one byte/Character from serial buffer 
+        int result = base64.indexOf(c); // Base64 filtering 
+        if (result>=0) 
+            Serial.print(c); // Only print Base64 string 
+    } 
+}
+
+Command Handling over Serial
+
+byte incoming; 
+String inBuffer; 
+
+void setup() { 
+    Serial.begin(9600); // or whatever baud rate you would like 
+} 
+
+https://riptutorial.com/
+
+63
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+void loop(){ 
+    // setup as non-blocking code 
+    if(Serial.available() > 0) { 
+        incoming = Serial.read(); 
+
+        if(incoming == '\n') {  // newline, carriage return, both, or custom character 
+
+            // handle the incoming command 
+            handle_command(); 
+
+            // Clear the string for the next command 
+            inBuffer = ""; 
+        } else{ 
+            // add the character to the buffer 
+            inBuffer += incoming; 
+        } 
+    } 
+
+    // since code is non-blocking, execute something else . . . . 
+} 
+
+void handle_command() { 
+    // expect something like 'pin 3 high' 
+    String command = inBuffer.substring(0, inBuffer.indexOf(' ')); 
+    String parameters = inBuffer.substring(inBuffer.indexOf(' ') + 1); 
+
+    if(command.equalsIgnoreCase('pin')){ 
+        // parse the rest of the information 
+        int pin = parameters.substring("0, parameters.indexOf(' ')).toInt(); 
+        String state = parameters.substring(parameters.indexOf(' ') + 1); 
+
+        if(state.equalsIgnoreCase('high')){ 
+            digitalWrite(pin, HIGH); 
+        }else if(state.equalsIgnoreCase('low)){ 
+            digitalWrite(pin, LOW); 
+        }else{ 
+            Serial.println("did not compute"); 
+        } 
+    } // add code for more commands 
+}
+
+Serial Communication with Python
+
+If you have an Arduino connected to a computer or a Raspberry Pi, and want to send data from 
+the Arduino to the PC you can do the following:
+
+Arduino:
+
+void setup() { 
+  // Opens serial port, sets data rate to 9600 bps: 
+  Serial.begin(9600); 
+} 
+
+void loop() { 
+  // Sends a line over serial: 
+
+https://riptutorial.com/
+
+64
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+  Serial.println("Hello, Python!"); 
+  delay(1000); 
+}
+
+Python:
+
+import serial 
+
+ser = serial.Serial('/dev/ttyACM0', 9600)  # Start serial communication 
+while True: 
+    data = ser.readline()  # Wait for line from Arduino and read it 
+    print("Received: '{}'".format(data))  # Print the line to the console
+
+Read Serial Communication online: https://riptutorial.com/arduino/topic/1674/serial-communication
+
+https://riptutorial.com/
+
+65
+
+ 
+ 
+Chapter 22: Servo
+
+Introduction
+
+A Servo is a an enclosed system containing a motor and some supporting circuitry. The shaft of a 
+servo can be rotated to a fixed angle within an arc using a control signal. If the control signal is 
+maintained, then the servo will maintain its angle. Servos can easily be controlled with the Arduino 
+Servo.h library.
+
+Syntax
+
+•
+•
+•
+•
+
+#include <Servo.h> // Include the Servo library
+Servo.attach(pin) // Attach to the servo on pin. Returns a Servo object
+Servo.write(degrees) // Degrees to move to (0 - 180)
+Servo.read() // Gets the current rotation of the servo
+
+Examples
+
+Moving the servo back and forth
+
+#include <Servo.h> 
+
+Servo srv; 
+
+void setup() { 
+  srv.attach(9); // Attach to the servo on pin 9 
+
+}
+
+To use a servo, you need to call attach() function first. It starts generating a PWM signal 
+controlling a servo on a specified pin. On boards other than Arduino Mega, use of Servo library 
+disables analogWrite() (PWM) functionality on pins 9 and 10, whether or not there is a Servo on 
+those pins.
+
+void loop() { 
+  Servo.write(90); // Move the servo to 90 degrees 
+  delay(1000); // Wait for it to move to it's new position 
+  Servo.write(0); // Move the servo to 0 degrees 
+  delay(1000); // Wait for it to move to it's new position 
+}
+
+Note that you are not guaranteed that the servo reached the desired position, nor you can check it 
+from the program.
+
+Read Servo online: https://riptutorial.com/arduino/topic/4920/servo
+
+https://riptutorial.com/
+
+66
+
+ 
+ 
+ 
+Chapter 23: SPI Communication
+
+Remarks
+
+Chip select signals
+
+Most slaves have an active low chip select input. So proper code to initialize and use a chip select 
+pin is this:
+
+#define CSPIN 1 // or whatever else your CS pin is 
+// init: 
+pinMode(CSPIN, OUTPUT); 
+digitalWrite(CSPIN, 1); // deselect 
+
+// use: 
+digitalWrite(CSPIN, 0); // select 
+... perform data transfer ... 
+digitalWrite(CSPIN, 1); // deselect
+
+Deselecting a slave is just as important as selecting it, because a slave may drive the MISO line 
+while it is selected. There may be many slaves, but only one may drive MISO. If a slave is not 
+deselected properly, two or more slaves might be driving MISO, which may lead to shorts between 
+their outputs and might damage the devices.
+
+Transactions
+
+Transactions serve two purposes:
+
+•
+•
+
+tell the SPI when we want to start and end using it within a particular context
+configure the SPI for a specific chip
+
+The clock line has different idle states in the different SPI modes. Changing the SPI mode while a 
+slave is selected might confuse the slave, so always set the SPI mode before selecting a slave. 
+The SPI mode can be set with an SPISettings object passed to SPI.beginTransaction:
+
+SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0)); 
+digitalWrite(CSPIN, 0); 
+... perform data transfer ... 
+digitalWrite(CSPIN, 1); 
+SPI.endTransaction();
+
+SPISettings may also be stored elsewhere:
+
+SPISettings mySettings(1000000, MSBFIRST, SPI_MODE0); 
+SPI.beginTransaction(mySettings);
+
+https://riptutorial.com/
+
+67
+
+ 
+If another part of the code tries to use the SPI between a pair of calls to beginTransaction() and 
+endTransaction(), an error may be raised - how that is done depends on the implementation.
+
+Also see Arduino Reference: SPISettings
+
+Using the SPI in Interrupt Service Routines
+
+If the SPI has to be used within an ISR, no other transaction may be taking place at the same 
+time. The SPI library provides usingInterrupt(interrupt_number) to facilitate this. It works by 
+disabling the given interrupt whenever beginTransaction() is called, so the interrupt cannot fire 
+between that pair fo calls to beginTransaction() and endTransaction().
+
+Also see Arduino Reference: SPI: usingInterrupt
+
+Examples
+
+Basics: initialize the SPI and a chip select pin, and perform a 1-byte transfer
+
+#include <SPI.h> 
+#define CSPIN 1 
+
+void setup() { 
+  pinMode(CSPIN, OUTPUT); // init chip select pin as an output 
+  digitalWrite(CSPIN, 1); // most slaves interpret a high level on CS as "deasserted" 
+
+  SPI.begin(); 
+
+  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0)); 
+  digitalWrite(CSPIN, 0); 
+
+  unsigned char sent = 0x01; 
+  unsigned char received = SPI.transfer(sent); 
+  // more data could be transferred here 
+
+  digitalWrite(CSPIN, 1); 
+  SPI.endTransaction(); 
+
+  SPI.end(); 
+} 
+
+void loop() { 
+  // we don't need loop code in this example. 
+}
+
+This example:
+
+•
+•
+•
+
+properly initializes and uses a chip select pin (see remarks)
+properly uses an SPI transaction (see remarks)
+only uses the SPI to transfer one single byte. There is also a method for transferring arrays, 
+which is not used here.
+
+https://riptutorial.com/
+
+68
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Read SPI Communication online: https://riptutorial.com/arduino/topic/4919/spi-communication
+
+https://riptutorial.com/
+
+69
+
+Chapter 24: Time Management
+
+Syntax
+
+•
+
+•
+
+•
+
+•
+
+•
+
+unsigned long millis()
+
+unsigned long micros()
+
+void delay(unsigned long milliseconds)
+
+void delayMicroseconds(unsigned long microseconds)
+
+See the elapsedMillis header for constructors and operators of that class. In short:
+
+○
+
+○
+
+○
+
+○
+
+elapsedMillis elapsedMillisObject; creates an object to keep track of time since it was 
+created or since some other explicitly set point in time
+elapsedMillisObject = 0; reset the time tracked by the object to "since now"
+unsigned long deltaT = elapsedMillisObject; lets us look at the tracked time
+elapsedMillisObject += and -= these work as expected
+
+Remarks
+
+Blocking vs. non-blocking code
+
+For very simple sketches, writing blocking code using delay() and delayMicroseconds() can be 
+appropriate. When things get more complex, using these functions can have some drawbacks. 
+Some of these are:
+
+•
+
+•
+
+•
+
+Wasting CPU time: More complex sketches might need the CPU for something else while 
+waiting for an LED blinking period to end.
+unexpected delays: when delay() is called in subroutines that are not obviously called, for 
+example in libraries you include.
+missing events that happen during the delay and are not handled by an interrupt handler, for 
+example polled button presses: A button might be pressed for 100 ms, but this might be 
+shadowed by a delay(500).
+
+Implementation details
+
+millis() usually relies on a hardware timer that runs at a speed that's much higher than 1 kHz. 
+When millis() is called, the implementation returns some value, but you don't know how old that 
+actually is. It's possible that the "current" millisecond just started, or that it will end right after that 
+function call. That means that, when calculating the difference between two results from millis(), 
+you can be off by anything between almost zero and almost one millisecond. Use micros() if higher 
+precision is needed.
+
+https://riptutorial.com/
+
+70
+
+Looking into the source code of elapsedMillis reveals that it indeed uses millis() internally to 
+compare two points in time, so it suffers from this effect as well. Again, there's the alternative 
+elapsedMicros for higher precision, from the same library.
+
+Examples
+
+blocking blinky with delay()
+
+One of the most straight forward way of making an LED blink is: turn it on, wait a bit, turn it off, 
+wait again, and repeat endlessly:
+
+// set constants for blinking the built-in LED at 1 Hz 
+#define OUTPIN LED_BUILTIN 
+#define PERIOD 500 
+
+void setup() 
+{ 
+  pinMode(OUTPIN, OUTPUT);      // sets the digital pin as output 
+} 
+
+void loop() 
+{ 
+  digitalWrite(OUTPIN, HIGH);   // sets the pin on 
+  delayMicroseconds(PERIOD);        // pauses for 500 miliseconds 
+  digitalWrite(OUTPIN, LOW);    // sets the pin off 
+  delayMicroseconds(PERIOD);        // pauses for 500 milliseconds 
+
+  // doing other time-consuming stuff here will skew the blinking 
+}
+
+However, waiting as done in the example above wastes CPU cycles, because it just sits there in a 
+loop waiting for a certain point in time to go past. That's what the non-blocking ways, using 
+millis() or elapsedMillis, do better - in the sense that they don't burn as much of the hardware's 
+capabilities.
+
+Non-blocking blinky with the elapsedMillis library (and class)
+
+The elapsedMillis library provides a class with the same name that keeps track of the time that 
+passed since it was created or set to a certain value:
+
+#include <elapsedMillis.h> 
+
+#define OUTPIN LED_BUILTIN 
+#define PERIOD 500 
+
+elapsedMillis ledTime; 
+
+bool ledState = false; 
+
+void setup() 
+{ 
+  // initialize the digital pin as an output. 
+  pinMode(OUTPIN, OUTPUT); 
+
+https://riptutorial.com/
+
+71
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+} 
+
+void loop() 
+{ 
+    if (ledTime >= PERIOD) 
+    { 
+        ledState = !ledState; 
+        digitalWrite(OUTPIN, ledState); 
+        ledTime = 0; 
+    } 
+    // do other stuff here 
+}
+
+You can see in the example that the ledTime object is assigned zero when the LED pin was 
+toggled. This might not be surprising at first glance, but it has an effect if more time-consuming 
+things are happening:
+
+Consider a situation where the comparison between ledTime and PERIOD is done after 750 
+milliseconds. Then setting ledTime to zero means that all following toggle operations will be 250 ms 
+"late". If, in contrast, PERIOD was subtracted from ledTime, the LED would see one short period and 
+then continue blinking as if nothing happened.
+
+Non-blocking blinky with millis()
+
+This is very close to an example from the arduino docs:
+
+// set constants for blinking the built-in LED at 1 Hz 
+#define OUTPIN LED_BUILTIN 
+#define PERIOD 500  // this is in milliseconds 
+
+int ledState = LOW; 
+
+// millis() returns an unsigned long so we'll use that to keep track of time 
+unsigned long lastTime = 0; 
+
+void setup() { 
+  // set the digital pin as output: 
+  pinMode(OUTPIN, OUTPUT); 
+} 
+
+void loop() { 
+  unsigned long now = millis(); 
+  if (now - lastTime >= PERIOD) // this will be true every PERIOD milliseconds 
+  { 
+    lastTime = now; 
+    if (ledState == LOW) 
+    { 
+      ledState = HIGH; 
+    } 
+    else 
+    { 
+      ledState = LOW; 
+    } 
+    digitalWrite(OUTPIN, ledState); 
+  } 
+
+  // now there's lots of time to do other stuff here 
+
+https://riptutorial.com/
+
+72
+
+ 
+ 
+ 
+ 
+ 
+ 
+}
+
+Using millis() in this way - to time operations in a non-blocking way - is something that is needed 
+quite frequently, so consider using the elapsedMillis library for this.
+
+Measure how long something took, using elapsedMillis and elapsedMicros
+
+#include <elapsedMillis.h> 
+
+void setup() { 
+  Serial.begin(115200); 
+  elapsedMillis msTimer; 
+  elapsedMicros usTimer; 
+
+  long int dt = 500; 
+  delay(dt); 
+
+  long int us = usTimer; 
+  long int ms = msTimer; 
+
+  Serial.print("delay(");Serial.print(dt);Serial.println(") took"); 
+  Serial.print(us);Serial.println(" us, or"); 
+  Serial.print(ms);Serial.println(" ms"); 
+} 
+
+void loop() { 
+}
+
+In this example, an elapsedMillis object and an elapsedMicros object are used to measure how 
+long something took, by creating them just before the expression we want to time is executed, and 
+getting their values afterwards. They will show slightly different results, but the millisecond result 
+won't be off by more than one millisecond.
+
+More than 1 task without delay()
+
+If you have more than 1 task to execute repeatedly in different intervals, use this example as a 
+starting point:
+
+unsigned long intervals[] = {250,2000}; //this defines the interval for each task in 
+milliseconds 
+unsigned long last[] = {0,0};           //this records the last executed time for each task 
+
+void setup() { 
+  pinMode(LED_BUILTIN, OUTPUT); //set the built-it led pin as output 
+  Serial.begin(115200);         //initialize serial 
+} 
+
+void loop() { 
+  unsigned long now = millis(); 
+  if(now-last[0]>=intervals[0]){ last[0]=now; firstTask(); } 
+  if(now-last[1]>=intervals[1]){ last[1]=now; secondTask(); } 
+
+  //do other things here 
+} 
+
+https://riptutorial.com/
+
+73
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+void firstTask(){ 
+  //let's toggle the built-in led 
+  digitalWrite(LED_BUILTIN, digitalRead(LED_BUILTIN)?0:1); 
+} 
+
+void secondTask(){ 
+  //say hello 
+  Serial.println("hello from secondTask()"); 
+}
+
+To add another task to execute every 15 seconds, extend the variables intervals and last:
+
+unsigned long intervals[] = {250,2000,15000}; 
+unsigned long last[] = {0,0,0};
+
+Then add an if statement to execute the new task. In this example, I named it thirdTask.
+
+if(now-last[2]>=intervals[2]){ last[2]=now; thirdTask(); }
+
+Finally declare the function:
+
+void thirdTask(){ 
+  //your code here 
+}
+
+Read Time Management online: https://riptutorial.com/arduino/topic/4852/time-management
+
+https://riptutorial.com/
+
+74
+
+ 
+Chapter 25: Using Arduino with Atmel Studio 
+7
+
+Remarks
+
+Setup
+
+•
+•
+
+Download and install Atmel Studio 7 from here.
+Purchase a debugger. You can get by with a ISP programmer, but if you want debugging 
+capabilities, which is one of the big advantages of using Atmel Studio, you will want a 
+debugger. I recommend the Atmel ICE, as it provides debugging capabilities for AVR based 
+arduinos (like the Uno, pro mini, etc) and the ARM based Arduinos, such as the Zero and 
+Due. If you are on a budget, you can get it without the plastic case and be careful not to 
+shock it.
+
+Connections
+
+•
+
+For the Uno, use the 6-pin ICSP cable. Plug one side into the Uno as shown. Plug the other 
+side into the debugger's AVR port.
+
+https://riptutorial.com/
+
+75
+
+For the Arduino Pro Mini, use the mini squid cable as shown, again connecting the other side the 
+debugger's AVR port.
+
+https://riptutorial.com/
+
+76
+
+Debugging considerations
+
+For debugging with the Uno, you will need to cut the Reset-enable trace (you can always solder it 
+back for using with the Arduino IDE):
+
+https://riptutorial.com/
+
+77
+
+Using the Pro Mini, if you intend to connect the serial port to your computer using an FTDI board, 
+do not connect the DTR line, as it will interfere with Atmel's Serial Wire Debug (SWD) interface. I 
+simply connect power, ground, Tx and Rx as shown here below. Rx and Tx on Arduino go to Tx 
+and Rx, respectively on FTDI board. Some FTDI boards are labeled differently, so if the serial port 
+doesn't work, swap Rx and Tx.
+
+https://riptutorial.com/
+
+78
+
+You will have to provide power separately to the Arduino because the debugger will not power it. 
+This can be done on the Pro Mini through the FTDI board as shown above, or with a USB cable or 
+AC adaptor on the Uno.
+
+Software setup
+
+Plug the Atmel ICE into your computer, start Atmel Studio and you can now import an existing 
+Arduino project.
+
+In Atmel Studio, go to File -> New -> Project and select "Create project from Arduino sketch". Fill 
+out options including board and device dropdown menus.
+
+Go to Project -> yourProjectName Properties, click on Tool, select Atmel ICE under 
+debugger/programmer and debugWire under interface. Go to Debug -> Start debugging and 
+
+https://riptutorial.com/
+
+79
+
+break. You should see a warning and be asked if you want to set the DWEN fuse. Choose OK, 
+unplug the Arduino from power and plug it in again. You can stop debugging by clicking the red 
+square button and start by clicking the green triangle button. To return the Arduino to a state that it 
+can be used in the Arduino IDE, while you're debugging, choose Debug -> disable debugWIRE 
+and close.
+
+Note that any functions you add must include a function prototype as well (loop and setup don't 
+need them). You can see the ones Atmel Studio added at the top of the sketch if there were any 
+functions when you imported your project into Atmel Studio (see sample code for example).
+
+C++11 support is enabled by default in Arduino 1.6.6 and above. This provides more C++ 
+language features and enabling it may increase compatibility with the Arduinio system. To enable 
+C++11 in Atmel Studio 7, right click on your project file, select properties, click on ToolChain on 
+the left, Click on Miscellaneous under AVR/GNU C++ Compiler and put -std=c++11 in the Other 
+flags field.
+
+To include libraries in your sketch
+
+Copy the .cpp library file into C:\Users\YourUserName\Documents\Atmel 
+Studio\7.0\YourSolutionName\YourProjectName\ArduinoCore\src\core, then in Atmel Studio, open the 
+Solution Explorer window right click on the Arduino Core/src/core folder, choose add -> existing 
+item and choose the file you added. Do the same with the .h library file and the 
+YourProjectName/Dependancies folder.
+
+To add the terminal window
+
+You can always have the Android IDE open and use that Serial window (just select the correct 
+serial port), however to add a built in Serial window to Atmel Studio, go to Tools -> Extensions and 
+Updates, click on Available downloads and search for Terminal Window or Terminal for Atmel 
+Studio and install it. Once installed, go to View -> Terminal Window.
+
+Benefits
+
+Programming Arduino with a moder IDE like Atmel Studio 7 gives you numerous advantages over 
+the Arduino IDE, including debugging, autocompletion, jump to definition and declaration, 
+forward/backward navigation, bookmarks and refactoring options to name a few.
+
+You can configure key bindings by going to Tools -> Options -> Environment -> Keyboard. Some 
+that really speed up development are:
+
+•
+•
+•
+•
+
+Edit.CommentSelection, Edit.UncommentSelection
+View.NavigateForward, View.NavigateBackward
+Edit.MoveSelectedLinesUp, Edit.MoveSelectedLinesDown
+Edit.GoToDefinition
+
+https://riptutorial.com/
+
+80
+
+Examples
+
+Atmel Studio 7 imported sketch example
+
+This is an example of what a simple Arduino sketch looks like after being imported into Atmel 
+Studio. Atmel Studio added the auto generated sections at the top. The rest is identical to the 
+original Arduino code. If you expand the ArduinoCore project that was created and look in the src -
+> core folder, you will find main.cpp, the entry point for the program. There you can see the call to 
+the the Arduino setup function and a never ending for loop that calls the Arduino loop function over 
+and over.
+
+/* Begining of Auto generated code by Atmel studio */ 
+#include <Arduino.h> 
+/* End of auto generated code by Atmel studio */ 
+
+// Beginning of Auto generated function prototypes by Atmel Studio 
+void printA(); 
+// End of Auto generated function prototypes by Atmel Studio 
+
+void setup() { 
+  Serial.begin(9600); 
+} 
+
+void loop() { 
+    printA(); 
+} 
+
+void printA() { 
+    Serial.println("A"); 
+}
+
+Read Using Arduino with Atmel Studio 7 online: https://riptutorial.com/arduino/topic/2567/using-
+arduino-with-atmel-studio-7
+
+https://riptutorial.com/
+
+81
+
+ 
+ 
+ 
+ 
+ 
+Chapter 26: Variables and Data Types
+
+Examples
+
+Create variable
+
+To create a variable:
+
+variableType variableName;
+
+For example:
+
+int a;
+
+To create a variable and initialize it:
+
+variableType variableName = initialValue;
+
+For example:
+
+int a = 2;
+
+Assign value to a variable
+
+If you have a variable declared before, you can assign some value to it:
+
+For example:
+
+int a;  // declared previously 
+a = 2;
+
+Or change the value:
+
+int a = 3;  // initalized previously 
+a = 2;
+
+Variable types
+
+•
+•
+•
+•
+
+•
+•
+
+char : signed 1-byte character value
+byte : unsigned 8-bit integer
+int : signed 16-bit (on ATMEGA based boards) or 32-bit (on Arduino Due) integer
+unsigned int : unsigned 16-bit (on ATMEGA based boards) or 32-bit (on Arduino Due) 
+integer
+long : signed 32-bit integer
+unsigned long : unsigned 32-bit integer
+
+https://riptutorial.com/
+
+82
+
+•
+•
+
+float : 4-byte floating point number
+double : 4-byte (on ATMEGA based boards) or 8-byte (on Arduino Due) floating point number
+
+Examples:
+
+char a = 'A'; 
+char a = 65; 
+
+byte b = B10010; 
+
+int c = 2; 
+
+unsigned int d = 3; 
+
+long e = 186000L; 
+
+unsigned long f = millis(); // as an example 
+
+float g = 1.117; 
+
+double h = 1.117;
+
+Read Variables and Data Types online: https://riptutorial.com/arduino/topic/2565/variables-and-
+data-types
+
+https://riptutorial.com/
+
+83
+
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+Credits
+
+S. 
+No
+
+1
+
+2
+
+3
+
+4
+
+5
+
+6
+
+7
+
+8
+
+9
+
+Chapters
+
+Contributors
+
+Getting started with 
+arduino
+
+Abhishek Jain, Christoph, Community, Danny_ds, Doruk, 
+geek1011, gmuraleekrishna, H. Pauwelyn, jleung513, Martin 
+Carney, Mizole Ni, Shef, uruloke, Wolfgang
+
+Analog Inputs
+
+Jake Lites, MikeS159, Ouss4, uruloke
+
+Arduino IDE
+
+geek1011, Jeremy, jleung513, sohnryang, uruloke
+
+Audio Output
+
+Jake Lites, MikeCAT
+
+Bluetooth 
+Communication
+
+Girish, Martin Carney
+
+Data Storage
+
+Danny_ds, robert
+
+Digital Inputs
+
+Martin Carney, uruloke
+
+Digital Output
+
+uruloke
+
+Functions
+
+datafiddler, Leah, MikeCAT
+
+10 Hardware pins
+
+Jeremy, Martin Carney
+
+11
+
+12
+
+How Python 
+integrates with 
+Arduino Uno
+
+How to store 
+variables in 
+EEPROM and use 
+them for permanent 
+storage
+
+Danny_ds, Peter Mortensen, Stark Nguyen
+
+AZ Vcience, Chris Combs, Danny_ds, Jeremy, Peter Mortensen
+, RamenChef
+
+13
+
+I2C Communication
+
+Asaf
+
+14
+
+Interrupts
+
+DavidJ, Martin Carney
+
+15
+
+Libraries
+
+Oscar Lundberg
+
+16
+
+Liquid Crystal Library Morgoth
+
+17
+
+Loops
+
+datafiddler, Martin Carney, MikeCAT
+
+https://riptutorial.com/
+
+84
+
+18 MIDI Communication Rich Maes
+
+19
+
+PWM - Pulse Width 
+Modulation
+
+Danny_ds, Johnny Mopp, JorgeGT, Martin Carney
+
+20 Random Numbers
+
+Danny_ds, Javier Rizzo Aguirre, MikeCAT
+
+21
+
+Serial 
+Communication
+
+blainedwards8, Danny_ds, geek1011, Leah, Martin Carney, 
+MikeS159, Morgoth, Nufail Achath, Peter Mortensen, uruloke
+
+22 Servo
+
+geek1011, mactro, Morgoth
+
+23 SPI Communication
+
+Christoph
+
+24
+
+Time Management
+
+Christoph, Rei
+
+25
+
+26
+
+Using Arduino with 
+Atmel Studio 7
+
+Variables and Data 
+Types
+
+Danny_ds, Nate
+
+Leah, MikeCAT
+
+https://riptutorial.com/
+
+85
+
+
\ No newline at end of file