Sistemas de Regadío com Microcontroladores

•

Engenharias

edw ga

1/5/2024

¡Este material tiene más páginas!

Entonces, ¿te gustó este material?

Ayude a animar a otros estudiantes a mejorar el contenido

¿Te gustó este material? ¡Compartir! 🧡

Sistemas de microcontroladores y microcontroladores

473 Materiales compartidos

Descarga la aplicación para disfrutar aún más

Lea materiales sin conexión, sin usar Internet. Además de muchas otras características!

Vista previa del material en texto

UNIVERSIDAD DE SEVILLA

ESCUELA POLITÉCNICA SUPERIOR

Trabajo Fin de Grado en Ingeniería Electrónica Industrial

Microcontroladores y FreeRTOS aplicado a sistemas de regadío.

Departamento de Arquitectura y Tecnología de computadores

Autor: Javier Martín Gutiérrez
Tutores: Alejandro Linares Barranco
Luis Muñoz Saavedra
Titulación: Grado en Ingeniería Electrónica Industrial.
Septiembre 2022

Trabajo de fin de grado en Ingeniería Electrónica Industrial

Inteligencia artificial aplicada a los sistemas de regadíos.

Autor:
Javier Martín Gutiérrez

Tutores:
Alejandro Linares Barranco
Luis Muñoz Saavedra

Departamento de Arquitectura y Tecnología de computadores.

Escuela Politécnica Superior de Sevilla
Universidad de Sevilla

Sevilla,2022

2
Trabajo de fin de grado: Inteligencia artificial aplicada a los sistemas de
regadíos.

Autor: Javier Martín Gutiérrez

Tutores: Alejandro Linares Barranco y Luis Muñoz Saavedra

El tribunal nombrado para evaluar el proyecto estará compuesto por los
siguientes miembros:

Presidente:

Vocales:

Secretario:

Acuerdan otorgarle la calificación de:

Sevilla, 2022

El secretario del tribunal:

3
Agradecimientos.
En primer lugar, quisiera agradecer a Alejandro Linares Barranco y Luis Muñoz
Saavedra la oportunidad que me ha brindado para realizar este proyecto y
aprender de él, y al Departamento de Arquitectura y Tecnología de
Computadores por permitirme realizarlo y culminarlo en este trabajo.
A mi familia por su confianza y consejos, pues siempre me han ayudado y
acompañado en los buenos y malos momentos.
Y a todos mis profesores, compañeros y amigos por los conocimientos que he
adquirido gracias a vosotros y que espero poner en práctica pronto.
Gracias por estar a mi lado.

4
Resumen.
En este proyecto se trata el control automático y eficaz de un sistema de riego.
Para ello, se ha consultado los tipos de sistema de riegos más comunes
utilizados en la actualidad, siendo el sistema de riego por goteo uno de los más
extendidos y propicio a este tipo de control.
Para realizar este control del riego se ha decido usar una potente placa
controladora stm32 que permite la toma de información del exterior por sensores,
administrarla y gestionarla eficientemente por una programación de multitarea
en tiempo real. Todo esto en conjunto con una interfaz amigable para el usuario
permite configurar fácilmente programas de riego y mostrar información
actualizada de la situación del riego.

5
Abstract.
This project deals with the automatic and efficient control of an irrigation system.
To do this, we have consulted the most common types of irrigation systems used
today, being the drip irrigation system one of the most widespread and conducive
to this type of control.
To carry out this irrigation control it has been decided to use a powerful stm32
controller board that allows the collection of information from the outside by
sensors, administer and manage it efficiently by a multitasking programming in
real time. All this in conjunction with a user friendly interface allows to easily
configure irrigation schedules and display updated information of the irrigation
situation.

6
Contenido.

Documento 1: Memoria Descriptiva.
Documento 2: Mediciones y Presupuesto.
Documento 3: Anexo I. Manual de usuario.
Documento 4: Anexo II. Código.

7
Índice.

Resumen. ........................................................................................................... 4
Abstract. ............................................................................................................. 5
Contenido. .......................................................................................................... 6
Índice. ................................................................................................................. 7
Índice de Figuras. ............................................................................................. 10
Documento 1. Memoria Descriptiva. ................................................................ 11
1. Introducción. ........................................................................................... 12
1.1. Motivación. ....................................................................................... 13
1.2. Antecedentes. .................................................................................. 14
1.3. Objetivo. ........................................................................................... 15
1.4. Alcance. ........................................................................................... 16
1.5. Normas y referencias. ...................................................................... 17
1.5.1. Legislación de ámbito europeo. ................................................. 17
1.5.2. Legislación de ámbito nacional. ................................................ 17
1.5.3. Legislación de ámbito autonómico. ........................................... 17
1.5.4. Normas. ..................................................................................... 17
1.6. Requisitos de diseño. ....................................................................... 18
1.6.1. Requisitos del Hardware. .......................................................... 18
1.6.2. Requisitos del Software. ............................................................ 18
1.7. Electroválvula. .................................................................................. 19
1.7.1. Elementos de una electroválvula. .............................................. 19
1.7.2. Funcionamiento. ........................................................................ 21
1.7.3. Tipos de electroválvulas. ........................................................... 22
2. Descripción del software. ....................................................................... 23
2.1. Lenguaje de programación. ............................................................. 23
2.1.1. Tipos de lenguaje de programación. ......................................... 23
2.1.2. Lenguaje C. ............................................................................... 23
2.1.2.1. Características del lenguaje. ................................................ 24
2.1.2.2. Sintaxis. ............................................................................... 25
2.2. Entorno de programación. ................................................................ 26
2.2.1. Editores. .................................................................................... 26
2.2.2. Procesadores del lenguaje. ....................................................... 26
2.2.3. Enlazadores. ............................................................................. 27

8
2.2.4. Depuradores. ............................................................................. 27
2.2.5. STM32CubeIDE ........................................................................ 28
2.2.5.1. STM32CubeMX.................................................................... 28
2.2.5.2. TrueSTUDIO. ....................................................................... 29
2.2.6. Putty. ......................................................................................... 30
3. Descripción del Hardware....................................................................... 31
3.1. Placa STM32. ..................................................................................31
3.1.1. Microcontrolador. ....................................................................... 32
3.2. Pantalla OLED. ................................................................................ 33
3.2.1. Conexionado. ............................................................................ 35
3.2.2. Visualización de gráficos. .......................................................... 35
3.2.3. I2C. ............................................................................................ 36
3.2.3.1. Esquema de comunicación. ................................................. 36
3.2.3.2. Bits de la trama. ................................................................... 37
3.2.3.3. Modos de comunicación. ..................................................... 38
3.3. Botonera. ......................................................................................... 38
3.3.1. Pulsador. ................................................................................... 38
3.3.1.1. Circuito antirebote. ............................................................... 40
3.4. Electroválvula. .................................................................................. 41
3.4.1. Características técnicas. ........................................................... 41
3.5. Montaje del circuito. ......................................................................... 42
4. RTOS. .................................................................................................... 43
4.1. Tarea................................................................................................ 43
4.1.1. Comunicación entre tareas. ....................................................... 43
4.2. Programador. ................................................................................... 44
4.3. Tic del sistema. ................................................................................ 44
4.4. Ventajas de los RTOS...................................................................... 45
5. Programación. ........................................................................................ 45
5.1. Configuración STM32CubeIDE. ....................................................... 45
5.1.1. Configuración del reloj. .............................................................. 45
5.1.2. RTOS. Tareas, colas y semáforos............................................. 47
5.1.2.1. Diagrama de bloques. .......................................................... 49
5.1.3. Configuración de los pines. ....................................................... 50
6. Ensayos. ................................................................................................. 51
6.1. Rebote en pulsadores. ..................................................................... 51

9
6.2. Variables globales. ........................................................................... 51
6.3. Utilización de electroválvulas. .......................................................... 52
7. Conclusiones y proyectos futuros. .......................................................... 53
7.1. Conclusiones. .................................................................................. 53
7.2. Proyectos futuros. ............................................................................ 53
8. Bibliografía.............................................................................................. 54

10
Índice de Figuras.

