Lecture 2.3: Compiling Code - Arduino Environment | Coursera

Explorar todo lo que Coursera tiene para ofrecer

Para EmpresasPara los estudiantes

Explorar
Principales cursos
Inicia Sesión
Únete de forma gratuita

Lecture 2.3: Compiling Code

Loading...

The Arduino Platform and C Programming

Universidad de California en Irvine

4.6 (5,003 calificaciones) | 120K estudiantes inscritos

Curso 2 de 6 en An Introduction to Programming the Internet of Things (IOT) Programa Especializado

Inscríbete gratis

The Arduino is an open-source computer hardware/software platform for building digital devices and interactive objects that can sense and control the physical world around them. In this class you will learn how the Arduino platform works in terms of the physical board and libraries and the IDE (integrated development environment). You will also learn about shields, which are smaller boards that plug into the main Arduino board to perform other functions such as sensing light, heat, GPS tracking, or providing a user interface display. The course will also cover programming the Arduino using C code and accessing the pins on the board via the software to control external devices. Please note that this course does not include discussion forums. Upon completing this course, you will be able to: 1. Outline the composition of the Arduino development board 2. Describe what it means to program the board's firmware 3. Read board schematics 4. Install Arduino IDE 5. Describe what "shields" are and how they are used 6. Specify the role of libraries in the use of shields 7. Compile and run a program 8. Name C Variables and Types 9. Name common C operators 10. Use conditionals and loops 11. Explain functions, their definition and invocation 12. Explain the implications of global variables 13. Undertake the Arduino build process 14. Describe the role of the tools behind the IDE 15. Describe how to invoke functions in classes 16. Explain the structure of an Arduino sketch 17. Access the pins of the Arduino 18. Differentiate between digital and analog pin 19. Debug embedded software 20. Explain the importance of controllability and observability in the debugging process 21. Describe common debugging architectures for embedded systems 22. Explain how the UART Serial communication protocol works 23. Describe how the Arduino Serial library performs serial communication

Destrezas que aprenderás

Arduino, C Programming, Debugging

Revisiones

4.6 (5,003 calificaciones)

5 stars
72%
4 stars
22%
3 stars
4%
2 stars
1%
1 star
1%

TA

Jun 16, 2019

THIS COURSE HAS GIVING ME MORE HOPE AN EASY WAY OF LEARNING.\n\nI WOULD HAVE WASTED MORE TIME MOVING FROM ONE PLACE TO THE OTHER IN OTHER TO LEARN WHAT I HAVE BEEN TAUGHT ON THIS PLATFORM

SY

May 11, 2020

Course was great and interesting to learn. Explanation of concepts was nice and easy to grasp. After Completion of Course worth checking out the next Course in series of specialization.

De la lección

Arduino Environment

This module provides an introduction to the Arduino environment which is composed of three things: the Arduino board, the Arduino IDE, and the Arduino-compatible shields together with their libraries. We first investigate the board, discussing all of its main components, inputs, and outputs. We discuss how each component is used and we examine the board schematic to see how they are connected. We then discuss the Arduino Integrated Development Environment (IDE) which is used primarily to write, compile, and upload code. We survey the interface of the IDE and discuss how to install and use it. We also examine the use of shields to extend the functionality of an Arduino-based system. We discuss how shield libraries provide a useful abstraction to facilitate programming.

Lecture 2.1: Arduino Schematics4:42

Lecture 2.2: Arduino IDE7:54

Lecture 2.3: Compiling Code4:38

Impartido por:

Ian Harris
Professor

Prueba el curso Gratis

Transcripción

[MUSIC] In this lecture, we'll talk about how you compile using the IDE, how you compile, and you upload using IDE, and what it looks like, so, and what errors look like, which you will most certainly see. So compiling code. If you want to compile a code, cross-compile technically, you can either verify or upload. So those are both buttons, verify and upload. Also, you can get those from the pull-down menus. So verify and upload both compile the code. Upload additionally copies a code, the executable, final executable to the Arduino, but both of those will compile a code. Now, what happens is when you do it, there's a message window at the bottom. And the message window is there to show you the status of the compile. So it will either, after it's done compiling, it'll either show you some completion message, to say, you know, compile complete, something like done uploading if you're uploading, something like that, or it'll show you an error, one or more errors. Error messages will show the line numbers, too. So whenever there's an error inside your code, you want to know where in your code it happened. So it helps you to find the errors somewhat. So first thing, you can see that, so in this program, if you look at the program, I'm just showing a few lines, three lines of code. In this program I messed up the code intentionally. I typed in an XX. So if you look in there, there's a line, and it's highlighted pink. Okay? That line, I typed in the letters XX, just to put an error in there, right? So that's an error, bad syntax. So when I compiled it, it gave an error. First thing it did was, in the error, well, you can look in the message window and it reports the error. It says what the error, XX is not good text. And it tells you the line number that it's on. So you can go back to the code and figure out which line number it's on. Also, you can see in the main text editor that it's highlighted pink the line with the error on it, with the first error. So that's also helpful. You can look straight at that line. I mean, you don't have to look at the line number. You can just look at the line that's highlighted and say, okay, there's my first error. So it's helping you to zero-in on where the errors are. And then you examine the line and try to find it. Just a warning about these errors, you'll notice that it gives you an error on that line. It also gives you an error on the next line, right? This happens in C a lot. Because with C you get these semicolons at the end of your statements. Notice the statements up there, each line, correct ending would be a semicolon at the end. So since there's a line with the error, you can see there's a semicolon and then there's an XX after the semicolon. And what happens is that the compiler thinks, look, anything between two semicolons is one line. So it thinks the XX is actually the beginning of the next line. And that's why it gives us an error on the next line as well, because an XX shouldn't be at the beginning of the next line. So just be wary of that. When you see these errors, you'll see sort of a cascade of errors. So what you do is, generally when you're debugging, you go with the first error first. You look for the first error, fix that, then recompile. And some of, multiple errors may disappear as a result. So the serial monitor, I mentioned that before. The serial monitor is basically a pop-up window. You pop it up and it looks like this. It's got a main window, and then it's got, up near the top it's got a row where you can type in text. So this is an interface to the Arduino. The main window is where messages will pop up. So if you, you can write, there are library functions that allow you to write in your code to print some messages to this serial monitor. So if you have a serial monitor open and you write serial print, serial.print, and we'll look at this later. You write serial.print in your code, it will print text to the serial monitor. So you can see the results of your computation, let's say. You can send it through, to the serial monitor and a human can see it. Now, also, serial monitor can work in the other direction. So somebody can type into the serial monitor. So if you look at that top row up there on the serial monitor, you can type in there and click that send button. It will send that data to the Arduino, and the Arduino will receive it. And you can write code that does something with that data that interprets it in some way. So the serial monitor is like a, sort of a keyboard and screen interface for the Arduino. You can open the serial monitor and then you can write code in your Arduino that accesses the serial monitor, either writes to it or reads data from it. Thank you. [MUSIC]

Explora nuestro catálogo

Inscríbete de manera gratuita y obtén recomendaciones personalizadas, actualizaciones y ofertas.

Coursera

Acerca de
Liderazgo
Empleo
Catálogo
Certificados
Certificados MasterTrack™
Grados
Para Empresas
Para gobiernos
Para el campus
En respuesta al Coronavirus

Comunidad

Estudiantes
Socios
Desarrolladores
Probador beta
Traductores
Blog
Blog de Tecnología

Más

Términos
Privacidad
Ayuda
Accesibilidad
Prensa
Contacto
Directorio
Afiliados

Aplicación móvil

© 2020 Coursera Inc. Todos los derechos reservados.