35 Week Arduino Class - Best Arduino Training Available

brought to you by HackerSpace Tech

The 35 week Arduino Class series is a series of free weekly classes held at HackerSpace Tech meetups. The material used in these free meetups comes from Arduino Step By Step Arduino Training which has 20 hours of content in 110 lectures. This is definitely the best arduino workshop offered anywhere. In this Arduino workshop series you will learn how to create electronic projects with the Arduino, the world's friendliest electronics prototyping platform. Here is what you will learn in this arduino training:

What Will You Learn With This Arduino Training?

  • Program the Arduino prototyping platform
  • Understand and use many types of sensors and components
  • Use tools to build electronic devices
  • Understand the principles of programming micro-controllers
  • Connect your Arduino to the Internet for reporting and controlling
  • Understand basic principles in electronics design

Who is the Arduino class for?

  • Anyone with a curiosity for making electronics
  • People with no experience in electronics
  • People with an intermediate knowledge of electronics
  • Children over 12 years old (or younger with supervision)

If you are unable to attend the HackerSpace Tech meetups or you would like to access the class material from outside the physical meetup time and location then you will need join HackerSpace Tech meetup group and watch for the private link that will be posted on the day of the class. This link will give you access to the videos for the duration of the class. If you would like to have 24x7 access to the course along with email support we offer you two options.

  1. Purchase from Udemy
  2. Purchase from Teachables (click here for Teachables coupon).
** The price on Udemy is normally $150 but they have sales that you want to watch for. The price on Teachables is $50 (minus) the coupon currently available on Hackerspace tech.

 

See our Meetup Calendar for class schedule. Students can drop in and have the option to work independently if they want to review past classes or work ahead.

The first session of the Arduino workshop series will focus on a general overview of the Arduino and it's echo system

Presentations:
  • The Arduino ecosystem. (7:45)
    The Arduino ecosystem is made up of these parts:
    1. The Arduino board
    2. The Arduino IDE
    3. The Arduino core software library ("Arduino language")
    4. Third party software libraries
    5. Shields
    6. Components
    This arduino lesson looks into these parts of the Arduino ecosystem.
  • Tools and prototyping workflow (7:45)
    In this lecture I will show you the tools and process involved in prototyping with the Arduino.
    Topics Covered:
    1. The prototyping process
    2. Multimeters
    3. Solderless Breadboards
    4. Jumper wires
    5. Power supplies
  • Let's make a light blink! (11:35)
    In this lecture, I discuss the Light Emitting Diode (LED), and make one blink on and off in our first Arduino sketch. I also discuss the structure of an Arduino sketch, and specifically functions and variables.
  • Make the LED fade on and off (5:45)
Parts Needed:

The second and third weeks of Arduino Class will focus on a wide range of sensors you can use with the Arduino to sense the physical environment

Presentations:
  • About Sensors (3:03)
    This is a short introduction to the world of sensors. I enumerate the sensors that I'll be showing you in this section, and then get straight into it!
  • Measuring Light (8:29)
    In this lecture, you will learn about how to detect and measure light using a photo-resistor. You will also learn about a common technique in electronics, the voltage divider. You will put all this in practice in a simple Arduino circuit.
  • Temperature and humidity (7:09)
    In this presentation you will learn how to measure temperature and humidity. To do this, we will use a sensor from the DHT family of temperature and humidity sensors. You will also learn about the dielectric property of certain materials, and of how to include an external software library to your Arduino sketch.
  • Barometric pressure sensors (7:11)
    This presentation discusses barometric pressure and how you can measure it with the BPM085 sensor. You will also learn about the I2C communications interface that this sensor uses to communicate with the Arduino.
    PLEASE NOTE: A new sensor, BMP180, has been release as a drop-in replacement of the BPM085. The new device is a drop-in replacement of the old, so you can use the exact same connections schematic and library as described in this presentation. Also, Adafruit has released a new version of the library, compatible with both BPM085 and BPM180 with new useful features; I will be creating a new presentation showing how to use the new library.
  • Infrared motion sensors (9:04)
    In this presentation, we will connect a passive infrared sensor to our Arduino, calibrate it, and turn an LED on every time motion is detected. We also discuss the different technologies used to detect motion.
