Datos y tipos de datos

Un dato es la expresión general que describe los objetos con los cuales opera una computadora.
Existen dos tipos de datos

Simples sin estructura:

● Numéricos (enteros y los reales)

● Lógicos (Boolean)
● Carácter (char, string)

Compuestos (estructurados)

● Registros
● Arreglos (vectores, matrices)
● Archivos

De tipo numérico:

● Enteros:
o Números naturales
o Enteros (positivos o negativos)
● Reales (de coma flotante)
o Parte decimal (positivos o negativos)
o Mantisa (positiva o negativa) y un exponente
● Booleana (True, False)
● Carácter
o Caracteres
o Cadenas de caracteres

En el lenguaje de Arduino, ciertos tipos de datos se adaptan mejor a tareas específicas que otros
tipos de datos, aunque más de un tipo de datos podría funcionar. Seleccionar el tipo de datos
correctos a menudo da como resultado un programa que se ejecuta más rápido y usa menos
memoria [ CITATION Jac15 \l 9226 ].

Arduino C es compatible con casi todos los tipos de datos de ANSI C, y maneja los siguientes tipos
de variables:

Tipo Descripción Ejemplo

void Reservado para la declaración void setup ()
de funciones sin valores de void loop()
retorno
byte Un número entero del 0 a 255 byte variableprueba;
codificado en un objeto o byte
(8 bits)
int / (Integer = entero) Un número int conteo = 0;
short entre 32767 y -32768 (2 bytes)
long Un entero comprendido entre long contadorgranos;
2’147.483.647 y
-2’147.483.648 (4 bytes)
float / Un número real (con float temperatura;
double decimales) almacenado en 4
bytes y comprendido entre
3,4028325*10^38 y
-3,4028325*10^38
unsigned Un número natural (entero unsigned int rpmmotor = 0;
int positivo) almacenado en 2
bytes y comprendido entre 0 y
65,535
unsigned Un número nratural (entero unsigned long variabletest
long positivo) almacenado en 4 = 51000;
bytes y comprendido entre 0 y
4.294’967.296
word Lo mismo que unsigned word rpmmotor = 0;
int
boolean Una variable booleana que boolean variableprueba =
(bool) puede tener solamente dos true;
valores: true (verdadero) o
false (falso)
char Un carácter ASCII almacenado Char letra = ‘a’;
en 8 bits. Esto permite
almacenar caracteres como
 valores numéricos (su código char letra = 97;
ASCII asociado).

unsigned Este tipo de dato es idéntico al unsigned char testchar =

char tipo byte explicado arriba. Se 36;
utiliza para codificar números
de 0 a 255. Ocupa un byte de
memoria

Hace décadas, los fabricantes de computadoras decidieron organizar estos dígitos binarios, o bits,
en grupos de 8 bits. Cada grupo de 8 bits tomado como una unidad se llama byte. Debido a que un
byte solo puede tener dos estados, 1 o 0, los bytes son más utilizados aplicando aritmética de base
2, en lugar de la base 10 a la que está acostumbrado.

1 Byte = 8 bits => 28=256 ; 2 bytes = 16 bits => 216=65536=¿−32768 … 0 …32767

Se recomienda leer el capítulo 3 del libro Beginning C for Arduino segunda edición para más
información.

Arrays (arreglos)
Es una colección indexada de valores del mismo tipo. en el caso de un array el índice no es una
palabra, sino un número (que corresponde al número de orden de la variable concreta dentro del
array). se puede declarar un array de la siguiente manera:

int listasistencia[5];

si se desea inicializar un arreglo, puede hacerse de la siguiente manera:

int listasistencia[5] = {2, 8, 26, -15, 3};

dato 2 8 26 -15 3
índice 0 1 2 3 4

Nota importante 1: tener en cuente que el primer índice de un array es siempre 0, no 1.

Nota importante 2: tener especial cuidado de no tratar de acceder datos fuera del array (por
ejemplo, si colocásemos un sexto dato, nos devolvería datos sin sentido de la memoria).

Ejemplos de operaciones con arrays