Figura 1. Acueducto romano. Calle Luis Montoto, Sevilla ................................ 14
Figura 2. Ejemplo de electroválvula. ................................................................ 19
Figura 3. Electroválvula de membrana ............................................................. 19
Figura 4. Funcionamiento de una electroválvula asistida. ................................ 21
Figura 5. Consola de un pdp11. ....................................................................... 24
Figura 6.Sintaxis de lenguaje C para un PIC.................................................... 25
Figura 7. Equivalencia código máquina y ensamblador. .................................. 26
Figura 8.Presentación STM32CubeIDE ........................................................... 28
Figura 9.Interfaz gráfica STM32CubeIDE. ....................................................... 29
Figura 10.Menú de configuración de Putty. ...................................................... 30
Figura 11.Placa STM32. ................................................................................... 31
Figura 12. Diagrama STM32F070RB. .............................................................. 33
Figura 13.Pantalla OLED. ................................................................................ 33
Figura 14.Regulador de tensión. ...................................................................... 34
Figura 15. Conexiones pantalla. ....................................................................... 35
Figura 16. Matriz de visualización. ................................................................... 35
Figura 17.Esquema I2C. .................................................................................. 36
Figura 18. Ejemplo trama I2C. .......................................................................... 37
Figura 19. Funcionamiento de un pulsador ...................................................... 38
Figura 20. Tipos de pulsadores. ....................................................................... 39
Figura 21. Botonera. ......................................................................................... 39
Figura 22. Rebotes del pulsador. ..................................................................... 40
Figura 23. Circuito antirebote. .......................................................................... 40
Figura 24. Electroválvula RN 150. .................................................................... 41
Figura 25. Montaje del circuito. ........................................................................ 42
Figura 26. Configuración Reloj 1. ..................................................................... 46
Figura 27. Configuración reloj 2. ...................................................................... 46
Figura 28. Prescalers según el reloj. ................................................................ 47
Figura 29. Tareas y colas. ................................................................................ 48
Figura 30. Semáforos. ...................................................................................... 48
Figura 31. Diagrama de bloques. ..................................................................... 49
Figura 32. Vista de pines. ................................................................................. 50

file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295277
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295278
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295279
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295280
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295281
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295282
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295283
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295284
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295285file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295286
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295287
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295288
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295289
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295290
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295291
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295292
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295293
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295294
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295295
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295296
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295297
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295298
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295299
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295300
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295301
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295302
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295303
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295304
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295305
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295306
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295307
file:///C:/Users/marti/OneDrive/Escritorio/TFG/Capitulos/Documento%201%20-%20Memoria%20Descriptiva.docx%23_Toc113295308

UNIVERSIDAD DE SEVILLA

ESCUELA POLITÉCNICA SUPERIOR

Documento 1. Memoria Descriptiva.

Microcontroladores y FreeRTOS aplicado a sistemas de regadío

Departamento de Arquitectura y Tecnología de computadores

Autor: Javier Martín Gutiérrez
Tutores: Alejandro Linares Barranco
Luis Muñoz Saavedra
Titulación: Grado en Ingeniería Electrónica Industrial.
Septiembre 2022

12
1. Introducción.

Este proyecto estudia el control automático del riego formado por una o varias
electroválvulas mediante un sistema empotrado.
Para poder hacer un control correcto y eficaz, deberemos analizar en primera
instancia las necesidades de riego, puesto que varían significativamente de un
pequeño huerto a un cultivo extensivo.
Esto se traduce en número de electroválvulas, las cuales pueden acometer
diferentes secciones del cultivo. También atañe a la frecuencia de riego e incluso
a tener cuenta la temperatura ambiente.
Para dar una solución a esta problemática se tendrá que realizar una interfaz
para que el usuario pueda configurar tanto la fecha y hora actual, como la
frecuencia de riego e incluso mostrar información sobre la temperatura y otros
datos de interés. Dicha interfaz estará compuesta primeramente por una pantalla
por la que se mostrará las diferentes opciones de configuración.
Seguidamente, por una botonera para poder acceder a los distintos menús de
configuración. Esta botonera estará conformada por pulsadores siendo lo más
amigable posible en su utilización para el usuario.
También cabe destacar la toma constante o periódica de la temperatura
mediante un sensor externo, necesario tanto para información como para la toma
de decisiones a la hora del riego.
Todo ello conectado a una placa controladora cuyo núcleo es un
microcontrolador.
Se podrá mostrar toda la información referida a la hora y fecha actual, frecuencia
de riego y temperatura actual mediante la comunicación con un visualizador para
poder saber en todo momento el estado y configuración del riego.
Una vez descrita la interfaz, se aborda el procesado de toda esta información
suministrada por el usuario y recogida por el sensor externo para poder controlar
un actuador, una electroválvula.
Para llevar a cabo esta tarea se hará uso del entorno STM32CubeIDE, el cual
dispone de un control de tareas en tiempo real denominado FreeRTOS. Mediante
estas tareas, las cuales poseen diferentes prioridades según se requiera, se
consigue el control efectivo del riego en todo momento.
En dicho entorno se deberá configurar perfectamente la señal de reloj para que
el sistema funcione de forma exacta y precisa, algo necesario cuando se trata de
aplicaciones dependientes de unos horarios determinados.
En caso de que el sistema empotrado se encuentre lejos del cultivo, se dispone
de una serie de indicadores que ayudara a conocer el estado actual del riego e
incluso si por exceso de temperatura no se pudiese regar.

13
1.1. Motivación.
Si de algo se caracteriza un ingeniero es de resolver problemas cotidianos de la
mejor forma posible utilizando todos los conocimientos que posee. Es por esto
por lo que durante toda mi formación he ido adquiriendo conocimiento
multidisciplinares, de los cuales algunos han sido de mayor interés personal.
La programación de sistemas empotrados y los microcontroladores siempre
estuvieron presentes incluso antes de mis estudios de grado, por lo que de todas
las temáticas de ingeniería electrónica industrial siempre ha sido la que más me
ha aportado.
Mi familia tiene cultivos y frutales de toda la vida. A la hora de mantenerlos, se
presentaba el problema de como regarlos y el tiempo que se requería en hacerlo.
Por esto, decidí aplicar lo que pude aprender a lo largo de toda mi formación en
intentar hacer del riego de los cultivos una tarea fácil y que no se necesitara un
mantenimiento constante.
Un sistema empotrado es una gran solución al problema que puede acarrear el
riego de cultivos y además debido a su versatilidad permita la ampliación de la
instalación si fuera necesario.

14
1.2. Antecedentes.
Los primeros inicios de riego se remontan al 6000 a.C. en Mesopotamia y Egipto.
Reconducían los ríos Nilo, Tigris y Éufrates cuando se desbordaban entre julio y
diciembre hacia los campos de cultivos. Una vez finalizado el ciclo de cultivo se
drenaba el agua de nuevo hacia los ríos.
El primer gran proyecto de irrigación llegaría en el 3100 a.C. en Egipto, donde
se construyeron presas y canales para desviar el agua proveniente del río Nilo a
un lago artificial. Sistemas de canalización similares existían en América
precolombina, China e India.
Un milenio más tarde aparecería los acueductos, tuberías de cemento y roca
molida. Inventado por los romanos, permitiría salvar desniveles de terrenos con
facilidad.

Alrededor del 700 a.C. se desarrolló en Egipto la rueda hidráulica. Muy parecida
a la actual vaciaba el agua en abrevaderos y acueductos. Fue el primer
dispositivo de elevación no operado por humanos.
La rueda persa, llamada sakia, alimentadapor bueyes fue la primera aplicación
de lo que hoy conocemos como bomba.
Hoy en día, se utilizan varios tipos de sistemas de riego, pudiendo ser de
superficie, por goteo o por aspersión. Los agricultores escogen el método más
apropiado para el área, los cultivos y los recursos disponibles.
El riego permitió que tuvieran una fuente constante de alimento cultivándose a
gran escala. También ha facilitado que las civilizaciones sobrevivan en entornos
desfavorables y habitarlos permanentemente.
Figura 1. Acueducto romano. Calle Luis Montoto, Sevilla

15
1.3. Objetivo.
El objetivo principal de este proyecto es el control automático de un sistema de
riego mediante un sistema empotrado. Esto implicará la toma de información del
entorno por parte de sensores externos, los parámetros introducidos por el
usuario a través de la interfaz y el procesado de todos estos datos por parte de
un microcontrolador programable. Este microcontrolador será el encargado de
gobernar los actuadores, en este caso, una o varias electroválvulas.
Para conseguir este objetivo se tratarán una serie de pasos intermedios que nos
ayudarán a conseguirlo. A saber:
➢ La elección y montaje de un hardware, que nos permita la perfecta
comunicación entre los sensores externos, la interfaz conformada por la
pantalla y la botonera, los actuadores como la electroválvula y el
microcontrolador. También se escogerá los indicadores necesarios para
el seguimiento del estado del riego y posibles fallos.

➢ La implementación de un software, para poder recoger y analizar toda la
información proveniente del exterior y decidir cuándo y cómo debe
funcionar el actuador. Para ellos nos serviremos del entorno ya
mencionado con anterioridad stm32CubeIDE, el cual nos permitirá crear
un programa que pueda entender nuestro microcontrolador y funcionar de
la manera deseada.