Parts Needed:
Presentations:
  • Ultrasonic distance sensor (10:11)
    In this presentation you will learn about how to measure distance using an ultrasonic distance sensor. This is a fairly sophisticated sensor that carries out a quite involved function when it comes to the physics of its implementation, however, as you will see, its application is as simple as it can be. You will also learn how to use a more advanced function of the Arduino language, the pulseIn function, through which you can time external events.
  • Detecting acceleration (6:22)
    In this presentation, you will learn how to use a common 3-axis accelerometer, the ADXL335, to accurately measure the acceleration applied to an object. At the end of the presentation, you will be invited to create your first non-trivial circuit using this accelerometer.
  • Line sensor (infrared) (3:36)
    In this presentation, we look at the infrared line sensor, a sensor that can detect the reflection of infrared light that it emits of nearby objects. Sensors like this are used in toy robots, for detecting colour, tracking objects, even in measuring pulse in medical equipment.
  • Tilt and impact (8:54)
    In this presentation, you will learn how to use a simple sensor that can detect the shock of an impact or being upside down. Even though in an earlier presentation we learned about the accelerometer, a sensor that can give us a lot of details about impact and the forces applied to it from which we can derive information about orientation, sometimes our needs are simple enough no not warrant using something as sophisticated as that. A simple switch that engages depending on its orientation or if something hits it is enough in such cases.
Parts Needed

The next two Arduino Lessons will be focusing on interacting with the Arduino

Presentations:
  • Buttons (6:18)
    In this class you will learn how to use a push button. You will assemble a circuit where pressing a button turns on an LED. You will also learn about the different kinds of buttons that you can use in your projects.
  • Potentiometer (7:26)
    In this class you will learn how to use a potentiometer. You will learn how potentiometers work, and what Pulse Width Modulation is, avery useful feature in some of Arduino's digital pins (which we have used in an earlier lecture but did not explain).
  • The flex sensor (4:52)
    In this class you will learn how to use a flex sensor, a device for which the resistance changes when it is bent.
  • Membrane potentiometer (4:12)
    In this class you will learn how to use a membrane potentiometer, a device electricaly similar to a regular rotary potentiometer but where instead of rotating a knob in order to change the resistance of the middle pin, you can slide your finger over the sensor's surface.
  • Making noise with a passive buzzer (5:26)
    Generating simple tones with this little buzzer is very easy. In this lecture you'll learn how.
Parts Needed:
Presentations:
  • Keypad, Part 1: Introduction (4:05)
    In this presentation, I will demonstrate how to connect a common 4x4 membrane keypad that contains numbers, letters “A”, “B”, “C”, and “D”, a “*” and a “#”. I will do it in two ways. First, I'll use the keypad library that comes with the Arduino IDE in a sketch that reads the keypad, while the keypad is connected in parallel. In demo 2 you learn how to hack together a solution that allows a connection that uses a single signal pin.
  • Keypad, Part 2: Parallel connection wiring (12:15)
    In this presentation, I will demonstrate how to connect a common 4x4 membrane keypad that contains numbers, letters “A”, “B”, “C”, and “D”, a “*” and a “#”. I will do it in two ways. First, I'll use the keypad library that comes with the Arduino IDE in a sketch that reads the keypad, while the keypad is connected in parallel. In demo 2 you will learn how to hack together a solution that allows a connection that uses a single signal pin.
  • Keypad, Part 3: Parallel connection sketch (5:10)
    This is Part 3 of 5 of the keypad presentation. Here I describe the sketch that works with the parallel wiring of the keypad. This configuration was demonstrated in Part 2.
  • Keypad, Part 4: Single wire connection (12:24)
    This is Part 4 of 5 of the keypad presentation. Here I describe an alternative way to connect the keypad that only uses one signal wire. The single wire configuration concludes in Part 5.
  • Keypad, Part 5: Single wire connection conclusion (11:30)
    This is Part 5 of 5 of the keypad presentation. Here I conclude the discussion of the single wire connection configuration.
