Semana 04

Dispositivos de
Microelectrónica
Programación y
Aplicaciones
Funciones
Programación en C++
Introduciendo funciones
Una función es un fragmento de código definido por un nombre y que se puede reutilizar / ejecutar desde
muchos puntos diferentes en un programa C. El nombre de una función debe ser único en un programa en C.
También es global, lo que significa que, como ya leyó para las variables, se puede usar en cualquier lugar del
programa C que contenga la declaración / definición de función en su alcance.
Una función puede requerir que se le pasen elementos especiales; estos se llaman argumentos.
Una función también puede producir y devolver resultados.
Estructura de una función
Una función es un bloque de código que tiene un encabezado y un cuerpo. En el estándar C, la declaración y la
definición de una función se realizan por separado. La declaración de la función se denomina específicamente
declaración del prototipo de la función y debe realizarse en el header file.

Creando prototipos de funciones usando el IDE de Arduino

El IDE de Arduino nos facilita la vida; crea prototipos de funciones para nosotros. Pero en casos especiales, si
necesita declarar un prototipo de función, puede hacerlo en el mismo archivo de código al principio del código.
Esto proporciona una buena forma de centralizar el código fuente.
Tomemos un ejemplo sencillo, queremos crear una función que sume dos enteros y produzca / devuelva el
resultado. Hay dos argumentos que son variables de tipo entero. En este caso, el resultado de la suma de estos
dos valores int (integer) también es un valor int. No tiene que ser así, pero para este ejemplo lo es. El prototipo
en ese caso sería:
int mySum (int m, int n);
Encabezado y nombre de funciones
Saber cómo se ve el prototipo es interesante porque es similar a lo que llamamos el encabezado. El
encabezado de una función es su primera definición de declaración. Avancemos más escribiendo la estructura
global de nuestra función mySum:
int mySum(int m, int n) // this row is the header
{
// between curly brackets sits the body
}
El encabezado tiene la forma global:
returnType functionName (arguments)

returnType es un tipo de variable. A estas alturas, supongo que comprende mejor el tipo void.
En el caso de que nuestra función no devuelva nada, tenemos que especificarlo eligiendo returnType es igual a
void.
functionName debe elegirse para que sea fácil de recordar y debe ser lo más autodescriptivo posible.
Imagínese el código de soporte escrito por otra persona. Encontrar myNiceAndCoolMathFunction requiere
investigación. Por otro lado, mySum se explica por sí mismo. ¿Qué ejemplo de código preferiría apoyar?
El núcleo de Arduino (e incluso C) sigue una convención de nomenclatura llamada camel case. La diferencia
entre dos palabras, debido a que no podemos usar el carácter en blanco / espacio en el nombre de una
función, se hace poniendo la primera letra de las palabras en mayúsculas. No es necesario, pero se recomienda
especialmente si desea ahorrar tiempo más adelante. Es más fácil de leer y hace que la función se explique por
sí misma: Ejm: mysum es menos legible que mySum.
Los argumentos son una serie de declaraciones de variables. En nuestro ejemplo mySum, creamos dos
argumentos de función. Pero también podríamos tener una función sin argumentos. Imagine una función que
necesita llamar para producir una acción que siempre será la misma, no dependiendo de las variables. Lo
harías así:
int myAction()
{
// between curly brackets sits the body
}
Cuerpo y declaraciones de funciones
Como probablemente entendió intuitivamente, el cuerpo es el lugar donde todo sucede; es donde se
construyen todos los pasos de instrucción de una función.
Imagínese el cuerpo como un bloque de código fuente real, puro y nuevo. Puede declarar y definir variables,
agregar condiciones y jugar con bucles. Imagínese el cuerpo (de instrucciones) como donde la arcilla del
escultor se forma y moldea y sale al final con el efecto deseado; quizás en una pieza o en muchas, quizás en
copias idénticas, etc. Es la manipulación de lo que hay, pero recuerde: ¡La basura entra, la basura sale!
También puede, como acabamos de presentar, devolver el valor de una variable. Creemos el cuerpo de nuestro ejemplo
mySum:

int mySum(int m, int n) // this row is the header

{
int result;
// this is the variable to store the result
result = m + n;
// it makes the sum and store it in result
return result; // it returns the value of result variable
}

int result ; declara la variable y nombra su resultado. Su alcance es el mismo que el alcance de los argumentos. result = m
+ n; contiene dos operadores, y ya sabe que + tiene una precedencia mayor que =, lo cual es bueno, ya que la operación
matemática se realiza primero y luego el resultado se almacena en la variable de resultado.
Tome dos operadores y haga uno con ellos. Recuerde que, en una combinación de múltiples operaciones matemáticas, no
olvide el orden de precedencia; es fundamental para que no obtengamos resultados inesperados.

Por fin, return result; es la declaración que hace que la llamada a la función resulte en un valor. Veamos un ejemplo real
del código Arduino para entender esto mejor:
void setup() {
Serial.begin(9600); Let's check an actual example of Arduino code to understand this better.
}

Void loop() {
// let's sum all integers from 0 to 99, 2 by 2 and display
int currentResult;
for (int i = 0 ; i < 100 ; i++)
{
currentResult = mySum(i,i+1);
// sum and store
Serial.println(currentResult);
// display to serial monitor
}
delay(2000); make a 2 second pause
}
int mySum(int m, int n) // this row is the header
{
int result;
// this is the variable to store the result
result = m + n;
// it makes the sum and store it in result
return result; // it returns the value of result variable
}
Como acaba de ver, la función mySum ha sido definida y llamada en el ejemplo. La declaración más importante
es currentResult = mySum (i, i + 1) ;. Por supuesto, el truco i e i + 1 es interesante, pero lo más importante a
reconocer aquí es el uso de la variable currentResult que se declaró al comienzo de la función loop ().

En programación, es importante reconocer que todo lo que está a la derecha (contenido) va a la izquierda (el
nuevo contenedor). De acuerdo con las reglas de precedencia, una llamada de función tiene una precedencia
de 2 contra 16 para el operador de asignación = . Significa que la llamada se realiza primero y la función
devuelve el resultado de la operación +, como la diseñamos.

Desde este punto de vista, acaba de aprender algo muy importante: la declaración de llamada de una función
que devuelve un resultado es un valor.
Elementos de
Código de
Arduino en C++
https://www.arduino.cc/reference/es/

Constantes Tipos de Datos Alcance de Variable & Calificadores

Floating Point Constants array const
boolean scope
byte static
Conversión char volatile
byte() double
char() float
float() int Utilidades
int() long PROGMEM
long() short sizeof()
word() string
String()
unsignedChar
unsignedInt
unsignedLong
void
word
 ESTRUCTURA: Los elementos del código de Arduino (C++).
Sketch
Sintaxis Adicional Estructuras de Control loop()
#define (define) break
setup()
#include (include) continue
/* */ (block comment) do...While Operadores de Bits
// (single line comment) else & (bitwise and)
; (semicolon) for << (bitshift left)
{} (curly braces) goto >> (bitshift right)
if...else ^ (bitwise xor)
Operadores Aritméticos return | (bitwise or)
* (multiplication) switchCase ~ (bitwise not)
- (subtraction) while
Operadores Compuestos
Operadores Booleanos
Operadores de Comparación &= (compound bitwise and)
! (logical not)
!= (not equal to) *= (compound multiplication)
&& (logical and)
< (less than) ++ (increment)
|| (logical or)
<= (less than or equal to) += (compound addition)
== (equal to) -- (decrement)
Operadores con punteros de acceso -= (compound subtraction)
> (greater than)
& (reference opearator) /= (compound division)
>= (greater than or equal to)
* (dereference operator) |= (compound bitwise or)
#include
Se utiliza para incluir bibliotecas externas en su boceto. Esto le da al programador acceso a un gran grupo de bibliotecas C
estándar (grupos de funciones prefabricadas) y también bibliotecas escritas especialmente para Arduino.

La página de referencia principal para las bibliotecas de AVR C (AVR es una referencia a los chips Atmel en los que se basa
Arduino) está aquí .