➢ La comunicación del sistema empotrado con un visualizador, para
obtener información al instante de la configuración del riego, temperatura,
etc. Esta comunicación será unidireccional, ya que solo se requiera la
toma de información y no de actuación sobre nuestro sistema empotrado.
El control de éste se hará atrás de la interfaz únicamente.

➢ La realización de los ensayos necesarios hasta conseguir que el sistema
funcione como se desea. Habrá que tener en cuenta modificaciones en el
hardware como la depuración del código que conforma el programa para
conseguir el resultado esperado.

➢ Definir los límites del sistema empotrado. Determinar cuántos actuadores
puede gobernar, cuanta información es capaz de procesar proveniente
del exterior, en qué condiciones climáticas puede funcionar, etc.

➢ Contemplar las posibles ampliaciones del sistema. Esto atañe tanto al
aumento de sensores, actuadores y mejora de la interfaz; como al código
necesario para adaptar estas mejoras.

16
1.4. Alcance.
Los requisitos necesarios para nuestro sistema son:
✓ Lectura de temperatura exterior.

✓ Una botonera para que el usuario pueda configurar el riego según sus
necesidades.

✓ Un visualizador o pantalla donde el usuario pueda observar el menú que
va a configurar y muestre la información necesaria.

✓ La posibilidad de mostrar externamente información sobre el programa de
riego, temperatura, etc.

✓ La capacidad de actuar sobre una electroválvula que controlará el riego
del cultivo.

Una vez determinado los requisitos que hay que abarcar, tendremos que
implementar un hardware y software que los cumplan.
En lo referente al hardware se necesitará un sensor de temperatura, una
pequeña pantalla, una serie de pulsadores que harán de botonera, una
electroválvula y una placa controladora. Esta placa controladora poseerá un
núcleo de la gama stm32. También hay que destacar la placa de montaje y las
conexiones necesarias entre los diferentes elementos.
En cuanto al software, se desarrollará un código en el entorno stm32CubeIDE.
El cual está diseñado específicamente para la familia de microcontroladores que
se va a emplear y además permitirá conectar los diferentes elementos de la
interfaz usando los protocolos necesarios. Del mismo modo permitirá la
visualización de información en un computador externo al sistema empotrado
usando el protocolo adecuado como hemos descrito anteriormente.

17
1.5. Normas y referencias.
1.5.1. Legislación de ámbito europeo.
• Directiva 2012/19/UE del Parlamento Europeo y del Consejo, de 4 julio
de 2012, sobre residuos de aparatos electrónicos y eléctricos.
• Directiva 2014/30/UE del Parlamento Europeo y del Consejo, de 26 de
febrero de 2014, sobre la armonización de las legislaciones de los
Estados miembros de compatibilidad electromagnética.
• Reglamento de Ejecución (UE) 2017/699 de la Comisión de 18 de abril
de 2017, que establece una metodología común para el cálculo del
peso de los aparatos eléctricos y electrónicos (AEE) introducidos en el
mercado de cada Estado miembro y una metodología común para el
cálculo de la cantidad de residuos de aparatos eléctricos y electrónicos
(RAEE) generados en cada Estado miembro, expresada en peso.
• Directiva 2018/849/UE del Parlamento Europeo y del Consejo, de 30
de mayo de 2018, por la que se modifican la Directiva 2000/53/CE
relativa a los vehículos al final de su vida útil, la Directiva 2006/66/CE
relativa a las pilas y acumuladores y a los residuos de pilas y
acumuladores y la Directiva 2012/19/UE sobre residuos de aparatos
eléctricos y electrónico.
• Reglamento de Ejecución (UE) 2019/290 de la Comisión, de 19 de
febrero de 2019, por el que se establece el formato para la inscripción
en el registro y para la presentación de informes de los productores de
aparatos eléctricos y electrónicos al registro.
1.5.2. Legislación de ámbito nacional.

• Real Decreto 110/2015, de 20 de febrero, sobre residuos de aparatos
eléctricos y electrónicos.
• Real Decreto 338/2010, de 19 de marzo, por el que se modifica el
Reglamento de la Infraestructura para la calidad y seguridad industrial,
aprobado por el Real Decreto 2200/1995, de 28 de diciembre.

1.5.3. Legislación de ámbito autonómico.

• Decreto 73/2012, de 22 de marzo, por el que se aprueba el
Reglamento de Residuos de Andalucía.

1.5.4. Normas.

• UNE-EN ISO 10218-1:2012. Robots y dispositivos robóticos.
Requisitos de seguridad para robots industriales.
• UNE-EN 55024:2011. Equipos de tecnología de la información.
Características de inmunidad. Límites y métodos de medida.

18
1.6. Requisitos de diseño.
1.6.1. Requisitos del Hardware.
Los requisitos de hardware que debe cumplir el sistema empotrado son:
✓ Conexión vía USB para la comunicación entre la placa controladora y
computador.

✓ Poseer entradas analógicas para los sensores externos que tomaran
información del ambiente.

✓ Conexión para la pantalla de la interfaz con protocolo I2C.

✓ Poseer entradas digitales para la botonera perteneciente a la interfaz.

✓ Poseer salidas tanto para poder conectar electroválvulas, como para
conectar indicadores.

1.6.2. Requisitos del Software.
Los requisitos necesarios para el Software son:
✓ El entorno de programación deberá ser compatible con la familia de
microcontroladores stm32.

✓ EL entorno debe ser capaz de trabajar con FreeRTOS, es decir,
multitareas en tiempo real.

✓ Deberá permitir la comunicación con un computador externo usando
un protocolo UART.

✓ Tendrá que ser compatible con protocolo I2C para la comunicación
con la pantalla de la interfaz.

19
1.7. Electroválvula.
Una electroválvula es un dispositivo electromecánico empleado de forma
genérica para controlar un líquido o un gas en una instalación. En la
automatización de un sistema de riego posee un papel fundamental, ya que son
las encargadas de controlar elflujo de agua que circula por el sistema.

1.7.1. Elementos de una electroválvula.

Figura 2. Ejemplo de electroválvula.
Figura 3. Electroválvula de membrana

20
Una electroválvula está compuesta principalmente por dos partes:
❖ Una cabeza magnética formada por una bobina, tubo, culata, anillo
desfasado y resortes.

❖ Un cuerpo, conformado por orificios para racord, obturados por clapet,
membrana, pistón, etc. Dependiendo del tipo de válvula utilizada.
Se describirá brevemente los elementos vistos en la figura anterior,
correspondientes a una válvula de membrana, para una mayor comprensión.
A saber:
▪ Anillo de desfasado, situado en la parte inferior de la culata por encima
del núcleo móvil y que sirve en corriente alterna para limitar las
vibraciones. Las versiones en corriente continua pueden no llevar anillo
de desfasado.

▪ Bobina, es la encargada de crear un campo magnético, compuesta por
un cilindro de hilos de cobre enrollado y aislado. La bobina se mantiene
en posición en el tubo mediante un clip.

▪ Clapet, su función es cerrar el orificio principal de forma estanca.

▪ Tapón roscado, pieza generalmente atornillada que contiene la cabeza
magnética y permite la adaptación directa en una tapa o en un cuerpo de
válvula.

▪ Tapa, fijada con tornillos en ciertas válvulas para sujetar las piezas
internas.

▪ Culata, peso metálico situado en el extremo del tubo que tiene como
función mejorar el campo magnético durante el funcionamiento.

▪ Guarniciones de estanquidad, conjunto de elementos que aseguran la
estanquidad del cuerpo de válvula.

▪ Núcleo, elemento desplazado por la fuerza electromagnética.

▪ Orificio calibrado, asegura el cierre de la electroválvula mediante
presencia permanente de la presión de entrada.

▪ Orificio piloto, situado en el centro de la membrana, se cierra por la
guarnición de estanquidad montada en el núcleo.

▪ Porta-clapet, parte accionada por el núcleo móvil y que contiene el clapet.

▪ Resorte de clapet, se monta sobre el núcleo y asegura un cierre positivo
del clapet.

21
▪ Resorte de núcleo, resorte que mantiene la posición del núcleo móvil en
ausencia de alimentación de la bobina.

▪ Asiento, parte del cuerpo de válvula en la que la guarnición del clapet
asegura la estanquidad.

