What Is Arduino? Learn Programming And Electronics With Arduino podcast

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

Tech Higher Education Programming Electronics Academy Podcasting Education

Player FM - Internet Radio Done Right

five 年前已添加！

内容由Programming Electronics Academy提供。所有播客内容（包括剧集、图形和播客描述）均由 Programming Electronics Academy 或其播客平台合作伙伴直接上传和提供。如果您认为有人在未经您许可的情况下使用您的受版权保护的作品，您可以按照此处概述的流程进行操作https://zh.player.fm/legal。

S

Species Unite

Species Unite podcast artwork

Species Unite podcast artwork

1
Andrew Stein: Living with Lions 46:39

8天之前46:39

46:39

“If we march into that village and we start trying to persecute people for using poison, something that's very illegal, nobody's going to talk to us. We're not going to find out where the poison came from. We're not going to be able to shut anything down. We should take the approach that people are using poison because they're desperate, because they see no other alternative.” – Andrew Stein Andrew Stein is a wildlife ecologist who spent the past 25 years studying human carnivore conflict from African wild dogs and lions in Kenya and Botswana to leopards and hyenas in Namibia. His work has long focused on finding ways for people and predators to coexist. He is the founder of CLAWS , an organization based in Botswana that's working at the intersection of cutting-edge wildlife research and community driven conservation. Since its start in 2014 and official launch as an NGO in 2020, CLAWS has been pioneering science-based, tech-forward strategies to reduce conflict between people and carnivores. By collaborating closely with local communities, especially traditional cattle herders, CLAWS supports both species conservation and rural livelihoods—making coexistence not just possible, but sustainable.…

Learn Programming and Electronics with Arduino « »
What is Arduino?

8年之前 4:24

分享

MP4•单集首页

内容由Programming Electronics Academy提供。所有播客内容（包括剧集、图形和播客描述）均由 Programming Electronics Academy 或其播客平台合作伙伴直接上传和提供。如果您认为有人在未经您许可的情况下使用您的受版权保护的作品，您可以按照此处概述的流程进行操作https://zh.player.fm/legal。

Have you seen some really cool stuff being made with a thing called Arduino? What is Arduino anyway?

It sounds like an Italian sandwich with extra cheese or something...

Well - it's that and a lot more. I hope this video can help explain some the basic premise of the Arduino!

… continue reading

61集单集

#Tech #Higher Education #Programming Electronics Academy #Podcasting Education

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

What is Arduino?

Learn Programming and Electronics with Arduino

published 8年之前

分享

MP4•单集首页

内容由Programming Electronics Academy提供。所有播客内容（包括剧集、图形和播客描述）均由 Programming Electronics Academy 或其播客平台合作伙伴直接上传和提供。如果您认为有人在未经您许可的情况下使用您的受版权保护的作品，您可以按照此处概述的流程进行操作https://zh.player.fm/legal。

Have you seen some really cool stuff being made with a thing called Arduino? What is Arduino anyway?

It sounds like an Italian sandwich with extra cheese or something...

Well - it's that and a lot more. I hope this video can help explain some the basic premise of the Arduino!

… continue reading

61集单集

#Tech #Higher Education #Programming Electronics Academy #Podcasting Education

Wszystkie odcinki

×

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Arduino Course for Absolute Beginners 2nd Edition 3:20

8 years之前3:20

3:20

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
What is Arduino? 4:24

8 years之前4:24

4:24

Have you seen some really cool stuff being made with a thing called Arduino? What is Arduino anyway? It sounds like an Italian sandwich with extra cheese or something... Well - it's that and a lot more. I hope this video can help explain some the basic premise of the Arduino!

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
How to change the font color in the Arduino IDE 4:55

8 years之前4:55

4:55

Have you ever wanted to change the font color in the Arduino IDE? Maybe it is hard for you to read the light grey comments in the Arduino IDE, or maybe you prefer something a little bolder. Whatever your reason, in this short video, I demonstrate a relatively easy way to change the font color of comments.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Use Serial.print() to display Arduino output on your computer monitor: Part 2 6:25

8 years之前6:25

6:25

In many cases while using an Arduino, you will want to see the data being generated by the Arduino. One common method of doing this is using the Serial.print() function from the Serial library to display information to your computer’s monitor. In this week’s episode we will talk about the intricacies of the Serial.print() function. This is the second part of a two part series on the Serial.print() function (Click here for the first part). Here are the exact topics we will cover in this lesson: Adjusting the number of digits to be displayed after the decimal point with the Serial.print() function. Adjusting the format to display with the Serial.print() function Formatting the output with text and tabs If you enjoyed this video, you should consider signing up for our free Arduino Crash Course - it has 19 high quality video training classes to help build your imagination with Arduino.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Use Serial.print() to Display Arduino output on your computer monitor: Part 1 8:36

8 years之前8:36

8:36