Tenga en cuenta que #include, al igual que #define, no tiene un terminador de punto y coma, y ​el compilador producirá
mensajes de error crípticos si agrega uno.

Sintaxis
#include <LibraryFile.h>
#include "LocalFile.h"
#definir
[Sintaxis adicional]

Descripción
#define es un componente útil de C ++ que permite al programador dar un nombre a un valor constante
antes de compilar el programa. Las constantes definidas en arduino no ocupan espacio de memoria de
programa en el chip. El compilador reemplazará las referencias a estas constantes con el valor definido en el
momento de la compilación.

Sin embargo, esto puede tener algunos efectos secundarios no deseados si, por ejemplo, un nombre de
constante que ha sido #definido se incluye en algún otro nombre de constante o variable. En ese caso, el
texto sería reemplazado por el número # definido (o texto).

En general, const se prefiere la palabra clave para definir constantes y debe usarse en lugar de #define.
#define constantName value

Parámetros
constantName: el nombre de la macro a definir.
value: el valor a asignar a la macro.

Código de ejemplo
#define ledPin 3
// The compiler will replace any mention of ledPin with the value 3 at compile time.

Notas y advertencias
No hay punto y coma después de la instrucción #define. Si incluye uno, el compilador arrojará errores crípticos más abajo
en la página.

#define ledPin 3; // this is an error

De manera similar, incluir un signo igual después de la declaración #define también generará un error críptico del
compilador más abajo en la página.

#define ledPin = 3 // this is also an error

Código de ejemplo
Este ejemplo incluye la biblioteca Servo para que sus funciones se puedan usar para controlar un servomotor.

#include <Servo.h>

Servo myservo; // create servo object to control a servo

void setup() {
myservo.attach(9); // attaches the servo on pin 9 to the servo object
}