▪ Tubo, Sirve de guía al núcleo móvil que se desplaza por la fuerza
electromagnética genera por la bobina.
1.7.2. Funcionamiento.
La válvula, a diferencia de una de accionamiento manual, es gobernada por
un solenoide que no deja de ser más que una bobina.
la membrana se apoya en el cuerpo de la válvula con la ayuda del muelle, y
evita que el agua pase por la presión que ella misma ejerce y que está
unificada tanto en la parte inferior como en la superior.
Cuando el solenoide recibe una señal eléctrica, genera un campo magnético
impulsando el núcleo. De esta manera, queda un pequeño orificio en la tapa
liberando el agua de la cámara superior. Se consigue cambiar la presión
liberando el orificio principal permitiendo que la entrada y salida de la válvula
se comuniquen.

Figura 4. Funcionamiento de una electroválvula asistida.

22
1.7.3. Tipos de electroválvulas.
Existen diferentes tipos de electroválvulas en función de la forma en la que
se activa el solenoide o características internas que difieren de los demás.
o Sencillas. Pueden ser normalmente abierta o cerrada. Ante la
ausencia de excitación del solenoide, las abiertas permanece la
válvula cerrada y las cerradas quedan abiertas. Su uso se limita para
jardines, pequeños electrodomésticos como lavadoras, etc.

o Asistidas. también llamadas hidráulicas, se caracterizan en que el
solenoide no controla la válvula de forma directa si no que controlan
una válvula secundaria. Para activar la válvula principal depende de la
presión del propio líquido. Si la presión es muy grande puede abrirse
sin la actuación del solenoide por lo que su uso es recomendable en
sistemas de riego con salida directa a la presión atmosférica.

o Membrana. Es el tipo de electroválvula más común para riego. Su
funcionamiento radica en la presión que ejerce el agua sobre una
membrana flexible.

o Globo. No son habituales y su sistema de apertura y cierre funciona
mediante el giro manual de una maneta, dando una respuesta de hasta
0.5 segundos.

o Motorizadas. Se consideran más una válvula motorizada que una
electroválvula motorizada. Poseen un programador integrado y se
acciona por un motor. Las electroválvulas en cambio funcionan con
mecanismos hidráulicos. La principal ventaja de éstas es que no
dependen del flujo del agua para funcionar, pudiendo trabajar en
tuberías sin presión.
También podemos encontrar diferentes electroválvulas según la forma en la que
se alimente el solenoide, pudiéndose encontrar electroválvulas alimentadas a 24
v AC, 9 V DC o incluso a pilas.

23
2. Descripción del software.
A continuación, se describirá tanto el entorno como el lenguaje de programación
utilizado para la elaboración del código necesario para este proyecto.
2.1. Lenguaje de programación.
Se entiende por lenguaje de programación al conjunto de instrucciones que
utiliza el usuario para comunicarse con el computador. La comunicación se
realiza a través de algoritmos e instrucciones que el computador entiende e
interpreta en lenguaje máquina.
Cada lenguaje posee un conjunto único de palabras claves y una sintaxis
especial para organizar y estructurar las instrucciones del programa.
2.1.1. Tipos de lenguaje de programación.
Los lenguajes de programación pueden clasificarse en tres grandes grupos:
➢ Lenguaje de bajo nivel. Están diseñados para un hardware específico por
lo que no pueden exportarse a otros computadores. Sacan el máximo
provecho al sistema para el que fueron diseñado. Algunos ejemplos
serían el ensamblador y código máquina.

➢ Lenguaje de alto nivel. Diseñados para ser un lenguaje universal, pueden
utilizarse sin tener en cuenta la arquitectura del hardware, siendo así
posible utilizarse en diferentes sistemas. Los hay de propósito general y
específicos. Python o C# serían un claro ejemplo.

➢ Lenguaje de medio nivel. Son lenguajes que combinan características de
los dos anteriores. Permiten operaciones a alto nivel y a la vez la gestión
local de la arquitectura del sistema. El lenguaje C podría ser un ejemplo.
2.1.2. Lenguaje C.
El lenguaje de programación C fue creado por Brian Kernighan y Dennis
Ritchie a mediados de los años 70. Recibió el nombre de C simplemente
por una cuestión alfabética, ya que sustituyó a sus lenguajes
predecesores B y BCPL que codificaban la minicomputadora PDP-7.
El desarrollo del lenguaje C toma protagonismo para la creación del
sistema operativo UNIX que llevarían consigo los nuevos
minicomputadores PDP-11, primeros en conectar el procesador, los
periféricos y la memoria entre sí mediante un BUS bidireccional.

2.1.2.1. Características del lenguaje.
Algunas de las características de este lenguaje son:
✓ Es un lenguaje estructurado.

✓ Se puede considerar un lenguaje de nivel medio.

✓ Se puede migrar a otros sistemas, no depende del hardware.

✓ Se utiliza para objetivos generales, pudiendo programas un sistema
operativo o un juego.

✓ Permite control absoluto de todo lo que sucede en el computador.

✓ Conjunto reducido de palabras claves. Pero a su vez es rico en tipo de
datos, operadores y variables.

✓ Acceso a memoria de bajo nivel, mediante punteros.

✓ Los programas son producidos de forma rápida y son potentes.

✓ El uso de Librerías que dotan al lenguaje de múltiples funciones ya
definidas facilitando la programación.Figura 5. Consola de un pdp11.

25
2.1.2.2. Sintaxis.
La sintaxis en C es una serie de reglas y procesos que lideran la estructura de
un programa. Estas reglas tienen que ser entendidas por el compilador para que
se pueda crear un programa en C válido, es decir, tienen que establecer cómo
comienza una línea de código en C, cómo termina o cuándo usar, por ejemplo,
comillas o llaves.
El lenguaje en C hace distinción entre mayúsculas y minúsculas siendo este el
motivo por el que se programa en minúsculas. La sintaxis básica determina la
forma en que se agrupan los caracteres para formar tokens, que son la unidad
mínima de programación en C.

Figura 6.Sintaxis de lenguaje C para un PIC.

26
2.2. Entorno de programación.
El entorno de programación es un conjunto de programas que recogen todas
las tareas necesarias para poder desarrollar un programa o aplicación. Estas
tareas son principalmente:
• Edición del programa.
• Compilación y enlazado.
• Ejecución.
• Depuración.
2.2.1. Editores.
Un editor es un programa que nos permite escribir las instrucciones del
programa y posteriormente guardarlo en un fichero en una unidad de
almacenamiento. Cualquier editor de texto se puede utilizar para editar
programas teniendo en cuenta que a la hora de guardarlo se hará sin ningún
tipo de formato, es decir, estilo de la letra, etc.
2.2.2. Procesadores del lenguaje.
Después de editar el programa, es necesario procesarlo y transformarlo en
instrucciones que pueda entender el computador. Estas instrucciones deben
estar en el único lenguaje entendible por un computador, el código máquina.

Figura 7. Equivalencia código máquina y ensamblador.

27
Dentro de los procesadores de lenguaje destacan:
o Compilador. Programa encargado de transformar un programa escrito en
un lenguaje de programación a código máquina. De esta forma se genera
un programa entendible por el computador sin la necesidad de la
intervención de un compilador.

o Intérprete. Es un programa que convierte línea a línea el programa escrito
en un lenguaje de programación y a la vez ejecuta las instrucciones. El
intérprete no devuelve nada ya que la ejecución se realiza de forma
simultánea.

o Traductor. Es un programa que convierte un lenguaje de programación a
otro sin generar código máquina.
2.2.3. Enlazadores.
De forma genérica, durante la escritura de un programa es necesario utilizar
otros subprogramas en forma de bibliotecas de funciones o bien que el propio
programa esté formado por varios programas almacenados en diferentes
ficheros. Esta situación hace que durante la compilación de cada módulo no se
conozca con exactitud la ubicación de las instrucciones del resto de programas
o bibliotecas de funciones.
La función del enlazador es unir en un único fichero ejecutable el resultado de
todas las compilaciones, así como las bibliotecas de funciones. Es frecuente que
el enlazado sea un paso más de la compilación y que se ejecute inmediatamente
tras la compilación de todos los ficheros.
2.2.4. Depuradores.
Una vez editado y compilado el programa es necesario ejecutarlo, pero es
habitual que durante el desarrollo de un programa que genera ficheros
ejecutables, aunque sean correctos desde un punto de vista sintáctico, no
realicen lo que realmente se espera de ellos por lo que se consideran que no
funcionan correctamente.
Los depuradores son capaces de ejecutar el programa paso a paso incluyendo
además un conjunto de utilidades que permiten observar el valor de las variables
y estructuras de datos permitiendo así una mejor localización de errores no
evidentes.

28
2.2.5. STM32CubeIDE