Parts Needed:
Presentations: Parts Needed:
Presentations:
  • Fingerprint sensor Part 1: About (5:40)
    This sensor is internally a sophisticated device, that contains a 32-bit microprocessor dedicated to do digital signal processing of fingerprint images.
    A library developed by Adafruit makes this sensor very easy to use with the Arduino. Connect it to your Arduino using serial or software serial pins, and you can start enrolling and recognising fingerprints within minutes.
    In this first part of the arduino training, I discuss the device and its features.
  • Fingerprint sensor Part 2: Wiring, registering, recognizing (10:30)
    In this second part, you will learn how to connect the device to the Arduino and enroll and recognise fingerprints using a couple of the included sketches.
  • Fingerprint sensor Part 3: Demo app with an electric lock (7:35)
    In this third part you learn a small demo application that involves an electric door lock. I use the fingerprint sensor to energise the coil in the door lock and grand or deny access to my lab (when eventually the lock is installed to my door).
Parts Needed:
Presentations:
  • LCD character screen, Part 1 (14:40)
    In part 1, you will learn how to wire up the screen and display a message on it.
  • LCD character screen, Part 2 (6:51)
    In this arduino workshop, we expand the project from part 1 by adding a DHT22 sensor and displaying its readings to the screen.
  • Single data wire LCD and I2C, Part 1 (15:40)
    In the LCD Arduino Training, you learned how to display text in a LCD screen. Although this was a simple way to show useful information to the user, the sheer number of wires required to make the LCD screen work makes this solution far from elegant.
    In this Arduino Class, you will learn a much improved solution to the same problem, one that involves a single data wire (plus power).
    To achieve this reduction in total number of wires we have to switch the type of interface we use to connect the screen to the Arduino. Natively, the screen uses a parallel interface, where each of the 8 bits that make up a character encoding uses up a wire. In the previous class we used a 4-bit parallel mode instead of the full 8-bits in order to save 4 wires. Still, even 4 wires are too many for transferring data. We also needed wires for power, and for the screen backlit.
    To improve the design, we'll use an adaptor that allows us to connect the parallel LCD screen to the Arduino using the I2C serial bus.
    The adapter I'll use in the demos is the 1602LCD Display I2C board
  • Single data wire LCD and I2C, Part 2 (7:40)
    In this Part 2, you will learn how to connect a second I2C device to the circuit from Demo 1. The second device is a real-time clock.
Parts Needed:
Presentations:
  • LCD TFT Screens (15:40)
    In this class you learn how to add a TFT LCD screen to your Arduino project in order to produce colourful text and shapes. The lesson contains two demos in which you learn one of the common TFT LCD shields. In the first one, you learn how to use the screen itself, while in the second how to use the 5-button joystick that is integrated into the screen shield.
Parts Needed:
Presentations:
  • Seven Segment LED Displays, Part 1: Intro and assembly (11:31)
    In this Arduino Class, we will build on our knowledge from the Arduino class on the Shift register. In that class, you learned how to use a shift register in order to control multiple LEDs using only three wires: one for data, one for clock, and one for the latch. Because there are so many SSD out there, I will assume that you don't have your particular display's datasheet and have no idea which pin controls the pins. I will describe the process of figuring out the correct wiring and then constructing the numerical symbols in the sketch.
    Please consider watching the videos on Shift Registers if you are not familiar with this component as it is central to driving the seven-segment display. The arduino workshop on shift registers is in the section titled "Integrated Circuits Peripherals"
  • Seven Segment LED Displays, Part 2: Sketch (14:32)
Parts Needed:
Presentations: Parts Needed:
Presentations:
  • Direct Current Motors Part 1 (17:30)
    In this presentation you will learn how to use a DC motor through a series of demos. All involve two geared DC motors (why use just one when we can use two?) and a motor break-out circuit. I'll explain what these are in a minute. Here's what we are going to build in this presentation:
  • Direct current motors, Part 2 (7:50)
    In this part, you will learn about how to control the speed and direction of rotation of a motor using a potentiometer.
  • Direct current motors, Part 3 (11:55)
    In this part, you will learn about how to control the speed and direction of rotation of a motor using an ultrasonic distance sensor. After that, you could go ahead and design your fist autonomous driving vehicle.