//crear e inicializar un array de 4 valores

int listasistencia[4]={1, 2, 3, 4};
//asignando a una variable, un valor del arreglo
NuevaVariable = listasistencia[2];
//asignarle a un arreglo un nuevo valor
listasistencia[0]= 453;

Strings
Un string es una cadena (array) de caracteres. Los strings pueden ser declarados de dos
maneras diferentes: como variables tipo char o como objetos pertenecientes a una clase más
compleja llamados ‘Strings’.

Cuando una cadena de caracteres es almacenada es una variable tipo char normalmente se les
hace terminar por el carácter nulo (ASCII 0). Esto se hace con el fin de permitir a las funciones que
manipulan cadenas de caracteres en variables char reconocer el final de la cadena. Por lo tanto,
cuando se calcule el tamaño de una cadena dentro de un array se debe recordar añadir una
posición para el carácter de ‘fin de cadena’ (ASCII 0).

Un array de caracteres puede ser declarado de diversas maneras:

char cadena1[10]; //creando un array sin incializar
char cadena2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'}; /*en la segunda cadena
inicializamos y el sistema añada un carácter nulo*/
char cadena3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o','\0'}; /*en la tercera
cadena añadimos el carácter de fin de array explícitamente*/
char cadena4[] = "arduino"; /*en la cuarta cadena el array se fracciona en
caracteres individuales y se dimensiona automáticamente*/
char cadena5[8] = "arduino"; /* en este quinto array, la cadena se fracciona en
caracteres individuales automáticamente*/
char cadena6[10] = "arduino"; /* en este sexto array, la cadena se fracciona en
caracteres individuales automáticamente y se dejan espacios libres para nuevos
datos*/

El tipo de datos char y los conjuntos de caracteres

Según Purdum [ CITATION Jac15 \l 3082 ] cuando las computadoras aparecieron por primera vez,
todos los caracteres que se consideraban necesarios podían ser representado con relativamente
pocos valores. Su teclado, por ejemplo, probablemente tenga menos de 127 teclas.
Debido al número relativamente pequeño de caracteres necesarios, el Código Estándar
Estadounidense para el intercambio de caracteres de Información (ASCII) se desarrolló en base a
valores de 8 bits (es decir, 1 byte). Al tratar los ocho bits como una cantidad sin signo, el conjunto
de caracteres ASCII se amplió posteriormente para también incluir caracteres gráficos limitados. El
conjunto de caracteres ASCII fue la norma durante décadas. Sin embargo, a medida que las
computadoras se globalizaron, la necesidad de ampliar el conjunto de caracteres se hizo evidente.
El conjunto de caracteres kanji japonés, por ejemplo, tiene casi 2000 caracteres. Claramente, estos
caracteres no se pueden representar en un byte de 8 bits. Por esta razón, se desarrolló el juego de
caracteres Unicode.
El juego de caracteres Unicode se basa en un valor de 2 bytes para cada carácter. Desde el punto
de vista de un programador, los caracteres Unicode son cantidades sin firmar, por lo que se
pueden representar más de 65.000 caracteres. Para obtener detalles sobre el juego de caracteres
Unicode, consulte www.unicode.org/charts. Para el conjunto de caracteres ASCII, consulte
www.asciitable.com.) Debido al deseo de "internacionalizar" los softwares de computadora, cada
vez más programadores se trasladaron al juego de caracteres Unicode. Sin embargo, hubo
también programadores acérrimos de ASCII. Quizás como un compromiso, hay juegos de
caracteres Unicode para diferentes longitudes de bits. Por ejemplo, UTF-8 es el formato de
transformación Unicode para juegos de caracteres de 8 bits. Ahora puedes seleccionar de UTF-8,
UTF-16 y UTF-32.
Si necesita Unicode en su software, puedes improvisarlo usando Arduino C.

Uno de los programas de muestra incluidos con Arduino C IDE es uno que puede generar una tabla
de Juego de caracteres ASCII.