Es una herramienta de desarrollo integrada multifuncional, que integra
TrueSTUDIO y STM32CubeMX. Es una plataforma de desarrollo C / C ++
avanzada, con configuración de microcontrolador STM32, generación de código,
compilación de código y funciones de depuración.
El entorno de desarrollo es el popular Eclipse que integra al compilador GCC, lo
que se conoce como un “toolchain”. Posee un generador gráfico de código que
nos permite inicializar todos los periféricos y bloques del micro de una manera
visual, un depurador que nos permite ejecutar el programa por pasos,
inspeccionar variables y establecer “breakpoints” entre otras funciones.
También incluye una herramienta de selección de micros y documentación que
nos permite elegir el micro apropiado para nuestro proyecto, acceder a toda la
documentación, ejemplos, comunidades de usuarios, etc.
2.2.5.1. STM32CubeMX
STM32CubeMX es una herramienta gráfica que permite una configuración muy
sencilla de microcontroladores y microcontroladores STM32, así como la
generación del código C de inicialización correspondiente para el núcleo Arm
Cortex-M o una rama de dispositivos Linux® para el núcleo Arm Cortex-A®, a
través de un proceso paso a paso.
Las características más destacadas de esta herramienta son:
✓ Selección de microcontroladores y microcontroladores STM32.

✓ Una interfaz gráfica fácil de usar para el usuario que permite la
configuración de:

Figura 8.Presentación STM32CubeIDE

▪ Pinout con resolución automática de conflictos
▪ Modos funcionales de periféricos y middleware con validación
dinámica de restricciones de parámetros para el núcleo Arm
Cortex-M.
▪ Árbol de reloj con validación dinámica de configuración.
▪ Secuencia de potencia con resultados de consumo esperado.

✓ Inicialización del proyecto de código C compatible con STM32CubeIDE.

2.2.5.2. TrueSTUDIO.
Atollic TrueSTUDIO es un IDE de C/C++ basado en Eclipse, CDT, GCC y GDB.
La herramienta proporciona a los desarrolladores potentes extensiones
profesionales, características y utilidades para un proceso de desarrollo fácil y
eficiente.
Las actualizaciones se suspendieron desde 2017, pero todas sus características
principales se incluyen en la herramienta de desarrollo STM32CubeIDE, que
incluye la depuración de FreeRTOS. Además de la amplia selección de
características y productos compatibles, STM32CubeIDE incluye las
características más avanzadas de TrueSTUDIO y correcciones de errores que
contribuyen a un proceso simplificado con características del proyecto y
documentación de la guía de importación.

Figura 9.Interfaz gráfica STM32CubeIDE.

30
2.2.6. Putty.
Es un cliente que permite la conexión con una maquina por medio de Raw, Serial,
Telnet, Rlogin o SSH. Nos permite conectarnos a una maquina no solo de
manera remota, que sería el uso más común a esta aplicación, si no también
puede hacer conexiones por Serial.
Como aplicación a este proyecto, será utilizado por Serial para la comunicación
con el sistema empotrado para mostrar información relevante como se ha
descrito en puntos anteriores.
La comunicación se lleva a cabo de una manera muy sencilla. En el desplegable
de la izquierda seleccionado Sesión, accederemos a la pantalla mostrada en la
figura siguiente.

Posteriormente, en tipo de conexión se seleccionará Serial. En el apartado
velocidad colocaremos la velocidad de comunicación previamente establecida
en STM32CubeIDE en su apartado UART, como se verá más adelante.
Finalmente hay que identificar en que puerto se encuentra conectado la placa
STM32 y definirlo en el apartado Serial line.
El puerto en el que se encuentra conectado, en el caso de usar la aplicación en
Windows, se puede identificar en administrados de dispositivos en el apartado
puerto serie.

Figura 10.Menú de configuración de Putty.

31
3. Descripción del Hardware.
En este apartado se mencionarán todos los componentes utilizados en la
elaboración de este proyecto. También se hará una descripción de cada uno deellos incluyendo la placa controladora con su núcleo de la familia STM32.
3.1. Placa STM32.
La placa utilizada es de la familia STM32. Ésta proporciona una forma fácil y
flexible de crear proyectos pudiendo elegir entre las distintas combinaciones de
características de rendimiento y consume de energía, proporcionadas por el
microcontrolador.
Para las placas compatibles, el SMPS externo reduce significativamente el
consumo de energía en el modo de ejecución y además integra el
depurador/programador ST-LINK.
Algunas de las características destacables de la placa son:
✓ Microcontrolador STM32 en paquete LQFP64 o LQFP48.
✓ 1 LED disponible para el usuario y un botón de reinicio.
✓ Oscilador de cristal de cuarzo de 32,768 KHz.
✓ Pines de extensión ST morpho para acceso a todas las E/S STM32.
✓ Se puede alimentar por ST-LINK USB o fuentes externas.
✓ Depurador/programador ST-LINK integrado con función de
almacenamiento masivo, puerto COM virtual y puerto de depuración.
✓ Compatibilidad con una amplia selección de entornos de desarrollo,
incluido IAR Embedded Workbench, MDK-ARM y STM32CubeIDE.

Figura 11.Placa STM32.

32
3.1.1. Microcontrolador.
El microcontrolador utilizado en este proyecto es el STM32F070RB. Incorpora el
núcleo RISC arm Cortex-M0 de 32 bits de alto rendimiento que funciona a una
frecuencia de 48 MHz, memorias integradas de alta velocidad (hasta 128 Kbyte
de memoria Flash y hasta 16 Kbyte de SRAM) y una amplia gama de periféricos
y E/S mejorados.
Funciona en el rango de temperatura de -40 a +85 °C de una fuente de
alimentación de 2,4 a 3,6 V. Un conjunto completo de modos de ahorro de
energía permite el diseño de aplicaciones de bajo consumo.
A continuación, se mostrarán algunas de las características las relevantes de
este microcontrolador:
✓ Frecuencia de hasta 48 MHz.

✓ 32 a 128 Kbytes de memoria Flash.

✓ Modos de bajo consumo: suspensión, parada, modo de espera.

✓ Gestión del reloj
• Oscilador de cristal de 4 a 32 MHz.
• Oscilador de 32 kHz para RTC con calibración.
• RC interno de 8 MHz con opción x6 PLL.
• Oscilador RC interno de 40 kHz

✓ Hasta 51 E/S rápidas, mapeables en vectores de interrupción externos.

✓ 11 Timers incluyendo Systick.

✓ Un ADC de 12 bits con hasta 16 canales.

• Rango de conversión de 0 a 3,6V.
• Suministro analógico separado de 2,4 a 3,6V.

✓ Calendario RTC con alarma y activación periódica desde Stop/Standby.

✓ Hasta dos interfaces I2C.

✓ Hasta cuatro USART compatibles con SPI.

✓ Hasta dos SPI (18 Mbit/s) con 4 a 16 tramas de bits programables
Estas características hacen que el microcontrolador STM32F070RB sea
adecuados para una amplia gama de aplicaciones, como control de
aplicaciones e interfaces de usuario, equipos portátiles, receptores A/V y TV
digital, periféricos de PC, plataformas de juegos y GPS, aplicaciones
industriales, PLC, inversores, impresoras, escáneres, sistemas de alarma,
videoporteros y HVAC.

3.2. Pantalla OLED.
La pantalla es unos de los componentes que conforman la interfaz por la cual el
usuario puede consultar una variedad de información, como por ejemplo la
temperatura.

Sus dimensiones son de 0.96 pulgadas y su resolución máxima de 128x64
píxeles. Se puede encontrar en varios colores de visualización, pero la escogida
para el proyecto es amarillo y azul.

Figura 12. Diagrama STM32F070RB.
Figura 13.Pantalla OLED.

34
Es una pantalla OLED, esto significa que está compuesta por diodos orgánicos
de emisor de luz capaces de consumir muy poca energía. Son pantallas muy
delgadas, se comunican por I2C o por SPI y producen una imagen más brillante
y nítida que una pantalla LCD. Otra de las ventajas del OLED frente al LCD es
que no requiere luz de fondo ni de filtros.
Esta pantalla utiliza un controlador conocido como es el SSD1306, se trata de un
controlador potente OLED CMOS. De lo que se encarga este controlador es de
la comunicación con el microcontrolador, en este caso STM32 F070RB, para
obtener los datos y enviarlos a la pantalla para que los dibuje.
La comunicación entre el SSD1306 y el microcontrolador se establece mediante
I2C o SPI. LA comunicación SPI es más rápida pero también requiere más pines
que la I2C.
La alimentación del SSD1306 y la de la Pantalla son deferentes a pesar de estar
incluido todo en un mismo módulo.
➢ Voltaje SSD1306: 1,65V a 3,3V.
➢ Voltaje Pantalla: 7V a 15V
Esta diferencia de voltaje es posible gracias a los dobladores de tensión y los
circuitos de bomba de carga que permiten obtener valores de tensión superiores
a los de alimentación. Además, esta pantalla incluye un regulador de tensión o
LDO. Este regulador permite un voltaje de entrada de entre 1,8V y 6V
manteniendo un valor de salida estable a 3,3V.
Gracias a esta electrónica se puede alimentar la pantalla a 3,3V o a 5V, ambas
tensiones pueden ser suministrada por la placa STM32.