In many cases while using an Arduino, you will want to see the data being generated by the Arduino. One common method of doing this is using the Serial.print() function from the Serial library to display information to your computer’s monitor. In this week’s episode, we will talk about the intricacies of the Serial.print() function. This is the first part, of a two part series on the Serial.print() function. Here are the specific topics we will cover in this lesson: Why would you want to use the Serial.print() function? A brief overview of the Serial library The basic use of the Serial.print() function Like this video? Sign up for our FREE Arduino Crash Course to get more videos that don't assume you have a PhD. Why Would You Want to Use the Serial.print() Function? You may know that a function is a programming tool - it performs a specific task for you. The Serial.print() function’s task is to send information from your Arduino to your computer, so you can see the value displayed on your computer’s monitor. There are an endless number of reasons you may want to send information from the Arduino to a computer display, but two reasons really stand out to me: The first reason is being able to see information that you are generating with your Arduino. For example, if you have a temperature sensor hooked up to your Arduino and you want to see the value that the temperature sensor is recording, then you can use the Serial.print() function to send the data to a computer monitor via the USB cable. If you open up the serial monitor window (Tools > Serial Monitor), you will see the values streaming in from the Arduino. The other big reason to send information to a computer display using the Serial.print() function is for developing and debugging Arduino sketches. Very often, when you are developing an Arduino sketch, what you end up coding does something differently than what you expected it to do. Maybe you have a variable that gets incremented every so often and blinks an LED when it reaches a threshold. When you upload the code to the Arduino, you notice that the LED is blinking more often than it should. You can look at the code until your eyes bleed, but actually visualizing the variable being incremented [via the Serial.print() function], to see its values every time through the loop() can help explain what is happening very quickly. A Brief Overview of the Serial Library We can’t talk about the Serial.print() function, without briefly talking about the Serial library. Generally speaking, a library is simply a collection of functions that all have something in common. The print() function is part of a library called the Serial library. Now, it's not cereal like Cheerios or Captain Crunch we're talking about - it's serial as in “one after another”. The serial library allows us to interface the Arduino with other hardware, like a computer. In order for us to use the functions of the Serial library, we have to initiate serial communication - to do this we use the Serial.begin() function. Serial.begin() needs to go in the setup(). void setup() { //Initiate Serial communication. Serial.begin(9600); } Now for reasons beyond the scope of this discussion, it is convenient to use the number 9600 in the Serial.begin() function. The value 9600 specifies the baud rate. The baud rate is the rate at which information will pass from the Arduino to the computer, or in the other direction. The Basic Use of the Serial.print() Function Let's talk about how to use the Serial.print() function. Say we have a sketch. This sketch has a variable called coolFactor . I want to be able to monitor the value of the coolFactor variable – that is, I want it displayed on my computer screen. A perfect use for the Serial.print() function! The first thing we must do in the Arduino sketch is begin serial communications. Like we just said, we use the Serial.begin() function and place it within the setup() of the sketch. //A variable to hold the level of coolness int coolFactor = 3; void setup() { Serial.begin(9600); } void loop() { //Send the value of coolFactor to the the Serial port. //So we can see it in the serial monitor window Serial.print(coolFactor); } Now in the loop(), if I want to display coolFactor ’s value with print(), I simply type Serial.print() and in the parenthesis I type the variable name. If we upload this sketch to the Arduino, the value of coolFactor will be sent to the serial port every time through the loop(). In the Arduino IDE, if you open up the serial monitor window [Tools > Serial Monitor], you will see the values streaming down. In next week’s episode, we’ll talk about some more intricacies of the Serial.print() function. If you enjoyed this lesson, I welcome you to join 1000's of students who have enjoyed our free Arduino Crash Course - it's a 19 part video training series on using Arduino (You can sign up below).…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
How to make a secret knock detector to trigger anything with only an Arduino and a few cheap components 12:57

8 years之前12:57

12:57

There are a couple good use-case scenarios for making a secret knock detector using an Arduino. You are a spy who needs to authenticate your cohorts You are a super hero who wants a secret knock to open the entrance to your lair Whatever the reason - by the end of this tutorial you will know how to use an Arduino, a piezo transducer and a couple other cheap components to make secret knock detector. Here is an overview of exactly what we will talk about in this lesson: The components you will need and how to set up this simple circuit. The concept of operation of this secret knock detector A thorough description of each block of code in the Arduino sketch Why North American grizzly bears love piezo transducers For this secret knock detector circuit you need: Arduino (I use the Arduino Uno) [1] Solderless breadboard [1] 1 Mohm Resistor [1] Piezo transducer (aka buzzer) [1] Jumper wires [4] 5.1V Zener diode (for extra protection) [1] No spill stopper for a “to-go” coffee cup How to set up the Circuit: This is a really simple circuit to setup, below are step-by-step instructions and a breadboard diagram. Place the piezo transducer on the breadboard, with the positive lead and the negative lead on separate rails. Connect the positive lead to pin A0 on the Arduino and the other lead to ground. Finally, use the 1Mohm resistor to connect the leads of the piezo transducer. As an additional level of protection, you might consider adding a 5.1V zener diode between the leads to protect against high voltage spikes from frying your input pin - you might call it a cheap insurance policy. An Overview of this Secret Knock Detectors operation Here is the basic concept of how this will work. We want something to happen when you tap out a secret code. We will create a sequence of soft and hard taps - this will be our secret code which will be represented as 0’s and 1’s in an array . For example: secretKnock[secretKnockLength] = {0, 0, 1, 0}; The code above represents a secret code of soft , soft , hard, soft . The piezo transducer will turn the mechanical pressure created by the tap into a signal that the Arduino analog pin can read . The level of the signal will determine whether a tap gets characterized as soft or hard. The threshold of a soft vs hard tap need to be determined empirically, once you have the circuit built - it will depend on what you have the piezo transducer attached to - I have mine taped to a piece of paper. You should start with the default threshold values provided in the sketch and change them to suit your specific setup. Once a tap signal is picked up by the Arduino, the sketch will compare the entered sequence of taps to the secret code, one tap at a time. If the code is entered correctly, then we will trigger an action on the output pin. In this code below, we trigger an LED to turn on for a couple seconds - but you could trigger a servo arm, a pump, or whatever you might need. If the code is entered incorrectly - nothing happens. Here is the code for your hacking enjoyment: /* A simple sketch to detect a secret knock using a piezo transducer Created JUL 2015 by Michael James http://www.programmingelectronics.com/ This code is in the public domain */ const int outputPin = 6; // led indicator connected to digital pin const int knockSensor = A0; // the piezo is connected to an analog pin const int thresholdHIGH = 150; // threshold value to decide when the detected knock is hard (HIGH) const int thresholdLOW = 120; // threshold value to decide when the detected knock is gentle (LOW) const int secretKnockLength = 4; //How many knocks are in your secret knock /* This is the secret knock sequence * 0 represents a LOW or quiet knock * 1 represents a HIGH or loud knock * The sequence can be as long as you like, but longer codes increase the difficulty of matching */ const int secretKnock[secretKnockLength] = {0, 0, 1, 0}; int secretCounter = 0; //this tracks the correct knocks and allows you to move through the sequence int sensorReading = 0; // variable to store the value read from the sensor pin void setup() { //Set the output pin as an OUTPUT pinMode(outputPin, OUTPUT); //Begin Serial Communication. Serial.begin(9600); } void loop() { // read the piezo sensor and store the value in the variable sensorReading: sensorReading = analogRead(knockSensor); // First determine is knock if Hard (HIGH) or Gentle (LOW) //Hard knock (HIGH) is detected if (sensorReading >= thresholdHIGH) { //Check to see if a Hard Knock matches the Secret Knock in the correct sequence. if (secretKnock[secretCounter] == 1) { //The Knock was correct, iterate the counter. secretCounter++; Serial.println("Correct"); } else { //The Knock was incorrect, reset the counter secretCounter = 0; Serial.println("Fail - You are a spy!"); }//close if //Allow some time to pass before sampling again to ensure a clear signal. delay(100); //Gentle knock (LOW) is detected } else if (sensorReading >= thresholdLOW) { //Check to see if a Gentle Knock matches the Secret Knock in the correct sequence. if (secretKnock[secretCounter] == 0) { //The Knock was correct, iterate the counter. secretCounter++; Serial.println("Correct"); } else { //The Knock was incorrect, reset the counter. secretCounter = 0; Serial.println("Fail - You are a spy!"); }//close if //Allow some time to pass before sampling again to ensure a clear signal. delay(100); }//close if else //Check for successful entry of the code, by seeing if the entire array has been walked through. if (secretCounter == (secretKnockLength) ) { Serial.println("Welcome in fellow Illuminante!"); //if the sececret knock is correct, illuminate the LED for a couple seconds digitalWrite(outputPin, HIGH); delay(2000); digitalWrite(outputPin, LOW); //Reset the secret counter to 0. secretCounter = 0; }//close success check }//close loop If you enjoyed this lesson, you should join our free Arduino Crash Course - it has 19 Video Training lessons all about using Arduino (you can sign up below).…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Arduino Pseudo Random Non-Consecutive Number Generator 11:13

8 years之前11:13

11:13

In this video we demonstrate how to create pseudo random numbers with Arduino - with a useful twist. This lesson was inspired by the following viewer question: How do I create Random Non-Consecutive numbers with Arduino? P.S. These are the best tutorials that a complete idiot like you could ever make, thanks. -Chris Let's overview exactly what we will talk about in today's episode: Talk about pseudo random numbers. Identify the problem - using an Arduino sketch to demonstrate. Discuss how we might solve the problem. Write an Arduino sketch that solves the problem. Review what we talked about. Before we answer the viewer’s question it is important to talk about what a pseudo random number is. A purely random number in the mathematical sense can't be predicted. The microcontroller that the Arduino uses (and for that case, most computers in general) can't really create pure random numbers. What they create instead are called pseudo random numbers . These are numbers that appear to be randomly generated, but if studied over time a predictable pattern emerges. The bottom line is that the random numbers we create with Arduino can be predicted. Now there are clever ways to create pseudo random numbers that act like the real deal – you can learn about one method in our video tutorial talking all about random numbers – but for this discussion, let’s return to our viewers inquiry. Identify the Viewer’s Problem - use an Arduino sketch to demonstrate. Ok, so let's go back to the viewers question, he wants to generate random numbers, but he never wants the same number generated two times in a row. Let's write an Arduino Sketch to make this clear. //This sketch outputs pseudo random integers. //A variable to hold pseudo random integers. int randomInt = 0; void setup() { //Initiate serial communication. Serial.begin(9600); }//Close setup function void loop() { //Create a random number and assign it to the randomInt variable. randomInt = random(0, 10); //Send randomInt to the serial port for displaying on the serial monitor window. Serial.print(randomInt); }//Close loop function. In the first block of code a variable that will hold the pseudo random integers is declared and initialized. //A variable to hold pseudo random integers. int randomInt = 0; In the setup() function we begin serial communication in order to display the numbers we generate on a computer display. void setup() { //Initiate serial communication. Serial.begin(9600); }//Close setup function In the loop() we create the random number with the Arduino random() function and assign the output to the variable we had just created. The random() function can take two arguments 1) the minimum value of the number we want generated 2) the maximum value we want generated. //Create a random number and assign it to the randomInt variable. randomInt = random(0, 10); I will use 0 for the minimum, and 10 for the maximum. Every time through the loop, a new random number will be assigned the randomInt variable. Finally, the value of randomInt is sent over the serial port to be displayed in the serial monitor window. //Send randomInt to the serial port for displaying on the serial monitor window. Serial.print(randomInt); If you upload this code and open the serial monitor you will see in some cases where the same number shows up two times in a row. This is the problem. The viewer doesn't ever want the same number two times in a row. Discuss how we might solve the problem. So let's talk about how we might solve this problem. We know we need to generate a random number. What if we create a variable to track the previous random number? Then we could use a condition that says something like "If the previous random number is equal to the random number that was just generated, toss that number out the window, and create a different one.” The final thing we would need to do is set the previous random number equal to the new random number, that way we keep updating our previous random number every time through the loop(). Let’s Implement our solution in an Arduino Sketch. Copy and paste this code into your Arduino IDE. All you need is an Arduino board attached to your computer to make it work. //This sketch outputs pseudo random non-consecutive integers. //A variable to hold pseudo random non-consecutive integers. int randomInt = 0; //A variable to hold the previously assigned pseudo random non-consecutive integers. int previousRandomInt = 0; void setup() { //Initiate serial communication. Serial.begin(9600); }//Close setup function void loop() { //Create a random number and assign it to the randomInt variable. randomInt = random(0, 10); /*Check if the random number is the same as the previous random number. If it is, then reassign a new random number until it is different from the previously set one.*/ while (randomInt == previousRandomInt) { //Create a random number and assign it to the randomInt variable. randomInt = random(0, 10); //When a consecutive random number has been identified, indicate it. Serial.println(); }//close while statement //Set previousRandomInt equal to the current randomInt. previousRandomInt = randomInt; //Send randomInt to the serial port for displaying on the serial monitor window. Serial.print(randomInt); }//Close loop function. If you upload this code to your Arduino and open the serial monitor window you will see the numbers scrolling across the serial monitor window, but now you will not witness any duplicates side-by-side. You may notice some X’s intermittently between the numbers, this is where the Arduino sketch identified a duplicate random number and generated a replacement. If you look through the code, you will see this is accomplished with a While Statement . I hope you can find some application for this simple process of creating a pseudo random non-consecutive number with Arduino. Let me know what you think the comments!…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
A Review of Make: Magazine 8:55

8 years之前8:55

8:55

I don’t subscribe to many magazines, but I love my subscription to Make: magazine. And even though I rarely have time to sit down and enjoy a magazine in peace and quiet (parents forget what peace and quiet means), I still manage to get through my Make: magazine cover to cover. I like it that much! This video is a short review of why I enjoy Make: magazine, and why I think you would enjoy it too. Here are some highlights: 1. Make: Magazine is published every 2 months. 2. Filled with detailed step-by-step projects 3. Has interesting editorial articles about technology 4. Covers a lot of hobby electronics topics (like Arduino) 5. Has sections dedicated to skill building Total Honesty: Nobody paid me to make this review of Make: magazine. I made this video because I personally enjoy the content and rigor and think you might like it too. That being said - if you are interested in subscribing to Make: magazine I would love for you to use the link below if you so choose: Click Here to Check Out Make: Magazine The above is an affiliate link. At no additional cost to you, I get a kick back from subscriptions that originate from the link. This cash allows me to furnish my mansion in downtown Manhattan, make necessary repairs to my yachts, and fuel the Lamborghini for joy rides. Do you subscribe to Make: magazine? I would love to hear your thoughts in the comments.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Understanding the Arduino Sketchbook: Opening and Saving Arduino Sketches 9:41

8 years之前9:41

9:41

Understanding how the Arduino IDE sets up its file directory system can spare you some confusion when it comes to saving, organizing and opening your Arduino sketches (or sketches you have downloaded from the internet). This week’s episode covers the following: The Arduino Sketchbook folder How to change the default location where your Arduino sketches get saved What happens when an Arduino file does not have an enclosing sketch folder of the same name Where and how multiple tabs get saved in an Arduino sketch Why the pancreas of a woodchuck is better suited than our own Want to fast-track your Arduino skills? Click here to join our 12-part HD Video Course. You are probably familiar with a file directory system on a computer. It's usually represented as a hierarchy of folders and files. An example would be your C Drive - inside the C drive, you may have a folder for Applications, Users, and Systems files. Inside the Users folder, you might have subfolders for Documents, Downloads, Music, etc. All the files on the computer get organized in this fashion, and Arduino sketches are no exception. The Arduino Sketchbook Folder and Changing the Default Save Location The default location where Arduino sketches you write will be saved is called the Sketchbook. The Sketchbook is simply a folder on your computer like any other. It acts as a handy repository for sketches and is also where add-on code libraries get saved. You can see the sketches in the Sketchbook folder by going to File > Sketchbook. The default name of the Sketchbook folder is “Arduino” and the default location of the Sketchbook folder is in the “My Documents” folder (or just “Documents” for Mac users). If your Sketchbook does not appear to be in this default location, you can see exactly where it is by opening the Arduino IDE and going to Arduino > Preferences. The default file path for your sketches is listed at the top of Arduino Preferences window. Mine is: /Users/michaelJames/Documents/Arduino When I save a file in the Arduino IDE, this “Arduino” folder is the default location where the sketch will be saved, unless I choose to change that location by selecting a different folder on my computer's directory. If you want to change this default location, you click the Browse button next to the file directory path and choose a different place. Pretty simple. Sketch Folders If you go into your file directory system and open up the Sketchbook folder (again, named “Arduino” by default), you may see a bunch of folders that you didn’t make. This is because every Arduino file must be inside a folder that has the same name as the file (there are some exceptions to this that we'll talk about in a moment). Let me say that one more time because it is really important to understand. Every Arduino file must be inside a folder that has the same name as the file When I write a new sketch and save it, the Arduino IDE automatically creates a new folder that has the exact same name as the sketch itself. The Arduino file (which has the extension .ino) is placed inside this enclosing folder, which is called a sketch folder. If you go into the Sketchbook folder and change the name of the enclosing folder, it will create some issues. The first issue is that when you go to File > Sketchbook, the sketch will no longer show up! If you want to open this sketch you need to go to the .ino file in your directory and open it from there. If you open a .ino file that is not inside an enclosing sketch folder of the exact same name, then you will get a pop-up from the Arduino IDE that says: “The file “sketch_name.ino” needs to be inside a sketch folder named “sketch_name”. Create this folder, move the file, and continue?” If you choose Cancel, the sketch will not open. If you choose OK, then a folder gets created (it will have the same name as the sketch) and the .ino file is placed inside it. This sketch folder will be created in whatever directory the .ino file was that you tried to open. For example, if you tried to open a .ino file that was in your My Downloads folder, then the enclosing sketch folder also will be created inside the My Downloads folder. Saving Tabs in Arduino The exception to the rule about the sketch folder having the same name as the .ino file is when you create multiple tabs in an Arduino sketch. The additional tabs do NOT need to bear the same name as the enclosing sketch folder. Once you get a handle on some of these intricacies of the Arduino IDE file system, it can really help to clear things up. Please take a moment to leave a comment if you have any insights or thoughts about this tutorial. I would love to hear them!…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
An Easy Way to Learn I2C, SPI, RTC, ADCs and More with this Awesome Arduino Education Shield 5:04

8 years之前5:04

5:04

In this video we talk about an Arduino shield designed to teach you about shift registers, I2C, SPI, temperature sensors, real time clocks, analog to digital convertors and flash memory chips - all this on one awesome Arduino shield! Electronics Concepts can be Intimidating Like any industry or hobby, electronics has its fare share of acronyms. A couple of the more common ones you might have come across are SPI, I2C, ADC, RTC and YOMAMA. All these acronyms can be intimidating. It’s like this giant lion staring you down. You can spend a lot of time reading about each of these concepts, buying a bunch of different parts and working up breadboards - this is a great way to learn – it’s kind of the common path many hobbyist and professionals have taken alike. But if you want to grab the lion by the throat - I would like to introduce you to my new favorite Arduino shield. The Rheingold Heavy Education Shield . It's an Arduino shield designed to teach you about the ins and outs of all these really common electronics concepts (like I2C and SPI) and applying that understanding to hardware (like analog to digital convertors and Flash RAM). It’s not just the shield that makes this an education board, it’s all of the really thorough documentation and tutorials that accompany the hardware on the Rheingold Heavy website. Have Fun Learning Electronics If you are going to learn electronics, you might as well have fun doing it. That's one great thing about the Rheingold Heavy tutorials - they are fun - the author has a great sense of humor and keeps things real. He does a great job at demystifying electronics concepts that on the outside seem extremely complex, but dissected piece by piece can be made elementary. I would say my favorite part about the tutorials is the depth and detail they cover. I think this line from one of the introductory tutorials captures the style of the author… ...I don’t like “just making it work” — I want to know why it works the way it does. Hardware and Education Unite The real magic happens when you have the Education Shield and start working through the tutorials. The lessons on the Rheingold Heavy website are all designed step-by-step to walk you through understanding in detail the hardware on the shield. The lessons are a good length, focus on just a couple concepts at a time and get into the nuts and bolts. The Rheingold Heavy Education Shield itself is jam packed with components. It's got a shift register hooked up to 8 surface mount LEDs for learning about shift registers, a real time clock, a temperature sensor, a 10 bit analog to digital convertor, and 8Mbytes of Flash RAM. All this hardware you learn to use with either I2C protocol or SPI! It’s like an electronics learning laboratory on a single Arduino shield . If you already have a handle on some of these concepts, and you don’t think you need the whole shield, you can purchase breakout boards for each separate component and all the documentation on the website works equally well for those. I know I’ve said it once, but it deserves saying again - the tutorials are written in a fun and relaxing tone - with tons of diagrams, questions along the way to make sure you’re on track and Arduino code to help experiment with the shield and concepts. History of the Rheingold Heavy Education Shield The brainchild of this education shield is Dan Hienzsch. In 2014 he ran a successful Kickstarter campaign that brought these shields to fruition. After successfully fulfilling all his Kickstarter backers (and on time!) he has set up shop and is now churning out these education shields all over the world. My Unabashed Endorsement I am just little biased towards this education shield - I know Dan - he's a great guy and very passionate about what he does. After buying the shield and the breakout boards and working through the tutorials on the website I have learned a ton! The best part is how much fun it has been to work through the material. I love learning and if I can have a single “aha!” kind of moment everyday, then I sleep at night pretty good. My experience with the Rheingold Heavy Education Shield has brought me these moments left after right. Needless to say I highly recommend this Arduino shield to any body who wants to get a solid and detailed grasp of concepts like SPI and I2C, or about using real time clocks, analog to digital convertors, temperature sensors, shift sensor and a whole lot more. With all this education packed into Rheingold Heavy Education Shield , backed-up with really enjoyable tutorials, you can't go wrong.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
The Process and Tools I use for Creating Arduino Tutorials 8:10

8 years之前8:10

8:10

This week's Episode is what I am calling an intermission, which is basically me taking a break from hardcore Arduino tutorial making, and present a less technical topic. In this intermission video, I walk through the process I use when creating Arduino tutorials and some of the software that helps me do it. Here is a list of software I use when creating Arduino tutorials: Full Disclosure: Some of these are affiliate links that help me afford gold toilets on my private island. Brainstorming/ Mindmapping software (mac): MindNode Simple Text Editor (mac): TextMate Screen Capture software: Camtasia for Mac Audio Editing: Audacity Circuit Design: Fritzing More Robust Text Editor: Microsoft Word for Mac If you want to check out some of our best Arduino tutorials, sign up for our free Arduino Crash Course below.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Using the Same Input to Trigger Multiple Arduinos 9:41

8 years之前9:41

9:41

If you ever have a project using two or more Arduinos, it's likely you'll want them to work together. Say for example you have one Arduino connected to an LCD shield, and another Arduino controlling an LED matrix. You want both to do something when you press a single button - how can this be done? It turns out to be extremely easy. This video will describe in detail how to trigger multiple Arduinos with a single input. CODE: /* Button Turns on and off a light emitting diode(LED) connected to digital pin 13, when pressing a pushbutton attached to pin 2. The circuit: * LED attached from pin 13 to ground * pushbutton attached to GND through pin 2 on two (or more) Arduino's * Note: on most Arduinos there is already an LED on the board attached to pin 13. created 2005 by DojoDave modified 30 Aug 2011 by Tom Igoe Modified 16 APR 2015 by Michael James https://programmingelectronics.com/using-the-same-input-to-trigger-multiple-arduinos/ This example code is in the public domain. http://www.arduino.cc/en/Tutorial/Button */ // constants won't change. They're used here to // set pin numbers: const int buttonPin = 2; // the number of the pushbutton pin const int ledPin = 13; // the number of the LED pin // variables will change: int buttonState = 0; // variable for reading the pushbutton status void setup() { // initialize the LED pin as an output: pinMode(ledPin, OUTPUT); // initialize the pushbutton pin as an input: pinMode(buttonPin, INPUT_PULLUP); } void loop() { // read the state of the pushbutton value: buttonState = digitalRead(buttonPin); // check if the pushbutton is pressed. // if it is, the buttonState is HIGH: if (buttonState == LOW) { // turn LED on: digitalWrite(ledPin, HIGH); } else { // turn LED off: digitalWrite(ledPin, LOW); } } Breadboard Layout: Downloads: Schematic Fritzing File.fzz If you like this tutorial, check out some of out very best by signing up for our free Arduino Crash Course below.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
6 Tips on Assembling an Arduino Shield (Or any Electronics Kit) 8:15

8 years之前8:15

8:15

In this video we will be talking about some key points to keep in mind when assembling an Arduino shield from a kit. Many of these tips will apply equally well to any type of electronics kit you are assembling. So you just bought an awesome Arduino shield - it's going fly you to the moon and back, but before you start using it you have to do some basic assembly. Here are six tips to help you get the assembly done right the first time. Read the Directions: The first advice is painfully obviously, but still worth mentioning - read the directions! When all you have to do is solder on some pin headers and a couple LEDs, it's tempting to ignore the need for directions and just go at. You’re a genius right - who needs directions? As J.R.R. Tolkien said... "Shortcuts make for long delays". Even on simple assemblies it pays to take the time to read through the directions. Most companies keep the directions online – they are really only a search away. I'm telling you it’s worth it! Consider Where you Will be Assembling the Board: You may not have a dedicated space for your electronics addiction. There have been many times when I find myself soldering stuff on my kitchen table. If you don’t have a dedicated space, a couple things you will want to consider are: • Having good lighting, so you can see what you are up to • Access to a wall outlet for your soldering iron – you want the cord to have some maneuver room • A floor without shag carpet, as they tend to be repositories for small electronics parts (the smallest parts are always the first to fall) You can’t always have the best spot, but you can make the best of what you have available. Get Your Tools Together Good instruction manuals will let you know what tools you need for the job. Generally speaking, the essential tools are: • soldering iron • solder • wire cutters Some other tools that are not necessary but make life way easier are: • Needle nose: pliers for grabbing tiny parts • Helping hand: these help not only holding parts when soldering, but also provide the magnifying glass which is good for checking solder joints • Solder wick for undoing your mistakes • A pair of safety glasses is also a good idea. You might be thinking – ah, heck with safety glasses… It's easy to write them off when assembling boards. What I have done is get a pair that is comfortable and that I keep clean - this makes using them less a hassle. It’s a small precaution to take from getting a piece of tiny sharp metal in your eye. Inventory All the Parts For whatever reason, inventorying all the parts always seemed like a waste of time to me, but now it is something I make sure to do. Two big reasons I do this. Many of the boards I get are from Kickstarter campaigns, so the people manufacturing these might be kind of new at the gig, and with all the stuff they have going on, it's very possible they missed a part in the package. Another reason I like to do the inventory is so I know if I have extras. If I have pieces left over when I finish, then I am usually wondering if I did the assembly correct or not. If you do the inventory, then you can be confident that you assembled it right. I also separate the components into different jars, or bowls. This helps me quickly find components when I am assembling the shield and prevents the pieces from ending up lost in the carpet. Check Twice Solder Once I like solder wick as much as the next guy, but I would prefer not use it. It is really worth your time to double check part locations before you start soldering. I learned my lesson when I soldered a 24 pin connecter on the wrong side on a board. Now I always check a diagram or the directions at least twice before pulling out the solder. After I solder, I also make it a point to look over the solder joints. I am amazed at how much my soldering joints can stink, even when I feel like I had done a great job (this is when a helping hand or magnifying glass is good to have). Use an Arduino Board to Help Align the Pin Headers. One thing all Arduino Shields have in common are pin headers. These are the metal rows of pins that go on the bottom of the shield and plug into the Arduino stackable headers . If you don’t get the pin headers aligned correctly then your shield may not fit well, or may not fit at all on top of the Arduino. One trick to get the alignment right is to use an Arduino to hold the pin headers in the correct position when you solder them to the bottom of the shield. To do this, simply insert the headers how they would go into the Arduino, place the shield on top, and then do your soldering. It works like a charm. Troubleshooting the Assembly Now that your Arduino shield is fully assembled, it’s time to get that puppy running. Hopefully the shield came with some type of test sketch that you can load and it verifies that everything is up and running correctly. If not, try to find some code that you know works and load it onto the Arduino. If you start with code that you can verify works (or at least works for others), it can be easier to troubleshoot any issues you might encounter. I know how demoralizing it can be to load your first sketch and getting nothing better errors when you press the verify button. Here is a tidbit of moral support - there is a learning curve to everything - no matter how easy it is “supposed” to be. In fact, some of my favorite shields took me a while to understand how to use. So try not to get frustrated if your sketch isn’t working instantly. In the end, a little bit of determination goes a long way. Do you have any tips for building Arduino shields or electronics kits in general? I would love to hear about them in the comments.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
A YouTube Channel for Learning about Arduino 5:34

8 years之前5:34

5:34

In this episode I talk about the video channel that I host on YouTube. If you have watched any previous episodes of this channel then you know I focus on Arduino related topics. The purpose of the channel is to help people learn about using Arduino. Specifically, the target audience is electronics hobbyists who are interested in learning to use Arduino. That being said, I try to make the videos from the perspective of a beginner so if you don't know jack about electronics or programming, then the show should still be a great place for you to learn.Every Tuesday I will be releasing a new episode. Every fourth video will be something like the video shown above. The reason I am doing this is because it gives me a little bit of a break in video production, which is extremely time consuming. I am calling these types of videos "Intermissions" which is all I could come up with. So this is the first intermission video (and post). A Little Bit About Myself: I am an electronics hobbyist - I've be messing around with hobby electronics for a about a decade, and I have been learning about Arduino for a big part of that time. I don't have any formal training in electronics so the perspective you get from me might be a lot like you, someone who has tried really hard to learn about electronics with as much spare time as I could find between work, family, and the curve balls of life. I do have some formal training in programming (though not much). I took a C++ course in college and used Matlab for some research I was doing at the university. What type of topics can you expect to watch on this video channel? Like I said before this channel is focused on Arduino - but there so many applications for Arduino it gives me a bunch of latitude for all types of stuff. There will be a ton of “how to” tutorials. Not about cutting and pasting the code – they’ll be about understanding how to make your own code. I'll talk about Arduino derivatives, shields and cool hardware and sensors you can use. I am really interested in science, so I plan to start doing some videos on using Arduino to enable Citizen Science. I might start with some data logging ideas. Student Projects: On a quick aside, what I do for a living is run an online course that uses a very structured curriculum to teach electronics hobbyists how to use Arduino. The Arduino Course is designed so you don’t need any electronics background to work through it, but I find most of my students do have some electronics experience to begin with. The reason I bring this up is because many of the students submit projects they are working on and I plan to use these “intermission” videos to show off some of the stuff they have done. For example, James (a really quick study) who took the course has been making all types of cool Laser tag accessories using Arduino . Which is pretty awesome - and very impressive. Projects I am Working on: I will also use these “intermission” videos to talk about some of the projects I am working on. Lately, I have been thinking about a little robot that can draw. I only really work on it when my kids are around, so the progress is painfully slow. What I would really like is to get the robot to draw sketches of people. No idea if I will ever make it to that point (or how the heck I am going to pull it off), but it's my pet project that I have been working on. So that’s it for this first intermission post (and video). I will see you in the next show, where we will be talking more things to consider when assembling Arduino Shields from kits. Until then! If you are interested in learning how to use Arduino, sign up for our free Arduino Crash Course below.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
What is a Breakout Board for Arduino? 8:21

8 years之前8:21

8:21

If you have been learning about Arduino for any amount of time, than you have probably come across the term Breakout Board. Now, you might think, as I did when I first heard about breakout boards, that they were some fixture for practicing your Kung Fu fighting. In this lesson, we will discuss what breakout boards are, how they can accelerate your Arduino prototyping and some things to look out for when you buy them. Want to step-up your Arduino skills? Click here to join our 12-part HD Video Course. Basic Concept of a Breakout Board The basic concept of a breakout board is that is takes a single electrical component and makes it easy to use. Usually the electrical component is an integrated circuit (IC). Integrated circuits, as you may know, have pins on them. The pins on an IC can do a multitude of things, but you usually have pins for supply power, pins for providing a ground, pins for receiving an input and pins for sending an output. A breakout board "breaks out" these pins onto a printed circuit board that has its own pins that are spaced perfectly for a solderless breadboard, giving you easy access to use the integrated circuit. There are all type of breakout boards - but most of them are for different types of sensors, for example: accelerometers, ultrasonic distance sensors, RFID tag sensors, temperature sensors, pressure sensors, and they even have seismic breakout boards for sensing dinosaurs' footsteps! Breakout Board vs Arduino Shield: What's the difference? You might be wondering what the difference is between a breakout board and an Arduino shield, and that is a good question. Breakout boards usually have a smaller form factor - they don't need the entire space of an Arduino shield to accomplish their mission. And while the market for most breakout boards is being driven because of their use with Arduino , since the pin-out of a breakout board is not designed specific to the Arduino headers, it means you could use a breakout board with any other microcontroller development board you want - which gives them a bit more scope than Arduino shields. Also, since breakout boards generally have fewer components than a shield does, you may find the cost is lower than a comparable Arduino shield. As you may have guessed by now, you can find a breakout board that does essentially the same thing as a shield. You might be wondering, if breakout boards are only a few components, why not just buy the integrated circuit the breakout board uses, put it on a solderless breadboard yourself, and t hen hook them up to your Arduino ? That is great question, and there is nothing saying you can't – plenty of people do - especially since the components by themselves are often far cheaper to buy alone from an electronics distributor, like digikey or mouser. So, why the heck are people buying all these breakout boards? It essentially comes down to convenience. Let me list the ways a breakout board can help you out, and then you make the call: Breakout boards can save you space We have already said that breakout boards use integrated circuits. Integrated circuits are kind of like t-shirts - you can get them in all different sizes. Usually breakout boards utilize a tiny version of an integrated circuit called an SMD (surface mounted device). The pins on SMD parts are really small - not something you can easily pop into a breadboard. The larger form factor of an integrated circuit, called a DIP (dual inline package) has bigger pins, which fit easily into a breadboard. The DIP package of an IC will be bigger than the SMD form factor. The point, I am getting to here, is that Breakout boards can sometimes save you space which may or may not be important for your project. Breakout Boards are designed for reuse Another thing about using DIP packages is that while the pins are bigger, they are not necessarily sturdy. If you plan to use a DIP component over and over, the usable life of the pins is only so long - the pins on a breakout board however, are heavy duty and designed for reuse. The DIP version on a component may not be available One other issue you may find is that the DIP version of an integrated circuit is not available - as electronics get smaller over time, the demand for larger components is drying up and manufacturers are moving away from even bothering with the DIP package, which ultimately brings you back to a breakout board. Pin labeling on a Breakout board One great feature of breakout boards is that they usually have the pin names of the integrated circuit labeled on the PCB. This makes hooking up the breakout board to your Arduino a cinch, especially when there are a ton of pins. Otherwise, you are looking at the black box of an IC and referencing the datasheet of the integrated circuit to try to figure out which pin is for what. So now that you know some of the benefits of a breakout board, let's talk about a couple things you might want to consider when you are buying them. Good documentation I said this about Arduino Shields in the last lesson , but I will say it again - good documentation is like water in the desert. The more you can get your hands on, the better. Let's face it - a lot of this electronics and programming stuff is not self evident - you need good instructions and reference material to make it work right. The test I usually use before buying a breakout board is to see what reference material I can find online for it. If nothing tangible exists, you might be spending way more time trying to get it up and running than you would prefer. Breakout boards are not necessarily interchangeable As you search for particular breakout boards, you may find that there is a super cheap version available. If you plan on using pre-existing code for a breakout board that references the more expensive version of the breakout board – i.e. maybe in the sketch comments it says, "use XYZ breakout board", one thing you will want to check is that the breakout boards use the same integrated circuit. If they don't use the same integrated circuit, and you don't know how to adjust the code for these differences, then you may find that the cheap version will cost you more time in trying to figure out how to use it. Soldering and header pins may be required Many breakout boards are sold as kits. Usually, the only things you have to solder are the header pins that allow the breakout board PCB to plug into a breadboard - this is really easy to do. It may also be the case that a kit maker just sells the breakout board with the SMD components, and you have to buy the pin headers separately. So those are a few things to keep in mind when buying a breakout boards. Using the correct supply voltage Finally, once you actually have your breakout board, make sure that you know what voltage supply pin it needs hooked up to. The Arduino has two voltage out pins, one at 3.3 volts and one at 5 volts. Many breakout boards use a supply voltage around 3.3 volts. Sometimes the supply voltage will be printed right on the PCB by the associated pin, but other times it will just say Vcc, so you will want to check the specs on the breakout board. If you are just getting started with breakout boards, a great place to look is in the Arduino IDE examples. Some pre-written sketches get you up and running quick with some common breakout boards. If you like the style of this lesson, I welcome you to join the free Arduino Crash Course - you can sign up below.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
What is an Arduino Shield? 9:34

8 years之前9:34

9:34

If you are learning about Arduino, you have no doubt come across the term Arduino Shield . This tutorial will explain what Arduino Shields are, why they are awesome, and several things to consider when buying shields. cool electronics ideas that you have. Now the Arduino in and of itself is pretty amazing - you can do a lot of stuff with an Arduino alone. But when you want to start adding all types of cool technologies like bluetooth, wifi, RF, motor-drivers, etc. it can be pretty tricky; especially if you are new to electronics and programming. Arduino shields take all the complexity of the hardware and reduce it to a simple interface. This allows you to get your idea up and running fast. Now it's not just the hardware that shields take care of, in many cases, Arduino shields also have programming libraries associated with them. These libraries allow you to easily implement the hardware features available on the shield. There are shields for all types of things - LCD shields, LED matrix shields, wifi and bluetooth shields, motor shields, power supply shields, geiger counter shields, there are even shields for cooking hot dogs. Chances are if you need to do something, a shield exists to get you up and running quick. Shields plug right into the top of an Arduino. The black plastic rows of holes along the sides of an Arduino are called headers , and on the bottom of a shield, you have these long spiky pieces of metal, these are called pins . The pins on a shield line up with the header rows on an Arduino and fit snuggly (more on this later). Buying an Arduino Shield? Think about this stuff: Does it have good documentation? Documentation is the fancy way of saying - “will they show me how to use this thing?” Basically, is there some type of tutorial or user manual or forum that talks about how to use the shield. This is one of the biggest factors for me when it comes to buying an Arduino shield. For all the ease of use that a shield provides, if I don't know how to use it, it's about as a good as a rock. Lucky for us, people who use Arduino tend to be awesome and do a great job writing about how to use stuff, so even if the manufacturer doesn't have good instructions, if people actually use the shield, then you will find a wealth of information online. But if you do a web search and it doesn't turn up much of anything useful, you might consider looking for another option. Two US companies that provide superb documentation of the shields they make and sell are Adafruit Industries and Sparkfun . Soldering may be required Many shields are sold as kits, that means they are not fully assembled - and will require you to do some soldering. If you are buying from a reputable source, you should know this ahead of time, but it is worth double checking. Sometimes manufacturers will offer the shield as a kit or fully assembled - I often go for the fully assembled option just to save time. If you have not soldered before, shields are usually a cinch to solder, so don't be intimidated - go get a cheap soldering iron and some solder and go for it! Probably the most important thing when soldering a shield is making sure that the pins on the bottom of the shield are straight up and down, if they aren't they won't line up to the Arduino headers and be a major pain to connect. Stackable or Not Stackable Arduino Shields If you plan on stacking an Arduino shield with other shields, you will want to make sure it is stackable. If it doesn't have pin headers on the top of the shield, or they don't look aligned correctly (usually too narrowly spaced), than it is likely another shield cannot be stacked on top of it. You might also run into a problem if components on the shield stick up too high to allow shields above from getting a snug fit. Manufactures of shields are getting more savvy to this issue, but you should always check. Not all Arduino shields have the same pinout Some older Arduino shields may not have all the pins to fill the header rows of an Arduino . This is because older versions of Arduino didn't have as many pin header slots. This usually isn't too much trouble, unless you needed to use those pins that are not connected on the shield. If you have an older version of Arduino, then a shield you buy might have more pins than your Arduino has headers for - usually they are still physically compatible - this should not be anything to sweat about. Matching Hardware and Software Versions On a final note, if you are having trouble with a shield working, it worth checking to see if you are using the most current library version for your version of shield. A great example is the near ubiquitous Adafruit motor shield. There is a hardware version 1 and a hardware version 2. There are two separate code libraries for these. If you are trying to run your new version of the hardware on the old version of the library - then you will likely run into troubles. It worth checking to see you have the correct library for the job. I hope you found this tutorial helpful, please be sure to check out our free Arduino Crash Course (signup below) if you want to accelerate your learning.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
How to Use and Understand the Arduino Reference 12:48

8 years之前12:48

12:48

So you just opened up your fancy new gadget - maybe an awesome DSLR camera, or the newest gaming system, or maybe a new Blu-ray player. As you gladly tear away the packaging - you notice a small book that feels like it was printed on 4th generation recycled newspaper - it’s the instruction manual. As you skim the pages you realize it was first written in Japanese, translated to Chinese by an Australian ventriloquist and then an intern in California used Google Translate to finish the job for your native tongue. So you toss the instruction manual and just plug the gadget in. Good for you - especially since it appears as everything is working just fine. Until.. ...something isn’t working just fine. Maybe you can’t navigate the menu options to find a setting that was advertised on the box, or maybe the functionality you thought your gadget has does not appear to be working no matter how correctly it seems you are pressing the buttons. This tutorial is going to focus on the Arduino instruction manual, known more commonly as the “Arduino Reference” or the “Arduino Documentation”. It is an important and useful aspect of learning to use Arduino - it will be your best friend in times of bewilderment, brain lapses and fits of rage. I know that instruction manuals get a bad wrap - but don't fret - the Arduino Reference is awesome! To be honest what really keeps us away from the documentation is our fears. That’s right - the reference pages can be a bit intimidating when you are just starting out. They use a lot of technical jargon, are loaded with funky acronyms and filled with rabbit holes. Nobody uses the stuff anyway...right? ( Not right - that was a joke! ) This Tutorial Will Cover: What is the Arduino Reference? The Anatomy of an Arduino Reference Page. Why You Should Be Using the Arduino Reference More. How to use brain waves to trick your cat into eating less. Have you ever read a book and come upon a word you didn’t understand? Sometimes you can infer the meaning from it’s context, but what about when no such context exists? Likely, you used a search engine to find the definition. The definition told you what the word meant, whether is was a verb or adjective (or both), it gave some examples of how to use the word, and maybe even the etymology. The Arduino Reference is the same thing. It is the “dictionary” for all the structures, variables and functions that you can use when programming a sketch. It tells you the description, the parameters it uses, the syntax (how it is written), and even gives a bunch of examples on how to use it. So let’s jump into an Arduino Reference page and dig into what we can learn. The Anatomy of an Arduino Reference Page So let’s navigate to a reference page to start our journey. You can find the index of all the Arduino Reference pages on the Arduino Website: http://arduino.cc/en/Reference/HomePage Or - if you are offline - don’t worry, your Arduino IDE comes with an html copy of all the pages. You can get to it through the Arduino IDE: Help > Reference You will note at the top of the Reference Index page, there are three columns; Structure, Variables, Functions. This is the first level of organization in the reference. So if you are looking for a variable, you know which column to start looking in. Each of the hyperlinked items on this index page will take you to the individual entries reference page. What’s great about the individual reference pages is that they are organized in a similiar manner from one to the next, so you should know what to expect. They are also terse, so don’t think you are going to have to scour through someones dissertation. Each page has some major headings. We will walk through each of the main ones, and then talk about some less common ones. Description: All entries will have a description. Pretty straightforward - this is going to be a simple explanation of what the item does. It usually uses language that is basic. Syntax: Most all entries have a “syntax” heading, but they are more prevalent for functions. The syntax shows how the function (or other code) should be written when you use it in your sketch. Basically - it is what the function needs to know to do it’s job. Let's take an example from the digitalWrite() reference page. The words in the parentheses are telling you what type of value should be passed to the function. If we want to use this function than it will need to know 2 things - the pin number and the value to write to the pin. You don’t type in the word “pin” when you use the function, you would replace that with the actual pin number, or a variable that represents that pin number. Same is true for the word “value”, you would replace this with one of the acceptable parameters (see below). So when you actually wrote the function, it might look like this: digitalWrite( 13 , HIGH ) Where 13 is the “pin” and HIGH is the “value”. Parameters: Only structures and functions will have the “Parameters” heading. These describe exactly what can go in the parentheses in the syntax above. This is good to know, because you might be trying to pass a floating point number when the function calls for an integer. Returns: This tells you what value to expect a function to give you back. For example, when you use the square root function, you expect to get back the square root. But what data type will the square root be - an integer, a float or a double? The “Return” heading will tell you. Sometimes, a function will return nothing. Take the pinMode() function for example, you give it the pin number and the mode that you want the pin to be and it simply sets the mode - there is no data it needs to give you back. Example: This is your best bet at understanding how the structure, function or variable is intended to be implemented in code. It is usually a very short code snippet, though sometimes they can be lengthy. The example below is taken from the map() reference page. A nice feature of the example description is the “get code” option on the right of the reference page next to the example code. When you click this, it will take your browser to a plain text web page where you can copy and then paste the code into your Arduino IDE. See Also: This is a bulleted list of similar or related entries to the reference page you are looking at. They will link to other reference pages inside the reference directory. If I end on a reference page that isn’t quite what I was looking for, I will usually check out the options they provide here. Sometimes, they will also link to tutorials on the Arduino website (and who doesn’t like tutorials?) Keep in mind if you are using the reference in the offline mode through the Arduino IDE and you do not have an internet connection that any links outside the reference directory will not work. That includes the most common headings, what follow are some less common, but none-the-less useful headings you will run into. Programming Tips / Coding Tip / Tip: These are going to little bits of knowledge provided by people who know their stuff. I always like to read these, because they add to the depth of my understanding. Warning: These point out common errors that occur when people like me and you try to use the code. Caveat: If there is an exception to the rule, they will be described here. Note: In many cases, the notes are the “miscellaneous” heading, capturing information that doesn’t particularly fall under other headings. Why You Should Be Using the Arduino Reference More Here is a scenario I have played out myself about 7,000 times. I am writing a program and some function does not seem to be working right. I spend 30 minutes making changes to the program, but keep getting errors. Every time I think I have it fixed, I find I am wrong. Then I decide to check out the reference at which point I quickly realize I simply didn’t understand how a function was supposed to work. So the habit I have developed when I don’t completely understand a function it to check out the associated Arduino Reference page. It saves me times, teaches me something I didn’t know or re-teaches me something I forgot - and it will do the same for you. Let’s sum all this up. The Arduino Reference page is: The Bee’s Knee’s. The Lions Mouth. My favorite page on the Arduino website. Your favorite page on the Arduino website? Challenge(s): Go the Arduino Reference Index Page and start perusing some functions. See if you can find entries with the following headings: Caveat / Warning / Tip Further Reading: Warning - this gets deep! - AVR Libc (This is the reference for what the Arduino language is based on) - User Manual for the AVR Libc P.S. Ok - as much as I love the Arduino Reference page, sometimes it has errors. So if you find any, mention it on the Arduino Forum .…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Using Red-Green-Blue (RGB) LEDs with Arduino (Common Cathode Type) 14:47

8 years之前14:47

14:47

In this tutorial we describe using RGB LEDs of the Common Cathode Type. We will describe setting up the circuit, talk about the LED and discuss the code used to adjust the hue.

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Using Random Numbers with Arduino 13:02

8 years之前13:02

13:02

This video tutorial talks about using the random() and randomSeed() functions with Arduino. It is pretty straight forward, but there are some intricacies worth noting. Creating truly random numbers in Arduino is harder than you might think. The closest we can get in Arduino, and just about anywhere else, is using pseudo random numbers. That is, numbers that mimic randomness, but in fact do have a pattern if Want to fast-track your Arduino skills? Click here to join our 12-part HD Video Course. Why are Random Numbers with Arduino All the Same? The most important thing to understand when using the random() function with Arduino is that it will generate the exact same list of pseudo random numbers every time. So if you build a slot machine, and the first crank of the handle is a winner, then you can be sure that if you reset the Arduino board and pull the handle again - it will still be a winner the first time. The easy way to overcome this is using the randomSeed() function. This function takes a value (an integer for example), and uses the number to alter the random list generated by the random() function. The number you pass to the randomSeed() function is called a 'seed'. You might put randomSeed() in the setup, and then use the random() function in the loop. Something like this: //this variable will hold a random number generated by the random() function long randomNumber; //Set up - this is where you get things "set-up". It will only run once void setup() { //setup serial communications through the USB Serial.begin(9600); //Let's make it more random randomSeed(42); }//close setup void loop() { //generate a random number randomNumber = random(2,5); //display the random number on the serial monitor Serial.print("The Random Number is = "); Serial.println(randomNumber); } But there is still an issue - even though the sequence of random numbers is different when using the randomSeed() function - it will still be the same every time the sketch is run. It is just a different list of pseudo random numbers! One Solution to the Random Problem So, what to do? Lucky for us the Arduino reference has a great solution. Use the analogRead() function to read a value from an unused analog pin. Since an unused pin that has no reference voltage attached to it is basically 'floating', it will return a "noise" value. This noise value can seed the randomSeed() function to produce differing sequences of random numbers every time the sketch is run. Below is the sketch from the video using analogRead() and randomSeed() in unison: /*How to use the random() and randomSeed() function YOU WILL NEED: (3) LEDs (3) 220OHM resistors (1) Jumper Wire (4) Hot cakes CIRCUIT: Connect a resitor to pin 2 and then to a breadboard. Connect the long leg of an LED to the resitor and the short leg to one of the ground rails on the breadboard Repeat this for the other components at pin 3 and 4 Coonect the ground on the breadboard to one of the Arduino GND pins. Created JUL 2014 by Michael James https://programmingelectronics.com/thearduinocourse */ //Declare and initialize LED pin variables int LED_1 = 2; int LED_2 = 3; int LED_3 = 4; //this variable will hold a random number generated by the random() function long randomNumber; //Set up - this is where you get things "set-up". It will only run once void setup() { //setup serial communications through the USB Serial.begin(9600); //Let's print a start messgae to the serial monitor when a new sequence of random numbers starts Serial.println("Starting new Random Number Sequence"); //set the LED pins as outputs pinMode(LED_1, OUTPUT); pinMode(LED_2, OUTPUT); pinMode(LED_3, OUTPUT); //Let's make it more random randomSeed(analogRead(A0)); }//close setup //The loop() runs over and over again void loop() { //generate a random number randomNumber = random(2,5); //display the random number on the serial monitor Serial.print("The Random Number is = "); Serial.println(randomNumber); Well, hopefully that was random enough for you! If you enjoy this tutorial, I highly recommend checking out our free Arduino Crash Course (You can sign up below).…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Kit-on-a-Shield for Arduino 1:18

8 years之前1:18

1:18

Ever ever spent too much time searching for a 220 ohm resistor or just one more jumper wire? Are you sure you had that extra LED, LDR, [Fill in the blank], but have no idea where it went? Do you just want to throw up a quick circuit and get to coding? Travel a lot and want an easy way to learn Arduino on the road?…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
How to Make One Button Have the Functionality of Two or More with Arduino 15:40

8 years之前15:40

15:40

Do you have an application where you want multiple buttons for different user inputs? Maybe you have a timer and you want one button for minutes and another for hours. But there is a problem – you only have room for one button! In this tutorial, we are going to use Arduino to explore how to make one button have the functionality of two or more. Click here to join our 12-part HD Video Course. You Will Need: (1) Momentary push button (5) Jumper wires (1) Solderless breadboard (2) LEDs (2) 220 Ohm resistors Set Up The Circuit: To demonstrate making one button have the functionality of two or more, we will set up a simple circuit with 2 LEDs and a button. Based on how we press the button, different LEDs will illuminate. Follow the instructions and schematic below to get the circuit set up before we dive into the mechanics of the Arduino code. Using a jumper wire, connect any GND pin from the Arduino, to the ground rail on your breadboard. Place an LED on your breadboard, make sure to note which way the long leg is facing. Using a jumper wire, connect pin 13 from your Arduino to the breadboard in the same channel where you have the long leg of the LED attached. Now connect one side of the 220 Ohm resistor to the short leg of the LED, and connect the other leg to the ground rail on the breadboard. The orientation of the resistor doesn’t matter. Repeat this using pin 12, and another LED and resistor. Finally, place your push button on the breadboard. Depending on the style of your pushbutton, they often fit well straddling the long trench that goes through the breadboard. Connect a jumper wire from one side of the button to pin 2 on the Arduino. Connect a jumper wire from the other side of the button to the ground rail on the breadboard. That's it for the circuit setup. Now, when you press the push button (which will electrically connect both sides of the button), pin 2 to will have ground voltage applied. We will use this ground voltage input to trigger our different functions. Examine the Sketch: There are couple ways to implement the multi-function button press using Arduino. One way is to have the number of presses determine the output. For example, a single click might highlight the “hour” field of an LCD timer and a double click might highlight the “minute” field of the display. Another way that we can implement multiple functions with one button is for the user to hold down the button for different lengths of time with the length of the hold determining the output. For example, if the user holds the button for half a second and releases, something happens. If she holds it for 2 seconds, something different happens. This latter method of using button hold length time to determine separate functions is the strategy we will learn here. Before I go any further though, I would like to thank Steve for creating the base Arduino code that we will be using. Steve is a member of the Premium Arduino course (a couple of months ago, he was new to Arduino). While creating a home automation project, he was in need of using a single button to do multiple things, and came up with a very simple way to make it happen. Thanks Steve! Here is the complete sketch, I recommend looking it over first, and then we will discuss it piece by piece below. /*Using a Single Button, create mutliple options based on how long the button is pressed The circuit: * LED attached from pin 13 to ground through a 220 ohm resistor * LED attached from pin 12 to ground through a 220 ohm resistor * one side of momentary pushbutton attached to pin 2 * other side of momentary pushbutton attached to Ground * Note 1: on most Arduinos there is already an LED on the board attached to pin 13. * Note 2: In this circuit, when the button is pressed, Ground Voltage is what will be applied. Created DEC 2014 by Scuba Steve Modified JAN 2015 by Michael James Both members of https://programmingelectronics.com This code is in the public domain */ /////////Declare and Initialize Variables//////////////////////////// //We need to track how long the momentary pushbutton is held in order to execute different commands //This value will be recorded in seconds float pressLength_milliSeconds = 0; // Define the *minimum* length of time, in milli-seconds, that the button must be pressed for a particular option to occur int optionOne_milliSeconds = 100; int optionTwo_milliSeconds = 2000; //The Pin your button is attached to int buttonPin = 2; //Pin your LEDs are attached to int ledPin_Option_1 = 13; int ledPin_Option_2 = 12; void setup(){ // Initialize the pushbutton pin as an input pullup // Keep in mind, when pin 2 has ground voltage applied, we know the button is being pressed pinMode(buttonPin, INPUT_PULLUP); //set the LEDs pins as outputs pinMode(ledPin_Option_1, OUTPUT); pinMode(ledPin_Option_2, OUTPUT); //Start serial communication - for debugging purposes only Serial.begin(9600); } // close setup void loop() { //Record *roughly* the tenths of seconds the button in being held down while (digitalRead(buttonPin) == LOW ){ delay(100); //if you want more resolution, lower this number pressLength_milliSeconds = pressLength_milliSeconds + 100; //display how long button is has been held Serial.print("ms = "); Serial.println(pressLength_milliSeconds); }//close while //Different if-else conditions are triggered based on the length of the button press //Start with the longest time option first //Option 2 - Execute the second option if the button is held for the correct amount of time if (pressLength_milliSeconds >= optionTwo_milliSeconds){ digitalWrite(ledPin_Option_2, HIGH); } //option 1 - Execute the first option if the button is held for the correct amount of time else if(pressLength_milliSeconds >= optionOne_milliSeconds){ digitalWrite(ledPin_Option_1, HIGH); }//close if options //every time through the loop, we need to reset the pressLength_Seconds counter pressLength_milliSeconds = 0; } // close void loop Comments: At the top of the sketch, we find the comments. You should make it a habit to read the comments in a sketch before jumping into the mechanics of the code. The comments should lay the groundwork for what is going to happen in the program and will help you interpret the intent of the code as you begin to analyze it. Declare and Initialize Variables: After the comments, we start initializing and declaring variables. Since, we are going to be tracking time, we need to have a variable to record the length of time a button is being held. We do that with the pressLength_milliSeconds variable: //We need to track how long the momentary pushbutton is held in order to execute different commands //This value will be recorded in seconds float pressLength_Seconds = 0; Now, you might think that the variable name is really long and annoying. And I wouldn’t particularly argue with you – I mean, why would I include milliSeconds in the name of the variable? The reason I do this is because I think including the unit of measurement in the variable name is helpful when other people are trying to read your code. Writing code that other people can read is not only good for other people, but also future versions of yourself who forget what the heck you were thinking when you wrote the code! [End Rant] The next thing we need to set up are the parameters for when options will get executed. In this example, I have two variables for two options: // Define the *minimum* length of time, in milli-seconds, that the button must be pressed for a particular option to occur int optionOne_milliSeconds = 100; int optionTwo_milliSeconds = 2000; Each option is defined by the number of milliseconds that the button must be held for that specific option to get executed. In order to get my first option to happen, I have to hold the button for at least 100 milliseconds which is pretty much a short tap on the button. If I want the second option to happen, then I have to hold the button for at least 2000 milliseconds aka 2 seconds. If you wanted more options, you would add more variables here with their corresponding hold times. Our final initializations will be to specify pin numbers for our button and LEDs. //The Pin your button is attached to int buttonPin = 2; //Pin your LEDs are attached to int ledPin_Option_1 = 13; int ledPin_Option_2 = 12; Setup() the Sketch: The setup() for this sketch is pretty straight forward (if it’s not straight forward to you, make sure to check out our free 12-part Arduino Course , after which this setup will be very familiar to you). We want to make sure that the pin our push button is connected to is set as an INPUT_PULLUP: // Initialize the pushbutton pin as an input pullup // Keep in mind, when pin 2 has ground voltage applied, we know the button is being pressed pinMode(buttonPin, INPUT_PULLUP); We do this to make sure that the button pin is not floating (if you are wondering what the heck that means, you can read more on that here – but if you just roll with me until we get through this tutorial, you should be fine ). We also want to specify the pins that our LEDs are attached to as OUTPUTs, because we will be applying voltages to these pins in order to illuminate them: //set the LEDs pins as outputs pinMode(ledPin_Option_1, OUTPUT); pinMode(ledPin_Option_2, OUTPUT); Finally, it never hurts to start serial communications for debugging purposes. //Start serial communication - for debugging purposes only Serial.begin(9600); With setup() complete, now we can jump into the main loop of our sketch… The Main Loop(): We know we are going to have to measure the length of time the button is pressed, and then record it. To do this, we use a while statement whose condition requires the button pin to be in a LOW state (remember, when we push the button, pin 2 will have a ground voltage applied). //Record *roughly* the tenths of seconds the button in being held down while (digitalRead(buttonPin) == LOW ){ Once the button is pressed and held, the while statement starts executing. The first thing we do in the while statement is to delay 100 milliseconds, and then record that into our time tracking variable: delay(100); //if you want more resolution, lower this number pressLength_milliSeconds = pressLength_milliSeconds + 100; Keep in mind the first time through the loop, pressLength_milliSeconds will be equal to 0, so we are just adding 100 to the variable. It can be handy to know how long the button has been pressed as you add options. To make this easy, we want to print the current value of the pressLength_milliSeconds variable to the serial monitor window: //display how long button is has been held Serial.print("ms = "); Serial.println(pressLength_milliSeconds); Let’s ignore the rest of the code for a second, and imagine what happens if we keep holding the button. The first time through the while loop, we add 100 milliseconds to the time tracking variable and we print that value to the serial port. The next time through loop, we add another 100 milliseconds to the timer counter variable, and print this new value to the serial monitor. As long as the button is being held down, then we keep adding time to the pressLength_milliSeconds variable – this is the crux of the program. When we release the button, the while statement stops, because the condition is no longer met, and we stop adding time to pressLength_milliSeconds. So let’s pretend we held the button for three seconds, and then let go - what happens? Well, as we discussed, the while statement ends and the next line of code we encounter is an if statement. //Option 2 - Execute the second option if the button is held for the correct amount of time if (pressLength_milliSeconds >= optionTwo_milliSeconds){ digitalWrite(ledPin_Option_2, HIGH); } The condition of the if statement requires that the time we held the button be longer than or equal to the time we set for option number two. If you recall, option number two was set to occur with at least 2 seconds of button press time. Since we held the button for three seconds, this if statement will get executed. And all we do is write HIGH voltage to our “option 2” LED, making it illuminate. What if we had only held the button for one second – then what would happen? If this were case, then the first if statement condition would not have been met, but a subsequent else-if statement only requires the button hold time be 100 milliseconds or more – so the second else-if statement would get executed, which turns on the “option 1” LED. //option 1 - Execute the first option if the button is held for the correct amount of time else if(pressLength_milliSeconds >= optionOne_milliSeconds){ digitalWrite(ledPin_Option_1, HIGH); }//close if options Basically, if we hold the button a long time, the second option gets executed. If we hold the button a short time, the first option gets executed. If we wanted to add more options, we add the longer hold options at the top, and the shorter hold options at the bottom. I wouldn’t try to squeeze too many options in a small span of time or it might drive the end user crazy trying figure out the timing. Nor would I try to add more than three options for a single button within a given context, or else you chance making your potential end user want to beat you up. To finish up the sketch, we reset our button press timing variable to zero. This ensures that next time the button is pressed and held, we will start from time zero again. Try On Your Own Challenge: Add another option, which turns off both LEDs. Try adding it before the first option (you will have to adjust the timing) and then after each option. How tight can you squeeze the option time together? Experiment and determine what is a good rule of thumb. Download: PDF of this Arduino Tutorial…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Understanding HIGH and LOW Arduino Pin States 12:31

8 years之前12:31

12:31

If you are just getting started with Arduino, you might be wondering what the heck all this HIGH and LOW stuff everyone is talking about really means. At first I just figured everyone using micro-controllers was just on some type of emotional roller-coaster, until I began to realize that HIGH and LOW are actually abstractions. But let us not talk in abstractions - let us talk in concrete numbers and get down to the bottom of what HIGH and LOW actually mean. This Tutorial Will Include: What the heck is a PIN state? What are the values for Arduino Pin States? Practical Application: What do we see in practice?…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Floating Pins, Pull-Up Resistors and Arduino 10:29

8 years之前10:29

10:29

Floating Pins on Arduino have always been a bit of mystery to me. It just never made much sense. I did this video more for my own sake - just to concrete it in my brain. I hope it can add some solidarity to your understanding as well...

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
The MOST guaranteed way to NOT buy a Fake Arduino (The Story of Pizza-Duino) 5:48

8 years之前5:48

5:48

Let's not be duped by people trying to sell us authentic Arduino's that are counterfeit. This video will show you the one way to be sure you get the real deal, and five methods of telling if you bought a counterfeit or not.

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Throw out your breadboard! Dr. Duino: An Arduino Shield for debugging and developing Arduino projects 11:35

8 years之前11:35

11:35

In the last couple of episodes we have talked about Arduino shields and breakout boards. In this video, we will review a specific Arduino shield that makes developing projects and debugging sketches on the Arduino extremely easy - it's called Dr. Duino.Arduino Shield for Arduino Shields The Dr. Duino is an Arduino Shield . As would expect, it fits snuggly on top of the Arduino headers and has pin headers of it's own, which can easily accept a shield on top. The first thing you notice about Dr. Duino is that it's built like a doughnut - it's got a giant hole in the middle! (FYI - It does not taste like said pastry…) There are a couple reasons for this form factor, but foremost is that even after you stack another shield on top of Dr. Duino, you still have easy physical access to all its resources. Dr. Duino Hardware Resources What resources are we talking about? Dr. Duino has 4 momentary pushbuttons, 5 LEDs, 6 potentiometers, an RS232 connector, and a bunch of access points for 5 volts, 3.3 volts and ground, oh yeah, and a siren (piezo buzzer). So how do you access these resources and why would you even care to? Both great questions! The core feature that allows us to use all the hardware I just talked about are groups of three “jumper” pins that surround the board. Almost every pin on the Arduino is associated with a set of these jumper pins. The middle pin is connected directly to the Arduino pin. The pin on the left is connected to the pin header on top of the Dr. Duino. The pin on the right is connected to the one of the hardware resources on the Dr. Duino board. With each set of these three jumper pins we get a plastic encased "jumper" - it fits snug on top 2 pins, and electrically connects them together. For every Arduino pin that has associated Dr. Duino jumper pins we have 2 decisions: 1) We can route the Arduino pin to the shield above by connecting the center pin to the jumper pin on the left. This passes the Arduino pin directly up to the shield if you have one attached, bypassing the Dr. Duino. 2) Or, we can route the Arduino pin to the resource on the Dr. Duino shield, bypassing the shield above. Each pin has a different "resource" or piece of hardware that you can use. Here is a quick mnemonic for remembering how to place the “jumper” on the “jumper pins” – Left goes Up (to the shield above), Right goes to Down (to the Dr. Duino). Digital pins 5, 6, 10, 11, and 13 have LEDs attached. Digital Pins 7, 8, 9 and 12 have momentary pushbuttons attached. Analog pins A0 - A5 have potentiometers attached and digital pin 3 is attached to the piezo buzzer. All these asset are extremely helpful. For example, let's say I am prototyping with a motor shield. What I want is for every time I press a button, then a servo moves 180 degrees. Instead of having to bust out a breadboard and jumper wires, I simply move a jumper on the Dr. Duino and I now have a preinstalled button. As long as the shield is not using that pin for anything, it's fair game to route that pin to the Dr. Duino. Or, maybe I want to turn a potentiometer to get the servo to move. Once again - scrap the breadboard - just move a jumper on one of the analog pins and you have a built in potentiometer - in fact, every analog pin has its own dedicated potentiometer! Trying to put 6 potentiometers on a breadboard and run jumpers is a major pain - having these built right in and so compact is great. Potentiometers are great for simulating sensor inputs too. Say you are developing a project that lights up LEDs based on inputs from a pressure sensor - but you don't have the sensor yet. No worries - just use the potentiometer built in to the Dr. Duino to simulate the input from the pressure sensor. Another great resource is the piezo buzzer. Most of us get used to using the serial window to debug our sketches. For example - we use the Serial .print() function to send a value to the serial monitor window when some threshold is met. What this ends up doing is dividing our visual attention from the Arduino to the computer monitor. With the piezo buzzer, you can get the same information, but be able to look at your Arduino - it allows you to incorporate more of your senses into the debugging process. All of these features add up to a great little development package - it's like a breadboard full of components all connected on a handy shield. So if I am traveling I don’t have to pack away a bunch of pieces-parts, I can just throw the Dr. Duino in with my Arduino and go for it. A Tool for Learning Arduino Code Another great use of these resources is when you are learning to use Arduino. If you are really trying to jump right into the code, then setting up the circuit can sometimes be a hassle, even if its just a button and an LED. (Yes - I am that lazy!) With Dr. Duino you can work through practically every sketch in the examples section of the Arduino IDE with only some minor code changes (mostly pin designations changes), without having to add a single piece of hardware. That’s a time saver (especially when it’s hard enough to carve out time to learn). Especially if having to place the components just feels like another barrier to practicing your Arduino coding. A Debugging Tool So far, most of my love for the Dr. Duino has come from this development aspect, but the Dr. Duino has actually been designed to help you debug your sketches when using shields. Microcontrollers (like the Arduino uses) are truly at the threshold of hardware and software. The more you know about both the physical and virtual, the better off you will be. Here in also lies a challenge – you can screw up both the hardware and the software. A big part of debugging your work is tracking down where the issue exists – is it the copper or code? (Or both !@#$) The Dr. Duino’s key feature of being able to direct an Arduino pin to or away from a shield you are using enables you to more quickly establish the starting point of debugging. Once you master how the rerouting works, the Dr. Duino will be a go-to shield for developing and debugging. With such a diverse set of applications it’s no wonder Arduino continues to grow wildly popular. Shields like the Dr. Duino make it that much more fun to use Arduino as a rapid prototyping tool. Special Bonus If you are interested in getting your hands on a Dr Duino, you can buy them directly from the Dr. Duino website . The creator of Dr. Duino (Guido Bonelli) has been kind enough to offer Open Source Hardware Group readers a free shipping code. Free Shipping Code: OSHWG_RULES (So true…)…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Shorthand Arithmetic :: Using Compound Operators (+= , -= , *= , /= ) with Arduino 12:43

8 years之前12:43

12:43

In this lesson we discuss some common shorthand for simple arithmetic in Arduino. We cover several compound operators that add, subtract, multiply and divide making it easy to increment variables in useful ways.

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Understanding Boolean Data Types and Using the Boolean NOT (!) operator to Switch Arduino Pin States 8:11

8 years之前8:11

8:11

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
What to do when you just don't know :: Arduino, ADXL345 triple axis accelerometer and an RGB LED 14:04

8 years之前14:04

14:04

This lesson discusses what to do when you open an existing program and realize that you simply don't understand all the stuff that is going on. It also talks about using the ADXL345 triple axis accelerometer breakout board to control the hue of a Red-Green-Blue (RGB) LED.

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
3 Ways to Use Acceleration in an Arduino Sketch 17:37

8 years之前17:37

17:37

This lesson covers three easy ways to implement some form of acceleration in your Arduino sketches. It will cover the following: Linear Acceleration Exponential Acceleration Messing Around with the Square Root function What is Acceleration? Acceleration is the rate of change of something over time. Acceleration would help describe things like: Have fast can a stopped car get to 88mph? If I do a wing-suit jump from the top of Mount Everest, how fast will I be when I am gliding over base camp? How can I gently slow down the movement of a mechanical servo before it comes to rest? We can implement acceleration when programming Arduino quite easily with just a couple lines of code. The basic concept is that a variable will need to change - how it changes over the course of the sketch is what we are interested in. Below are three examples of how we can code change in variables so they display acceleration. Linear acceleration Linear acceleration is a constant rate of change. It can be represented by a sloped line on an x-y axis. A simple way to use it is to increment or decrement a variable every time through a loop like below... for (int i = 0; i < 10; i++) { //accel gets increasingly smaller as for loop continues accel = accel - 100; }//close for You can see in the code above, that each time through the 'for loop', the accel variable is decreasing by 100. If accel started at 1000, this is what accel would look like with respect to the number of iterations of the for loop. You can see that the accel variable decreases at a set rate over time in a linear fashion. Exponential Acceleration Exponential acceleration changes over time too, but it does so more dramatically (It's basically a drama queen). At first the rate of change in the variable is small, but once it begins to increase it really takes off! You can use the power function built into the Arduino IDE to make a variable change exponentially. The power function syntax is quite easy. pow( base, exponent ) The parameter base is the number that get raised to the power of the exponent . Like 2 to the 5th power. Below is an example of how you might code it to change a variable exponentially over the course of a 'for loop'. for (int i = 0; i < 10; i++) { //accel grows exponentially as the for loop continues accel = pow(2, i); }//close for Looking at a chart of accel over the course of the 'for loop', we can see that the way it changes is much different than linear acceleration: The theme for exponential growth is that is starts out slow, but once it starts going it really get's going! Using the Square Root Function for Acceleration The square root function can also provide some flavor to the output from your Arduino. It's syntax is simple: sqrt( x ) It returns the square root of the number or variable that you put in the parenthesis. Below is an easy way to use it in a 'for loop': for (int i = 0; i < 6; i++) { //accel quickly decreases through the loop accel = sqrt(accel); }//close for Let's look at how accel changes over the course of the for loop(let's say it started at 10,000): You can see the a rapid deceleration in the value of the accel variable of the 'for loop'. Practice With Acceleration: If you want to take a look at what these types of acceleration will do in "real" life, then set up the circuit below. You Will Need: (10) LEDs (10) 220 Ohm Resistors (1) Jumper Wire Arduino Board Bread Board Black Marker Set Up The Circuit: Start by by placing one resistor at pin 2 on your Arduino. Connect the other end of the resistor to the breadboard and then connect the long leg of the LED to the resistor. Place the short leg of the LED in the outer ground rail of the bread board. Then add 9 more resistors and LEDs across - you should stop at Pin 11 on the Arduino. Then add a jumper wire from GND on the Arduino to the shared ground on the breadboard. (All LEDs not pictured). That is pretty much it for the circuit. Below are the code examples for the different ways to program acceleration that we talked about: Here is the code for the linear acceleration: /* Linaer ( Constant ) Acceleration The circuit: * LEDs from pins 2 through 11 to ground created 2006 by David A. Mellis modified 30 Aug 2011 by Tom Igoe Modifeid 21 Jul 2014 by Michael James This example code is in the public domain. http://www.arduino.cc/en/Tutorial/Array */ //Declare and initialize variables // The higher the number, the slower the timing. int timer = 1000; // an array of pin numbers to which LEDs are attached int ledPins[] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; // the number of pins (i.e. the length of the array) int pinCount = 10; void setup() { // the array elements are numbered from 0 to (pinCount - 1). // use a for loop to initialize each pin as an output: for (int thisPin = 0; thisPin < pinCount; thisPin++) { pinMode(ledPins[thisPin], OUTPUT); } //Start Serial Communication Serial.begin(9600); }//close setup void loop() { // loop from the lowest pin to the highest: for (int thisPin = 0; thisPin < pinCount; thisPin++) { // turn the pin on: digitalWrite(ledPins[thisPin], HIGH); delay(timer); // turn the pin off: digitalWrite(ledPins[thisPin], LOW); //decrement timer (EASY WAY) timer = timer - 100; //let's take a look at the numbers via the serial monitor window (Tools > Serial Monitor) Serial.print("Back ... LED #"); Serial.print(thisPin); Serial.print(" = "); Serial.println(timer); }//close for //reset timer for next for loop timer = 1000; // loop from the highest pin to the lowest: for (int thisPin = pinCount - 1; thisPin >= 0; thisPin--) { // turn the pin on: digitalWrite(ledPins[thisPin], HIGH); delay(timer); // turn the pin off: digitalWrite(ledPins[thisPin], LOW); //decrement timer timer = timer - 100; //let's take a look at the numbers via the serial monitor window (Tools > Serial Monitor) Serial.print("Forth ... LED #"); Serial.print(thisPin); Serial.print(" = "); Serial.println(timer); }//close for //reset timer for next for loop timer = 1000; }//close loop Here is the code for the exponential acceleration: /* Exponential Acceleration The circuit: * LEDs from pins 2 through 11 to ground created 2006 by David A. Mellis modified 30 Aug 2011 by Tom Igoe Modifeid 21 Jul 2014 by Michael James This example code is in the public domain. http://www.arduino.cc/en/Tutorial/Array */ //Declare and initialize variables // The higher the number, the slower the timing. float timer = 1000; // an array of pin numbers to which LEDs are attached int ledPins[] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; // the number of pins (i.e. the length of the array) int pinCount = 10; void setup() { // the array elements are numbered from 0 to (pinCount - 1). // use a for loop to initialize each pin as an output: for (int thisPin = 0; thisPin < pinCount; thisPin++) { pinMode(ledPins[thisPin], OUTPUT); } //Start Serial Communication Serial.begin(9600); }//close setup void loop() { // loop from the lowest pin to the highest: for (int thisPin = 0; thisPin < pinCount; thisPin++) { // turn the pin on: digitalWrite(ledPins[thisPin], HIGH); delay(timer); // turn the pin off: digitalWrite(ledPins[thisPin], LOW); //decrement timer timer = pow(2, thisPin); //let's take a look at the numbers via the serial monitor window (Tools > Serial Monitor) Serial.print("Back ... LED #"); Serial.print(thisPin); Serial.print(" = "); Serial.println(timer); }//close for //reset timer for next for loop // loop from the highest pin to the lowest: for (int thisPin = pinCount - 1; thisPin >= 0; thisPin--) { // turn the pin on: digitalWrite(ledPins[thisPin], HIGH); delay(timer); // turn the pin off: digitalWrite(ledPins[thisPin], LOW); //decrement timer timer = pow(2, thisPin); //let's take a look at the numbers via the serial monitor window (Tools > Serial Monitor) Serial.print("Forth ... LED #"); Serial.print(thisPin); Serial.print(" = "); Serial.println(timer); }//close for //reset timer for next for loop timer = 1000; }//close loop Here is the code for messing around with the square root: /* square root The circuit: * LEDs from pins 2 through 11 to ground created 2006 by David A. Mellis modified 30 Aug 2011 by Tom Igoe Modifeid 21 Jul 2014 by Michael James This example code is in the public domain. http://www.arduino.cc/en/Tutorial/Array */ //Declare and initialize variables // The higher the number, the slower the timing. float timer = 1000; // an array of pin numbers to which LEDs are attached int ledPins[] = { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 }; // the number of pins (i.e. the length of the array) int pinCount = 10; void setup() { // the array elements are numbered from 0 to (pinCount - 1). // use a for loop to initialize each pin as an output: for (int thisPin = 0; thisPin < pinCount; thisPin++) { pinMode(ledPins[thisPin], OUTPUT); } //Start Serial Communication Serial.begin(9600); }//close setup void loop() { // loop from the lowest pin to the highest: for (int thisPin = 0; thisPin < pinCount; thisPin++) { // turn the pin on: digitalWrite(ledPins[thisPin], HIGH); delay(timer); // turn the pin off: digitalWrite(ledPins[thisPin], LOW); //decrement timer timer = sqrt(timer); //let's take a look at the numbers via the serial monitor window (Tools > Serial Monitor) Serial.print("Back ... LED #"); Serial.print(thisPin); Serial.print(" = "); Serial.println(timer); }//close for //reset timer for next for loop timer = 1000; // loop from the highest pin to the lowest: for (int thisPin = pinCount - 1; thisPin >= 0; thisPin--) { // turn the pin on: digitalWrite(ledPins[thisPin], HIGH); delay(timer); // turn the pin off: digitalWrite(ledPins[thisPin], LOW); //decrement timer timer = sqrt(timer); //let's take a look at the numbers via the serial monitor window (Tools > Serial Monitor) Serial.print("Forth ... LED #"); Serial.print(thisPin); Serial.print(" = "); Serial.println(timer); }//close for //reset timer for next for loop timer = 1000; }//close loop I hope the lesson was helpful. The idea of adding acceleration to a sketch can seem a bit intimidating at first, but as you can see, it turns out to be a rather simple addition of code. Try on Your Own Challenge: Can you make the fade amount of an LED accelerate/deccelerate? Can you add a potentiometer to the circuit above and find a way to control the amount of acceleration - either linear, exponential or otherwise.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Check out our premium Arduino Training Course 2:16

8 years之前2:16

2:16

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Understanding the Arduino uber functions loop() and setup() 10:26

8 years之前10:26

10:26

Discussion: In this lesson, we're going to discuss two very special functions that you will use in every single Arduino sketch that you write. They're called Setup and Loop. Specifically, we’ll cover: How Setup Operates and the type of code that it executes How Loop Operates and the type of code that it executes Loop Function’s Responsive Outputs How to get those little ships inside the glass bottles I want you to pretend for a moment that you own a specialty Italian sub shop. Business is great, and you have wonderful customers. However, you have one major problem. Employee turnover is very high. This is mostly because the majority of your employees are teenagers who, by nature, tend to move on to different things. It feels like as soon as you get an employee trained, they move on to Harvard Business School or get a scholarship to MIT - or they just decide that bungee jumping all day long is better than making subs. In order to help train new employees, you create two binders of procedure lists. One binder is called “The Morning Setup Binder”, and it lists all the stuff that you have to do when you open the store. This binder contains things like unlock the front and back doors, turn on the “Open” sign, put the delivered sausage in the fridge, and get the broccoli out of the fridge. It's stuff that only has to be done once. Once all of that stuff has been done, a new employee can take that binder and stick it on the shelf. Then, they can pull out “The Sub Making Binder”. This is the binder that lists step-by-step everything an employee has to do to make a sub and deliver quality customer service. It might go something like this: When a customer walks in, welcome them with a warm, "Hello!" Ask them what type of sub they want. Ask them what type of bread they want. Ask them what type of condiments they want. Ask them if it will be for here or to go. See if they want to add one of Mama's homemade cookies to their order. I think you get the gist. The binder lists these steps in detail and talks about the quantities of toppings for different subs. “The Sub Making Binder” is really the procedure list that drives the task of the employee and will be the binder that the new employee will keep open all day long when they're starting out. They're going to go back to it over and over again for every sub. So, what does this have to do with programming? Well, a program in Arduino has to do similar things like the sub shop. The Setup Function There are certain tasks that need to be done just once when the program first starts. These are things like: setting up a serial communication to talk with the computer over a USB port, setting the modes of microcontroller pins as either inputs or outputs, displaying a welcome message on an attached LCD screen, or possibly turning a servo to a default location. All of these things might only need to happen once when the sketch first starts and never need to be bothered with again until the program is restarted or the Arduino is reset. These are the type of tasks that are put into a special function called Setup. Let's take a look at Setup. First, notice that the color of Setup is different. Unfortunately, the color is reminiscent of baby poop. This automatic coloring, though, is letting you know that the Arduino IDE recognizes the function Setup as a special type of function that's used for controlling the structure of the code. You'll also notice that right after the word Setup there is an opening and closing parenthesis. The Setup function doesn't need any arguments to operate, but you still have to include the opening and closing parentheses just as you would in any other function. To the left is the word void. Void means that the Setup function will not return any data. So this is a function that doesn't need any arguments from us in order to operate and doesn't return any values to us, but it does do something. Its job is to execute all the code inside its opening and closing curly braces precisely one time. Let me say this again - and with a dramatic pause - because it’s that important! Setup only runs once. When the program starts up, Setup will run just once. All of the code inside the curly brackets will get executed one time. If you pretend the program is like the high schooler at the sub shop, the first thing she does when she comes to work is open “The Setup Binder” and go line-by-line until everything is done. Once everything in Setup is finished, she closes the binder, and then she goes on to the next binder. The Loop Function For the Arduino sketch, the next binder is the Loop function. The Loop function looks just like the Setup function. It doesn't take any arguments. It has the opening and closing parentheses. It doesn't return any values, so it has that void to the left. Then, it has the opening and closing curly brackets. Just like Setup, when Loop gets executed, the program will work line-by-line down the sketch. However, here’s how Loop is different. When the code between the curly brackets has been executed, the program starts back at the top of the loop and does it all over again. Back to our sub shop example, imagine the teenage employee during the lunch hour rush. He has customer after customer lined up, and he's going through each line in the procedure guide step-by-step. He asks what kind of sub they want. He asks what kind of bread they want. He asks if they want it for here or to go, and so on and so forth. He keeps working down that list until he gets to the end of the procedure list. Then, he starts back at the top of the list with the next customer. He does this over and over and over, all through the lunch rush and all day long. This is how the Loop works. It executes all of the code inside the curly brackets, step-by-step. When it gets to the closing curly bracket, it starts all over at the top, working through all of the code again, line-by-line. It does this over and over and over. How fast can it go through the loop? How fast can it actually execute this code? Well, that's a really good question. The answer is that it depends, but the microcontroller that the Arduino uses can run at 20 megahertz. Each line of code you write might end up being multiple instructions when it actually gets translated into machine code, but needless to say, even a sketch with several thousand instructions will be looping pretty fast. Even though I really do like this sub shop analogy, there's one key place that it breaks down. I want to point it out so that you're not misled. In the sub shop example, the teenager waits to start the instructions again when a new customer shows up. In reality, the code in the Loop automatically starts over. Once it gets to the bottom, it jumps back to the top. It doesn't wait for any outside input to do so. Responsive Outputs for Loop Functions You might be wondering how the same code running over and over again can produce any coherent result. How does it add any variation? Well, think about that teenage sub maker. Do you remember the steps that she had to follow? Many of the steps could have different results depending on the response of the customer. So she may have had one procedure guide, but she could make a giant variety of tasty subs as a result. It's the same way with the programming code. You're going to write instructions that will do different things based on different new inputs. For example, if the water level is above some threshold, then beep an alarm. Otherwise, don't do anything. As the code loops over and over again, it's probably doing nothing until it sees that the threshold was too high. Then it executes what you've asked it to do. Or maybe something like... while the light is shining, keep the servo arm at 60 degrees. There's all types of amazing things that you can do and all types of possibilities of how you can control things. There’s one last thing to keep in mind. The Setup and Loop functions are required in your sketches. Your sketches will not compile without them being present. In fact, these two functions are so integral that when you open up a new sketch in the Arduino IDE, you'll find them already there for you pre-populated. Review This was a lot of information, so let's review. Setup and Loop are special functions that help define the structure of the program. Setup is written before the loop and only executes once. All of the code in the Setup function only runs once. The code in the Setup function does things like set pin modes, start serial communication with the computer, display default messages to an LCD screen, or just about anything that needs to happen only once at the beginning of a program. The Loop function comes after the Setup function. All of the code in the Loop function runs over and over forever really fast. Both the Loop and the Setup function are required in your sketch. The program will not compile without them. If you ever forget what the Loop and the Setup do, just say their names. Setup sets up the sketch. Loop loops over and over again. I hope you have a wonderful day, and I can't wait to see you in the next video lesson.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Functions: Let's make programming Arduino as easy as possible 11:00

8 years之前11:00

11:00

Discussion: In this lesson, we're going to do an overview of functions. This will be just a general discussion to lay out a framework for understanding how functions work and how we can use them. More specifically, we'll be talking about: Function Calls Function Parameters Passing Arguments Different Ways Functions Work In an earlier lesson, we said functions are like the verbs of a programming language. If you want to get something done, it's probably going to involve a function. Function Calls The Arduino programming language is essentially the same as C++ and a lot like C. So, it’s chock-full of different types of functions that do all kinds of things for us. If you can think of something, there's probably a function that does it. To use this grand variety of functions, all we have to do is type the name of the specific function that we want to use. That's it. You just type its name. Then you follow its name by an opening and closing parenthesis. Sometimes, you have to put values in between those parentheses. Let's take this function called digitalWrite, for example. The digitalWrite function wants to know a pin number on your Arduino, and then it wants to know a state, either HIGH or LOW. Once you give it that information, it will apply either five volts, which would be a HIGH state, or zero volts, which would be a LOW state. When we type digitalWrite in our program, that is called a function call. I want to make sure that you’ve heard that terminology, function call, because you’ll be hearing it quite a bit. We'll actually be going over a lot of terminology in this lesson. Function Parameters Some functions require information from us in order to work properly. The function digitalWrite needed to know two things. It needed to know pin number and high or low voltage. The pieces of information that the function needs to operate are called the function's parameters. You might be wondering, “How am I supposed to know what the parameters of a function are?” That's actually a really good question because when you look at the word digitalWrite, there's nothing in the name that alludes to what parameters it needs. In order to know what the parameters are, you have to look it up in a resource called the reference. The reference is like a user manual for programming languages. For functions that you use all the time, you'll become very familiar with what the parameters are. You won't have to look it up all the time. However, for functions that are unfamiliar, you'll probably have to refer to the reference frequently. It's really easy to use, and you'll learn a lot more about it throughout the course. Passing Arguments Back to our discussion on parameters. As said before, parameters are what a function wants or expects. The actual values that you give to the function, though, are called the arguments. In our digiWrite example, we have the number three and the state as HIGH. Those specific values are the arguments. This might sound like a case of semantics to you, but it's actually quite different. Parameters are just the general definition of what the function expects, like pin number or state. The argument is the specific value that you pass to a function, like 3 or HIGH. One more term to learn is “passing”. When I give a function arguments, it's called passing. I pass the arguments to a function. Okay, so let's do a quick recap. When we use a function, it's called a function call because we're calling a function. Seems straightforward, right? The information a function needs to operate are called its parameters. The actual values we send into the function are called arguments. Lastly, when we send those arguments, we say we’re passing the arguments to a function. Phew, that's a lot of terminology! Keep in mind that that's all it really is. It's just fancy computer programming words. The reason I want to talk about it here is because we're going to be using these terms throughout the course, and I'm sure you'll hear them elsewhere. Therefore, I think if you understand these terms, it will help us communicate better since we'll all be speaking the same language. Different Ways Functions Work Now let's move on to the different ways that functions work. For some functions, like our example digitalWrite, do something for us. We might pass the number 13 and HIGH to digitalWrite, and digitalWrite then applies five volts at pin 13. The function actually does something physical for us. Other functions just return values. For example, the function digitalRead monitors a pin on the Arduino and lets you know the state of the pin, either HIGH or LOW. It only has one parameter, which is the number of the pin that you want to check. To make sense of this, let's look at this line of code as an example. We have pinState = digitalRead(3). This line of code assigns the output of the digitalRead function to the variable pinState. So when this gets executed, the function digitalRead gets called, and we pass it the value three. Therefore, three is our argument. Now, digitalRead goes and checks the state of pin three. It's either going to be HIGH or LOW. Then, it sends that value back to our program. When it sends that value back, it's called returning the value. In other words, the function digitalRead returns the state of that pin. The value that gets returned will then be assigned to the variable pinState. Another example would be a Celsius to Fahrenheit converter function. It takes a number in Celsius and then returns the different, converted value in Fahrenheit. If you want that new Fahrenheit value, you need to assign it to a variable. Alright, so far we've been talking about functions that take parameters. In order for them to work, you have to give them some information. However, there are other functions that don't need any information to work. One common example is the millis function. When you call the millis function, it pulls the number of milliseconds that the current Arduino sketch has been running. Millis uses hardware that's integral to the integrated circuit the Arduino uses. It's going to pull information behind-the-scenes and return this value to you. You don't have to do anything. There are other functions that do this, as well. You don't have to give it any information. It goes out, it does stuff, and it gives that information back to you. So in this line of code, the variable timing will be assigned the number of milliseconds that the millis function returns. Finally, there are some functions that don't take parameters and don't return values. They just do something when they're called. Maybe you're working on a project that waters plants at different time intervals. You might need a function that simply opens a valve. In this line of code, we have OpenValve. The OpenValve function doesn't take any parameters. It simply opens a valve that we specify elsewhere. When we use a function, it's important to realize that there's more than meets the eye. For example, do you know what DNA stands for? It stands for deoxyribonucleic acid. It's quite a mouthful to say. So instead of saying deoxyribonucleic acid, people just shorten it and use the acronym DNA. It's a quick and easy way to communicate deoxyribonucleic acid without actually having to say deoxyribonucleic acid. Functions are similar to this in that they allow quick and easy access to a mouthful of useful code - the function definition. For every function name that you use, like digitalWrite or digitalRead, there's a function definition that gets executed for you behind the scenes. The function definition spells out exactly how that function is going to behave, what parameters it will use, whether or not it will return any values, and the like. In most cases, you're going to care very little about the function definition. You're going to be more interested in how to use the function. After all, the power of a function is its ability to reduce your workload. Programming languages are filled with tons of useful functions. Some are used far more frequently than others. You'll find that you'll get quite familiar with a couple dozen or so of your most frequently used, most effective functions. Other functions you'll slowly integrate into your knowledge. Later in the course, you're even going to learn how to write your own function definitions so that you can make your own handy user-defined functions, but that's going to be for a later time. Review Alright, let's review this lesson. We discussed what it means to make a function call. We also discussed that parameters are the general values that a function expects in order to work. The specific values we give a function are the arguments. Giving the function these arguments is called passing the arguments to the function. Finally, we talked about different ways that functions work. Some take arguments and then physically do something. Some take arguments and then return a value. Some don't take any arguments and but still return a value. Some don't take any arguments and don't return a value, but they still do something. We also touched on a lot about terminology in this lesson. Again, the goal of this lesson was just to layout a framework. I wanted to give you an overview of how we're going to be interacting with all different types of functions throughout the course. I look forward to seeing you in the next lesson.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Data Types: One size does not fit all 11:15

8 years之前11:15

11:15

Discussion: We're going to explore some of the specific data types you'll encounter as you begin to program with Arduino. We’ll tackle data types in more detail, to include: Integer and Integer Qualifier Long Float Byte Boolean Character Data Types Recap Let's review what we’ve learned in previous units. We know that when we create a variable, we need to declare its data type. We also know that a data type is simply a way to classify the types of information that you're going to put in a variable. Data type determines several things: what range of values can be stored in the variable how much space and memory that variable needs what types of operations can be performed on that variable Integer We'll begin our discussion of data types with the most common one that you'll see in this course - the integer. This is abbreviated “int” when you type it into the Arduino IDE. The integer is really the go-to data type if you need to store a number. It can hold a value from -32,768 all the way up to 32,767. Keep in mind that it only holds a whole number. You can't store a decimal, such as 3.14, in a variable whose data type is integer. Also, an integer is a 16-bit value. In other words, it takes 16 bits (or two bytes) of memory to store an integer. It doesn't matter if you put a small number in that integer variable like 10, or a big number like 30,000. The compiler will always set aside two bytes for any integer, regardless of number size. In the grand scheme of things, that's pretty small and is why integers are our friends. They don't take up that much space, even if you need to hold a very large value. Now, what happens if you try to put a number bigger than 32,767 inside an integer variable? Well, it actually rolls over. I’m sure most of you are familiar with Pac-Man. You know how if he goes off the screen, he comes right back on the other side? The same thing happens with variables. Let’s say we had an integer variable storing 32,767. Then, we add one to it. The result will actually be -32,768, which is called rolling over. Likewise, if you subtract one from -32,768, the result will be 32,767. This leads us to a really important point. When you create a variable, you should have some idea about how big you expect the stored value will be. That expected value will help you determine what data type you should use for a given variable. Remember, the key aspect of variables is that they change - they can vary. At some point, you'll probably do calculations with those variables and change what is stored there based on your results. You can only put so much water in a bucket before it spills over. Therefore, if the value in that variable at any time exceeds the size allow by its data type, it's going to roll over. You can imagine that might return some really weird results. With this in mind, what happens if you need to store a number bigger than 32,767? Well, you have a couple of options. However, before we abandon the integer for a data type that takes up more of our precious memory storage, let's talk about what signed and unsigned means. Integer Qualifier By default, an integer is signed. This means that it accepts both positive and negative signs. So when we say signed, we're talking about the fact that the value could be negative or positive. What if we know we won’t be working with negative numbers? Our variable will never need to store negative values. For example, if I'm using a variable to store the number of days that have passed, there's never going to be a negative number of days. The number is only going to increase from its starting point - unless, for all of you 80’s kids out there, I jump in a Delorean or something like that. If this is the case, we can use what is called a qualifier to make an unsigned integer. This gets rid of all the negative values and shifts them into the positive range. To use the unsigned qualifier, all you have to do is write unsigned before the “int” data type and voila... now you can store a value in the range from zero to 65,535 AND you’re still only using two bytes of storage. Totally awesome! Rolling over still works the same way, though. If you add one to 65,535, you will roll back to zero. Long That’s great, but what if you need a number bigger than 65,535? This brings us to a long. Long is a data type that stores four bytes of data and can hold a value from -2,147,483,648 to 2,147,483,647. You can think of a long as a really big integer. It acts the same way in that it can only hold whole numbers and can be made to qualify as unsigned if needed. This reaps you a whopping range of zero all the way up to four million and some change. Float We still keep running into this whole number wall, though. What if I want to store a decimal value? In programming, a number with a decimal point is called a floating point number. The point can float around the number. The data type for a floating point number is simply the float, and it can hold a value in the range from 340 undecillion 282 decillion, 315 nonillion (or 3.4028235E38 for you math whizzes). That's pretty big, so you might be thinking, “Geez, how much memory does it take to store a floating point number?” It's actually only a cool four bytes. That's right. It's no bigger than the long. How is this possible? It comes down to precision. In reality, a floating point number is only good up to six or seven actual numbers that mean anything. That's the total number - not just how many numbers after the decimal point. A number like 4,056.897 would be within the precision of a floating point number. You can see we only have seven digits there. The same would go for something like 40.1234. The less significant numbers after that, though, are going to be rounded off, chopped off, and battered. You really don't know exactly how the compiler's going to handle them. Large floating point numbers can be made using a capital “E” following the number. This means the same as it did in math class. For example, 42E2 means 42 times 10 to the second, or 4,200. You can think of the number that follows the E as the number of zeroes you want to add to the number before the E. To be honest, I hardly ever use the E. I just want to throw it out there just in case you run into it. Byte Another data type is the byte. A byte can store a number from zero to 255. As the name implies, it only takes up one byte of storage. That’s extremely small. You could also run into a number like B10010 being set equal to a byte. This is a number represented in the binary numeral system. B is the binary formatter. It lets the computer know to interpret the number following the B as a binary number. We aren’t going to delve into the binary numeral system because we really don't need to right now. You can check out the further reading section if you want to learn more about that, though. Boolean There is a data type that goes even smaller than a byte. The Boolean data type only takes up one bit of data. It can only hold one of two values: either true or false. Boolean is quite interesting. What happens if you try to put the number 2 in a Boolean data type? Does it roll over? No, it doesn't. With Boolean, any value other than zero is true. Numbers like 2, 5, -2, and 47 put in as a Boolean variable would be represented as true. False can be represented by several things. It can be represented by the keyword FALSE, the number zero, or the keyword LOW. We'll talk more about LOW later on. The true state can be represented by the keyword TRUE, any non-zero number as illustrated previously, and the keyword HIGH. If a variable only needs to represent two states, then a Boolean data type is a good option. Character This brings us to the final data type, the character. A character data type takes one byte of storage, and it holds a character symbol, such as a letter. The letter is actually stored as a number, and that number represents a specific text character in a system called ASCII. ASCII stands for the American Standard Code for Information Interchange. It's the way text is encoded numerically in programming. You can assign values to the character data type two different ways. It can be set equal to the actual character you want, as in an actual a, n, asterisk, or dollar sign, but you have to put single quotes around that character. The other way is to assign it as a number value since characters can be represented by numbers. For example, the following two lines of code would be equivalent because 97 is a lowercase a in ASCII code. This also means that you can perform math on characters. We won’t get into that now, but it's kind of neat. Review Let's review what we've covered in this lesson. We talked a little bit more about data types and what they do for us. We talked about integers and the fact that they only hold whole numbers. Roll over and integer qualifiers were also explained, with special attention given to unsigned qualifiers. Long data types were next and how it's a really big number. Then, we moved on to the float for floating point numbers and the byte for simple numbers from zero to 255. The last two data types were Boolean, which is either true or false, and character. I hope you don’t feel overwhelmed with all of this information. You don't have to memorize everything. I just wanted at the very least to give you a feel for what they represent because I guarantee you're going to see them as you open up different programs. Take a deep breath, soak it all in, and I’ll see you in the next lesson.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Understanding Variables 11:26

8 years之前11:26

11:26

Discussion: This lesson covers one of the most fundamental of all programming concepts: Variables. This is a really exciting topic because once you have a handle on how variables work, you have one of the biggest keys to understanding how programming works. Specifically, we'll be discussing: Memory Data Types Declaring a Variable Naming Conventions Initializing a Variable What is a variable? Variables are a programming tool that help us store and recall information in our programs. Memory A microcontroller, like the one the Arduino uses, as well as computers in general, have something called memory. Memory is really handy because it allows us to store information for use at a later time. Let's say I'm working on a project that will monitor temperature during the day. I have a temperature sensor that reads the current temperature every 60 minutes from 1 am until midnight. I want the program to record the highest temperature and then display it at the end of the day on an LCD screen. In order for the program to accomplish this, it needs to store two key pieces of information. It needs to store the value of the current temperature, and then it also needs to store the value of the highest temperature that it has encountered thus far. But how do we actually save this information in a sketch? Furthermore, how do we recall it when we need to remember it? In order to do this, we need to use the memory. For now, think of memory as a big wall of lockers, and you can use the lockers to store something. When you need that something again, you just go back to locker and grab it. But how do you remember what locker you put it in? In order for us to do that, we first have to give the locker a name. That name you gave to the “locker”, the place where you’re storing your stuff, is called a variable. Now technically speaking, a variable is the named address of a specific location of memory. However, I don't want to get caught up in all of the technical stuff. I want to dive into the practical use of variables. Therefore, let's go back to this temperature project. As previously stated, we want to record the highest temperature during a 24 hour period. For our program, I need to store those two key pieces of information: the current temperature and the highest temperature. That means I’ll have to name two lockers. I’ll call one locker "Current Temperature", and I'll name another locker "Highest Temperature". Let's say my Arduino begins taking the first reading of the day. Maybe the temperature is 50 degrees. So I'll open the “Current Temperature” locker, and I'll put in the number 50. At the same time, I'll also open up the “Highest Temperature” locker. Right now there's nothing in it, but 50 is larger than nothing. Therefore, I'll put the number 50 in the “Highest Temperature” locker, as well. So now both of our lockers have the number 50 in them. After 60 minutes pass, I read the temperature again. Let's say it has raised two degrees to read 52 degrees Fahrenheit outside. I open up my “Current Temperature” locker, and I put in 52. This means that 52 overwrites the number 50 so that now the “Current Temperature” locker has the number 52 in it. I also peek inside the “Highest Temperature” locker. I see that 52 is hotter than 50. I go ahead and replace that also. I'm just going to repeat that process every hour. I open up the “Current Temperature” locker, replace the old value with the new value, and then check to see if I need to replace the temperature in the “Highest Temperature” locker. This reveals the first really important thing about variables and the most powerful thing about variables. The contents of a variable change. The name of the variable stays the same because the variable is just the container for the information. We don't want to confuse it with the actual information itself. The variable is the locker. It's not the actual stuff inside the locker. Let's recap what we’ve learned thus far. We need to store information, and we use memory to store it. We can think of memory like a wall of lockers. To use one of these lockers, we have to name it, and the name of the locker is called a variable. Once we have it named, we can put stuff in it and refer back to that stuff at a later time whenever we need it again. Again, the name refers to the location of the locker, not the actual content of the locker. Data Types There is another thing we have to do when we make a variable. We also have to say what type of thing we're going to put in it. This is called the Data Type. A good analogy here is to imagine that you have to build a zoo. You have to figure out where each animal is going to go in your zoo, and you have to make sure that each animal is given enough space so it can do its thing. For example, you'll need a bigger cage for a tiger than you will for an African frog display. If you're going to have an aquatic display, you'll need a bigger tank for a shark than you will for a goldfish. Where am I going with this zoo analogy? Here's the deal. You can't take a monkey and put him in a cage designed for fish. Likewise, you can't take a fish and put it in a cage designed for a tiger. It just won’t work. Variables are similar to this because you have to specify a data type for the variable. Maybe an example will clarify what I mean. Let's assume I have a variable, and I say, "This variable can only hold whole numbers." I can put whole numbers in that variable all day long. However, if I try to put a number like a fraction into that variable, I'm going to get an error. The reason is that I specified the data type for that variable to be whole numbers. I can't put a fraction into a variable that I've designated as a whole number variable. Declaring a Variable Creating a variable is called "declaring" it. To declare a variable, you need two things: a name and a data type. The data type comes first, followed by its name. One example of a common data type is an integer. An integer is a data type that can store a whole number from -32,768 to 32,766. Of course, you don’t need to memorize that. Just understand that a whole number is like 1, -5, or 18. It doesn't have a decimal point after it, such as the number 1.0567. In order to specify a variable as an integer data type, we use the abbreviation "int". The Arduino IDE recognizes all possible data types. Therefore, when you type “int”, it will conveniently change the color of the text for you automatically. Following the data type, we need to key in the name. There has to be a space between the data type and the name. You can name a variable almost anything you want, but there are some basic rules to follow. A variable name cannot contain any spaces or special characters, such as a pound sign, dollar sign, or percent. You may use numbers in a variable name, as long as the name doesn’t start with a number. Also, you can't use a keyword as the name of a variable. Keywords are special words that you will learn about later in the course. They're words that the Arduino IDE restricts for certain uses. Just like data types, the Arduino IDE will change the color of the text when you type a keyword. Thankfully, this means you don't have to know all the keywords right now. If you happen to type one, it’ll change color and will help you realize that you can't use that as a variable name. Naming Conventions Using these rules, how should we name variables? Even though you can name them whatever you want, there are still some naming conventions that are best to follow. The bottom line is that your variable names should be descriptive of what information they will hold. For example, if we wanted to save the current temperature in a variable called "mom", we could. However, it really wouldn't make that much sense. It'd be more logical to name that variable "currentTemperature". That way, if somebody else reads our sketch, they will have a basic idea of what information is actually in that variable. Notice how I wrote the word "currentTemperature". I capitalized the T in the second word temperature. This is called camelCase. It's simply a way to help distinguish the words in a variable name. You could also type "current_temperature" with an underscore between the two words. How you write the name of the variable is up to you. The important concept here is that this is called the "naming convention". It is a way to keep things standardized to make the code easier to read and easier to understand. Throughout the course you'll see me use a mix of camelCase and underscoring, depending on the context of the variable I create. Again, you're free to use whatever name you want, as long as you follow the rules we discussed. Initializing a Variable As mentioned before, when we are declaring a variable, we need the data type followed by the name. Then, at the end of that statement, we want a semicolon. Once we've declared a variable, it can now hold information. To put a value inside a variable, we use what is called the "assignment operator", which is simply just an equals sign. The first (or initial) time we assign a value to a variable, it's called "initializing the variable". We can actually declare and initialize a variable on the same line of code. Here’s an example: We have "int" for the data type and "currentTemperature"as the name of the variable. Next, there is the assignment operator, the equals sign. After that is the value to which we are initializing that variable. In this case, the initial value we are putting in the variable is 40. Lastly, we finish the statement with the all-important semicolon. If we want to change that value at some point later in the program, we just use the assignment operator again. In other words, we would type the variable name "currentTemperature", use the equals sign as our assignment operator, type the new value, and then end it with a semicolon. Review Let's recap this lesson. A variable is simply the name of a memory location. It's how we're able to store and recall information in our sketch. In order to use a variable, we have to give it both a data type and a name. The data type determines what we can put in a variable. Although you can use almost anything for a variable name, we did go over a few helpful rules and naming conventions. When we want to assign a value to a variable, we use an equals sign called the assignment operator. The first time we do this, it's called initializing that variable. Throughout the program, if we want to change the value of a variable, we simply type its name, assignment operator, and new value. That concludes this lesson. I know it's all kind of abstract right now, but these concepts will become more concrete as we move forward in the course. I look forward to next time where we'll dive more into data types and the like.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Syntax; the spelling and grammar of programming 11:32

8 years之前11:32

11:32

You Will Need: The Arduino IDE installed and an Arduino connected to your computer. Discussion: In this lesson, we're going to be talking about programming syntax. We'll be introducing some of the basic programming syntax that you'll be using every time you write a sketch. Specifically, we'll be talking about: what programming syntax is comments the semicolon keywords function syntax layout & indentation Programming Syntax What is programming syntax? I like to use this analogy. You can think of programming syntax like the punctuation and grammar of computer programming. If you've ever read a book, then you're probably really familiar with written punctuation and grammar. For example, in the written word, we use things such as periods, commas, dashes, or semicolons. Languages also have verbs, nouns, diphthongs, and all types of crazy grammar that goes with them. The punctuation and grammar that you're familiar with are tools that help us communicate effectively with one another in the written word. Commas convey a pause. Periods let us know a sentence has ended. Italics and bold text let us know if a word is emphasized. When we're communicating to another person, these are tools that help us do so. Just as written sentences require correct grammar and punctuation to be correct, the same is true for programming languages. However, with programming, in most cases we're communicating with the compiler - the compiler being the program that looks at our code and creates machine language for us. The programming syntax that we use is meant to communicate our intent to the compiler program. For this reason, the programming syntax MUST be correct. You can get away with messing up some grammar and punctuation when you're writing to a friend or an audience. They'll probably understand what your intent is. On the other hand, if you make an error in your programming syntax, there's almost assuredly going to be an issue. You’ll have either a compiler error when you go to compile the code or a subtle and hard to find bug in the actual operation of your sketch. When you start out, you'll likely find that getting all the program syntax correct is a major hassle. It just doesn't feel natural, and the compiler is far more exacting than most “red pen crazy” elementary school teachers. The good news is that as you get more comfortable in the programming language, the syntax will come more naturally to you. It will become second nature as you write your code. Comments Let's start with one of the most important tools in programming - the comment. Comments are descriptive statements that a programmer writes to help explain the code. They are syntax and punctuation that really have nothing to do with the compiler. In fact, the whole purpose of a comment is so that you can hide these words from the compiler. There are two ways to create a comment. The first is the single line comment, which uses a double forward slash. It looks like this: Notice that all the text after the double forward slash is grayed out. If you have a lot to say, then you can use a multi-line comment. To start a multi-line comment, you type a forward slash followed by an asterisk. Now you can type multiple lines of comments. You'll notice that they're all grayed out. Also, when you press the enter key after that first line, the Arduino IDE actually auto closes the comment for you. It is closed with an asterisk and another forward slash. These additional asterisks on the lines in between are not required, but they are added by the Arduino IDE. These help the multi-line comment stand out from the rest of the code. As I said, comments are hidden from the compiler. They are words specifically for any other person reading your code - not the computer. I won't go into the substance of comments right now. You'll learn more about what comments should say as you work through the course, but I will say that comments should be descriptive statements explaining what that part of the code will do. Semicolons The next thing I want to talk about is the semicolon. The semicolon is to the C++ programming language as the period is to the English language. A semicolon lets the compiler know that a specific statement of computer code is complete. Let's take this line of code: . I know right now this code means nothing to you, but what I want you to see is the semicolon at the end. This semicolon lets the compiler know that your next line of code is independent from the previous one. If you wanted, you could move the semicolon to the next line of code or even insert spaces. It wouldn't make a difference. However, this is horrible form. You really should keep your semicolon on the same line of code that it ends. I just wanted to point this out to demonstrate that the compiler will ignore the spaces before and after a semicolon. If you forget to type a semicolon and then compile your sketch, you may get several different types of errors. I took out the semicolon from the previous line of code and compiled the code using the verify button. I then get an error. The message bar says, “expected unqualified id before numeric constant”. What does that mean? Well, let's look down into the error and see what it actually says. If we look through these error messages, we can see that it's referring to the name of the program and the line of code - line 12. Then it says, “expected comma or semicolon before void”. If we look back up to line 12, it says, “void”. It's saying that it expected a comma or a semicolon. Now we can trace back our steps to that particular line of code and put in a semicolon. If I compile it now, it will be successful. In many cases, error codes are not very informative. Luckily, these are pretty descriptive. They tell you what line of code to look at, and they even tell you what you forgot. So it's pretty handy. Keywords You may have noticed that some of the words typed into the Arduino IDE automatically change color. These are called keywords. Keywords are specially designated terms in a programming language. They perform specific functions for us and are reserved to be used only for those functions. You'll get very familiar with different keywords as you work through the course. Therefore, we won't give an in-depth description of every keyword in this module. Remember, you'll know when you've typed a keyword because it will automatically change color. Function Syntax The next thing I want to talk about are functions. Keep in mind that this is a very cursory overview of functions. I want to give you just the gist of what a function does. Functions are programming tools that package up frequently used pieces of code to make them easy to use. Let's say, for example, that you had some code that did a calculation to convert degrees Celsius to degrees Fahrenheit. Maybe it was just a couple lines of code, but you found yourself using that code pretty frequently. Instead of having to type that code into the program every time you wanted to do the calculation, you could turn it into a function. To use a function, all you have to do is write the name of the function. Then, give it some pieces of information so that it can do the job. For example, if it was a Celsius to Fahrenheit converter, you'd have to give it the temperature in Celsius, and it would give you back the value in Fahrenheit. The Arduino language has tons of built-in functions, and, just like keywords, they also change color automatically when you type them. Functions are kind of like the verbs of a programming language. They make things happen, and they do stuff for us. The real reason I brought up functions isn't because I want to explain how they work. We'll be learning, in detail, about all different types of functions throughout the course. What I really want to talk about is function syntax. All functions are followed by an opening and closing parenthesis. Inside these parentheses is where you give the function what it needs to perform its task. If the function needs multiple pieces of information, those items are separated by commas. Some functions don't take any data, but they still must have a pair of parentheses. Also, every open parenthesis MUST have a closing parenthesis. Notice when I put my cursor on an opening parenthesis that the closing parenthesis is highlighted. Likewise, if I put my cursor by the closing parenthesis, the opening parenthesis is highlighted. This can be a handy tool to determine if you've actually closed the parenthesis after you opened it, or vice versa. Some functions, called control structures, have opening and closing curly brackets following the parentheses. The code that goes between these opening and closing curly brackets will get executed under different circumstances. Just as with parentheses, every open curly bracket must have a closing curly bracket. Furthermore, just like parentheses, if you put your cursor by one of the curly brackets, it will highlight the partner of that curly bracket. Layout & Indentation You may have also noticed that there is indentation in these lines of code. Indentation doesn't communicate anything at all to the compiler, but it helps the author of the code - as well as anyone else reading it- navigate through what’s been written. As a general rule of thumb, when you're writing code inside opening and closing curly brackets of a control structure, the code is indented two spaces from the rest of that code. Then, that indentation continues if a new set of curly brackets is opened up. Another tool for indenting is the “Auto Format” tool in the Arduino IDE. Simply go up to “Tools” at the top of the screen, and then choose “Auto Format”. You could also just press command T. This will automatically create the correct layout for you. It’s much easier to use than manually indenting, and it keeps your code from looking sloppy. Review We talked about what programming syntax is. It’s like punctuation and grammar for computer programming languages. We talked about comments, both single line and multi-line. We also talked about the semicolon and how it's like the period of a sentence for the C++ programming language. Next, we discussed the automatic coloring of keywords and about function syntax. Finally, we talked about layout indenting. That's it for this lesson. Again, this was just a cursory overview. Don't worry about memorizing every little thing and about whether or not you understood the coding shown. That's not the expectation right now. Really we just want to get our eyes inside the Arduino IDE and start understanding some of the basics - symbols being used and what some of the coloring and layout mean. I look forward to seeing you in the next lesson. Try On Your Own Challenge: Type the following code (exactly how it is typed), into the Arduino IDE. Remember - the compiler program will not accept errors - so don't get angry if you see a couple spur up the first time around - it is just part of the learning experience. When you are done, Verify the code by pressing "Control + r", you should not get any errors. //Type this into your Arduino IDE *EXACTLY* how it is typed here. //Don't worry about what the program does - this is about practicing the syntax. //This is a single line commment - What color is the text here? //Will the complier *see* these comments? /* This is a mutli-line comment. Will the compiler see these words? Are these multi-line comments colored different than single line comments? */ String dog; //Which of these words is a keyword? How do you know? //Setup only runs once. void setup() { //notice that setup() has a different color. // Comments are meant to explain your code to you and other people. //Set up Serial Communication. Serial.begin(9600); //This is the color of a library function }//This curly bracket "closes" the setup function. // Put your main code here, to run repeatedly: void loop() { //This curly bracket opens the loop() function. //Assign a bark to the dog. dog = "bark"; //Send the dog bark to the computer. Serial.println(dog); //Upload this code to the Arduino (CONTROL + U) and open the Serial Monitor Window (SHIFT + CONTROL + M) } //This curly bracket closes the loop() function. Further Reading: ; Semicolon {} Curly Braces Comments…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Progress vs Perfection: Chicken Analogy 2:26

8 years之前2:26

2:26

Discussion: Will the Chicken Cross the Road? So there's this chicken, and he's on the side of the road. He wants to cross the road. He wants to get to the other side. Before he steps out and crosses the road, he looks both ways. That is a rational thing to do. If he doesn't look both ways, and he just steps out, he's going to get smashed by a car, and he won't get to the other side of the road. This chicken is a little bit of a nervous chicken. He is just sitting there and watching. A car passes by, another car passes by, and he's looking at each one. He is analyzing the traffic, but he never steps out in the street and actually makes any progress because he's always afraid a car is going to come and nail him. Now, in some regards, you and I are a little bit like that chicken. No, I'm not calling you yellow, or anything like that. That's not where I'm going with this. What I'm saying is that, many times, when we're learning something, especially a step-by-step process, we can get a little caught up on learning it and trying to learn that something to perfection. Instead of actually stepping out into the street and crossing the road, and actually making progress, we're sitting back and kind of studying, and studying, and studying. We're studying that traffic. We're actually not getting anywhere. Stepping out into Uncertainty- At Some Point You Have to Cross the Road In programming electronics, there is a lot to learn. Anytime you start to learn one thing, another thing is going to pop up. It's like this endless amount of rabbit holes. In order for us to actually make progress to our goal, we have to be willing to accept a certain level of uncertainty. We have to be willing to say, okay, you know what, maybe I don't get all of this. But, I am going to take a step forward, and I am to keep moving forward. That is really what I want you to try to think about as you learn all this new information. Some of it might (will) feel a little fuzzy as you move forward, and that is okay ! As we go through the course, I'll give you some really good rules of thumb for when I think it's okay for you to take a step forward and say, “You know what? I think that I know this enough.” Alright, let's go ahead and get cracking!…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
The Arduino Development Toolchain - How it all gets done... 8:40

8 years之前8:40

8:40

Discussion: In this lesson, we're going to do an overview of the Arduino toolchain. The toolchain includes all of the software tools that are between us pressing the Verify/Upload buttons and that code actually getting loaded onto the integrated circuit on the Arduino board. I definitely want to stress the keyword overview because there is a lot going on behind the scenes that actually makes it happen. In practice for us, though, the entire process is just a matter of pressing a button. As we start to dig in, it's tempting to want to know every detail. However, remember that our goal in this course is to learn programming and electronics. If we're not careful, we can get pulled down this huge rabbit hole. That being said, I do think it's important to be familiar with the process. We don’t need to understand it in depth. I just want you to be able to understand and recognize some of the terms and basic concepts associated with this toolchain. Specifically, we’ll discuss: What Is a Toolchain A Toolchain Analogy Toolchain Basics What in the World Is a Toolchain? So, what is a toolchain in the first place? In programming, a toolchain is just a series of programming tools that work together in order to complete a task. If we were cooking something, like carrot soup, the toolchain might include a carrot peeler, a produce knife, a pot, some water, and a stove. Together, these tools help you create the desired output, carrot soup. When we're developing programs for Arduino, we'll also be using a toolchain. This all happens behind the scenes. On our end, we literally only have to press a button for the code to get to the board, but it wouldn’t happen without the toolchain. A Helpful Analogy So, I want to start peeling back the curtain on this Arduino toolchain. Imagine for a moment that you're an author. In fact, you're a New York Times bestselling author... just like me. What type of toolchain might you use? Maybe you start off with text editing software, just like Microsoft Word, to type your awesome story. Once you're done with that manuscript, you send it off to a professional editor at a publishing company. That professional editor is part of this toolchain. He will look over your manuscript and point out any errors. He might do some rearranging and other things, as well. After he sends the suggested edits back to you, you make any necessary corrections. Then, you give the manuscript back to that professional editor to do one last check for errors. He then hands it off to the office next door at that publishing company. The publishing company can't just take that Microsoft Word file and send it off to a printer. They need a special file type to format the book for how it should look on a physical page when it actually gets printed. Therefore, they take the manuscript in a Microsoft Word file format, and they turn it into a new file format. Once this is done, the publisher can send it off to be printed. Luckily, to make the process of printing a whole lot easier, this publisher has an in-house printer. So, he simply needs to just go right down the hall, so to speak. The printer takes that file and prints it onto an actual physical page. So, let's review this author's toolchain. The author writes with a text editor program. Then, he sends the manuscript to an editor at a publishing company. That editor reviews the manuscript until it is perfect. He then sends it next door to be formatted. The manuscript is converted into the proper file format, and it is sent off to the printer to create the physical book. Finally, voilà, somebody buys your book from Amazon to read all about zombies over a warm cup of latte. Arduino Toolchain Basics Why did I go through that long scenario? Well, the Arduino has a similar toolchain. When we start writing our code, and we become the author. We do this in the Arduino IDE, which is akin to a text editor. We also write the code in a programming language called C++, with a file type extension of .ino. The code that we write is called human readable code since it's meant for us to read and, hopefully, understand. However, the Arduino hardware doesn't understand C++ code. It needs what's called machine code. In order to generate that machine code, we use a software tool called a compiler. Remember that Verify button in the Arduino IDE that looks like the checkmark? When you press this button, it compiles the code using compiler software called AVR-GCC. This compiler software does a bunch of stuff. The main thing it does it rearrange some code and check for errors. This is like the professional editor at the publishing company. The compiler also translates the human readable code into machine code. There are some in-between file types and other fuzzy things that go on, but the final output of the compiler is a machine language saved as a .hex file. In order to get this .hex file loaded onto our Arduino's integrated circuit, we need to press the Upload button. This begins another piece of software called AVRDUDE, which sends the file to the integrated circuit. Normally, we would have to use some external hardware to load that circuit. However, in Arduino’s infinite wisdom, they loaded a small piece of software onto the integrated circuit that automatically comes with an Arduino board. That piece of software is called a bootloader. It works with ARVDUDE to take the outputted .hex file and put it onto the flash memory of that Arduino's integrated circuit using only the USB cable. Again, all we had to do was press the Upload button. This whole process happens behind the scenes. Now the process is complete. So, what was our toolchain? We have the Arduino IDE Editor. Then, we have the compiler, which is AVR-GCC. The result is a .hex file. Next, we have AVRDUDE and the bootloader on the integrated circuit of the Arduino board. These work together to upload the .hex file to the board. REVIEW That was a lot of information to absorb. Let’s summarize what we learned in this lesson. First, we learned that in programming, a toolchain is simply a group of software tools used to complete a task. Then we discussed the book publishing analogy to help illustrate that point. Lastly, we walked through the Arduino toolchain. As an encore, we’ll go over that toolchain one more time. We start by writing human-readable C++ code in the Arduino IDE Editor. Then, we click Verify. The compiler program, called AVR-GCC, checks the code for error and adjusts some of the code for us. The result is machine code in a .hex file. When we press the Upload button, AVRDUDE takes that .hex file and works with the bootloader. The bootloader is pre-installed on the Arduino's integrated circuit, and it helps get the machine code loaded onto the Arduino's integrated circuit. Wow, I'm so glad that all happens behind the scenes! Again, this was meant only to be a cursory overview. I wanted to make sure that if you see AVR-GCC in error message or hear the word compiler or any of the other jargon we discussed here, at least you now have an idea of their significance. You now know where they are in the Arduino toolchain.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Arduino Board Hardware overview for people like me 10:38

8 years之前10:38

10:38

Discussion: This lesson continues our quest of learning more about programming and electronics. In previous lessons, we already discussed several reasons why we have chosen to use an Arduino board as the tool to help us learn. Specifically, we chose the Arduino Uno board. The Uno is the baseline Arduino board, being the one around which other Arduino boards are designed . Therefore, the Uno is a great place for us to start digging in. It’s also a fantastic launchpad if you decide to move on to other platforms in the future. In this lesson, we'll do a high-level overview of the Arduino Uno hardware. Specifically, we’ll cover: The Concept of an Arduino Board The Three Types of Pin Header Rows: Digital, Analog, and Power Other Miscellaneous Valuable Tidbits The Concept of an Arduino Board As we discuss the hardware, I recommend holding your Arduino board in your hand. Pause the video as needed to take a closer look at the board as we discuss the different components. First, I want to point out that the integrated circuit is the brains behind the Arduino board. It’s very likely that the circuit is the Atmel ATmega 328, which is an 8-bit microcontroller. Don't worry about that fancy name. The only thing I want you to understand is that everything on the Arduino board is meant to support that integrated circuit. So, the Arduino exists to make it easy to use this microcontroller. If you look closely at the microcontroller, it may look slightly different from mine, depending on which model you have. It might be really small, called a surface mount component, or it could be a big one like mine, which is called a DIP. Either way, there will be little metal prongs that stick out of the side. These are called pins. These pins are how the microcontroller is able to do stuff. These are used to interface with other hardware and circuitry, such as LEDs, sensors, or even your computer. Therefore, we need to know how to actually connect them to other things. That's where the pin headers come into play. Pin headers, sometimes referred to as just headers, are the plastic rows of holes that stick up from the Arduino board. They are all along the border. Inside of the holes are little metal clips. When you stick a wire down into the hole, that wire will stick and stay there. For example, you can stick the wire that comes out of an LED or a resistor into those holes. The wires are called leads, by the way. The wire makes an electrical contact in that hole. In other words, the wire sticks in the pin header. The metal clamp inside the header clamps onto the wire, and an electrical connection between that wire and a specific pin on the microcontroller is then created. Digital Pin Headers There are three categories of headers: digital, power, and analog. The first one we’ll discuss is the digital category. Digital pin headers make up the longest row on the Arduino board. They are numbered from zero to 13. That means there are a total of 14 digital pins that we can use. To make this lesson as practical and easy as possible, for our purposes when I say digital, I mean something that is a discrete state. Let's use color as an analogy. Something that is digital can only be either black or white. Digital does not care about any point of gray in-between. Therefore, digital pins are used in one of two ways. They can be used as inputs to do things like read a voltage. Otherwise, they are used as outputs, such as applying a voltage. When they operate as an input, they can only read two different voltage states - high or low. The same is true when they act as outputs. They can only output two voltage states - five volts (high) or zero volts (low). Just as in anything else in life, there is an exception to this. You'll notice that some of these pins have a little squiggly mark next to them. There should be six of them, located at pins three, five, six, nine, 10, and 11. These specific pins allow you to use a technique called pulse width modulation, or PWM. PWM is a technique that we'll dive into later in the course. It enables us to use digital pins in such a way that they appear as though they are outputting a varying amount of voltage. Again, we'll get into PWM in much greater depth later. Right now I just want to point out those pins, and why they are special. I also want to point out two other pins. Notice that pins zero and one have a “TX” and “RX” next to them with little arrows. That stands for transmit and receive. The Arduino uses these two pins to communicate between the board and the computer. For example, maybe you need to upload your code. Maybe executing your sketch performs serial communication between the Arduino and the computer. Serial communication is another concept we'll be learning later in the course. It’s only important that you understand these pins used to transmit and receive. Therefore, it’s best to only use pins zero and one as a last resort if you’ve run out of available pins. The reason for this is that sometimes adding additional circuitry to these pins can interfere with serial communication. This will make a lot more sense when we get to that section of the course. For now, just know it’s a good rule of thumb to leave pins one and zero alone. There are also two on-board LEDs labeled “TX” and “RX”. These blink every time you send information back and forth between the Arduino Uno and the computer. If you have the Arduino hooked up, and it’s supposed to be communicating with the computer, you should see these blinking. If not, it’s a good indication that you probably don't have the Arduino set up correctly in the IDE, and communication is unsuccessful. Lastly, pin 13 is also worth noting. That is where an on-board LED is attached. You can use that LED as though it were externally connected through a resistor to the Arduino. Analog Pin Headers The next category of headers are analog pin headers. These are labeled A0 through A5, giving us six analog pins. As you might have guessed, “A” stands for analog. Before we said that digital means discrete states - either high or low, one or zero, black or white. However, analog is a lot more colorful. When we say something is analog, it means that it can be in any number of states. Analog embraces all of the various shades of gray between black and white. Many sensors create analog signals. They're not just on or off. They can be all of the states in-between. However, our integrated circuit really only knows discrete digital states. Therefore, the microcontroller handles analog inputs by using a tool called an analog-to-digital converter, or simply an ADC. The ADC is part of the integrated circuit, built right into the chip. The analog pins have access to it. The ADC takes all of the variation in an analog signal and cuts it up into discrete steps. In other words, instead of having an endless list of possibilities from your low to high limit, the ADC would cut that expanse from the low value to the high into a certain number of “chunks”. In addition to being able to use the ADC, analog pins can also act just like digital inputs or outputs. So, they are very versatile. We’ll do a deeper dive on this later in the course, as well. Power Headers The last row of pin headers is the power header row. They are next to the analog headers. There are only a handful of pins I want to point out right now. The first one is labeled “5V”. That stands for five volts. If you have the Arduino hooked up to the computer via USB, or if you have external battery power applied, this pin can provide five volts to a circuit. We'll be using this pin extensively throughout the course when we're setting up our circuits. The pin next to it is labeled “3.3V”, which stands for 3.3 volts. Obviously, it provides 3.3 volts to the circuit. Next to these pins are two pins labeled “GND”, which stands for ground. These two pins give us access to the lowest voltage on the Arduino board, which is zero volts. Miscellaneous Goodies to Know There is yet another ground pin located up next to the digital header row. It’s important to keep in mind that all of these ground pins are one in the same. They are all connected to each other. Therefore, throughout the course when we set up our circuits, it doesn't matter which one you decide to use. Let me make one final note about the pin headers. You may hear a term thrown around called the “Arduino Footprint”. That’s simply how the Arduino headers are aligned. If something is said to match the "Arduino Footprint", it means that it has that same header layout as the Arduino board. The most common example of this would be an Arduino shield because, by default, the headers on a shield are almost always going to match the board. That term is not really all that important to know, but I wanted to make sure you had heard the term if you ran into it. Another item that is helpful is the reset button. Just as the name implies, when you press that button, the program currently running on your Arduino board will start back at the beginning. It doesn't erase the program. It just starts the program over. There is also a reset pin on the Arduino. If you apply a low voltage to that pin, it does the same thing as the reset button. It will reset the current program running on the Arduino. Next, the Arduino Uno has a power on LED. It is illuminated anytime power is being applied to the Arduino. This is true no matter if the Arduino is powered through a USB cable or through an external power jack. Review Wow! Lots of components! How about we go back over the highlights? We talked about kind of the overall concept of the Arduino board. It is built to support the integrated circuit. We also discussed the three different pin header rows. We went into detail about the digital, analog, and power headers. Finally, we covered a few miscellaneous components. The Arduino Uno has a reset button, a reset pin, and a power on LED. Hey, don’t worry if you still have a lot of questions! That's to be expected this early in the course. A lot of terminology and some new concepts were thrown around. Remember, though, this was only meant to be an overview of the Arduino hardware. As we move further into the course and delve deeper into the specifics of these concepts, it will all begin to come together. Patience, young grasshopper.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Everything you need to know about the Arduino IDE (for now) 11:09

8 years之前11:09

11:09

Discussion: Now that you have downloaded and set preferences, you need to become familiar with the Arduino Integrated Development Environment, or IDE for short. It works just like a text editor program. I'm only going to cover what I think is important for us to know right now. We do a deeper dive on an as needed basis as we progress through the course. Specifically, in this lesson we'll cover: Selecting an Arduino Board and Serial Port Saving an Arduino File The Editor, Message Area, and Console A Few Other “Good to Know” Items So let's open the Arduino Integrated Development Environment (IDE) and get started. Do this by clicking the Arduino icon. Which Board and Serial Port Should I Use? The first thing we're going to discuss is selecting the correct board. We have to let the Integrated Development Environment know what Arduino board you're using. Go to the “Tools” tab, and then go down to where it says “Board”. You'll notice I selected the Arduino Uno since that is what I will use throughout the course. I recommend that you use an Uno or an Uno derivative throughout the course, as well. This will standardize our work in these lessons. Once you've selected the board, next you need to select your serial port. People can sometimes be intimidated by this technical term, but you don’t have to be. Serial ports are just the different things connected to your computer. The easiest way to find out which of the ports listed is your Arduino is to first unplug the Arduino from the computer. Go to the ports list under the “Tools” tab, and write down the names of these ports. You only need to write enough to differentiate one from the next - maybe the last word or last few letters. Then, close your Arduino IDE. Plug your Arduino board back in via the USB cable to your computer. Open the Arduino IDE. You should now be able to see an additional serial port not on the list you originally wrote down. That will be the serial port to which your Arduino is connected. For Mac, you'll usually see cu or tty after the “dev/”. Those are the common ways Arduino will show up on the serial port for a Mac. For a PC, it shows up as a COM port, but it's hard to know which one it will be. It could be one, two, four, etc. That’s why the best method, although primitive, is just to unplug and plug the Arduino back into that port. Once you’ve chosen the board and port the first time, these settings will stay the same for any subsequent times you reopen the Arduino IDE. The reason I point this out is that if you happen to get a different board at some point, you will have to remember to change the board that is selected. The Arduino File When you open the Arduino IDE for the first time, it will open up a file for you, giving it a default name. That default is sketch, underscore, and the current date. That name also appears at the top of the IDE, along with the version of Arduino you're using. To save this, go to the “File” tab and then to “Save”. It's just like saving any other file. Notice it asks you to save the file in “Documents”. Remember that in Arduino, files are referred to as sketches. So, the collection of our sketches is known as the sketchbook. The sketchbook folder is where all of the sketches we write will be saved. Of course, you can also nest your files in that folder just like you could in any other program where you're saving files. It's really no different. Take a look at the name I chose for my file. There are certain rules you must follow when choosing a name for your sketch. When you're naming a file, you can't use any spaces between the words. One common method is to use an underscore where you would have normally preferred a space. You can't use special characters, either. You can use numbers in the name, but you can't have a number as the first character. Lastly, the names are limited to 64 characters. So, using these rules, name your sketch and save it. You'll see that the name on the tab and at the top of the screen now displays the name of your newly saved sketch. So, saving is really easy. The shortcut command is Ctrl S. There is also a down arrow that you can click. The Editor, Message Area, and Console There are three main areas of the Integrated Development Environment: the editor, the message bar, and the console. The editor is the big white space. It’s where you type the Arduino code. It has number lines down the side - as long as that was one of the preferences you checked from our last lesson on choosing your settings. Right now it shows one through nine. If we were to add more code or move our cursor down further, it would adds numbers as lines are added. I want to point out one thing in this name here. Do you see the little funky looking “s”? Every time you make a change to the sketch that has not been saved, that s will be displayed. If I save the file, it goes away. If I were to type something in the sketch again, the funky little s would come back. It’s just a visual reminder to save your changes. Personally, I am a save fanatic. For just about every single line of code I write, I use the shortcut key Control S to save before I go on to the next line. I want to make sure I don't lose anything in the event that I have an issue with either the Arduino IDE, my computer, unexpected interruptions, or whatever might happen. There is something interesting you might have noticed when you open a new sketch in Arduino. It auto-populates two of the mandatory functions for coding in Arduino. This is why you see void setup an void loop. We'll talk about these in depth later, but it's perfectly normal for these to show up. It’s just a way of helping you save time when you code. On top of the editor area are two very important buttons. The first one is a check mark. It is the Verify button. When you click this, the code gets compiled. Compiling, as discussed before, is taking the human readable code that we've written and translating it into machine code. As it compiles, the program will point out any errors found in that code. It also does some optimization. This is a way behind the scenes concept that you don't have to worry about right now, though. You constantly want to check for errors in your code. I like to verify my code at almost every line of code I write along the way. The more you verify, the more quickly you can identify where you might have introduced an error into the code, i.e. find and fix a bug. We'll be using this verify button all the time. The shortcut key for verify is Command R or Control R. You can also verify by going to the “Sketch” tab. That other button is the Upload button. That takes all of the code that we've written and uploads it to the Arduino board. When you click that button and look at your Arduino board (assuming that it’s hooked up to your computer via the USB cable), you'll see two lights blinking rapidly. That is the TX and RX buttons. This is a good visual indicator that you have a good connection between the Arduino board and the computer. The IDE is recognizing that you have a board hooked up. In other words, the lights tell you that the code is successfully being uploaded to the board. The shortcut key to upload is Control U or Command U. It is available in the dropdown under the “Sketch” tab, as well. The second main area of the IDE is this blue bar. It is the message bar. It will display information about what you've done recently in the program. For example, I just uploaded. You can see that it says, “Done Uploading.” If I press Control S to save, it would say, “Done Saving.” There are other pertinent messages that display while you are using the program. The third main area of the IDE is the black space below the message bar. It is called the Console. Now, you probably won't hear it referred to as the console very often. Many people just call it the error section, or some other generic term. If you want to increase the console’s space, there is a bar you can drag up. It may be hard to see, so I put a box around it. The console displays the error messages. It will tell you information about the current operation that you did. For illustration purposes, let me introduce an error into the code and verify it. I’ll just type a crude, uncoded line somewhere in the editor area. You can see that we get definitely get a reaction out of the Arduino IDE. First, the message bar gives us a quick note saying that you wasn’t declared. Again, don't worry about understanding the error itself or any of the terminology displayed. I just want you to see where different types of information shows up. Then, in the console much more detailed information about the error is displayed. It tells you what file it was in, what function it was in, and even the line of code. Here it says the error was in line three. If we look back up at line three in the editor, we can see that it gets highlighted. That's where we can start looking for our error. Unfortunately, it will not always point out the correct line of code for the error. You might have to do a little searching around, but that is a discussion for another time and another lesson. You now know the three big pieces of the Arduino IDE. We walked through the editor, the message bar, and the console. Miscellaneous Tidbits There are a few final items we should discuss that are good to know. At the very bottom of the IDE is a number. Currently ours shows the number three. That simply refers to the line of code where your cursor is located. It seems like such a small detail, but it is very handy. Once you begin to work with larger and larger sketches, it may be harder to keep track of your cursor. This is especially true if you decide not to display line numbers down the side. Also, in the far right corner you'll see some additional information. It is the name of the Arduino board and which serial port that you identified earlier that you’re using. In the top right, there is a little magnifying glass. This is for the Serial Monitor. If you click it, a window like this opens: The Serial Monitor window allows us to see communication occurring between the Arduino and the computer, and vice versa. We'll have an entire lesson later down the road about the Serial Monitor and communications. For now, just know that the button is there. The shortcut key for the Serial Monitor is Shift-Control(or Command)-M. Now Get Going! You now know enough information to start using the Arduino IDE. You can see it's not too complex. The IDE is very simple and streamlined. Arduino was designed for ease of use. There's not a bunch of bells and whistles that can sometimes get in your way. I have no doubt you’ll be an Arduino pro in no time.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Mac - Download and Install the Arduino IDE 7:16

8 years之前7:16

7:16

Discussion: Before you begin using the Arduino IDE, you must first learn how to download, install, and set your preferences. This lesson is specifically tailored for those who use a Mac. (The last lesson covered this same topic, but for PC users.) I'm currently running Mac OS X Yosemite. You are probably running a newer version of Windows. However, the following instructions will be almost identical from one version to the next. If this should ever change, I’ll update this lesson to reflect those changes. Find the Arduino IDE Download First, jump on the internet with your favorite browser, and navigate to www.arduino.cc. Look for the tab labeled “Download”. The page on which you land might look a little different than this. It does change from time to time, but there will always be an obvious tab for Download. Go ahead and click Download. We're currently working on version 1.6.5, and what you'll do is select your operating system. Click on that “Downloads tab”. That will bring you to the “Download the Arduino Software” page. Once on this page, choose your operating system. For Mac users, you have two options. You can download from the green panel: Or you can get the absolute latest, razor-sharp release of the Arduino IDE. This is found in the section labeled “Hourly Builds”. If you want the most recent update, you can download from this section. But this is just as the name implies. The information here can be updated as often as hourly, and may not be as stable as an official public release. Therefore, in this lesson, I will demonstrate the Windows Installer. This is the best route to go in almost any case. It’s rare that another option is better. Download and Install I’m using Mac OS X. Therefore, I'll click that. It then prompts me to save a Zip file. It doesn't matter where you save this Zip file. I'm going to save it to my Downloads folder. I'm going to save it to my downloads folder. This will initiate the download. It’s not a big file. It’s around 131 Megabytes for this current release. I have just an everyday, run of the mill cable internet connection, and yet it still doesn’t take very long to download. Once it's completely downloaded, I'm going to find it using “Finder”. It found it in my Downloads folder. Double-click your Zip file. The Archive Utility for Mac will automatically unzip it for you. After the Zip file has been unzipped, you'll see that the Arduino IDE icon will be created inside whatever folder you unzipped the Zip file. (I'm just trying to see how many times I can say "Zip".) I'm going to move the Arduino program to the Applications folder on my Macintosh computer. So go to the Macintosh hard drive, then Applications, and then drop it in there. Now, I already have Arduino installed. If you already have an older version of Arduino installed, it will ask if you want to first uninstall the older version before continuing the download of the newer version. My recommendation is to select “Replace” to uninstall the older version. It will not harm anything or delete any work you have done. It simply gets rid of the older Arduino IDE, not your sketch folder. If you don't know what that means, it’s not important. Just know that you will not lose anything if you uninstall. Next, it will run through the uninstallation process. Once completed, you can see that the Arduino icon is in the Applications folder on my Mac. Right-click on this and choose to open it. It's going to give me a prompt the first time I open up the Arduino IDE. It double check whether or not you really want to open it since it is from an unidentified developer. Just click “Open”. By the way, if you try to open the Arduino icon from the Applications folder in your dock, you may not even get an “Open” option. In this case, locate the Arduino icon in the Finder and right click to open. Set Preferences for Arduino IDE Now that the Arduino IDE is open, maximize it. In another video, we'll discuss how this works in-depth, but for now I just want to set some preferences. Go up to Arduino, then click “Preferences”. Probably the most important thing to look at is the first line that comes up - the Sketchbook location. When we write a program in the Arduino IDE, it's called a sketch. All sketches are saved within a Sketchbook. The Sketchbook is a folder where you can to keep all of your work. The default location is usually under Users\The User’s Name\Documents\ and then a folder created that is named Arduino. If yours does not look like this, or if you would prefer the Sketchbook folder be in a different place, you can browse to select a different location. I would definitely recommend using a folder named Arduino. This default location has always worked pretty well for me. The next preference to set is the Editor language. You can pick from a bunch of different languages. I'm using English, obviously. Another setting is editor font size. The default is 12, but I prefer a larger font. Font size 18 works very well for me. Be aware that sometimes if you make the font too big, you'll see that one line actually gets written overtop of the other. Therefore, you might have to play around with font to find your optimal size. There are a few other things that I think are good to set in preferences. One is whether or not to display the line numbers. I suggest you check the box for this. It means that each line of your program, or sketch, will be displayed on the left side of the Arduino IDE. Another preferences I suggest you choose is to verify the code after upload. This won't mean anything to you now, but you’ll see later why this it’s an excellent idea to check this feature. The next setting I usually choose is to check for updates on startup. It's not imperative. You can check or uncheck this box depending upon your own personal taste. It depends on whether or not you want to stay with the same current version the whole time. If you just want the most updated version, you can keep that box checked. I do recommend, however, keeping the “Update sketch files to new extension” checked. Basically, this means that whenever you open an Arduino file, it ensures that if the file doesn’t have the proper extension, then that file will automatically be converted to .ino. Arduino files used to have a .pde extension. However, now they are .ino files. That’s why it’s handy to keep this option active. Finally, I think having the last preference chosen is also a good idea. That setting is to save the file when you are verifying or uploading. Again, we'll talk about verifying and uploading in depth in later lessons, but just take my word for now that it is always good practice to save as frequently as possible. Going Old School Not all versions are the same. It could be that maybe you prefer the look and feel of a previous version. Or maybe you’re just really familiar with and used to working within the framework of a certain version. If you prefer to download and use a previous version of Arduino, never fear. We have a solution for you that like to go old school. On the Arduino website for downloads, look to the bottom right panel. There is the section for previous releases. Clicking that will show you a list of all previous releases for each type of operating system, along with the date they were released. Click which you prefer, and from there downloading is the exact same process as before. Again, this lesson applies to those who own Macs. If you are using a PC, you can go back one lesson and see this same download, installation, and preference concept for your particular operating system.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
PC - Download and Install the Arduino IDE 7:10

8 years之前7:10

7:10

Discussion: Before you begin using the Arduino IDE, you must first learn how to download, install, and set your preferences. This lesson is specifically tailored for those who use a PC. The next lesson will cover this same topic, but for Mac users. I'm currently using a Windows 8.1. You are probably running a newer version of Windows. However, the following instructions will be almost identical from one version to the next. If this should ever change, I’ll update this lesson to reflect those changes. Find the Arduino IDE Download First, jump on the internet with your favorite browser, and navigate to www.arduino.cc. Look for the tab labeled “Download”. The page on which you land might look a little different than this. It does change from time to time, but there will always be an obvious tab for Download. Click on that “Downloads tab”. That will bring you to the “Download the Arduino Software” page. Once on this page, you have several options. You can download the Windows Installer, or you can download a Windows ZIP file if you are a non-administrator. The third option is to get the absolute latest, razor-sharp release of the Arduino IDE. This is found in the section labeled “Hourly Builds”. If you want the most recent update, you can download from this section. But this is just as the name implies. The information here can be updated as often as hourly, and may not be as stable as an official public release. Therefore, in this lesson, I will demonstrate the Windows Installer. This is the best route to go in almost any case. It’s rare that another option is better. Download and Install When you click on the “Windows Installer” link, it takes you to a contributions page. It’s completely up to you if you want to contribute to the Arduino cause. It is a great idea if you do. However, since this is simply a demonstration, I'm just going to choose download. Next, a popup window opens so that you can direct where to save the ZIP file. It really doesn't matter where you save it. I'm going to save it to my downloads folder. It will then immediately start to download. It’s not a big file. It’s around 77.7 Megabytes for this current release. I have just an everyday, run of the mill cable internet connection, and yet it still doesn’t take very long to download. Once the file is done downloading, double click the executable file. This will open a couple of popup windows. The first one is dependent upon whether or not you already have a older version of Arduino installed. If you already have an older version of Arduino installed, it will ask if you want to first uninstall the older version before continuing the download of the newer version. My recommendation is to select “Ok” to uninstall the older version. It will not harm anything or delete any work you have done. It simply gets rid of the older Arduino IDE, not your sketch folder. If you don't know what that means, it’s not important. Just know that you will not lose anything if you uninstall. Next, it will run through the uninstallation process. Once completed, click “Ok”. Then, close the uninstall box. Afterwards, agree to the new license, which is just like any other license that basically says you owe Arduino your children. The popup window then asks you to set a few installation options. Just leave all these checked. Finally, you select the install location. I personally put it into my programs folder. Once you click “Install”, it will start extracting. That's really it for the installation. It does take a little longer than you might expect - maybe a minute or two to install the whole package. Set Preferences for Arduino IDE Once installed, open the Arduino IDE. You can either use the desktop icon or go to your programs folder to use the icon there. We're going to set some Preferences. Go to “File” and then “Preferences”. Probably the most important thing to look at is the first line that comes up - the Sketchbook location. When we write a program in the Arduino IDE, it's called a sketch. All sketches are saved within a Sketchbook. The Sketchbook is a folder where you can to keep all of your work. The default location is usually under Users\The User’s Name\Documents\ and then a folder created that is named Arduino. If yours does not look like this, or if you would prefer the Sketchbook folder be in a different place, you can browse to select a different location. I would definitely recommend using a folder named Arduino. This default location has always worked pretty well for me. The next preference to set is the editor language. You can pick from a bunch of different languages. I'm using English, obviously. Another setting is editor font size. The default is 12, but I prefer a larger font. Font size 18 works very well for me. Be aware that sometimes if you make the font too big, you'll see that one line actually gets written over top of the other. Therefore, you might have to play around with font to find your optimal size. There are a few other things that I think are good to set in preferences. One is whether or not to display the line numbers. I suggest you check the box for this. This means that each line of your program, or sketch, will be displayed on the left side of the Arduino IDE. Another preferences I suggest you choose is to verify the code after upload. This won't mean anything to you now, but you’ll see later why this it’s an excellent idea to check this feature. The next setting I usually choose is to check for updates on startup. This is not imperative. You can check or uncheck this box depending upon your own personal taste. It depends on whether or not you want to stay with the same current version the whole time. If you just want the most updated version, you can keep that box checked. I do recommend, however, keeping the “Update sketch files to new extension” checked. Basically, this means that whenever you open an Arduino file, it ensure that if the file doesn’t have the proper extension, then that file will automatically be converted to .ino. Arduino files used to have a .pde extension. However, now they are .ino files. That’s why it’s handy to keep this option active. Finally, I think having the last preference chosen is a good idea. That setting is to save the file when you are verifying or uploading. Again, we'll talk about verifying and uploading in depth in later lessons, but just take my word for now that it is always good practice to save as frequently as possible. Going Old School Not all versions are the same. It could be that maybe you prefer the look and feel of a previous version. Or maybe you’re just really familiar with and used to working within the framework of a certain version. If you prefer to download and use a previous version of Arduino, never fear. We have a solution for you that like to go old school. On the Arduino website for downloads, look to the bottom right panel. There is the section for previous releases. Clicking that will show you a list of all previous releases for each type of operating system, along with the date they were released. Click which you prefer, and from there downloading is the exact same process as before. Again, this lesson applies to those who own PCs. The next lesson explains this same download, installation, and preference concept, except it is for those that work on a Mac.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Arduino Integrated Development Environment Version 2:24

8 years之前2:24

2:24

Discussion: The following videos will show you step by step how to download and install the Arduino Integrated Development Environment, or IDE for short. We'll also be setting up some preferences in the IDE. The phrase Integrated Development Environment may sound complicated and crazy, but it's really not. To be perfectly honest, it looks and feels a lot like a text editor, such as Microsoft Word or Notepad. Arduino IDE is simply a small software program that we're going to load on our computer. It's where we'll write the code that actually gets loaded onto the Arduino board. Consistent Look and Feel It is completely free to download and use. Understand, though, that it's updated all the time. Being kept updated is a good thing. You just need to make sure you are aware of which version you are using. Usually the updates are fairly minor and only affect the appearance of the IDE. Maybe the some of the menu options will be reorganized, or maybe some keyword coloring will change. However, generally speaking, the IDE maintains a consistent look and feel from one version to the next. I really can't stress enough that it doesn't matter which version of the Arduino IDE you're using while you follow along in the course. The Version for This Course For this course and all of the videos, I used Version 1.6.6. Depending on when you take the course, there may be a newer version of the Arduino IDE available. Maybe some of you already have a different version installed. As I said before, the lion's share of the changes from one version to the next are very trivial. The computer code and concepts taught in this course, though, always stay the same. Now, I understand if you want to get the exact same version that we use in the course. This will ensure that everything you see in the videos is a mirror image of what you'll see in your Arduino IDE software. To do this, just make sure you click on Version 1.6.6 when you install. This and all past versions of the Arduino IDE are kept on the Arduino website. We'll discuss this further as we walk through the next few lessons. I can’t wait to get you up and running!…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Map of the Familiarization Module 2:11

8 years之前2:11

2:11

Discussion: Before we can start diving into programming the microcontroller on the Arduino, we need to have a solid understanding of the tools used to make it happen. Therefore, in this particular lesson, we're just going to do an overview of what you'll learn in this familiarization module. As the name implies, this module will get you familiar with the software and hardware tools used throughout this course and beyond. More specifically, this section will cover: The Arduino IDE Version Used in This Course How to Download, Install, and Set Preferences The Arduino IDE Itself The Arduino Board The Arduino Toolchain First, however, I want to explain how best to learn the objectives of this and any other module. There are several things provided in each lesson that can help you be more successful as you move through the course. Obviously, you need to become familiar with the Arduino software and hardware. In addition to this, each lesson has accompanying videos, challenges, and further reading suggestions. Take advantage of these, and you'll easily rock this course! Get to Know Arduino Integrated Development Environment (IDE) In the beginning of this module, we'll discuss administrative items regarding the version of the Arduino IDE used here. Then, I'll walk you step-by-step through downloading and installing the Arduino IDE. We'll also talk about setting up some of the preferences. Once we have it installed, then we'll get familiar with the Arduino IDE itself - some of the buttons, tabs, and that type of thing. Afterwards, we'll take a close look at the Arduino board hardware. Finally, we'll do an overview of the Arduino toolchain. Even if you already have the Arduino IDE installed, and even if you have already been creating programs with it, I still say it's a great idea to watch the videos in this section. There might be a couple of things that can help expand your knowledge of the IDE and the hardware - maybe even some tricks or tips that you've not seen before. Doing the Challenges is the Key to Growth Check out the challenges at the end of each lesson. This lesson will not have challenges since it is just an introduction to the module. However, most lessons will have programming challenges after the lesson discussion. These will help cement in your mind the concepts taught in that lesson, as well as offer more ways for you to practice your newly acquired skills. Practice and repetition will help your grow your knowledge base. By diligently doing the challenges, you'll get some real programming and electronics experience under your belt. Also, pay close attention to the further reading section. It will contain links that will point out other tutorials and helpful online resources online. Of course, don't feel like you have to read every linked article. If there's a resource that I feel is exceptionally helpful, I'll make sure to make a note of it in the further reading section. Enjoy this module!…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Parts List 7:03

8 years之前7:03

7:03

Discussion: In this video, I’ll explain what parts you'll need to complete this Arduino Crash Course. Immediately below this discussion section, there is a summary checklist of links for these parts. You're welcome to check it out! The links take you to Jameco, a United States based electronics supplier. I'm actually one of their affiliates. So, if you decide to click any of those links below, you’ll be helping to make me a multi-millionaire and continue to buy fuel for my yacht. So that would be awesome. All joking aside, you might already have a lot of this stuff laying around. It just depends on how much you've been into electronics thus far. The first thing you'll need is an Arduino UNO. As you may or may not know, Arduino has all types of derivatives out there. An Arduino UNO There is a company named Arduino that made the board. That is the official Arduino, but Arduino is open-source hardware. In other words, the Arduino company made the board’s schematics and everything publicly available. Therefore, anybody can take access that information and replicate the board. Anyone can duplicate it, modify it, and even legally sell it. That’s why there are so many derivatives, or clones, out there of an Arduino UNO board. They are basically the exact same thing as your official Arduino UNO. Sometimes you’ll find that maybe one or two customizations have been made. My recommendation to you is to get an authentic, official Arduino UNO from the Arduino company while working through this course. The reason is because that prevents any discrepancies and concerns about hardware when following the tutorials. If you're following everything in the lesson, and something is amiss, then you can at least know it's not the hardware. You’ll know that you have the same hardware with which I’m working. Again... that’s just my recommendation. Now, if you already have an Arduino clone or derivative, feel free to use it. It will probably work just fine. The next thing you'll need is a USB cable to plug your Arduino into your computer. Basic procedure is to write code on the computer and then transfer that code, uploading it to the Arduino board. An AB USB cord The USB we’ll be using in this course is an A-B type. One end looks like your typical USB that just plugs into a computer, and the other end is almost square - or maybe more like a little house, depending on your imagination. This other end is what would typically go into the back of a printer. You will also need light-emitting diodes, or LEDs. An LED It’s best to get at least 10 of the five millimeter type. Any color of mix of colors is fine. I usually use red or white. Next on the list are resistors. Resistors Resistors, as the name suggests, resist the flow of current in a circuit. The bigger the number of the resistor, the more current they resist. When it resists current, the resistor takes that electrical energy and transforms it into heat energy. Therefore, it’s important to note resistors can get hot. Just file that away as a quick mental note for later down the line when we begin setting up circuits. You may not notice it that much for the lower level things we will be doing. However, I wanted to make you aware just in case. This is the list of required resistors: ten 220 Ohm resistors and two 10,000 Ohm resistors (also referred to as 10 K resistors). You’ll also need a potentiometer. Potentiometers It really doesn't matter what size you get. I’ll be using a 10 K potentiometer for this course. If you have one around, you can just use that. A potentiometer is similar to a resistor, but it's resistance can vary. That allows you to create something called a voltage divider. We won't get into that now. Just know that you need a potentiometer of any size. Next, you'll use a solderless breadboard. No, we won’t be cutting bread - although food does sound really good right now…. But I digress, a solderless breadboard is a circuit board where you can connect electrical components together without having to solder them. It has a bunch of little holes in it, and in the holes are all these little copper clips. A solderless breadboard The holes are aligned in a bunch of rows and columns. The columns are electrically connected, but the rows are not. So, you stick the leads of your electrical components, such as an LED, into the holes for the metal clips. This will complete the circuit, connecting the electronics. This is an example of how you'll use the breadboard. Don’t worry, it’s a lot easier than it sounds. For prototyping, like we'll be doing, it's a great tool since it permits quick and easy setup and changes to your circuit. The next required items are jumper wires. Jumper wires These fit down into the little holes on a breadboard and into the little holes on the Arduino board. (We'll be talking about the Arduino board more later, but those are called the headers.) Anyway, the jumper wires allow you to extend your electrical connections, giving you some extra space with which to work. You'll need 12. Two momentary push-buttons are also on the course list. A push button This button is normally off. That means if you're not pressing the button, no electrical connection is made between either side of the button. The button is off until you push it. When you’re holding the button down, though, an electrical connection is made. Once you remove your finger, the button pops back out again, breaking the electrical connection. They come in all different styles. However, if you follow the links below, you'll get an idea for what to look. Finally, you'll need some alligator clips. Alligator clips These help you connect leads together if, for some reason, we need to connect them in a way a little different than using the holes on the solderless breadboard. It may seems like quite a bit of equipment, but it’s really not that bad. I kept convenience in mind when creating this list. All of these items are relatively cheap. There are a couple of other things you'll need, though. I assume that you already have a computer running Windows, Mac, some type of Mac software, or Linux. Of course, an internet connection is also required because you'll have to download the Arduino software. I’ll explain the Arduino software in a later lesson. There are few things that are optional. These are not covered in this crash course, but they would be fun to have in order to experiment with your code. This is the optional equipment. You could get a photoresistor, a temperature sensor, maybe some additional potentiometers, and an RGB LED. RGB means red, green, blue LED. It's kind of an all in one, and they are pretty neat use. I believe that's it for the required and optional equipment. Again, the parts list is below. I’m looking forward to jumping into the course with you. See you in the next video! Hardware List for the Arduino Crash Course Below is the list of items you will need to get you through the course. The quantities of each provide a little leeway in case your cat eats an LED or you loose a resistor in your shag carpet. I have made every effort to keep this list minimal to provide the lowest cost to entry. NOTE: The links below take you to Jameco, of whom I am an affiliate. The cost to you is the same, but I get a small commission for purchases that helps me keep the site running and allows me to buy giant yachts. I use Jameco for a bunch of stuff - I like and trust them. I also use Digikey, Mouser, Adafruit, Makershed and Sparkfun. Required: Arduino Compatible Board USB Cable to plug in Arduino (A/B type - one end is typical USB, the other is what would go into a printer) LEDs AKA Light Emitting Diodes (10) 10K potentiometer (1) 220 Ohm Resistor (10) 10K Ohm Resistor (2) Jumper Wires (12) Solderless Breadboard (1) Pushbutton (2) Alligator Clips (3) Another option is to buy our Kit-on-a-Shield for Arduino: Click here to learn more. You'll need this stuff too: Now there are certain things I am assuming you have access to that you will also need, these include the below items. A computer running Windows, Mac OS, or Linux An internet connection to download the Arduino Software Optional stuff: While the list above will meet all your needs, sometimes having a little extra stuff to play with makes for a more fun and diverse learning experience. Below are items you can easily experiment with alongside this course: Photo Resistor Additional potentiometers RGB LEDs - red, green and blue all in one LED matrix Temperature sensors Arduino Kit just for this course from Jameco: I have had the pleasure of working with Jameco to create a kit that provides all the needed items for the Arduino Crash Course. You can check it out here.…

L

Learn Programming and Electronics with Arduino

Learn Programming and Electronics with Arduino podcast artwork

1
Rebranding Clarification 1:05

8 years之前1:05

1:05

Open Source Hardware Group is now Programming Electronics Academy - we rebranded!

欢迎使用Player FM

Player FM正在网上搜索高质量的播客，以便您现在享受。它是最好的播客应用程序，适用于安卓、iPhone和网络。注册以跨设备同步订阅。

收听超过500个主题

边探索边听这个节目