Parts Needed
Presentations:
  • Servo motors Part 1 (15:10)
    In this presentation, we will learn about how to use a servo motor. We will use both the build-in servo motor library that comes standard with the Arduino IDE, and a third party library that adds a bunch of very useful features.
  • Servo motors, Part 2 (11:48)
    In part 2 you will learn how to use a third party library that adds a bunch of very useful features on top of what is available through the build-in servo library
Parts Needed:
Presentations: Parts Needed:
Presentations:
  • The Ethernet shield, Part 1 (23:55)
    In this 2-part presentation you will learn how to get your Arduino gadget to speak to the Internet! In part 1, you will learn how to connect your Ethernet shield, and how to make your Arduino part of your local network. Specifically, you will be shown how to connect to the network by automatically acquiring an IP address via DHCP, or how to acquire an IP address manually.
    In this presentation, I use the original Arduino Ethernet shield that is based on the w5100 chip. Ethernet shields with the w5200 chip are more common these days. To use a w5200-based shield, you will need to download the Ethernet_V2 library and use it instead of the one I use in the presentation. I link to Seedstudio which contains this library is available in the external resources.
  • The Ethernet shield, Part 2 (14:15)
    In this 2nd part, you will learn how to turn on and off an LED, and to read light intensity through a Telnet connection to your Arduino from your computer.
Parts Needed:
Presentations: Parts Needed:
Presentations:
  • An Arduino controlling web server (25:15)
    In this presentation, you will learn how to setup a web server on the Arduino that allows you to control LEDs via a web browser. You could replace the LEDs for other devices, like motors, without having to introduce significant changes to the sketch we'll see here. We will do this in the next presentation.
    First we will look at the HTTP request parsing issues that we will need to deal with before implementing the controlling web server sketch. Because the web browser will be sending information with instructions to the Arduino, the Arduino's web server HTTP parser will have a lot more work to do.
  • Controlling a motor with a web browser (16:30)
    In this presentation, you'll learn how to send HTTP GET requests that contain values other than 1s and 0s as we did in the previous presentations. To do that I will demonstrate how you can control a DC motor through your web browser. Motor control requires sending direction and speed values to the Arduino from your web browser, and this adds realism to our controlling web server.