void loop() {
for (int pos = 0; pos <= 180; pos += 1) { // goes from 0 degrees to 180 degrees
// in steps of 1 degree
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
for (int pos = 180; pos >= 0; pos -= 1) { // goes from 180 degrees to 0 degrees
myservo.write(pos); // tell servo to go to position in variable 'pos'
delay(15); // waits 15ms for the servo to reach the position
}
}
Setup()

La función se llama cuando comienza un boceto. Úselo para inicializar variables, modos de pin, comenzar a usar
bibliotecas, etc. La función setup() solo se ejecutará una vez, después de cada encendido o reinicio de la placa Arduino.

Código de ejemplo

int buttonPin = 3;

void setup() {
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}

void loop() {
// ...
}
Loop()

Descripción
Después de crear una función setup(), que inicializa y establece los valores iniciales, la función loop() hace precisamente lo
que sugiere su nombre y se repite consecutivamente, permitiendo que su programa cambie y responda.
Código de ejemplo
int buttonPin = 3;

// setup initializes serial and the button pin

void setup() {
Serial.begin(9600);
pinMode(buttonPin, INPUT);
}

// loop checks the button pin each time, and will send serial if it is pressed
void loop() {
if (digitalRead(buttonPin) == HIGH) {
Serial.write('H');
}
else {
Serial.write('L');
}

delay(1000);
}
pinMode ()
[E / S digital]

Descripción Código de ejemplo

Configura el pin especificado para que se comporte El código crea el pin digital 13 OUTPUT y lo alterna HIGH y LOW
como entrada o salida. Consulte la página de Pines
digitales para obtener detalles sobre la funcionalidad void setup() {
de los pines. pinMode(13, OUTPUT); // sets the digital pin 13 as output
}
Sintaxis
pinMode(pin, mode) void loop() {
digitalWrite(13, HIGH); // sets the digital pin 13 on
Parámetros delay(1000); // waits for a second
pin: el número de pin de Arduino para establecer el digitalWrite(13, LOW); // sets the digital pin 13 off
modo. delay(1000); // waits for a second
mode: INPUT, OUTPUT Ó INPUT_PULLUP. Consulte la }
página de Pines digitales para obtener una descripción
más completa de la funcionalidad.
Begin()

Descripción
Inicializa la interfaz a la pantalla LCD y especifica las dimensiones (ancho y alto) de la pantalla. begin() debe
llamarse antes que cualquier otro comando de la biblioteca LCD.

Sintaxis
lcd.begin (cols, rows)

Parámetros
lcd: una variable de tipo LiquidCrystal

cols: el número de columnas que tiene la pantalla

filas: el número de filas que tiene la pantalla

print()

Descripción
Imprime texto en la pantalla LCD.

Sintaxis
lcd .print (datos)
lcd .print (datos, BASE)

Parámetros
lcd: una variable de tipo LiquidCrystal

datos: los datos para imprimir (char, byte, int, long o string)

BASE (opcional): la base en la que imprimir números: BIN para binario (base 2), DEC para decimal (base 10),
OCT para octal (base 8), HEX para hexadecimal (base 16).
Lyquid Cristal : Cristal liquido

setCursor ()

Descripción
Coloque el cursor de la pantalla LCD; es decir, establezca la ubicación en la que se mostrará el texto posterior escrito en la
pantalla LCD.

Sintaxis
lcd.setCursor (columna, fila)

Parámetros
lcd: una variable de tipo LiquidCrystal

col: la columna en la que colocar el cursor (siendo 0 la primera columna)

fila: la fila en la que colocar el cursor (siendo 0 la primera fila)

LiquidCrystal()
Descripción
Crea una variable de tipo LiquidCrystal . La pantalla se puede controlar mediante 4 u 8 líneas de datos. Si es lo primero,
omita los números de pin para d0 a d3 y deje esas líneas sin conectar. El pin RW se puede conectar a tierra en lugar de
conectarse a un pin en el Arduino; si es así, omítalo de los parámetros de esta función.

Sintaxis
LiquidCrystal (rs, enable, d4, d5, d6, d7)
LiquidCrystal (rs, rw, enable, d4, d5, d6, d7)
LiquidCrystal (rs, enable, d0, d1, d2, d3, d4, d5, d6, d7)
LiquidCrystal (rs, rw, enable, d0, d1, d2, d3, d4, d5, d6, d7)

Parámetros
rs: el número del pin Arduino que está conectado al pin RS en la pantalla LCD
rw: el número del pin Arduino que está conectado al pin RW en la pantalla LCD ( opcional )
enable: el número del pin Arduino que está conectado al pin de habilitación en la pantalla LCD

d0, d1, d2, d3, d4, d5, d6, d7: los números de los pines Arduino que están conectados a los pines de datos
correspondientes en la pantalla LCD. d0, d1, d2 y d3 son opcionales; si se omite, la pantalla LCD se controlará utilizando
solo las cuatro líneas de datos (d4, d5, d6, d7)
analogWrite

Syntax Example Code

analogWrite(pin, value) Sets the output to the LED proportional to the value read from
the potentiometer.
Parámetros
pin: the Arduino pin to write to. Allowed data int ledPin = 9; // LED connected to digital pin 9
types: int. int analogPin = 3; // potentiometer connected to analog pin 3
value: the duty cycle: between 0 (always off) and int val = 0; // variable to store the read value
255 (always on). Allowed data types: int.
void setup() {
pinMode(ledPin, OUTPUT); // sets the pin as output
}

void loop() {
val = analogRead(analogPin); // read the input pin
analogWrite(ledPin, val / 4); // analogRead values go from 0 to
1023, analogWrite values from 0 to 255
}
Sintaxis if (condition1) {
// do Thing A
}
else if (condition2) {
// do Thing B
}
else {
// do Thing C
}

Código de ejemplo
A continuación se muestra un extracto de un código para el sistema de sensor de temperatura

if (temperature >= 70) {

// Danger! Shut down the system.
}
else if (temperature >= 60) { // 60 <= temperature < 70
// Warning! User attention required.
}
else { // temperature < 60
// Safe! Continue usual tasks.
}
Tutorial 7: Aplicación del Sensor de Ultrasonido: servomotor

Abrimos la ventana del código y

modificamos.
 Agregamos código mostrado.

https://leantec.es/tienda/micro-servo-sm-s2309s/ Hacemos la Simulación