Figura 14.Regulador de tensión.

35
3.2.1. Conexionado.
Esta pantalla utiliza el protocolo I2C para comunicarse con el microcontrolador,
por lo que posee 4 pines de conexión.

o VCC: pin de alimentación. Rango entre 1,8V y 6V.
o GND: pin de tierra.
o SDA: pin correspondiente a la señal de datos del I2C.
o SCL: pin correspondiente a la señal de reloj del I2C.
3.2.2. Visualización de gráficos.
Para mostrar los datos en pantalla, el controlador SSD1306 posee una memoria
RAM gráfica denominada GDDRAM de 1KB de capacidad. Esto equivale a 1024
bytes y a 8192 bits que se distribuyen en una matriz de filas, páginas, y columnas,
segmentos.

Figura 15. Conexiones pantalla.
Figura 16. Matriz de visualización.

36
En total hay 8 páginas, cada página posee 128 segmentos y cada segmento
puede almacenar 1 byte. Por lo tanto, se tiene una matriz de 128 columnas y 64
filas. Cada byte representa un pixel y programándolo correctamente se puede
conseguir controlar cada pixel para encenderlo o apagarlo y así muestre la
información que se desee.
3.2.3. I2C.
Es un protocolo de comunicación serial, define la trama de datos y las
conexiones físicas para transferir bits entre dos dispositivos. Se usan dos cables
para la comunicación SDA y SCL como ya se ha comentado anteriormente.
Este protocolo permite conectar hasta 127 dispositivos con esas dos líneas
llegando a velocidades de 100, 400 y 1000 Kbits/s.
Es un protocolo muy usado en la comunicación con sensores puesto que, a
diferencia de la comunicación serial, su arquitectura permite confirmación de los
datos recibidos entre otras ventajas. La conexión de tantos dispositivos al mismo
bus es una de las principales ventajas. Además, si comparamos el protocolo I2C
con otro protocolo, como Serial TTL, este incluye más bits en su trama de
comunicación que permite enviar mensajes más completos y detallados.
3.2.3.1. Esquema de comunicación.

En la comunicación se diferencian dos elementos básicos, un dispositivo
maestro y un esclavo. La Figura 17 muestra una conexión típica de tres
dispositivos. El bus consiste en dos líneas, SDA y SCL. En particular al bus se
conectan dos resistencias en pull-up, de entre 2.2K y 10K.

Figura 17.Esquema I2C.

37
El dispositivo maestro se encarga de controlar la señal de reloj (SCL), además
de iniciar y parar la comunicación. La información se envía sólo por la línea de
datos (SDA). Dos maestros no pueden hacer uso del mismo cableado. Puede
funcionar de dos maneras, como maestro-transmisor o maestro-receptor.
El dispositivo esclavo suministra la información de interés al maestro. Puede
actuar de dos formas, esclavo-transmisor y esclavo-receptor. Un esclavo no
puede generar señal de reloj (SCL).3.2.3.2. Bits de la trama.
En la comunicación I2C se utiliza una trama conformada por los siguientes bits:
• Inicio (S).
• Parada (P).
• Confirmación (ACK).
• No confirmación (NACK).
• Lectura/escritura (L/W).
• 7 bits para la dirección del dispositivo maestro o esclavo.
• 8 bits de dirección, algunos sensores son hasta 16 bits.
• 8 bits de datos.

El conjunto de estos bits y su orden va formando distintas tramas de
comunicación. Existen distintos modos de comunicación dependiendo del
arreglo de estos bits.
El puerto I2C está disponible si las dos líneas, SDA y SCL están en un nivel
lógico alto.

Figura 18. Ejemplo trama I2C.

38
3.2.3.3. Modos de comunicación.
Los modos de comunicación hacen referencia a las distintas tramas que pueden
formarse. Estas tramas o modos dependen de, por ejemplo, si queremos leer al
sensor esclavo, o si lo queremos configurar. Existen principalmente dos modos
de comunicación:
▪ Maestro-Transmisor y Esclavo-Receptor. Este modo se usa cuando se
desea configurar un registro del esclavo.

▪ Maestro-Receptor Y Esclavo-Transmisor. Se usa cuando queremos leer
información del sensor.
3.3. Botonera.
Otro de los elementos perteneciente a la interfaz física del sistema empotrado
es la botonera. Está conformada por pulsadores con los cuales se puede navegar
a través de la configuración.
3.3.1. Pulsador.
Un pulsador es un elemento eléctrico que impide o permite el paso de corriente
eléctrica cuando se pulsa. Se mantiene cerrado o abierto mientras el usuario lo
presione, al soltarlo vuelve a su posición inicial de reposo.
El paso de corriente se consigue mediante contactos eléctricos llamados bornes.
Los pulsadores poseen dos posiciones:
• Cerrado: los bornes están en contacto permitiendo el paso de corriente.
• Abierto: los bornes están separados impidiendo el paso de corriente.

Existen diferentes tipos de pulsadores que se pueden clasificar según su
funcionamiento:
Figura 19. Funcionamiento de un pulsador

39
✓ Normalmente abierto (NA): en su posición de reposo, es decir sin actuar
sobre él, los contactos eléctricos están separados por lo que no hay paso
de corriente.

✓ Normalmente cerrado (NC): en su posición de reposo los bornes están en
contacto permitiendo el paso de corriente por ellos.

✓ De varios contactos: es un pulsador que, en lugar de solo tener un
contacto abierto o cerrado, posee varios que en la posición de reposo no
tienen por qué ser iguales.

Para este proyecto se han utilizado cuatro pulsadores correspondientes al
incrementar y decrementar el valor numérico, ya sea de la fecha, la hora, etc.
Otro pulsador encargado de confirmar el valor para ir avanzando por la
configuración y que hará también la función de mostrar información. Por último,
un pulsador de menú que será utilizado para acceder a la configuración de la
frecuencia del riego.

Figura 20. Tipos de pulsadores.
Incrementar
Decrementar Confirmar
Menú
Figura 21. Botonera.

40
3.3.1.1. Circuito antirebote.
Generalmente en los elementos mecánicos de contactos, como es el caso de un
pulsador, el cambio de nivel lógico se produce con lo que se denomina rebote.
Estos rebotes no son más que impulsos transitorios de corta duración y que en
muchos circuitos son detectados como pulsaciones no deseadas.

Este problema puede solventarse mediante una solución software, con una serie
de retardos y lecturas del estado del pulsador se desecha esas pulsaciones no
deseadas. Pero en ocasiones no es suficiente o no del todo preciso según la
aplicación por lo que se recurre a una solución hardware llamada circuito
antirebote.
Este circuito filtra estas fluctuaciones indeseadas de cambio de nivel en el
pulsador generando una transición de la señal limpia, pasando de un estado alto
a bajo o viceversa. Se consigue esta filtración de la señal colocando un
condensador en paralelo a la salida del pulsador. En este caso se ha utilizado un
condensador de 1 µF y una resistencia de 10KΩ para cada pulsador.

Figura 22. Rebotes del pulsador.
Figura 23. Circuito antirebote.

3.4. Electroválvula.
En este apartado se describirá brevemente la electroválvula escogida para la
realización de este proyecto. No se ha realizado pruebas con ella ya que se ha
centrado el trabajo en la etapa de control.

La electroválvula es de la marca Rain, modelo RN 150 24VAC.

3.4.1. Características técnicas.
A continuación, se nombrarán las características más significativas de la
electroválvula citada:
▪ Solenoide estándar alimentado a 24 V.
▪ Apertura manual a través del solenoide mediante ¼ de vuelta.
▪ Presión mínima de 1 bar y máxima de 12 bares.
▪ Caudal soportado de 20 l/min a 50 l/min.
▪ No posee regulador de caudal.
▪ Diafragma de una sola pieza para un cierre fiable de válvulas sin fugas.
▪ Indicada para su uso en aguas limpias.
▪ Elaborada en nylon y fibra de vidrio.
▪ Certificación IP 68 9 PN12 resistiendo hasta 14 bares.

Figura 24. Electroválvula RN 150.