Parts Needed:
Presentations:
  • Web logging to Nimbits, Part 1 (9:00)
    In this arduino class you will learn how to use a cloud logging service, Nimbits, to record your Arduino's sensor data. Nimbits is one of several such services, but I prefer it to others because it is fully open-source software, which means that you can even setup your own logging server with Nimbits.
  • Web logging to Nimbits, Part 2 (18:35)
    In part 2, I will walk through the logging sketch and post photo-resistor values to Nimbits.
    IMPORTANT PLEASE READ BEFORE WATCHING THIS LECTURE:
    Nimbits has released a new version of their API which has rendered part of this lecture out of date.
    I have updated the sketch on Github so that it works with the latest changes in Nimbits.
    Please read the notes in the root of the folder on Github, there's a couple of things worth knowing about the changes. The code is still fairly simple. (The link to the sketch on Github is below)
  • Social logging to Twitter (16:25)
    In this presentation I you will learn how to post your Arduino sensor data to Twitter using the arduinoTweet proxy server and library. You can setup your own instance of this proxy on your own server (you can use a free virtual server on Google's App Engine cloud service) so that you can control privacy and access, or use public instances like arduino-tweet.appspot.com or my own asbs-twitter.appspot.com.
    In this presentation, you will learn how to set up your tweeting Arduino using asbs-twitter.appspot.com as the proxy. In the first demo, you will learn about getting the first tweet out there, and in the second, to post sensor data.
Presentations:
  • Wireless connectivity with Bluetooth, Part 1 (12:30)
    In this presentation, you will learn how to use a Bluetooth breakout board to create a wireless serial connection between your computer and your Arduino. With this connection, your Arduino will be able to send and receive data to and from your computer.
    In this part I discuss some basic concepts around Bluetooth, and compare with other wireless technologies, then in demo 1, I demonstrate how to connect the breakout board with the Arduino and establish a serial channel.
  • Wireless connectivity with Bluetooth, Part 2 (9:50)
    In the second part there are 2 demos. In the first demo, I show how to do 2-way communication, and in the second demo I how to use software serial (instead of hardware serial as in demos 1 and 2).
Parts Needed:
Presentations:
  • Wifi connectivity, Part 1 of 4 (2:40)
    For this lecture, I chose the Adafruit CC3000 breakout board, wit)h an on-board ceramic antenna. This product also is It comes as a shield, and with a connector for an external antenna if you need extended range. At around $35, it offers 802.11a/g connectivity, very small size, a nice library, and lots of documentation.
  • Wifi connectivity, Part 2 of 4 (25:25)
    In this part you will learn how to create a Wifi web client, whereby the Arduino will be polling a URL, and fetching a file contains instructions for turning an LED on or off. The polling method has an advantage over the web server method because it is not affected by firewall or NAT restrictions. This means that by polling an external URL to your local network, you will be able to control your Arduino from anywhere in the Internet without having to configure your router to allow access to the Arduino from the outside world.
  • Wifi connectivity, Part 3 of 4 (19:34)
    In this part you will learn how to create a Wifi web client, whereby the Arduino will be polling a URL, and fetching a file contains instructions for turning an LED on or off. The polling method has an advantage over the web server method because it is not affected by firewall or NAT restrictions. This means that by polling an external URL to your local network, you will be able to control your Arduino from anywhere in the Internet without having to configure your router to allow access to the Arduino from the outside world.
  • Wifi connectivity, Part 4 of 4 (6:59)
    In this part you will learn an adapted version of Demo 2 from the Ethernet lecture, where we had a web server running on the Arduino, showing us a simple user interface through which we could turn an LED on and off
  • Wifi connectivity: upgrading your CC3000 module (10:06)
    In this lecture, you will learn how to upgrade the firmware in your CC3000. It is an easy process: connect your CC3000 module to your Arduino just like you did in the other CC3000 lectures, and run the upgrade sketch from the Arduino IDE v1.0.6 or earlier.
Parts Needed:
Presentations:
  • Using the NRF24L01+ transceiver module (20:16)
    In this class you will learn how to use the cheap and reliable NRF24L01+ transceiver module. With this module you can achieve reliable point to point communications. We are showing you the basics so you can go on creating sophisticated wireless systems, including mesh sensor arrays!
Parts Needed:
Presentations:
  • Bluetooth Low Energy Part 1: About BLE (12:05)
    In this 4-part presentation I discuss Bluetooth Low Energy (BLE). It is a relatively new member of the Bluetooth standard, and has been responsible for the emergence of countless low-power mobile and wireless devices, like activity trackers, wireless headphones, lost item locators etc.
  • Bluetooth Low Energy Part 2: The Adafruit nRF8001 module (4:50)
    In this 2nd part, I discuss the Adafruit nRF8001 BLE module, and wire it to my Arduino.
  • Bluetooth Low Energy Part 3: UART demos (13:10)
    In this 3rd part, I demonstrate the Adafruit nRF8001 BLE module using the demo sketches that ship with the Adafruit library.
  • Bluetooth Low Energy Part 4: Firmata demo (7:45)
    In this 4th part, I discuss the Firmata protocol, a popular way to control an Arduino remotely via various kinds of data transport technologies. I demonstrate how you can use an nRF8001 module to read and write state of the Arduino's pin.