Constantes
Son espacios de memoria cuyo valor no cambia durante a la ejecución del programa (sketch). En
estos casos podemos añadir la palabra reservada ‘const’ al comienzo de la declaración de
variables. Estos se utilizan típicamente para definir número de pin o constantes matemáticas .

Ejemplo:
const int LED = 2; //declaro al pin 2 del microcontrolador como LED
const float Pi = 3.141592654;

El lenguaje Arduino tiene una serie de palabras reservadas que son constantes:

INPUT/OUTPUT (Entrada / Salida). Los pines digitales pueden ser configurados de ambos
modos: como entrada (INPUT) o como salida (OUTPUT) mediante la función pinMode
()
PinMode (13, OUTPUT) ;//configure el pin 13 como salida
digital
 INPUT_PULLUP: reservado como parámetro de la función pinMode () para el uso
de resistencias pull-up en los microcontroladores
PinMode (2, INPUT_PULLUP) ;//Habilite el pull-up del pin 2
(entrada)

LED_BUILTIN: reservada para el uso del LED de serie con el que viene equipado el
Arduino (13)

true / false (verdadero / Falso). Para el Arduino True (Verdadero) es cualquier valor
que no es cero (0). False (falso) es el valor 0.

HIGH / LOW (Alto / Bajo). Es el valor lógico en una puerta digital: LOW es el valor 0 – 0
voltios y HIGH es el valor 1 – 5 Voltios

Declaración de constantes enumeradas

Enum: Asigna un valor a cada elemento dentro de las llaves, empezando desde 0.

Representación de constantes de tipo enteras

Se trata de constantes usadas directamente en un sketch, por ejemplo 123. Por defecto, se tratan
como números enteros, pero se puede cambiar con los modificadores.

En general, se consideran las constantes representadas en base 10 (es decir, como números
decimales). Sin embargo, se pueden utilizar notaciones especiales para expresar números en otras
bases.

Base Ejemplo Formateador Comentario

10 (decimal) 123 Ninguno

2 (binario) B1111011 Prefijo ‘B’ Máximo 8 bits (0 a 255), solo caracteres

0-1 válidos
8 (octal) 0173 Prefijo ‘0’ Caracteres validos: 0-7

16 (hexadecimal) 0x7B Prefijo ‘0x’ Caracteres válidos: 0 -9, A - F

Las constantes expresadas sin ningún prefijo se consideran decimales

Ejemplo:
B101; // equivale al decimal 5

El formato binario (B) solo funciona con bytes (8 bits) entre 0 (B0) y 255 (B11111111). Si se
necesita utilizar un entero int (int de 16 bits) en forma binaria, se puede hacer en un
procedimiento de dos pasos como sigue:

milnt = (B11001100*256) + B10101010; /*B11001100 es el byte MSB

milnt = B1100110010101010*/

Formateadores U y L
Generalmente, una constante entera es tratada como un int con las consiguientes limitaciones
en cuanto a valores. Para especificar que la constante entera tiene otro tipo hay que añadirle el
sufijo

● ‘u’ o ‘U’ para que el formato de la constante sea “unsigned”. Ejemplo: 33u
● ‘l’ o ‘ L‘ para que el formato de la constante sea “long”. Ejemplo: 100000L
● ‘ul’ o ‘UL’ para el formato de la constante sea “unsigned long”. Ejemplo:
32767ul

Constantes de tipo coma flotante (float)

Del mismo modo que las constantes enteras, las constantes en coma flotante se usan para hacer el
código más legible. Estas constantes se reemplazan durante la compilación por el valor asignado
en la expresión declarativa.

Ejemplo:
n = .005;

Las constantes en coma flotante pueden también ser expresadas en una variedad de notaciones
científicas. Ambos caracteres ‘E’ y ‘e’ pueden ser utilizados como indicadores del exponente.

Constante en coma flotante Equivale a Y también a

10.0 10
2.34E5 2.34∗105 234.000

67e-12 67.0∗10−12 .00000000067

93.2E4 93.2∗104 932000

La precisión de un número se refiere al número de dígitos significativos que puede esperar ese
número. En Arduino C, la mayor precisión posible esperar para un valor de punto flotante es de 7
dígitos de precisión. Lo que esto significa es que, aunque puede representar un número de punto
flotante con 38 dígitos, solo los primeros 7 son significativos. Los 31 dígitos restantes son la mejor
conjetura de la computadora sobre cuáles deberían ser los dígitos. Dado ese hecho,

Parece engañoso que PI se defina tal como es. Para todo propósito práctico, PI podría definirse
como
#define PI 3.141592

y olvide el resto de los dígitos porque la computadora no podrá representar esos dígitos en
cualquier operación matemática con mayor precisión que seis o siete dígitos. Sin embargo, si solo
va a mostrar pi y no manipularlo de cualquier manera, entonces PI le da esa constante con
considerable precisión.

Nota: En alguna literatura de Arduino, se verá variables definidas usando uint8_t,

uint16_t, o quizás otros términos similares. Estas constantes se utilizan para ayudar a definir el
tipo de datos para el compilador de C ++ subyacente. Es bastante fácil de entender lo que
significan. Por ejemplo, uint8_t se traduce a un int sin signo compuesto por 8 bits. (El elemento
_t ayuda a marcarlo como un tipo de datos). A menos que se indique lo contrario, utilizamos los
tipos de datos C estándar presentados en la tabla anterior (Purdum, 2015).

Ámbito de las variables

Variables locales y globales
En todos los lenguajes estructurados como el de Arduino las variables tienen una propiedad
llamada “Ámbito” (“scope” en inglés). Esta propiedad se refiere al hecho de que el valor de la
variable puede ser accedido o no en unas partes del sketch según cómo donde esta variable haya
definida.

Aquellas variables que hayan sido definidas fuera de las funciones setup y loop se
denominan variables globales y su valor puede ser accedido desde cualquier punto del programa
o sketch

Por el contrario, aquellas variables definidas dentro una función se llaman locales y tienen un
ámbito local: sus variables accesibles desde dentro de la función en la que han sido declaradas.

A medida que los sketchs crecen en tamaño y complejidad, el uso de variables locales es
aconsejado porque evita confusiones entre variables con el mismo nombre.
En el caso de las funciones anidadas (una función llamada desde otra función, que a su vez ha sido
llamada desde otra función), el ámbito de aquellas variables definidas en las funciones exteriores
se extiende a las funciones interiores, pero no viceversa
Variables estáticas
La palabra reservada (keyword) static para crear variables que variables que son visibles para la
función. La diferencia con las variables locales es que éstas son creadas y destruidas cada vez que
se llama a una función. Las variables definidas como static persisten cuando la función ha
terminado y se conservan los datos almacenados en ellas disponibles para la próxima vez que se
llame a esa función. Estas variables se crean e inicializan solamente la primera vez que la función
que las crea es llamada.

Variables volátiles
Cuando declaramos una variable como “Volatile” lo que estamos haciendo es instruir al
compilador a cargar siempre la variable desde la memoria RAM y no desde uno de los registros
internos del procesador.

La razón por la que hacemos esto es que, bajo ciertas condiciones, el valor de una variable
almacenada en los registros internos puede sufrir alteraciones. En Arduino el único sitio en el que
esto puede suceder es en las partes de código asociado con interrupciones (interrupt services
routines)

#define: definiendo valores constantes

El #define es un componente útil de C que permite que el programador dé un nombre a un
valor constante antes de que se compile el programa. Las constantes definidas en Arduino no usan
memoria del programa en el microprocesador. El compilador sustituirá referencias a estas
constantes por el valor definido durante la compilación.
Sin embargo, esto puede tener efectos secundarios no deseados. Por ejemplo, el valor de una
constante que ha sido declarado como #define será incluido automáticamente en todos los
nombres de constantes o variables que incluyan es nombre como parte de su propio nombre.

Ejemplo:

La sintaxis del #define es:

#define nombreConstante valor

Nota: no hay punto y coma detrás de la instrucción #define.

Nota 2: del mismo modo no incluir un signo igual después del nombre del nombre de la constante,
pues generará un error de compilación