3.5. Montaje del circuito.
En este apartado se mostrará las conexiones de todos los elementos que
conforman el sistema empotrado. Cabe destacar que, debido a la naturaleza de
este proyecto, se realizará las conexiones utilizando de apoyo una protoboard
ya que sería un prototipo.
Otro aspecto para tener en cuenta es que se obviará la etapa de potencia
necesaria para alimentar tanto el sistema empotrado como la electroválvula
debido a dos factores:
➢ La alimentación del sistema empotrado sería de 5 V por lo que con un
transformador básico quedaría resuelto.

➢ La alimentación de la electroválvula ya quedaría resuelta en el cuadro
eléctrico para un control manual, ya contemplado con anterioridad y
motivo del desarrollo de este proyecto.
Para las conexiones se han utilizado:
o Las entradas D3 – D6 para la lectura de los botones.

o Las entradas D15 (SCL) y D14 (SDA) para la conexión I2C de la pantalla.

o La entrada analógica A0 para la lectura del sensor de temperatura.

o Las salidas de alimentación de 3,3 V y GND para todos los elementos.

Sensor
Alimentación
Pantalla Botonera
Circuito
antirebote
Figura 25. Montaje del circuito.

43
4. RTOS.
Los “RTOS” son sistemas operativos en tiempo real ligero que se utilizan para
facilitar la multitarea y la integración de tareas en diseños con recursos y tiempo
limitados, como es en el caso de los sistemas integrados. Además, el término
"tiempo real" indica previsibilidad y determinismo en el tiempo de ejecución más
que velocidad bruta.
4.1. Tarea.
Las tareas son funciones independientes que se ejecutan en bucles infinitos,
normalmente cada una responsable de una función. Las tareas se ejecutan de
forma independiente en su propio tiempo (aislamiento temporal) y pila de
memoria (aislamiento espacial).
El aislamiento espacial entre las tareas puede garantizarse con el uso de una
unidad de protección de memoria por hardware (MPU), que restringe la región
de memoria accesible y desencadena excepciones de fallo en caso de violación
de acceso. Normalmente, los periféricos internos están mapeados en la
memoria, por lo que se puede utilizar una MPU para restringir el acceso a los
periféricos también.
Las tareas pueden tener diferentes estados:
• Bloqueado: la tarea está esperando un evento (por ejemplo, tiempo de
espera, disponibilidad de datos o recursos).
• Listo: la tarea está lista para ejecutarse en la CPU, pero no se está
ejecutando porque la CPU está siendo utilizada por otra tarea.
• En ejecución: la tarea está asignada para ser ejecutada en la CPU.
4.1.1. Comunicación entre tareas.
Normalmente, las tareas tendrán que compartir información o eventosentre sí.
La forma más sencilla de compartir es leer y escribir directamente las variables
globales compartidas en la RAM, pero esto no es deseable debido al riesgo de
corrupción de datos causado por una condición de carrera. La forma más limpia
es utilizar objetos RTOS seguros para hilos, como la cola de mensajes, para
pasar información entre tareas.
Además de compartir información, los objetos RTOS también son capaces de
sincronizar la ejecución de tareas, ya que éstas pueden bloquearse para esperar
la disponibilidad de los objetos RTOS. La mayoría de los RTOS tienen objetos
como:
➢ Cola de mensajes: Cola de entrada y salida (FIFO) para el paso de
datos, estos datos pueden enviarse por copia o referencia (punteros). Se
utilizan para enviar datos entre tareas o entre una interrupción y tarea.

➢ Semáforo: se puede tratar como un contador de referencia para
registrar la disponibilidad de un determinado recurso. Pueden ser

44
binarios o de conteo y se utilizan para vigilar el uso del recurso o
sincronizar la ejecución de tareas.

➢ Mutex: similar al semáforo binario, se utiliza generalmente para proteger
el uso de un solo recurso (exclusión mutua). El mutex de FreeRTOS
viene con un mecanismo de herencia de prioridades para evitar el
problema de la inversión de prioridades (condición en la que una tarea
de alta prioridad termina esperando a otra de menor prioridad).

➢ Buzón: puede considerar como una cola de un solo elemento. Almacén
simple para compartir una sola variable.

➢ Grupo de eventos: grupo de condiciones (disponibilidad de semáforo,
cola, banderas, etc.). Las tareas pueden bloquearse o esperar a que se
cumpla una combinación específica de condiciones. Se puede encontrar
en FreeRTOS como QueueSets.
4.2. Programador.
Los programadores en los RTOS son los encargados de controlar qué tarea debe
ejecutarse en la CPU y existen diferentes algoritmos de programación.
Estos algoritmos pueden ser de carácter:
o Preventivo: la ejecución de la tarea puede ser interrumpida si otra tarea
con mayor prioridad está lista.
o Cooperativo: el cambio de tarea solo se producirá si la tarea que se está
ejecutando en ese momento se rinde.
La programación preventiva permite que las tareas de mayor prioridad
interrumpan a las de menor prioridad para cumplir con las restricciones de tiempo
real, pero tiene el costo de una mayor sobrecarga en el cambio de contexto.
4.3. Tic del sistema.
Los RTOS necesitan una base de tiempo para medir el tiempo, normalmente en
forma de una variable de contador de tics del sistema que se incrementa en una
interrupción periódica del temporizador de hardware. Con el tic del sistema, una
aplicación puede mantener más de un servicio basado en el tiempo (intervalo de
ejecución de la tarea, tiempo de espera, corte de tiempo) utilizando un solo
temporizador de hardware. Sin embargo, una tasa de tic más alta solo aumentará
la resolución de la base de tiempo del RTOS, no hará que el software se ejecute
más rápido.

45
4.4. Ventajas de los RTOS.
Algunas de las ventajas más significativas del uso de los RTOS son:
✓ Organización. A medida que aumenta la complejidad del código, tener
algún tipo de estructura ayudará a gestionar las diferentes partes de la
aplicación, manteniéndolas separadas. Además, con un modo de
desarrollo estructurado y un lenguaje de diseño familiar, un nuevo
miembro del equipo puede entender el código y empezar a contribuir
más rápidamente.

✓ Modularidad. Separando las funciones en diferentes tareas se pueden
añadir fácilmente nuevas funciones sin romper otras, siempre que la
nueva función no sobrecargue los recursos compartidos como la CPU y
los periféricos. El desarrollo sin RTOS se encontrará normalmente en un
gran bucle infinito en el que todas las funciones forman parte del bucle.
Un cambio en cualquier característica dentro del bucle tendrá un impacto
en otras características, lo que hace que el software sea difícil de
modificar y mantener.

✓ Pilas de comunicación y controladore. Muchos controladores o pilas
adicionales como TCP/IP, USB, pilas BLE y bibliotecas gráficas se
desarrollan para los RTOS existentes. Un desarrollador de aplicaciones
puede centrarse en una capa de aplicación del software y reducir el
tiempo de comercialización de forma significativa.
5. Programación.
En este apartado se describirá la programación realizada en el entorno de
programación STM32CubeIDE. Se dividirá en dos grandes bloques, uno
correspondiente a la configuración del propio STM32CubeIDE relacionada con
la asignación de patillas, configuración de reloj, RTOS, etc.; y otro bloque
destinado al código.
5.1. Configuración STM32CubeIDE.
Como se ha mencionado anteriormente en este apartado se describirá las
distintas partes configuradas dentro del entorno de programación para el
correcto funcionamiento del programa.
5.1.1. Configuración del reloj.
Para el correcto funcionamiento del sistema en tiempo real y actualizado, se
necesita configurar el reloj del sistema. Para ello en Clock Configuration y
utilizaremos la fuente de reloj externa llamada LSE que proporciona una
frecuencia de 32768 kHz.

Figura 26. Configuración Reloj 1.
Figura 27. Configuración reloj 2.

47
Una vez configurado, en System Core - RCC en el apartado LSE habrá que
seleccionar Crystal/Ceramic Resonator.
Posteriormente en el apartado Timers – RTC se tendrá que activar el
calendario para poder tomar la fecha y hora actual, además de configurar el
divisor de escala para obtener correctamente la frecuencia a 1Hz obteniendo
así un periodo de tiempo de un segundo.

5.1.2. RTOS. Tareas, colas y semáforos.
Para la programación se ha decidido usar una estructura de sistema operativo
en tiempo real (RTOS). Como se ha descrito en el punto anterior, los RTOS se
basan en una serie de objetos los cuales usan las tareas para comunicarse
entre ellas enviando datos o controlando la prioridad entre ellas.
Para este proyecto se ha necesitado usar dos de los objetos anteriormente
mencionados: colas y semáforos binarios. También se han utilizado una serie
de tareas que en conjunto con las colas y semáforos conforman el RTOS de
este proyecto.
Dentro del apartado FreeRTOS – Tasks and Queues es donde se agregaron
las tareas y colas que se vieron necesarias para el desarrollo de este proyecto.
En el apartado Timers and Semaphores se encuentran los semáforos
utilizados.