Parts Needed:
SD cards have matured over the years. Their sizes have expanded to many gigabytes, and their prices have dropped to a few cents per gigabyte. Compared to build-in memory, SD cards offer a really good mass storage solution. On the Arduino, an SD card can be used with the appropriate hardware extension and with an easy to use library that comes with the IDE. Your Arduino Ethernet shield comes with a micro-SD card slot, but you can also get them as a separate breakout board. In this class, we will use a dedicated, small and cheap break-out board.
Presentations: Parts Needed:
EEPROM stands for “Electrically Erasable Programmable Read-Only Memory”, and you can use it to store data that must be preserved even after power is lost. You could use EEPROM to store configuration values for your sketch that the user can modify, passwords, sensor logs and things of that sort.
Presentations:
  • EEPROM (internal and external) Part 1: Basic use (10:58)
    In this first demo, we'll use two sketches to write and read a pin number for a basic security system. The writing sketch will write the default pin in a specific internal EEPROM memory location, and the reading sketch will simply go to that location and read back the pin. Keeping things simple, we are not going to worry about LCD screens, a keypad for the pin entry, or encryption for storing the pin securely.
  • EEPROM (internal and external) Part 2: the EEPROMex library (5:36)
    In this Lecture, I'll show you a way to abstract the way that data is written to and read from the EEPROM in a bid to speed up your personal productivity.
  • EEPROM (internal and external) Part 3: Using an external EEPROM (10:40)
    In this Lecture, I'll show you how to use the Atmel 24C256 chip, which provides 256KBytes of external EEPROM memory.
Parts Needed:
Presentations:
  • Hardware interrupts Part 1: Introduction (12:16)
    In this first demo, we'll take the circuit from the button class and only modify the sketch it so that the LED is lit as a response to an interrupt generated by the button, instead of by polling the state of the button a few million times per second.
  • Hardware interrupts Part 2: Using volatile variables (5:17)
    In the second demo, we'll add a volatile variable which the code in the interrupt request function will be able to access and update. This variable will keep track of the number of times that we have pressed on the button.
  • Hardware interrupts Part 3: Timers (5:08)
    In this demo, we'll make an LED blink by setting a timer to trigger an interrupt once every second.
  • Hardware interrupts Part 4: High-definition Pulse Width Modulation (6:09)
    The TimerOne library also contains several other useful functions that you can explore. One of them provides that ability to create very accurate PWM output. In this fourth demo, I'll show you how to use the TimerOne library to create a PWM pulse.
  • Using the built-in pull-up resistors (7:16)
    In this lecture, you will learn how to use the Atmega's internal pull-up resistor on it's output pins. This is a convenience feature that will save you from having to use external pull-up resistors.
Parts Needed:
Presentations:
  • Memory management Part 1: Introduction and Flash (5:49)
    This is Part 1, and it discusses ways to optimize the use of the Flash memory.
  • Memory Management Part 2: Static RAM (7:40)
    This is Part 2, and it discusses ways to optimize the use of the SRAM memory.
  • Power management with sleep mode and prescaling (23:35)
    In this arduino class, I will show you three ways by which you can extend the life of a battery so that your Arduino-powered device can operate for very long periods of time.
    First, by using a simple library called Narcoleptic, which makes it very easy to place the CPU of the Atmega to sleep mode.
    Second, we will look at the power down mode that is available in AVR microcontrollers by which we can achieve the maximum reduction in power consumption.
    Third, I will show you a technique that can further reduce power consumption in these applications for the periods of time when the microcontroller out of sleep mode. This technique is based on the ability of AVR microcontrollers to change their clock speed.
Parts Needed:
In this workshop, you will learn how to use shift registers to multiply the available digital outputs.
Presentations:

Parts used in this workshop:

The Arduino Uno has 14 digital I/O pins. That sounds a lot, but it isn't consider that all these pins are multi-functional, so that they are used for tasks other than pure input/output, like Pulse Width Modulation, serial and SPI communications. We saw in an earlier lecture, that shift registers can be used to provide us with additional digital outputs.
But what about additional digital inputs? In this lecture, you will learn how to use the MCP23017 IC to easily add a total of 16 digital I/O pins to your Arduino project.
Presentations: Parts Needed:
In this 2-part presentation, you will learn how to use a typical real time clock with your Arduino. We will be using the DFRobot DS1307 RTC breakout. This device, like many others, is based on the popular DS1307 clock IC, and it can do anything you would expect a good clock can do. It counts seconds, minutes, hours, days, years, goes up to 2100 and compensates for leap years.
In the first part, you will learn how to connect the RTC module to the Arduino, set the time, and read the time from it. In the second part, you will learn how to time-stamp sensor readings and store them in an SD card.
Presentations:
  • Real time clock, Part 1 of 2 (15:45)
    In this lecture you will learn how to connect the RTC module to the Arduino, set the time, and read the time from it. In Lecture part 2, I show how to time-stamp sensor readings and store them in an SD card.
  • Real time clock, Part 2 of 2 (7:44)
    In this lecture you will learn how to time-stamp sensor readings and store them in an SD card.
Parts Needed:
In this 5-part presentation, you will learn how to work with relays and connect large loads to your Arduino.
Presentations: Parts Needed
Presentations:
  • GPS Part 1: An introduction (8:32)
    In this presentation, we look at GPS. You will learn the basic features of the Adafruit Ultimate GPS Breakout module, version 3, which is based on the MTK3339 chipset. This is a very high-quality serial GPS system, supported by an excellent library. I also look at a much cheaper U-blox PCI-5S-1-500 PCI-E B39 MINI PCI-E Wireless Card GPS Module, which can also used with the Arduino by breaking out its serial pins with a couple of jumper wires (a complete lecture on this module will follow).
  • GPS Part 2: Wiring the Adafruit module for direct communication with computer (5:50)
    In this presentation, you will learn how to wire the Adafruit Ultimate GPS Breakout so that it communicates via USB serial with the computer, using an Arduino as a conduit. The Arduino is not doing any processing, instead the communication from the GPS module simply passes through it and to the computer.
  • GPS Part 3: Getting and using raw text data from the module(5:40)
    In this presentation, you will learn how the GPS module acquires satellite fix and then sends raw text data to the computer. You will learn how to use the GPS visualizer web tool to plot the data on a Google map, and also plot the coordinates of your location directly to a Google map.
  • GPS Part 4: Using the Adafruit GPS library (15:60)
    In this presentation, you will learn the basic features of the Adafruit GPS library.
    Two of the sketches that ship with the library will be demonstrated, and we will spend a bit of time looking into how they use timer interrupts to process and parse the GPS text output.
  • GPS Part 5: Using the TinyGPS+ library (7:52)
    In this presentation, we look at the TinyGPS+ library. It is very good alternative/complement to the Adafruit GPS library, with a very nice user/programming interface and compatabilty with a wide range of serial GPS modules.
The objective of this arduino class is to build a “bare bones” Arduino on a breadboard, understand the basic principles under which the fundamental components work, and use our new skills to make our our Arduino clones!
Being able to make your own Arduinos is useful from both a cost and practicality perspective. Say, for example, that you want to create a monitoring system for your home which includes 10 Arduino modules with sensors and some kind of wireless communication capability to a base station (also an Arduino). If you use the cheapest official Arduino, the Uno, you will need at least $300 just for that. The Uno also contains component that you don't need for your project, like the USB interface, the various headers, even the LEDs are not really needed (plus they consume power). You could build an Arduino clone with exactly the components you need for less than $10.
Presentations: Parts Needed:
In the presentation that follow you will be shown how to convert your breadboard circuit design into a professional-looking printed circuit board (PCB). The presentation uses the free PCB design software from Fritzing.
Once you design your PCB using Fritzing, you can upload it to one of many online PCB fabrication shops around the world. They will manufacture your PCB and send it in the mail within a few weeks of your order.
In preperation for this class you will want to download Fritzing
Presentations
Processing is a programming environment and framework optimised for graphics. It is easy to learn, and great for visualising data that come from your Arduino.
In the presentations that follow you will be shown how to create a user interface on your computer in which you visualise data transmitted from your Arduino via USB, and how to control an LED on the Arduino from your computer.

Presentations:
Parts Needed:
Resources
In these presentations you will learn how to manage your ever expanding projects by creating a library.
Presentations: Resources: