El documento proporciona una introducción a la estructura y elementos básicos de un programa de Arduino, incluyendo secciones para declarar variables, setup y loop. Explica la estructura de control con bloques condicionales como if/else y switch/case, y bloques repetitivos como while, do y for para ejecutar código de forma condicional o repetitiva.
El documento explica la sentencia de control "do while" en Visual Basic. Esta sentencia establece un ciclo controlado por una condición que se evalúa al final de cada iteración, por lo que se garantiza que el bloque de instrucciones se ejecute al menos una vez. Se proveen ejemplos que ilustran cómo usar "do while" para contar dígitos de un número o iterar un bucle mientras una condición sea verdadera.
El documento proporciona instrucciones sobre sentencias de control en C++. Explica las sentencias condicionales IF, IF-ELSE y SWITCH, que permiten ejecutar código dependiendo de si se cumple una condición. También cubre las sentencias repetitivas WHILE, DO-WHILE y FOR, que permiten repetir código un número determinado de veces o mientras se cumpla una condición. Finalmente, presenta las sentencias BREAK y CONTINUE, que controlan el flujo de ejecución dentro de bucles.
El documento describe la instrucción if en C++, incluyendo su sintaxis y ejemplos. Explica que if evalúa una condición y ejecuta un bloque de código si es verdadera. También cubre else, que ejecuta un bloque alternativo si la condición es falsa. Los ejemplos muestran cómo usar if/else para imprimir mensajes condicionales basados en el valor de una variable.
El documento explica los diferentes tipos de ciclos en programación (while, do-while y for) y cómo funcionan. Proporciona ejemplos de código para ilustrar cómo se usan estos ciclos para repetir instrucciones un número determinado de veces. También advierte sobre los ciclos infinitos y cómo evitarlos asegurando que la condición del ciclo cambie para que eventualmente sea falsa.
Este documento resume las estructuras de control básicas como secuencia, selección y repetición. Explica las estructuras IF-THEN-ELSE, SELECT-CASE, WHILE-DO, REPEAT-UNTIL y FOR para controlar el flujo de un algoritmo. Proporciona ejemplos de pseudocódigo que ilustran el uso de estas estructuras para resolver problemas como determinar si un número es positivo, negativo o nulo, realizar conversiones de unidades y sumar valores repetidamente. Concluye que las estructuras de control son útiles para solucionar problemas inform
Este documento describe diferentes estructuras de control de flujo en C como if, switch, for, while, do/while y las sentencias break, continue y goto. Explica cómo funcionan estas estructuras y proporciona ejemplos de su uso para controlar el flujo de un programa.
Este documento presenta varios temas básicos de Java que se verán a lo largo de varias clases. Incluye ejemplos de programas en Java sobre áreas de círculos, ámbito de variables, conversión de tipos, sentencias de control como if/else y switch, y bucles while. Los estudiantes deberán analizar los conceptos en cada ejemplo y guardar los programas realizados.
El documento describe la instrucción while en el lenguaje de programación C. Explica que while repite una sentencia o grupo de sentencias mientras una condición sea verdadera, y consta de tres partes: 1) inicialización de la variable de control, 2) comprobación de la condición, y 3) actualización de la variable de control. También cubre bucles infinitos, bucles con cero iteraciones, bucles controlados por centinelas, y el uso de break para terminar un bucle prematuramente.
El documento explica la sentencia de control "do while" en Visual Basic. Esta sentencia establece un ciclo controlado por una condición que se evalúa al final de cada iteración, por lo que se garantiza que el bloque de instrucciones se ejecute al menos una vez. Se proveen ejemplos que ilustran cómo usar "do while" para contar dígitos de un número o iterar un bucle mientras una condición sea verdadera.
El documento proporciona instrucciones sobre sentencias de control en C++. Explica las sentencias condicionales IF, IF-ELSE y SWITCH, que permiten ejecutar código dependiendo de si se cumple una condición. También cubre las sentencias repetitivas WHILE, DO-WHILE y FOR, que permiten repetir código un número determinado de veces o mientras se cumpla una condición. Finalmente, presenta las sentencias BREAK y CONTINUE, que controlan el flujo de ejecución dentro de bucles.
El documento describe la instrucción if en C++, incluyendo su sintaxis y ejemplos. Explica que if evalúa una condición y ejecuta un bloque de código si es verdadera. También cubre else, que ejecuta un bloque alternativo si la condición es falsa. Los ejemplos muestran cómo usar if/else para imprimir mensajes condicionales basados en el valor de una variable.
El documento explica los diferentes tipos de ciclos en programación (while, do-while y for) y cómo funcionan. Proporciona ejemplos de código para ilustrar cómo se usan estos ciclos para repetir instrucciones un número determinado de veces. También advierte sobre los ciclos infinitos y cómo evitarlos asegurando que la condición del ciclo cambie para que eventualmente sea falsa.
Este documento resume las estructuras de control básicas como secuencia, selección y repetición. Explica las estructuras IF-THEN-ELSE, SELECT-CASE, WHILE-DO, REPEAT-UNTIL y FOR para controlar el flujo de un algoritmo. Proporciona ejemplos de pseudocódigo que ilustran el uso de estas estructuras para resolver problemas como determinar si un número es positivo, negativo o nulo, realizar conversiones de unidades y sumar valores repetidamente. Concluye que las estructuras de control son útiles para solucionar problemas inform
Este documento describe diferentes estructuras de control de flujo en C como if, switch, for, while, do/while y las sentencias break, continue y goto. Explica cómo funcionan estas estructuras y proporciona ejemplos de su uso para controlar el flujo de un programa.
Este documento presenta varios temas básicos de Java que se verán a lo largo de varias clases. Incluye ejemplos de programas en Java sobre áreas de círculos, ámbito de variables, conversión de tipos, sentencias de control como if/else y switch, y bucles while. Los estudiantes deberán analizar los conceptos en cada ejemplo y guardar los programas realizados.
El documento describe la instrucción while en el lenguaje de programación C. Explica que while repite una sentencia o grupo de sentencias mientras una condición sea verdadera, y consta de tres partes: 1) inicialización de la variable de control, 2) comprobación de la condición, y 3) actualización de la variable de control. También cubre bucles infinitos, bucles con cero iteraciones, bucles controlados por centinelas, y el uso de break para terminar un bucle prematuramente.
El documento describe las principales estructuras de control en programación, incluyendo IF-THEN-ELSE, DO-LOOP, WHILE-WEND, SELECT-CASE, FOR-NEXT y FOR EACH-NEXT. Estas estructuras permiten controlar el flujo de un programa mediante condiciones para ejecutar o no secciones de código. Se proveen ejemplos de la sintaxis y uso de cada estructura.
TEMA Nº 8: CONTROL DE EJECUCIÓN Y MANTENIMIENTO DE SESIÓNAnyeni Garay
Este documento trata sobre el control de ejecución y mantenimiento de sesión en Java. Explica las diferentes instrucciones de control de flujo como if-else, bucles while, do-while y for, así como palabras clave como return, break y continue. También cubre temas como el operador coma, la sintaxis foreach y el uso de switch.
El documento describe los diagramas de flujo, pseudocódigo y sus estructuras de control. Explica que el pseudocódigo permite describir algoritmos sin preocuparse por la sintaxis de programación y actúa como un borrador del código. Luego detalla las principales estructuras de control como if/else, while, for y switch usadas en pseudocódigo para elegir caminos condicionales.
El documento describe las estructuras básicas de programación como secuencia, selección e iteración. La secuencia consiste en una o más instrucciones ejecutadas en orden. La selección incluye if, if-else y switch para ejecutar diferentes instrucciones basadas en condiciones. La iteración repite instrucciones usando for, while y do-while.
Las estructuras de control permiten repetir instrucciones mientras se cumpla una condición y tomar decisiones. Estas incluyen estructuras selectivas como if/else y switch que ejecutan acciones diferentes según una condición, y estructuras repetitivas como while, do-while y for que repiten acciones mientras se cumpla una condición. Los ejemplos muestran cómo implementar estas estructuras en Java para resolver problemas como determinar si una persona es mayor de edad o realizar operaciones matemáticas.
Este documento explica las diferentes estructuras de control de flujo en Java, incluyendo instrucciones if-else, switch, y bucles for, while y do-while. También cubre el uso de las instrucciones break y continue para controlar el flujo dentro de los bucles, así como el uso de etiquetas con break para salir de bucles anidados.
El documento describe las estructuras de control en Java, incluyendo estructuras de selección como if, if-else y switch, así como estructuras de iteración como while, do-while y for. También explica declaraciones como break y continue que modifican el flujo de control de los bucles, y la declaración return que finaliza un método.
Este documento describe las estructuras de control en el lenguaje de programación Borland C++, incluyendo estructuras secuenciales, selectivas y repetitivas. Explica la sintaxis y uso de sentencias if, if-else, switch y while. Además, presenta ejemplos de problemas y su solución utilizando estas estructuras de control.
métodos procedimimientos estructuras de control javaHenry Upla
Este documento describe diferentes tipos de métodos en Java, incluyendo métodos de función y procedimiento, métodos get y set, y métodos con y sin parámetros. También explica las estructuras de control if/else y switch para la toma de decisiones condicionales.
La estructura switch case se utiliza en programación para tomar decisiones múltiples de forma eficiente. Funciona comparando el valor de una variable con los valores de cada caso ("case") y ejecutando las acciones correspondientes hasta encontrar una instrucción "break". Un ejemplo muestra un programa que cuenta calificaciones introducidas por el usuario utilizando un switch case anidado en un bucle while.
El documento describe diferentes estructuras de control en C, incluyendo sentencias if, if-else, if-else anidadas, y switch. También cubre expresiones condicionales y evaluación en cortocircuito de expresiones lógicas. El documento incluye ejemplos de código y sugerencias para evitar errores comunes en la programación con estructuras de control.
Este documento describe las estructuras de control en Pascal, incluyendo las estructuras alternativas como IF-THEN-ELSE y CASE-OF, y las estructuras repetitivas como WHILE, REPEAT-UNTIL y FOR. Explica cuándo usar cada una y proporciona ejemplos de su sintaxis y uso.
El documento describe la estructura básica del lenguaje de programación de Arduino, que consiste en las funciones void setup() y void loop(). La función setup() se ejecuta una vez al inicio del programa para inicializar los pines y puertos, mientras que la función loop() se ejecuta de forma cíclica. También describe conceptos como variables, tipos de datos, operadores, funciones y control de flujo que se utilizan en Arduino.
Este documento describe transacciones y procedimientos almacenados en bases de datos. Explica que las transacciones permiten realizar operaciones en bloque y pueden cancelarse o confirmarse. Los procedimientos almacenados permiten almacenar conjuntos de operaciones y ejecutarlas fácilmente. También cubre el manejo de errores mediante el uso de handlers que permiten controlar errores específicos y continuar o salir de una transacción.
El documento describe tres estructuras de selección en C: la estructura selectiva simple (if), la estructura selectiva doble (if-else), y la estructura selectiva múltiple (switch). La estructura if ejecuta una acción si una condición es verdadera, if-else ejecuta una de dos acciones dependiendo de si la condición es verdadera o falsa, y switch elige entre múltiples bloques de código dependiendo del valor de una expresión.
Este documento presenta los fundamentos de las instrucciones de control en Java, incluyendo repetición (for, while, do-while), selección (switch), y operadores lógicos (&&, ||, !). Explica cómo usar estas instrucciones con ejemplos como contadores, cálculo de intereses, y calificaciones escolares.
Este documento describe diferentes estructuras de repetición en pseudocódigo, incluyendo ciclos mientras, hacer-mientras y para. Explica cómo cada una funciona y cuando evaluar la condición, e ilustra su uso con ejemplos como calcular la suma de números enteros.
Este documento describe las estructuras condicionales en C, incluyendo sentencias if, else if, else y operador ternario ?. También cubre la sentencia switch que permite comprobar múltiples casos de una variable y ejecutar código asociado al caso coincidente.
El documento describe la estructura básica de un programa de Arduino, incluyendo las secciones setup() y loop(). Explica los bloques condicionales if, else if y switch, así como los bucles while, do y for. Se proporcionan ejemplos de cada una de estas estructuras de control de flujo para ilustrar su uso.
Las estructuras de control permiten ejecutar código de manera repetitiva y condicional. Existen bucles que ejecutan código mientras una condición sea verdadera (mientras, repetir-hasta-que) y bucles que ejecutan código un número fijo de veces controlado por un contador (desde-para). Las expresiones lógicas comparan valores y devuelven verdadero o falso para controlar la ejecución.
El documento describe las principales estructuras de control en programación, incluyendo IF-THEN-ELSE, DO-LOOP, WHILE-WEND, SELECT-CASE, FOR-NEXT y FOR EACH-NEXT. Estas estructuras permiten controlar el flujo de un programa mediante condiciones para ejecutar o no secciones de código. Se proveen ejemplos de la sintaxis y uso de cada estructura.
TEMA Nº 8: CONTROL DE EJECUCIÓN Y MANTENIMIENTO DE SESIÓNAnyeni Garay
Este documento trata sobre el control de ejecución y mantenimiento de sesión en Java. Explica las diferentes instrucciones de control de flujo como if-else, bucles while, do-while y for, así como palabras clave como return, break y continue. También cubre temas como el operador coma, la sintaxis foreach y el uso de switch.
El documento describe los diagramas de flujo, pseudocódigo y sus estructuras de control. Explica que el pseudocódigo permite describir algoritmos sin preocuparse por la sintaxis de programación y actúa como un borrador del código. Luego detalla las principales estructuras de control como if/else, while, for y switch usadas en pseudocódigo para elegir caminos condicionales.
El documento describe las estructuras básicas de programación como secuencia, selección e iteración. La secuencia consiste en una o más instrucciones ejecutadas en orden. La selección incluye if, if-else y switch para ejecutar diferentes instrucciones basadas en condiciones. La iteración repite instrucciones usando for, while y do-while.
Las estructuras de control permiten repetir instrucciones mientras se cumpla una condición y tomar decisiones. Estas incluyen estructuras selectivas como if/else y switch que ejecutan acciones diferentes según una condición, y estructuras repetitivas como while, do-while y for que repiten acciones mientras se cumpla una condición. Los ejemplos muestran cómo implementar estas estructuras en Java para resolver problemas como determinar si una persona es mayor de edad o realizar operaciones matemáticas.
Este documento explica las diferentes estructuras de control de flujo en Java, incluyendo instrucciones if-else, switch, y bucles for, while y do-while. También cubre el uso de las instrucciones break y continue para controlar el flujo dentro de los bucles, así como el uso de etiquetas con break para salir de bucles anidados.
El documento describe las estructuras de control en Java, incluyendo estructuras de selección como if, if-else y switch, así como estructuras de iteración como while, do-while y for. También explica declaraciones como break y continue que modifican el flujo de control de los bucles, y la declaración return que finaliza un método.
Este documento describe las estructuras de control en el lenguaje de programación Borland C++, incluyendo estructuras secuenciales, selectivas y repetitivas. Explica la sintaxis y uso de sentencias if, if-else, switch y while. Además, presenta ejemplos de problemas y su solución utilizando estas estructuras de control.
métodos procedimimientos estructuras de control javaHenry Upla
Este documento describe diferentes tipos de métodos en Java, incluyendo métodos de función y procedimiento, métodos get y set, y métodos con y sin parámetros. También explica las estructuras de control if/else y switch para la toma de decisiones condicionales.
La estructura switch case se utiliza en programación para tomar decisiones múltiples de forma eficiente. Funciona comparando el valor de una variable con los valores de cada caso ("case") y ejecutando las acciones correspondientes hasta encontrar una instrucción "break". Un ejemplo muestra un programa que cuenta calificaciones introducidas por el usuario utilizando un switch case anidado en un bucle while.
El documento describe diferentes estructuras de control en C, incluyendo sentencias if, if-else, if-else anidadas, y switch. También cubre expresiones condicionales y evaluación en cortocircuito de expresiones lógicas. El documento incluye ejemplos de código y sugerencias para evitar errores comunes en la programación con estructuras de control.
Este documento describe las estructuras de control en Pascal, incluyendo las estructuras alternativas como IF-THEN-ELSE y CASE-OF, y las estructuras repetitivas como WHILE, REPEAT-UNTIL y FOR. Explica cuándo usar cada una y proporciona ejemplos de su sintaxis y uso.
El documento describe la estructura básica del lenguaje de programación de Arduino, que consiste en las funciones void setup() y void loop(). La función setup() se ejecuta una vez al inicio del programa para inicializar los pines y puertos, mientras que la función loop() se ejecuta de forma cíclica. También describe conceptos como variables, tipos de datos, operadores, funciones y control de flujo que se utilizan en Arduino.
Este documento describe transacciones y procedimientos almacenados en bases de datos. Explica que las transacciones permiten realizar operaciones en bloque y pueden cancelarse o confirmarse. Los procedimientos almacenados permiten almacenar conjuntos de operaciones y ejecutarlas fácilmente. También cubre el manejo de errores mediante el uso de handlers que permiten controlar errores específicos y continuar o salir de una transacción.
El documento describe tres estructuras de selección en C: la estructura selectiva simple (if), la estructura selectiva doble (if-else), y la estructura selectiva múltiple (switch). La estructura if ejecuta una acción si una condición es verdadera, if-else ejecuta una de dos acciones dependiendo de si la condición es verdadera o falsa, y switch elige entre múltiples bloques de código dependiendo del valor de una expresión.
Este documento presenta los fundamentos de las instrucciones de control en Java, incluyendo repetición (for, while, do-while), selección (switch), y operadores lógicos (&&, ||, !). Explica cómo usar estas instrucciones con ejemplos como contadores, cálculo de intereses, y calificaciones escolares.
Este documento describe diferentes estructuras de repetición en pseudocódigo, incluyendo ciclos mientras, hacer-mientras y para. Explica cómo cada una funciona y cuando evaluar la condición, e ilustra su uso con ejemplos como calcular la suma de números enteros.
Este documento describe las estructuras condicionales en C, incluyendo sentencias if, else if, else y operador ternario ?. También cubre la sentencia switch que permite comprobar múltiples casos de una variable y ejecutar código asociado al caso coincidente.
El documento describe la estructura básica de un programa de Arduino, incluyendo las secciones setup() y loop(). Explica los bloques condicionales if, else if y switch, así como los bucles while, do y for. Se proporcionan ejemplos de cada una de estas estructuras de control de flujo para ilustrar su uso.
Las estructuras de control permiten ejecutar código de manera repetitiva y condicional. Existen bucles que ejecutan código mientras una condición sea verdadera (mientras, repetir-hasta-que) y bucles que ejecutan código un número fijo de veces controlado por un contador (desde-para). Las expresiones lógicas comparan valores y devuelven verdadero o falso para controlar la ejecución.
Este documento describe diferentes estructuras de repetición como ciclos mientras, haga-mientras y para. Explica que estas estructuras permiten ejecutar un bloque de instrucciones varias veces dependiendo de una condición. Luego detalla cada estructura y provee ejemplos para ilustrar cómo se usan para resolver problemas que involucran sumatorias y máximos divisores comunes.
Este documento presenta las estructuras de control en C++, incluyendo las sentencias if, if/else y switch. Explica que las estructuras de control determinan el orden de ejecución de las instrucciones en un programa. Luego proporciona ejemplos de código C++ que ilustran el uso de if, if/else para tomar decisiones basadas en una condición lógica, y switch para manejar múltiples opciones.
Este documento presenta una introducción a PL/SQL, incluyendo su uso para manejar datos en el esquema de una base de datos, así como bucles, procedimientos, funciones y el tratamiento de excepciones. Explica conceptos como bloques, variables, constantes, instrucciones SELECT...INTO, de control e instrucciones y manejo de excepciones. También cubre temas como cursores, triggers e índices.
El documento describe diferentes estructuras de decisión y repetición en Visual Basic, incluyendo el bloque IF/ELSE para bifurcaciones condicionales, SELECT CASE para comparar valores, y bucles FOR/NEXT, DO/LOOP para repetir instrucciones. También presenta ejercicios para practicar el uso de estas estructuras al resolver problemas matemáticos y de lógica.
Este documento describe las principales estructuras de control en PHP, incluyendo if/else, switch, while, for, foreach. Cada estructura permite bifurcar el flujo de un programa según ciertas condiciones. Se proveen ejemplos detallados de cómo usar cada estructura para tomar decisiones condicionales o repetir código mediante bucles.
1) El documento habla sobre estructuras de control en Java, las cuales permiten modificar el flujo secuencial de ejecución de un programa. 2) Explica las estructuras selectivas como if, if-else y switch que permiten tomar decisiones, y las estructuras repetitivas como while y do-while para repetir bloques de código. 3) Incluye ejemplos de código Java para ilustrar el uso de estas estructuras de control.
Este documento describe las estructuras iterativas o de repetición en programación, las cuales permiten ejecutar un bloque de instrucciones múltiples veces. Explica que existen tres tipos principales de estructuras iterativas: el bucle mientras, el bucle repetir-mientras y el bucle para. Luego, procede a detallar cada una de estas estructuras iterativas, incluyendo su sintaxis, funcionamiento y ejemplos para ilustrar su uso.
Este documento describe cómo crear un test bench en VHDL para probar un diseño. Explica cómo crear un proyecto, agregar archivos VHDL para el diseño y el test bench, y configurar las opciones del simulador. Luego, detalla cómo escribir el código VHDL para el test bench, incluyendo instanciar el diseño, generar una señal de reloj, y aplicar estímulos de entrada. Finalmente, muestra cómo simular el test bench para verificar el funcionamiento del diseño.
Este documento describe los tipos de datos primitivos y conceptos básicos en C como variables, identificadores, sentencias condicionales y de iteración. Incluye una tabla con los tipos de datos comunes como char, int, float y double junto con su tamaño en bits y rango de valores. También explica conceptos como declaración de variables, sentencias if-else, switch y bucles como for, while y do-while.
Este documento explica qué es un algoritmo y los pasos para diseñar uno. Define un algoritmo como un conjunto ordenado de operaciones para resolver un problema. Explica que el diseño de un algoritmo implica crear primero una versión narrativa, luego un modelo detallado y finalmente un diagrama de flujo o pseudocódigo. También incluye ejemplos de cada una de estas etapas y describe conceptos como estructuras secuenciales, de decisión, repetitivas y otros componentes básicos de los algoritmos.
El documento describe diferentes estructuras de control de flujo en JavaScript como if, if/else, for y for/in que permiten tomar decisiones y repetir bloques de código. También describe funciones útiles para cadenas, arrays y números como length, concat, join e isNaN. Finalmente, explica el ámbito de las variables y la diferencia entre variables globales y locales.
El documento describe diferentes estructuras de repetición en programación, incluyendo ciclos como "mientras", "para" y "switch". El ciclo "mientras" repite instrucciones mientras se cumpla una condición, "para" repite instrucciones un número especificado de veces usando un contador, y "switch" elige código a ejecutar basado en un valor. También presenta ejemplos de cómo usar estas estructuras en C para repetir código.
El documento describe diferentes estructuras de repetición en programación como ciclos, bucles y estructuras condicionales como while, for, do-while y switch. Explica que estas estructuras permiten ejecutar repetidamente un conjunto de instrucciones dependiendo de si se cumple una condición. Luego proporciona ejemplos detallados de cómo funcionan cada una de estas estructuras de control de flujo.
El documento describe diferentes estructuras de repetición como mientras, hacer-mientras, repita-hasta y para. Explica que estas estructuras permiten ejecutar un bloque de instrucciones de manera repetida según una condición. Luego, detalla cada una de estas estructuras y provee ejemplos para ilustrar su uso en la resolución de problemas que involucran ciclos.
El documento describe las diferentes estructuras de control en programación, incluyendo secuencia, selección e iteración. La secuencia ejecuta instrucciones en orden, la selección ejecuta una de varias secuencias basada en una condición, e iteración repite una secuencia un número determinado de veces. Ejemplos como if, else, for y while ilustran cómo estas estructuras controlan el flujo de ejecución de un programa.
Este documento presenta una introducción a MATLAB, un software ampliamente utilizado en ingeniería. MATLAB permite realizar cálculos, crear y manipular vectores y matrices, y graficar funciones. Se explican comandos básicos como suma, resta, multiplicación, división, así como comandos para crear y manipular vectores y matrices. También se describen conceptos como variables simbólicas, condicionales y ciclos para programar funciones y scripts en MATLAB.
Este documento presenta una lección sobre estructuras de control en Java. Explica diferentes estructuras como if, if-else, while, for, switch y do-while. Incluye objetivos de aprendizaje, referencias, un bosquejo del contenido y ejemplos de código para ilustrar el uso de cada estructura. El autor es José Navarro y el propósito es enseñar sobre estructuras de control para diseñar programas en Java que puedan tomar decisiones y realizar repeticiones.
Este manual describe diferentes métodos para el diseño de sistemas electroneumáticos avanzados, incluyendo métodos directos, de bandera, cascada, paso a paso mínimo y máximo. Incluye secciones sobre secuencias, controles lógicos programables y diagnóstico de fallas. El documento proporciona ejemplos y ejercicios para aplicar estos métodos.
Este documento trata sobre controladores lógicos programables (PLC). Presenta una introducción a los PLC, incluyendo su concepto, ventajas, campos de aplicación, estructura y equipos de programación. También clasifica los diferentes tipos de PLC y describe su uso en tableros de control industrial.
El documento consiste en una lista repetida de la dirección web www.FreeLibros.com en más de 200 líneas consecutivas. Proporciona poca información sobre el contenido del sitio web, pero indica que la dirección www.FreeLibros.com es el tema principal del documento.
Este documento presenta una introducción a los controladores lógicos programables (PLCs). Explica que un PLC es un equipo que puede tomar información del mundo exterior, procesarla realizando operaciones lógicas y matemáticas, y ejecutar acciones programadas como respuesta. Describe los elementos básicos de un sistema PLC, incluyendo la unidad central de procesamiento, memoria, módulos de entrada y salida, y dispositivos de entrada y salida. También explica conceptos como el cableado de dispositivos de entrada como interruptores, sens
Este documento presenta una introducción a los autómatas programables (PLC), incluyendo su historia, ventajas e inconvenientes. Explica la estructura interna y externa de los PLC, sus áreas de memoria y modos de funcionamiento. Finalmente, resume las instrucciones básicas de programación para PLC como operadores lógicos, temporizadores, contadores y saltos.
The document is a system manual that provides information about installing, programming, and configuring S7-200 SMART CPUs and expansion modules, including an overview of the products, new features, communication options, and instructions for connecting to a CPU and creating a sample program.
Siemens' SIMATIC S7-200 SMART PLC offers an affordable and flexible automation solution for developing markets. It provides a range of CPU modules with integrated I/O and communication ports. Additional I/O and communication can be added via cost-effective signal boards. The PLC uses a high-speed processor and user-friendly software to provide powerful motion control, networking, and programming capabilities despite its low cost. It can be integrated with other Siemens products to create complete automation solutions for applications like packaging machines.
El documento describe diferentes métodos para variar la velocidad de motores eléctricos de corriente alterna de dos o tres velocidades, incluyendo el uso de dos bobinados independientes, la conexión Dahlander y variadores de frecuencia electrónicos. Se explican circuitos de potencia y mando para cada método y se proporcionan ejemplos de relaciones de velocidad que se pueden lograr.
PLC: Buses industriales y de campo practicas de laboratorio por Jose Miguel R...SANTIAGO PABLO ALBERTO
El documento trata sobre buses industriales y de campo. Contiene 16 prácticas sobre diferentes buses como Profibus, Interbus, DeviceNet, ControlNet, DH+ y RIO, Ethernet, MPI y AS-i utilizando equipos Siemens y Rockwell Automation. El autor es José Miguel Rubio Calin, ingeniero técnico industrial que ha desarrollado las prácticas para su uso en centros de formación.
PLC y Electroneumática: Electricidad y Automatismo eléctrico por Luis Miguel...SANTIAGO PABLO ALBERTO
Este documento trata sobre electricidad y automatismos eléctricos. Explica conceptos básicos como la generación, transporte y medición de la corriente eléctrica, así como los componentes pasivos como resistencias, bobinas y condensadores. También analiza circuitos eléctricos en corriente continua y alterna monofásica, incluyendo cálculos, leyes y métodos de resolución. Por último, introduce conceptos de electromagnetismo.
Electrónica: Diseño y desarrollo de circuitos impresos con Kicad por Miguel P...SANTIAGO PABLO ALBERTO
Este documento presenta un manual sobre el diseño y desarrollo de circuitos impresos utilizando el software libre Kicad. Explica conceptos básicos como footprints, pads, pistas, capas y librerías. Incluye instrucciones para la instalación de Kicad en Windows y Linux, y guías detalladas sobre la edición de esquemas, la creación de la placa de circuito impreso y el diseño de pistas.
PLC: Diseño, construcción y control de un motor doble Dahlander(cuatro veloci...SANTIAGO PABLO ALBERTO
Este documento describe las condiciones de uso de una tesis protegida por derechos de autor. Se requiere reconocer los derechos del autor y citarlo correctamente. No se puede usar la tesis con fines comerciales ni distribuirla sin permiso.
Este documento presenta información sobre la documentación técnica necesaria para proyectos de automatización. Explica que la documentación debe incluir planos de instalación, diagramas de bloques, esquemas de circuitos, diagramas y tablas, y planos de conexiones. Además, detalla normas para la documentación como IEC 61082 e IEC 60617 y proporciona detalles sobre la identificación de componentes a través de códigos normalizados.
Electrónica digital: Introducción a la Lógica Digital - Teoría, Problemas y ...SANTIAGO PABLO ALBERTO
Este documento presenta un libro sobre electrónica digital que introduce conceptos básicos de lógica digital como sistemas de numeración, representación de números, codificación de información, álgebra de conmutación y funciones lógicas básicas. El libro fue desarrollado por un equipo de 11 profesores e ingenieros de la Universidad Nacional de Educación a Distancia y está destinado a estudiantes de ingeniería eléctrica y electrónica.
Los puentes son estructuras esenciales en la infraestructura de transporte, permitiendo la conexión entre diferentes
puntos geográficos y facilitando el flujo de bienes y personas.
1. 1
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
INTRODUCCIÓN
Puede dividirse en: ESTRUCTURA, VARIABLES, FUNCIONES.
I. ESTRUCTURA GENERAL DE UN SKETCH/PROGRAMA
1.1.ESTRUCTURA BÁSICA DEL PROGRAMA:
Se compone de tres secciones principales:
1.1.1. Sección de declaración de variables: Ubicadas al inicio.
1.1.2. Sección llamada “void setup”:
Delimitada por llaves de apertura y cierre. Es la primera función a ejecutar en el programa. Se
ejecutan una única vez en el momento de encender o resetear la placa ARDUINO.
Se usa para inicializar:
Los modos de trabajo de los pins E/S (PinMode)
Comunicación en serie
Ejemplo:
1.1.3. Sección llamada “void loop()”:
Delimitada por llaves de apertura y cierre; incluye el código que se ejecuta continuamente
leyendo entradas, activando salidas, etc. Esta función es el núcleo de todos los programas
ARDUINO y hace la mayor parte del trabajo. Se ejecutan justo después de la sección “void
setup()” infinitas veces hasta que la placa se apague (o se resetee).
Ejemplo:
int buttonPin = 3;
void setup() // Se ejecuta una zona vez, cuando el programa inicia
{
Serial.begin(9600); // Comunicación en serie
pinMode(buttonPin, INPUT); // Configura en pin digita l#3 como ENTRADA de datos
}
void loop()
{
// ...
}
Int pin = 10;
void setup()
{
pinMode(pin, OUTPUT); // Establece 'pin' como salida
}
void loop()
{
digitalWrite(pin, HIGH); // pone en uno (on, 5v) el ´pin´
delay(1000); // espera un segundo (1000 ms)
digitalWrite(pin, LOW); // pone en cero (off, 0v.) el ´pin´
delay(1000); // espera un segundo (1000 ms)
}
2. 2
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
1.2.ESTRUCTURA DE CONTROL:
BLOQUES CONDICIONALES
1.2.1. Bloque “if” , “if/else” y “If/else if” :
Las sentencias if comprueban si cierta condición ha sido alcanzada y ejecutan todas las
sentencias dentro de las llaves si la declaración es cierta. Si es falsa el programa ignora la
sentencia.
Ejemplo:
Veremos que solamente se muestran la “Frase 2”
y la “Frase 3”. Esto es debido a que la condición
del primer “if” es falsa: en él se comprueba si la
variable “a” es mayor que 10 Y A LA VEZ si es
menor de 20. En cambio, la condición del segundo
“if” es cierta: en él se comprueba si la variable “a”
es mayor que 10 O BIEN menor de 20: como ya se
cumple una de las condiciones –la primera–, la
condición total ya es cierta valga lo que valga el
resto de condiciones presentes. La condición del
tercer “if” también es cierta: en él se comprueba
si la variable “a” es mayor que 10 y a la vez, gracias
al operador “!”, que NO sea menor de 20.
Las sentencias if/else permiten un mayor control sobre el flujo del código que la declaración
if básica, por permitir agrupar múltiples comprobaciones. “Si esto no se cumple haz esto
otro”.
Ejemplo:
Hay que tener en cuenta que solamente se
pueden utilizar los operadores de comparación
cuando ambas cadenas han sido declaradas
como objetos String: si son arrays de caracteres
no se pueden comparar. En este sentido,
comparar si una cadena es mayor o menor que
otra simplemente significa evaluar las cadenas en
orden alfabético carácter tras carácter (por
ejemplo, “alma” sería menor que “barco”, pero
“999” es mayor que “1000” ya que el carácter “9”
va después del “1”). Recalcar que las
comparaciones de cadenas son case-sensitive (es
decir, el dato de tipo String “hola” no es igual que
el dato de tipo String “HOLA”).
byte x=50;
void setup() {
Serial.begin(9600);
if (x >=10 && x <=20){
Serial.println("Frase 1");
}
if (x >=10 || x <=20) {
Serial.println("Frase 2");
}
if (x >=10 && !(x<=20)) {
Serial.println("Frase 3");
}
}
void loop(){
}
String cad1="hola";
String cad2="hola";
void setup() {
Serial.begin(9600);
}
void loop() {
if (cad1 == cad2){
Serial.println("La cadena es
igual");
}
else
{
Serial.println("La cadena es
diferente");
}
}
3. 3
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
Las sentencias if/else if pueden realizar múltiples comprobaciones en una misma
estructura de condiciones. Cada comprobación procederá a la siguiente sólo cuando su
propio resultado sea FALSE. Cuando el resultado sea TRUE, su bloque de código contenido,
será ejecutado, y el programa esquivará las siguientes comprobaciones hasta el final de la
estructura de comprobaciones.
Ejemplo:
En el código anterior aparece un primer “if” que comprueba si hay datos en el buffer de entrada
del chip TTL-UART pendientes de leer. Si es así (es decir, si el valor devuelto por Serial.available()
es mayor que 0), se ejecutarán todas las instrucciones en su interior. En cambio, si la condición
resulta ser falsa (es decir, si Serial.available() devuelve 0 y por tanto no hay datos que leer),
fijarse que la función “loop()” no ejecuta nada.
En el momento que la condición sea verdadera, lo que tenemos dentro del primer “if” es la
función Serial.parseInt() que reconoce y extrae de todo lo que se haya enviado a través del canal
serie (por ejemplo, usando el “Serial monitor”) un número entero, asignándolo a la variable
“numero”. Y aquí es cuando llega otro “if” que comprueba si el valor de “numero” es igual a 23.
Si no es así, se comprueba entonces si su valor es menor de 23. Y si todavía no es así, solo queda
una opción: que sea mayor de 23. Al ejecutar este sketch a través del “Serial monitor”, lo que
veremos es que cada vez que enviemos algún dato a la placa, esta nos responderá con alguna
de las tres posibilidades.
Nota: Ahora que ya sabemos las diferentes sintaxis del bloque “if”, veamos qué tipo de
condiciones podemos definir entre los paréntesis del “if”. Lo primero que debemos saber es que
para escribir correctamente en nuestro sketch estas condiciones necesitaremos utilizar alguno
de los llamados operadores de comparación,
x == y (x es igual a y) x != y (x no es igual a y)
int numero;
void setup(){
Serial.begin(9600);
}
void loop(){
if (Serial.available() > 0) { //El nº introducido ha de estar en el rango del tipo "int"
numero=Serial.parseInt();
if (numero == 23){
Serial.println("Numero es igual a 23");
}
else if (numero < 23) {
Serial.println("Numero es menor que 23");
}
else {
Serial.println("Numero es mayor que 23");
}
}
}
4. 4
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
x < y (x es menor a y)
x > y (x es mayor a y)
x <= y (x es menor o igual a y)
x >= y (x es mayor o igual a y)
1.2.2. Bloque “switch/case”:
Consta en su interior de una serie de
secciones “case” y, opcionalmente, de una
sección “default”. Nada más llegar a la
primera línea del “switch”, primero se
comprueba el valor de la variable o
expresión que haya entre sus paréntesis. Si
el resultado es igual al valor especificado en
la primera sección “case”, se ejecutarán las
instrucciones del interior de la misma y se
dará por finalizado el “switch”, en caso de
no ser igual el resultado de la expresión a lo
especificado en el primer “case” se pasará
a comprobarlo con el segundo “case”, y si
no con el tercero, etc. Por último, si existe
una sección “default” (opcional) y el
resultado de la expresión no ha coincidido
con ninguna de las secciones “case”,
entonces se ejecutarán las sentencias de la
sección “default”.
BLOQUES REPETITIVOS (BUCLES)
1.2.3. Bloque “while”:
Este bucle repite la ejecución de las instrucciones que están dentro de sus llaves de apertura y
cierre mientras la condición especificada entre sus paréntesis sea cierta (“true”,1), sin importar
el número de veces repita. El número de iteraciones realizadas depende del estado de la
condición definida.
Ejemplo: El “Serial monitor” los primeros 50 mensajes
que aparecerán indicarán que la variable es menor de
50 porque se está ejecutando el interior del “while”.
Pero en el momento que la variable sea mayor (porque
en cada iteración del bucle se le va aumentando en una
unidad su valor), la condición del “while” dejará de ser
cierta y saltará de allí, mostrando entonces el mensaje
(ya de forma infinita) de que la variable es mayor que
50.
void setup(){
byte x=50;
Serial.begin(9600);
switch (x) {
case 20:
Serial.println("Vale 20 exactamente");
break;
case 50:
Serial.println("Vale 50 exactamente");
break;
default:
Serial.println("No vale ninguna de los
valores anteriores");
}
}
void loop(){
}
byte x=1;
void setup(){
Serial.begin(9600);
}
void loop(){
while (x <= 50)
{
Serial.println("Es menor
de 50");
x=x+1;
delay(250);
}
Serial.println("Es mayor
que 50");
delay(250)
}
5. 5
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
1.2.4. Bloque “do”:
La condición es evaluada después de ejecutar
las instrucciones escritas dentro de las llaves.
Esto hace que las instrucciones siempre sean
ejecutadas como mínimo una vez aun cuando la
condición sea falsa, porque antes de llegar a
comprobar esta, las instrucciones ya han sido
leídas (a diferencia del bucle “while”, donde si
la condición ya de entrada era falsa las
instrucciones no se ejecutaban nunca).
1.2.5. Bloque “For”:
El bucle for es una estructura que se utiliza cuando queremos que una serie de acciones se repita
un número determinado de veces, para ello se necesita de una variable índice, una condición y
un incrementador. Por tanto, usaremos el bucle “for” para ejecutar un conjunto de instrucciones
(escritas dentro de llaves de apertura y cierre) un número concreto de veces y estas son:
Valor inicial del contador: en esta parte se asigna el valor inicial de una variable entera
que se utilizará como contador en las iteraciones del bucle. Por ejemplo, si allí escribimos
x=0 , se fijará la variable “x” a cero al inicio del bucle. A partir de entonces, a cada
repetición del bucle, esta variable “x” irá aumentando (o disminuyendo)
progresivamente de valor.
Condición final del bucle: en esta parte se especifica una condición. Justo antes de cada
iteración se comprueba que sea cierta para pasar a ejecutar el grupo de sentencias
internas. Si la condición se evalúa como falsa, se finaliza el bucle “for”. Por ejemplo, si
allí escribimos x<10, el grupo interior de sentencias se ejecutará únicamente cuando la
variable “x” valga menos de 10.
Incremento del contador: en la última de las tres partes es donde se indica el cambio
de valor que sufrirá al inicio de cada iteración del bucle la variable usada como contador.
Este cambio se expresa con una asignación (x++,x=x+1).
int pulsador = 24;
int led= 25;
void setup() {
pinMode(pulsador, INPUT);
pinMode(led, OUTPUT);
}
void loop() {
do
{
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
}
while (digitalRead(pulsador) == HIGH);
}
for (valor_inicial_contador;condicion_final;incremento){
//Instrucciones que se repetirán un número determinado de veces
}
6. 6
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
Ejemplos:
Un led parpadee 5 veces tras accionar
un pulsador
En la primera repetición del bucle “for” se le asigna
el valor del primer dato sumar; en la segunda
repetición a ese valor de “suma” se le suma el
segundo valor (por lo que en ese momento “suma”
vale la suma de los dos primeros valores). En la
tercera repetición se le añade el tercer valor a esa
suma parcial (por lo que en ese momento “suma”
vale la suma de los tres primeros valores), en la
cuarta repetición el cuarto valor, y así y así hasta que
se acaba de recorrer el bucle “for” y todos los datos
se han ido añadiendo uno tras otro hasta conseguir
la suma total. Finalmente, muestro el resultado, y
muestro también la media, que no es más que esa
suma total entre el número de datos introducidos en
la suma.
La sentencia “for” primero se inicializa el contador (x=0) y
seguidamente se comprueba la condición. Como efectivamente,
x<10, se ejecutará la –única en este caso– sentencia interior, que
muestra el propio valor del contador por el “Serial monitor”.
Justo después, se realiza el incremento (x=x+1), volviéndose
seguidamente a comprobar la condición. Si “x” (que ahora vale
1) sigue cumpliendo la condición (sí, porque 1<10), se volverá a
ejecutar la instrucción interna, mostrándose ahora el valor “1”
en el “Serial monitor”. Justo después de esto se volverá a realizar
el incremento (valiendo x ahora por tanto 2) y se volverá a
comprobar la condición, y así y así hasta que llegue un momento
en el que la condición resulte falsa (cuando “x” haya incrementado tanto su valor que ya sea
igual o mayor que 10), momento en el cual se finalizará el “for” inmediatamente.
NOTA: Se presenta una tabla de “equivalencia” de algunos de los operadores compuestos.
byte x;
void setup(){
Serial.begin(9600);
for (x=0;x<10;x=x+1){
delay(500);
Serial.println(x);
}
}
void loop(){}
int pulsador = 24;
int led= 25;
void setup()
{
pinMode(pulsador, INPUT);
pinMode(led, OUTPUT);
}
void loop()
{
if (digitalRead(pulsador) == HIGH)
{
for (int i = 0; i<=4; i++)
{
digitalWrite(led, HIGH);
delay(1000);
digitalWrite(led, LOW);
delay(1000);
}
}
else
{
digitalWrite(led, LOW);
}
}
byte suma=0;
byte x;
void setup(){
Serial.begin(9600);
for (x=0;x<7;x=x+1){ //Sumo 7 veces el
número 5
suma= suma + 5;
}
}
Serial.println(suma);
Serial.println(suma/7); //Esto es la media
}
void loop(){}
7. 7
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
INSTRUCCIONES
1.2.6. Instrucción “break”: Ejemplo
Es usada para salir de los
siguientes bloques de bucle:
“do”,”for” y “while”,
“switch”, sin tener que
esperar a que termine el
bloque de instrucciones o a
que deje de cumplirse la
condición lógica.
Observar que ninguna de
ellas incorpora paréntesis,
pero como cualquier otra
instrucción, en nuestros
sketches deben ser
finalizadas con un punto y
coma.
Debe estar escritas dentro
de las llaves que delimitan
las sentencias internas de un
bucle.
int led;
void setup(){
for(led=24;led<31;led++){
pinMode(led,OUTPUT);
}
}
void loop(){
for(led=24;led<31;led++){
digitalWrite(led,HIGH);
delay(1000);
//digitalWrite(led,LOW);
}
for(led=30;led>23;led--){
//digitalWrite(led,HIGH);
//delay(1000);
digitalWrite(led,LOW);
delay(1000);
}
}
int x;
void setup() {
Serial.begin(9600);
}
void loop(){
while (Serial.available() > 0)
{
char dato = Serial. read();
if (dato =='X') break; //termina rutina al leer una letra X
switch (dato)
{
case 'R':
Serial.println("Se eligio el color rojo");
break;
case 'G':
Serial.println("Se eligio el color verde");
break;
case 'B':
Serial.println("Se eligio el color azul");
break;
}
}
}
8. 8
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
1.2.7. Instrucción “continue”:
También debe estar escrita dentro de las llaves que delimitan las sentencias internas de un bucle
y sirve para finalizar la iteración actual y comenzar inmediatamente con la siguiente. Es decir,
esta instrucción forzará al programa a “volver para arriba” y comenzar la evaluación de la
siguiente iteración aun cuando todavía queden instrucciones pendientes de ejecutar en la
iteración actual. En caso de haber varios bucles anidados (unos dentro de otros) la sentencia
“continue” tendrá efecto únicamente en el bucle más interior de ellos.
Ejemplo:
¿Qué pasaría si sustituimos la instrucción break por la
sentencia continue, dejando el resto del código anterior
exactamente igual? Que veríamos una lista de números
desde el 0 hasta el 9, excepto precisamente el 4. Esto es así
porque la instrucción continue interrumpe la ejecución de
la iteración en la cual “x” es igual a 4 (y por tanto, la
instrucción Serial.println() correspondiente no se llega a
ejecutar) pero continúa con la siguiente iteración del bucle
de forma normal, en la cual a “x” se le asigna el valor 5.
1.2.8. Instrucción “goto”: Ejemplo
Ésta es la instrucción que te otorga más libertad, pero
con la que más cuidado hay que tener, se escribe una
etiqueta en cualquier parte del programa, y al usar la
instrucción: goto etiqueta el programa inmediatamente
saldrá de cualquier estructura de selección o iteración
para dirigirse a la etiqueta seleccionada.
1.2.9. Instrucción “return”:
Ésta instrucción nos devolverá algo de una función (que no sea void). Lo que escribamos por
debajo de return en la función donde lo usemos, no se ejecutará nunca. Ya que, cuando llega a
return, vuelve a la función que lo llamó.
Hemos visto las funciones " void " ( quiere decir que no devuelven ningún valor ) , pero también
existen las que sí lo hacen, como las " int " , " float " ,etc ( vamos, que ponemos el tipo de variable
del valor que queremos retornar)
byte x;
void setup(){
Serial.begin(9600);
for(x=0;x<10;x++){
if (x==4){
break; //continue;
}
Serial.println(x);
}
}
void loop(){}
void setup(){
Serial.begin(9600);
}
void loop()
{
inicio:
Serial.println("Ciclo infinito");
delay(500);
goto inicio;
}
9. 9
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
Ejemplo:
1.3. ELEMENTOS DE SINTAXIS:
Para evitar errores de compilación, tener en cuenta lo siguiente:
“ ; “(punto y coma).- El punto y coma es uno de los símbolos más usados en C, C++; y se
usa con el fin de indicar el final de una línea de instrucción.
Ejemplo: int a = 13;
“{ }” (llaves).- Las llaves sirven para definir el principio y el final de un bloque de
instrucciones. Se utilizan para los bloques de programación setup(), loop(), if.., etc.
Ejemplos:
/*….*/ Bloque de comentario: Son áreas de texto que pueden abarcar más de una línea,
lo que escribamos entre esos símbolos será ignorado por el programa.
// Línea de Comentario: Funciona como el bloque de comentario, con la diferencia que
solo será ignorado el texto que este a su derecha, al cambiar de línea perderá el efecto.
#define.- permite al programador dar un nombre a un valor constante antes de compilar
el programa. Constantes definidas en ARDUINO no ocupan ningún espacio en el chip. El
compilador de reemplazar las referencias a estas constantes con el valor definido en
tiempo de compilación.
Ejemplo:
#define ledPin 3 // El compilador reemplazará cualquier mención de ledPin con el
valor 3 cuando se ejecute el programa.
int suma(int numero_A, int numero_B); // declaramos nuestra función
void setup()
{
Serial.begin(9600);
int resultado = 0;
int primerNumero = 19;
int segundoNumero = 2;
resultado = suma( primerNumero, segundoNumero ); // aquí vemos que el nombre de los
parámetros cambió, eso es porque realmente no opera con el nombre, si no, con las
posiciones
Serial.print("El resultado es: ");
Serial.println(resultado); // imprimimos el resultado
}
void loop()
{
}
int suma( int numero_A, int numero_B) // aqui tienen que tener los mismos nombres que
arriba
{
return numero_A + numero_B; // aquí nos devolverá la suma de los dos operandos
}
10. 10
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
#include.- se utiliza para incluir bibliotecas fuera de programa. Esto le da acceso al
programador para un gran grupo de bibliotecas estándar de C (grupos de funciones pre-
hechos), y también bibliotecas escrito especialmente para ARDUINO.
Ejemplo:
NOTA: Tenga en cuenta que “#include”, al igual que “#define”, no termina en “;” (punto y
coma), y el compilador producirá mensajes de error si se le agrega.
#include <avr/pgmspace.h>
prog_uint16_t myConstants[] PROGMEM = {0, 21140, 702 , 9128, 0, 25764, 8456,
0,0,0,0,0,0,0,0,29810,8968,29762,29762,4500};
11. 11
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
Ejemplo de Aplicación:
Se pretende realizar un programa que controle el tiempo de estado alto y bajo de un led, es
decir que le introduzcamos por el puerto serie un numero de 0 a 9, que indican 0mseg y 900mseg
de tiempo de estado alto y estado bajo, y podamos controlar el parpadeo del mismo. Por lo que
vamos a programar con el fin de que nos pida por pantalla que introduzcamos el tiempo de
estado alto y el tiempo de estado bajo y una vez introducido que se realice el control del
parpadeo del led.
Nota: ASCII-48=DEC
//Inicialización de variables
char datosbyte;
byte f=0;
int x=0;
int y=0;
void setup() {
Serial.begin(9600); //Inicializamos el puerto serie
pinMode(13, OUTPUT); //Asignamos al pin 13 como salida donde conectaremos el LED
//Escribimos por puerto serie la primera vez
Serial.println("Introduce el tiempo de estado ALTO:");
}
void loop () {
//Vamos a leer por puerto serie el valor de estado alto y bajo
if (Serial.available() > 0) { //Compruebo si el puerto serie esta accesible
if(f==0){ //Utilizamos una variable llamada bandera que nos
realizara la función de conmutación de tiempo alto y bajo
datosbyte=Serial.read(); //Leo los datos del puerto serie
x=datosbyte-48; // paso de código ASCII a decimal
Serial.print("El tiempo de estado ALTO es: ”);
Serial.println(x,DEC); // Muestra el tiempo introducido
Serial.println("Introduce el tiempo de estado BAJO:");
f=1;
}
}
if (Serial.available() > 0){
if(f==1) {
datosbyte=Serial.read(); //Voy leyendo los datos del puerto serie
y=datosbyte-48; //Convierto de código ASCII a decimal
Serial.print("El tiempo de estado BAJO es: ");
Serial.println(y,DEC); // Muestro el tiempo bajo introducido
Serial.println("Introduce el tiempo de estado ALTO:");
f=0;
}
}
digitalWrite(13, HIGH); // Pongo el Led en estado alto
int x1=1000*x; // multiplico los segundos introducidos para pasarlos a milisegundos
delay(x1);
digitalWrite(13, LOW) ; // Pongo el Led en estado bajo
int y1=1000*y; // Vuelvo a multiplicar
delay(y1); // Y mantengo en estado bajo
}
12. 12
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
II. FUNCIONES:
2.1. ENTRADAS Y SALIDAS DIGITALES:
2.1.1. pinMode():
Se usa en void setup() para configurar un pin específico para comportarse como:
Entrada (INPUT).- Pines configurados como INPUT están en un estado de alta
impedancia. Pines de entrada hacen extremadamente pequeñas demandas en el
circuito que están muestreo, esto equivale a una resistencia en serie de 100 MΩ en
frente del pin. Esto significa que se necesita muy poca corriente para mover el pin de
entrada de un estado a otro. Desactiva explícitamente estas resistencias “pull-ups”
internas. Se aplican para tareas como la implementación de un sensor táctil, la lectura
de un LED como un fotodiodo, o la lectura de un sensor analógico con un esquema tales
como RCTime1
.
Salida (OUTPUT).- Los pines configurados como OUTPUT están en un estado de baja
impedancia y pueden proporcionar 40mA (miliamperios) de corriente a otros
dispositivos y circuitos. Esta corriente es suficiente para alimentar un diodo LED (no
olvidando poner una resistencia en serie), pero no es lo suficiente grande como para
alimentar cargas de mayor consumo como relés, solenoides, o motores.
INPUT_PULLPUP.- Hay 20 kΩ de “resistencias pull-up” integradas en el chip Atmega que
se puede acceder por el software, configurando el pinMode() como INPUT_PULLUP.
Esto invierte efectivamente el comportamiento del modo de entrada, donde HIGH
significa que el sensor está apagado, y LOW significa que el sensor está encendido.
2.1.2. digitalWrite():
1
RCTIME se puede utilizar para medir el tiempo de carga o descarga de un circuito de resistencia /
condensador. Esto le permite medir la resistencia o capacitancia; utilizar sensores R o C como termistores
o sensores de humedad o responder a la entrada del usuario a través de un potenciómetro. En un sentido
más amplio, RCTIME también puede servir como un cronómetro rápido, preciso para eventos de muy
corta duración.
13. 13
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
Si el pin especificado en digitalWrite() está configurado como salida, usando la constante
OUTPUT:
La constante HIGH equivale a una señal de salida de hasta 40 mA y de 5 V.
La constante LOW equivale a una señal de salida de 0 V.
Si el pin está configurado como entrada usando la constante INPUT:
Enviar un valor HIGH equivale a activar la resistencia interna “pull-up” en ese momento
(es decir, es idéntico a usar directamente la constante INPUT_PULLUP).
Enviar un valor LOW equivale a desactivarla de nuevo. Esta función no tiene valor de
retorno.
NOTA:
Es posible que el valor HIGH (5V) ofrecido por un pin digital de salida no sea suficiente para
alimentar componentes de alto consumo (como motores o matrices de LEDs, entre otros), por
lo que estos deberían alimentarse siempre con circuitería extra (evitando así además posibles
daños en el pin por sobrecalentamiento).
2.1.3. digitalRead():
Devuelve el valor leído del pin digital (configurado como entrada mediante pinMode()) cuyo
número se haya especificado como parámetro. Este valor de retorno es de tipo “int” y puede
tener dos únicos: la constante HIGH (1) o LOW (0).
Ejemplo de Subcapítulo 3.1. :
void setup(){
//Inicia la comunicación serial
Serial.begin(9600);
//configura pin26 como ENTRADA y habilita la resistencia pull-up interna del ARDUINO
pinMode(26,INPUT_PULLUP);
pinMode(24, OUTPUT);
}
void loop(){
//read the pushbutton value into a variable
int sensorVal = digitalRead(26);
//print out the value of the pushbutton
Serial.println(sensorVal);
// Keep in mind the pullup means the pushbutton's
// logic is inverted. It goes HIGH when it's open,
// and LOW when it's pressed. Turn on pin 13 when the
// button's pressed, and off when it's not:
if (sensorVal == HIGH) {
digitalWrite(24, LOW);
}
else {
digitalWrite(24, HIGH);
}
}
14. 14
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
NOTA: Otra forma alternativa de activar la resistencia “pull-up”, diferente de la descrita en el
párrafo anterior, es utilizar la constante INPUT y además la función digitalWrite() de una forma
muy concreta.
Gráficamente:
2.2.ENTRADAS Y SALIDAS ANALÓGICAS:
2.2.1. analogReference():
Asigna el modo para seleccionar el voltaje usado como referencia para el comando
analogRead(), este valor será este será el voltaje máximo usado como referencia. El valor por
defecto para las tarjetas es 5 voltios. Los posibles modos son:
DEFAULT: a referencia analógica por defecto de 5 voltios o 3.3 voltios.
INTERNAL1V1: una referencia incorporada, igual a 1.1 volts en el ATmega168 o
ATmega328 (Sólo ARDUINO Mega).
INTERNAL2V56: Es una referencia de tensión interna de 2.56 voltios en el Atmega8 (Sólo
ARDUINO Mega).
EXTERNAL: Se usara una tensión de referencia externa que tendrá que ser conectada al
pin AREF. Debe estar en el rango 0-5V solamente).
NOTA:
NO aplique al pin AREF un voltaje fuera del rango 0-5V. Siempre que se use un voltaje de
referencia externo (cualquier cosa conectada al pin AREF) se debe llamar el comando
analogReference(EXTERNAL) antes de llamar el comando analogRead(), un buen lugar para
hacerlo es en la sección setup(). Si el pin AREF está conectado a una referencia externa no use
ninguna de los demás modos de referencia de voltaje en su programa, ya que hará un corto
circuito con el voltaje externo y puede causar daño permanente al microcontrolador de la
tarjeta, además es recomendable que cuando se use la referencia externa se conecte al pin AREF
usando una resistencia de 5K. Tenga en cuenta que esa resistencia afectara la tensión que se
use como tensión de referencia ya que el pin AREF posee una resistencia interna de 32K. Ambas
resistencias forman un divisor de tensión.
15. 15
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
Por lo tanto, si por ejemplo se conecta una tensión de 2.5V con la resistencia de 5K la tensión
que se utilice como tensión de referencia será de 2.2V ya que esa será la tensión que caiga en el
pin AREF debido al divisor de tensión al que se ha hecho referencia. (Segunda Ley de Kirchhoff).
Uso del pin AREF
La tensión aplicada en el pin AREF será la que haga que el conversor A/D de su máxima lectura
(1023) cuando lea una tensión igual a la aplicada en ese pin. Tensión por debajo de esa tensión
conectada a AREF será escalada proporcionalmente, así cuando se usa la tensión de referencia
por defecto (DEFAULT) el valor que nos devuelve una tensión de 2.5V en una entrada analógica
será 512.
La configuración por defecto del Arduino es la de no tener nada conectado de forma externa al
pin AREF. En este caso la configuración de la tensión de referencia será DEFAULT lo cual conecta
a VCC (Alimentación positiva +5 V) de forma interna al pin AREF. Este pin es un pin de baja
impedancia (mucha corriente) por lo que si usando la configuración DEFAULT de la tensión de
referencia se conecta otra tensión que no sea la que posee AVCC, podría dañar el chip ATMEGA.
El pin AREF también puede conectarse de forma interna a una fuente de referencia de 1.1 voltios
(o 2.54 en los Atmega8) usando el comando analogReference (INTERNAL).Con esta
configuración las tensiones aplicada a los pines analógicos que sean iguales a la tensión de
referencia interna o superior nos devolverán 1023 cuando se lleva a cabo su lectura con la
función analogRead(). Tensiones más bajas devolverán valores proporcionales, por ejemplo, si
tenemos una tensión de 0.55 voltios en el pin analógico, nos devolverá 512.
Donde:
Vin = Tensión que introducimos a Vref
Rinterna = Resistencia interna de Arduino de 32KΩ
Rexterna = Resistencia mediante la cual alimentamos Vref
Vrefencia = La tensión sobre que tomará referencia nuestro programa.
De manera que si por ejemplo, estamos introduciendo una tensión de +3v a través de una
resistencia de 5KΩ, la tensión real de referencia en nuestro Arduino será de:
𝑉𝑟𝑒𝑓𝑒𝑛𝑐𝑖𝑎 =
32𝑘
32𝑘+5𝑘
∗ 3𝑉 ≅ 2.59
16. 16
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
2.2.2. analogRead():
Lee el valor de un determinado pin definido como entrada analógica, por defecto, nuestra placa
Arduino nos realizará una conversión analógico-digital para toda señal (40mA máximo) de 0v a
5v con una resolución de 10 bit. Esto significa que convertirá tensiones entre 0 y 5 voltios a un
número entero entre 0 y 1023. Esto proporciona una resolución en la lectura de: 5 voltios / 1024
unidades, es decir, 0.0049 voltios (4.9mV) por unidad.
Ejemplo:
Veremos por el “Serial monitor” las lecturas realizadas a
través del pin analógico 2, que no son más que valores
entre 0 y 1023. Notar que no se ha utilizado la función
pinMode() como hasta ahora porque los pines-hembra
analógicos de la placa ARDUINO solo pueden ser de
entrada.
2.2.3. analogWrite() – PWM:
Envía un valor de tipo “byte” (especificado como segundo parámetro) que representa una señal
PWM, a un pin digital configurado como OUTPUT (especificado como primer parámetro).
Después de llamar a analogWrite (), el pin generará una onda cuadrada constante del ciclo de
trabajo especificado hasta la siguiente llamada a analogWrite () (o una llamada a digitalRead ()
o digitalWrite () en el mismo pin). La frecuencia de la señal PWM en la mayoría de los pins es de
aproximadamente 490 Hz y algunas placas de ARDUINO sus pines tienen una frecuencia de 980
Hz. Puede ser usado para controlar la luminosidad de un LED o la velocidad de un motor.
Ejemplo:
int brillo = 0;
void setup(){
pinMode(9, OUTPUT); //El LED está conectado al pin 9 (PWM)
}
void loop(){
//Incrementa el brillo (de mínimo a máximo)
for(brillo = 0 ; brillo<= 255; brillo=brillo+5) {
analogWrite(9, brillo);
delay(30);
}
//Disminuye el brillo (de máximo a mínimo)
for(brillo = 255; brillo>=0; brillo=brillo-5) {
analogWrite(9, brillo);
delay(30);
}
}
int valorPot=0;
void setup(){
Serial.begin(9600);
}
void loop(){
valorPot=analogRead(2);
Serial.println(valorPot);
delay(100);
}
17. 17
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
Ejemplo:
Nuestro diodo LED variará su intensidad lumíinoza en función del valor que esté aportando el
potenciómetro a nuestra entrada analógica, esto es el llamado efecto fading (desvanecimiento).
Entrada del potenciómetro:
NOTA:
Recordemos que una señal PWM (Pulse Width Modultation o Modulación de Ancho de Pulso),
es una señal digital cuadrada que simula ser una señal analógica.
El valor simulado de la señal analógica dependerá de la duración que tenga el pulso digital (es
decir, el valor HIGH de la señal PWM).
Si el segundo parámetro de esta función vale 0, significa que su pulso no dura nada (es
decir, no hay señal) y por tanto su valor analógico “simulado” será el mínimo (0V).
Si vale 255 (que es el máximo valor posible, ya que las salidas PWM tienen una resolución
de 8 bits, y por tanto, solo pueden ofrecer hasta 28
=256 valores diferentes de 0 a 255, pues),
significa que su pulso dura todo el período de la señal (es decir, es una señal continua) y
por tanto su valor analógico “simulado” será el máximo ofrecido por la placa (5 V).
Cualquier otro valor entre estos dos extremos (0 y 255) implica un pulso de una longitud
intermedia (por ejemplo, el valor 128 generará una onda cuadrada cuyo pulso es de la
misma longitud que la de su estado bajo) y por tanto, un valor analógico “simulado”
intermedio (en el caso anterior, 2,5 V).
int pinSensor = A0; // Entrada para el potenciómetro.
int pinLed = 2; // Seleccionamos pin para el Led.
int valorSensor = 0; // variable para el valor del sensor.
void setup() {
pinMode(pinLed, OUTPUT); // Establecemos el pin como salida.
}
void loop() {
// Leemos el valor del sensor y lo almacenamos:
valorSensor = analogRead(pinSensor);
// Establecemos el valor analógico para la salida PWM
analogWrite(pinLed, valorSensor / 4);
//Nos permitirá emular una señal analógica a partir de una digital en nuestros circuitos
delay(30);
}
18. 18
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
Esta imagen describe la acción de un pin PWM.
19. 19
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
Ejemplo del Subcapítulo 3.2. :
Se va a utilizar un LDR (Light Dependent Resistor o resistencia dependiente de la luz) para simular
una hipotética compensación lumínica de 5 niveles, es decir, a través de una resistencia que
varía su valor dependiendo de la luz recibida, aprovecharemos dicha variación para hacer un
programa que nos encienda o apague una serie de LED dependiendo de si hay más luz o menos
luz.
Mayor Cantidad de Luz reciba Menor Resistencia
Además, vamos a colocar un potenciómetro para regular el umbral de luz mínima, a partir del
cual, comenzará a funcionar nuestro circuito de luz artificial para que sea adaptable a cualquier
entorno.
Si añadimos una resistencia más, podemos utilizar el LDR para hacer el ya conocido divisor de
tensión de donde sacaremos la señal para conectar a nuestra entrada analógica de Arduino.
Podemos conectarlo de dos maneras diferentes:
Si utilizamos el LDR como resistencia inferior del divisor de tensión, nos dará la tensión
máxima cuando tengamos el LDR en plena oscuridad, ya que estará oponiendo el máximo
de su resistencia al paso de la corriente derivándose esta por Vout al completo
Si lo utilizamos como resistencia superior, el resultado será el inverso, tendremos la tensión
máxima cuando esté completamente iluminado, ya que se comportará prácticamente
como un cortocircuito, con una resistencia de 50Ω o 100Ω.
21. 21
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
Programa:
/*Conectamos una foto-resistencia a la entrada analógica para controlar cinco salidas en
función de la luz ambiente.*/
//Aquí almacenamos los datos recogidos del LDR:
int valorLDR = 0;
//Decimos que pines vamos a utilizar para LED
int pinLed1 = 6;
int pinLed2 = 5;
int pinLed3 = 4;
int pinLed4 = 3;
int pinLed5 = 2;
int pinLDR = 0; //pin para la LDR es el numero 0, A0
void setup()
{
//Establecemos como salida los pines para LED
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);
analogReference(EXTERNAL); //Le decimos que vamos a usar una referencia externa
}
void loop()
{
valorLDR = analogRead(pinLDR); //Guardamos el valor leido en una variable
//Y comenzamos las comparaciones:
if(valorLDR >= 1023)
{
digitalWrite(pinLed1, LOW);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 823) & (valorLDR < 1023))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
22. 22
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
2.3.Tiempo:
2.3.1. millis():
Devuelve el número de milisegundos (ms) desde que la placa Arduino empezó a ejecutar el
sketch actual. Este número se reseteará a cero aproximadamente después de 50 días (cuando
su valor supere el máximo permitido por su tipo, que es “unsigned long”). No tiene parámetros.
2.3.2. micros():
Devuelve el número de microsegundos (μs) desde que la placa Arduino empezó a ejecutar el
sketch actual. Este número –de tipo “unsigned long”– se reseteará a cero aproximadamente
después de 70 minutos. Esta instrucción tiene una resolución de 4 μs (es decir, que el valor
retornado es siempre un múltiplo de cuatro).
else if((valorLDR >= 623) & (valorLDR < 823))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 423) & (valorLDR < 623))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if((valorLDR >= 223) & (valorLDR < 423))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, HIGH);
}
else
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, HIGH);
}
}
23. 23
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
2.3.3. delay():
Pausa el sketch durante la cantidad de milisegundos especificados como parámetro –de tipo
“unsigned long”–. No tiene valor de retorno.
2.3.4. delayMicroseconds():
Pausa el sketch durante la cantidad de microsegundos especificados como parámetro –de tipo
“unsigned long”– . Actualmente el máximo valor que se puede utilizar con precisión es de 16383.
El mínimo valor que se puede utilizar con precisión es de 3 μs. No tiene valor de retorno.
2.4.Comunicación:
2.4.1. Serial:
El ARDUINO se comunica por serie vía USB con nuestro ordenador a través del chip FTDI. La
comunicación serial se puede utilizar para hacer un debugging (saber lo que está pasando en
nuestro programa) o para comunicarnos con otros programas.
Instrucciones Seriales:
Serial.begin(speed):
Abre el canal serie para que pueda empezar la comunicación por él. Por tanto, su ejecución es
imprescindible antes de realizar cualquier transmisión por dicho canal. Por eso normalmente se
suele escribir dentro de la sección “void setup()”. Además, mediante su único parámetro –de
tipo “long” y obligatorio–. Para comunicarse con el ordenador, utilice una de estas velocidades:
300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 o 115200.
Serial.print(val, [format]):
Envía a través del canal serie un dato (especificado como parámetro) desde el microcontrolador
hacia el exterior.
val: el valor a imprimir - de cualquier tipo
format: especifica la base (formato) a usar; los valores permitidos son:
BYTE, BIN (binarios o base 2)
OCT (octales o base 8)
DEC (decimales o base 10)
HEX (hexadecimales o base 16).
Para números de coma flotante, este parámetro especifica el número de posiciones decimales
a usar. Por defecto son dos.
Ejemplo:
Serial.print(78) imprime "78"
Serial.print('N') imprime "N"
Serial.print(78, BYTE) imprime "N"
Serial.print(78, DEC) imprime "78”
Serial.println(1.23456, 0) imprime "1.23”
Serial.println(1.23456, 2) imprime "1.23"
24. 24
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
Serial.println(val, [format]):
Hace exactamente lo mismo que Serial.print(), pero además, añade automáticamente al final de
los datos enviados dos caracteres extra: el de retorno de carro (código ASCII nº 13, o ‘r’) y el de
nueva línea (código ASCII nº 10, o n). La consecuencia es que al final de la ejecución de
Serial.println() se efectúa un salto de línea. Tiene los mismos parámetros y los mismos valores
de retorno que Serial.print().
Serial.flush():
La transmisión de los datos realizada por Serial.print() es asíncrona. Eso significa que nuestro
sketch pasará a la siguiente instrucción y seguirá ejecutándose sin esperar a que empiece a
realizarse el envío de los datos. Si este comportamiento no es el deseado, se puede añadir justo
después de Serial.print() la instrucción Serial.flush() –que no tiene ningún parámetro ni devuelve
ningún valor de retorno–, instrucción que espera hasta que la transmisión de los datos sea
completa para continuar la ejecución del sketch.
available()
If(Serial)
end()
fin()
finUntil()
parseFloat()
parseInt()
peek()
Serial.read()
readBytes()
readBytesUntil()
write()
int cont=0;
void setup (){
Serial.begin(9600); //iniciamos el puerto de serie
}
void loop () {
//Imprimimos el valor del contador
Serial.print("Contador: ");
Serial.println(cont);
cont++; //incrementamos el contador y esperamos ½ segundo
delay(500);
}
25. 25
MANUAL DE LENGUAJE DE PROGRAMACIÓN DE ARDUINO
SetTimeout
SerialEvent()
Sintaxis:
DEC // Imprime la información en formato decimal.
't' Un tabulador de 8 espacios de texto.
'n' Cambio de línea, ASCII 10.
'r' Retorno de carro ASCII 13.
Ejemplos:
NOTA: La velocidad para comunicarnos con el Monitor serial es 9600 Baudios. Con otros
dispositivos puede ser otra, por ejemplo el protocolo MIDI sería a 31250 Baudios.
Baudios: representa el número de símbolos por segundo en un medio de transmisión
digital. Un baudio puede contener varios bits.
void setup() // Se ejecuta una zona vez, cuando el programa inicia
{
Serial.begin(9600); // Velocidad de la transmisión y apertura del puerto
Serial.println("Hola Mundo!"); // Imprime Hola Mundo, en el monitor serial
}
void loop() // Se ejecuta indefinidamente
{
// No hace nada
}