#include: llamado a bibliotecas externas

La instrucción #include se utiliza para incluir bibliotecas (Libraries) externas en un sketch. Esto
da al programador el acceso a un gran número de bibliotecas estándar del lenguaje C (una
biblioteca es fundamentalmente un grupo de funciones ya desarrolladas), así como de muchas
bibliotecas escritas especialmente para Arduino.

Se puede encontrar la página principal de referencia para las bibliotecas del C del AVR (una
referencia a los microcontroladores Atmel en los cuales se basa Arduino) en la siguiente dirección:
http://www.nongnu.org/avr-libc/user-manual/modules.html

observe qué #include, de modo similar qué #define, no admite punto y coma al final.

Expresiones
Una expresión es una combinación de operadores y operandos. Los operandos podrán ser
constantes, variables u otras expresiones y los operadores de cadena, aritméticos, relacionales o
lógicos. Las expresiones se clasifican, según el resultado que producen, en:

Numéricas: Los operandos que intervienen en ellas son numéricos, el resultado es también de
tipo numérico y se construyen mediante los operadores aritméticos. Se pueden considerar
análogas a las fórmulas matemáticas. Debido a que son los que se encuentran en la mayor parte
de los lenguajes de programación, los algoritmos utilizarán los siguientes operadores aritméticos:
menos unario (– ), multiplicación ( * ),división real ( / ),exponenciación ( ** ),adición ( + ),resta
(– ),módulo de la división entera ( mod ) y cociente de la división entera ( div ). Tenga en cuenta
que la división real siempre dará un resultado real y que los operadores mod y div sólo operan con
enteros y el resultado es entero.
Alfanuméricas. Los operandos son de tipo alfanumérico y producen resultados también de dicho
tipo. Se construyen mediante el operador de concatenación, representado por el operador
ampersand (&) o con el mismo símbolo utilizado en las expresiones aritméticas para la suma.

Booleanas. Su resultado podrá ser verdad o falso. Se construyen mediante los operadores
relacionales y lógicos. Los operadores de relación son: igual ( = ),distinto ( <> ),menor que ( < ),
mayor que ( > ),mayor o igual ( >= ),menor o igual ( <= ). Actúan sobre operandos del mismo tipo y
siempre devuelven un resultado de tipo lógico. Los operadores lógicos básicos son: negación lógica
( no ), multiplicación lógica ( y ),suma lógica ( o ). Actúan sobre operandos de tipo lógico y
devuelven resultados del mismo tipo, determinados por las tablas de verdad correspondientes a
cada uno de ellos.

Moldeado de datos
La conversión de un tipo de datos en otro se conoce como conversión de tipos o conversión de
tipos. Por ejemplo, si desea almacenar un valor 'largo' en un entero simple, puede escribir cast
'largo' en 'int'. Puede convertir los valores de un tipo a otro explícitamente utilizando el operador
de conversión de la siguiente manera:
(Tipo_de_dato) expresion

Considere el siguiente ejemplo en el que el operador de conversión hace que la división de una
variable entera por otra se realice como una operación de punto flotante:

Considere el siguiente ejemplo en el que el operador de conversión hace que la división de una
variable entera por otra se realice como una operación de punto flotante:

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Cabe señalar aquí que el operador de conversión tiene prioridad sobre la división, por lo que el
valor de suma se convierte primero a tipo doble y finalmente se divide por recuento, lo que
produce un valor doble.

Las conversiones de tipos pueden ser implícitas, lo que el compilador realiza automáticamente, o
se pueden especificar explícitamente mediante el uso del operador de conversión. Se considera
una buena práctica de programación utilizar el operador de conversión siempre que sea necesario
realizar conversiones de tipo.

Promoción de enteros
La promoción de enteros es el proceso mediante el cual los valores de tipo entero "más pequeño"
que int o unsigned int se convierten en int o unsigned int . Considere un ejemplo de
cómo agregar un carácter con un número entero:

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Aquí, el valor de sum es 116 porque el compilador realiza una promoción de enteros y convierte el
valor de 'c' a ASCII antes de realizar la operación de suma real.

Conversión aritmética habitual

Las conversiones aritméticas habituales se realizan implícitamente para convertir sus valores a un
tipo común. El compilador primero realiza una promoción de enteros; si los operandos todavía
tienen tipos diferentes, entonces se convierten al tipo que aparece más alto en la siguiente
jerarquía:
Las conversiones aritméticas habituales no se realizan para los operadores de asignación, NAND
para los operadores lógicos && y ||. Tomemos el siguiente ejemplo para entender el concepto:

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Aquí, es sencillo entender que primero c se convierte en un número entero, pero como el valor
final es doble, se aplica la conversión aritmética habitual y el compilador convierte i y c en 'float' y
los agrega dando un resultado 'float' (Point, 2020).
Pseint
De acuerdo a Santillán [ CITATION Ivá14 \l 3082 ] PSeInt viene de las palabras ‘PSeudo Intérprete’ y
es una herramienta para asistir a un estudiante en sus primeros pasos en programación. Mediante
un simple e intuitivo pseudo lenguaje en español (complementado con un editor de diagramas de
flujo), le permite centrar su atención en los conceptos fundamentales de la algoritmia
computacional, minimizando las dificultades propias de un lenguaje y proporcionando un entorno
de trabajo con numerosas ayudas y recursos didácticos.

El programa es una aplicación de escritorio y se encuentra disponible libremente para Windows,

Linux y Mac OS desde el sitio web oficial http://pseint.sourceforge.net/.

Algunas características y funcionalidades de PSeInt son:

● Presenta herramientas de edición para escribir algoritmos en pseudocódigo en español

● Permite generar y editar el diagrama de flujo del algoritmo
● El lenguaje pseudocódigo utilizado es configurable (perfiles)
● Puede interpretar (ejecutar) los algoritmos escritos, incluso paso a paso.
● Determina y marca los errores de sintaxis y en tiempo de ejecución.
● Permite exportar el algoritmo de pseudocódigo a código C, C++, C#, java, php,
● VB.net, pascal, python, javaScript, Matlab.
● Ofrece un sistema de ayuda integrado y con ejemplos
● Es multiplataforma (Windows, GNU/Linux y Mac OS X)
● Es totalmente libre y gratuito (licencia GPL)

Perfiles
Los perfiles permiten configurar ciertas restricciones en el pseudocódigo. Existen perfiles
predefinidos en el programa, como el Flexible, y otros creados bajo solicitud de ciertas
instituciones como es el caso del perfil “Estricto”. Este perfil obliga a definir o declarar las variables
antes de ser usadas, lo cual resulta ser una buena práctica de programación y evitar posibles
errores de programación.

Para seleccionar el perfil vaya al menú ‘Configurar’, Opciones del lenguaje (perfiles).

Una vez declarada la variable se le puede asignar un valor y también pedir por teclado ese valor
(leer). También existe una palabra clave para mostrar datos por pantalla, esta es Escribir, si se
utiliza Sin Saltar, no se hace un salto de línea después, sino se utiliza se hará un salto de línea
[ CITATION htt21 \l 3082 ].
Identificadores (Keywords)
Identificadores son los nombres que se dan a las constantes simbólicas, variables, funciones,
procedimientos, u otros objetos que manipula el algoritmo. La regla para construir un identificador
establece que:

Reglas por formar un identificador

 Debe resultar significativo, sugiriendo lo que representa.
 No podrá coincidir con palabras reservadas, propias del lenguaje algorítmico. Como se
verá más adelante, la representación de algoritmos mediante pseudocódigo va a requerir
la utilización de palabras reservadas.
 Se recomienda un máximo de 50 caracteres.
  Comenzará siempre por un carácter alfabético y los siguientes podrán ser letras, dígitos o
el símbolo de subrayado.
 Podrá ser utilizado indistintamente escrito en mayúsculas o en minúsculas (Aguilar,
Rodríguez Baena, & Fernández Azuela, 2003).

Algunas instrucciones o comandos simples de los algoritmos con PSeInt

Existen otras palabras claves que realizan acciones simples, todas ellas junto con las anteriores,
son las llamadas secuenciales. Borrar Pantalla se utiliza para limpiar la pantalla, dejarla vacía
como el que limpia una pizarra. Esperar se utiliza para parar el algoritmo un intervalo de tiempo,
que se indica a continuación junto a la unidad de dicho intervalo, que puede ser segundos y
milisegundos, por ejemplo: Esperar 5 Segundos; Esperar Tecla se utiliza también para parar el
algoritmo hasta que el usuario pulsa una tecla[ CITATION htt21 \l 3082 ].

Operadores
Son símbolos que permiten operar, a las variables de forma aritmética, lógica o de carácter.

^ Exponenciación
* Multiplicación

+ Suma
- Resta

Mod Módulo o residuo

Expresión
Una expresión es una combinación de operadores y operando. Los operandos podrán ser
constantes, variables u otras expresiones y los operadores, aritméticos, relacionales o lógicos.
Orden de precedencia
Se refiere al orden de las operaciones que se dan a lugar en una operación aritmética y lógica.
 2
( 5−3 )2
(
Ejemplo: calcular 4 +2
2
−8 )
El orden de las operaciones sería:

1. Paréntesis internos:
2
( 2 )2
( 2
4+
2
−8 )
2. Potencias dentro de los paréntesis:
2
4
( 16+ −8
2 )
3. Las divisiones (o multiplicaciones) dentro de los paréntesis:
( 16+2−8 )2
4. Sumas y restas dentro del paréntesis:

( 10 )2
5. La potenciación:

100.
Operaciones lógicas
Son aquellas que trabajan operadores y operandos de tipo booleano, y cuyo resultado arroja un
valor verdadero o falso (A y B son variables lógicas).

Operador (PSeInt) Arduino

Y (AND) &&
O (OR) ||

NO (NOT) !
XOR ^

NO Y (NAND) !(A && B)

NO O (NOR) !(A || B)

XNOR !(A ^ B)
Operaciones relacionales (de comparación)
Comparan dos o más variables, y arrojan como resultado un valor booleano (lógico)

Operación OPERADOR PSeInt Arduino

Mayor que X>Y X>Y

Menor que X<Y X<Y

Mayor o igual que X≥Y X >= Y

Menor o igual que X≤Y X <= Y

Igual a X=Y X == Y
Diferente de X != Y, X <> Y X != Y

Nota: los operadores relacionales están antecedidos por los operadores lógicos y aritméticos

Ejemplo: realice las operaciones para calcular el valor final de s, a partir de las siguientes
operaciones:

a=10 ;
b=18 ;
s= ( a>b ) O ( 5<a−5 ) ;
s= ( F ) O ( F ) ;
s=F
Referencias
Arriarán, S. S. (2015). Todo sobre sistemas embebidos Arquitectura, programación y diseño de
aplicaciones prácticas con el PIC18F. Lima: Saxo.

Breijo, E. G. (2009). COMPILADOR C CCS y SIMULADOR PROTEUS para MICROCONTROLADORES

PIC. Barcelona: Marcombo.

Espressif Systems. (2020). ESP32 Technical Reference Manual .

https://terepebernal.com/sobre-mi/. (2021). Obtenido de Aprendiendo a programar programando:

https://terepebernal.com/blog/pseudocodigo/algoritmos-pseint-lo-mas-
basico/#Funciones_en_PSeInt

Nicolas GOILAV, G. L. (2016). Arduino - Aprender a desarrollar para crear objetos inteligentes. ENI.

Paul Scherz, S. M. (2013). Practical Electronics for Inventors. McGraw-Hill Education books.

Purdum, J. (2015). Beginning C for Arduino: Learn C Programming for the Arduino, Second Edition.
Cincinnati: Technology In Action.

www.arduino.cc. (2021). Arduino - ESP32 I2C Slave. Obtenido de

https://www.arduino.cc/reference/en/libraries/esp32-i2c-slave/