Figura 28. Prescalers según el reloj.

Figura 29. Tareas y colas.
Figura 30. Semáforos.

49
5.1.2.1. Diagrama de bloques.
Para una mayor compresión de cómo se relacionan las tareas en conjunto con
las colas y semáforos, se ha desarrollado un diagrama de bloques que
representa el flujo de datos entre las tareas e interrupciones y además las
prioridades impuestas por los semáforos cuando estos son tomados por las
distintas tareas.

Figura 31. Diagrama de bloques.

50
5.1.3. Configuración de los pines.
Para este proyecto, y como ya se mencionó en el apartado de Hardware, se
han necesitado varios puertos de funcionalidad diversas. Entra estas
funcionalidades se encuentran:
➢ Convertidor ADC.
➢ Comunicación I2C.
➢ Comunicación UART.
➢ Salida digital.
➢ Entradas digitales.
A continuación, se mostrará la vista de pines de este proyecto.

Figura 32. Vista de pines.

51
6. Ensayos.
En este apartado se va a tratar las diferentes versiones del proyecto y los
problemas que se han presentado hasta llegar a la versión final.
6.1. Rebote en pulsadores.
En una primera instancia, al implementar los pulsadores para la navegación por
el menú del control de riego, se encontró un problema de precisión en las
pulsaciones. Esto esalgo muy común en elementos de contacto debido a la
imprecisión entre los terminales del pulsador.
El primero intento de solución fue añadir un código para corregir este fenómeno
conocido como rebotes. Este código consiste principalmente en detectar un
cambio en el flanco de entrada y con una serie de retardos comprobar
posteriormente que el flanco volvió a su estado inicial. De esta manera se evita
contabilizar los numerosos cambios de flancos detectados por la imprecisión
mecánica del pulsador.
El problema pudo corregirse de una manera insuficiente, puesto que seguía
habiendo fallos de imprecisión provocando comportamientos no deseados. El
segundo intento fue resolver esta problemática vía hardware.
Un circuito antirebote no es más que un condensador colocado en paralelo a la
a la salida del pulsador y por ende a la entrada de la placa. La función de este
condensador es la de estabilizar el nivel de entrada generado por el pulsador
filtrando todas esas pequeñas variaciones.
Mediante este método en conjunto con el código se pudo corregir por completo
este problema.
6.2. Variables globales.
Otra de las versiones de este proyecto fue abordar la programación completa del
controlador. Desde el primer momento quedó claro que se usaría un sistema
operativo en tiempo real (RTOS) para abordar la programación.
Se desarrolló satisfactoriamente las tareas que componen un RTOS y para la
comunicación entre ella se eligió el método más común y fácil que hay en
programación, las variables globales.
El uso de estas variables puede parecer en primer momento la solución más
correcta y menos dificultosa, pero pronto empezó a dar los problemas que causa
usarlas, corrupción de valores en las variables debido al acceso simultaneo o
indebido de varias funciones o tareas.
El programa funcionaba, pero no de la manera deseada e incluso se quedaba
bloqueado en ciertas zonas del Código.

52
La solución fue utilizar los objetos que utilizan las tareas en los RTOS descritos
en apartados anteriores, se implementó las colas y los semáforos.
Se emplearon colas para la comunicación entre tareas y los semáforos para
marcar quien hacia uso de esas colas sin posibilidad de conflictos.
En un principio no se usaron correctamente las colas, puesto que se deben tratar
de sentido único y se utilizaron con sentido bidireccional. Una vez corregido este
error, el programa funcionaba con fluidez y sin perdidas de información.
Hubo otro inconveniente a la hora de usar colas y es que, si varias tareas usan
las mismas colas, a la hora de esperarlas no se debe usar “osWaitForever” como
tiempo de espera ya que, aunque esa tarea no haga nada en ese momento se
quedará esperando a una cola que está vacía quedando bloqueado el programa.
6.3. Utilización de electroválvulas.
Debido al carácter de prototipo de este proyecto, la activación de una
electroválvula no se ha llevado a cabo. En su lugar se ha utilizado, para indicar
que la salida se activa en las condiciones favorables, un indicador luminoso.
La implementación de una electroválvula en este proyecto hubiese acarreado el
diseño de un transformador 220/24 v en corriente alterna para la alimentación de
estas. También sería necesario un relé en lugar de un indicador luminoso para
usarlo como conmutador.
Un relé no es más que un elemento eléctrico capaz de controlar corrientes
grandes, en este caso la de corriente alterna, con una corriente pequeña
suministrada por la placa controladora.

53
7. Conclusiones y proyectos futuros.
En este apartado comentaremos las conclusiones que se han podido sacar en la
realización de este proyecto, como las posibles modificaciones y ampliaciones
para mejorarlo en un futuro.
7.1. Conclusiones.
EL objetivo de este proyecto era el control inteligente y automático de un sistema
de riego. Para lograr tal objetivo se ha utilizado una placa controladora stm32
para el control de una seria de sensores e interfaces.
Se ha profundizado en la comunicación I2C y UART utilizada para la
comunicación con pantalla y computador. También se ha puesto en práctica la
conversión analógica digital utilizada para la lectura de temperatura por el
sensor.
En cuanto al entorno de programación se ha usado el stm32CubeIDE con la
implementación de RTOS para la gestión de multitareas en tiempo real,
utilizando colas y semáforos.
En este proyecto se han presentado muchas problemáticas relacionadas con
rebotes de los pulsadores y con el uso del código en ciertas situaciones que se
han podido solucionar satisfactoriamente.
Hay que recalcar que, en este proyecto se han aplicado de conocimientos
básicos de circuitos para la instalación de toda la interfaz del sistema empotrado
y se ha profundizado sobre todo en el entorno de programación, la utilización del
reloj externo, las alarmas del calendario y en la multitarea en tiempo real.
7.2. Proyectos futuros.
Al ser este proyecto un prototipo y la gran potencia y versatilidad de la placa
controladora, permite la ampliación y mejora en muchos aspectos del controlador
de riego. Algunas de estas mejoras pudieran ser:
➢ La posibilidad de incorporar un teclado numérico.

➢ El control de varias electroválvulas con su programa de riego
independiente.

➢ La posibilidad de incorporar la alimentación de la placa como de las
electroválvulas en un mismo sistema, utilizando técnicas de electrónica
de potencia como rectificadores, divisores de tensión, etc.

➢ La implementación de más sensores para obtener un control mayor del
entorno, como puede ser un sensor de humedad.

54
8. Bibliografía.

➢ DingelmePyM. Electroválvula o válvula solenoide.
< https://dingelmepym.com/electrovalvula-o-valvula-selenoide/ >
[Consulta: 30 de julio de 2022].

➢ 4 tipos de electroválvulas para riego que puedes encontrar.
<https://anphibius.com/blog/tipos-de-electrovalvulas-para-riego/>
[Consulta: 30 de julio de 2022].

➢ Editorial Etecé. Lenguaje de programación.
< https://concepto.de/lenguaje-de-programacion/ > [Consulta: 5 de
agosto de 2022].

➢ ¿Qué es el lenguaje C? <
https://www.deustoformacion.com/blog/programacion-diseno-web/que-
es-lenguaje-c > [Consulta: 5 de agosto de 2022].

➢ I2c. < https://hetpro-store.com/TUTORIALES/i2c/ > [Consulta: 10 de
agosto de 2022].

➢ Lim Jia Zhi, Senior Embedded Software Engineer. Sistemas operativos
en tiempo real (RTOS) y sus aplicaciones. <
https://www.digikey.es/es/articles/real-time-operating-systems-and-their-
applications > [Consulta: 15 de agosto de 2022].

https://dingelmepym.com/electrovalvula-o-valvula-selenoide/
https://anphibius.com/blog/tipos-de-electrovalvulas-para-riego/
https://concepto.de/lenguaje-de-programacion/
https://www.deustoformacion.com/blog/programacion-diseno-web/que-es-lenguaje-c
https://www.deustoformacion.com/blog/programacion-diseno-web/que-es-lenguaje-c
https://hetpro-store.com/TUTORIALES/i2c/
https://www.digikey.es/es/articles/real-time-operating-systems-and-their-applications
https://www.digikey.es/es/articles/real-time-operating-systems-and-their-applications