TUTORIAL Como configurar un proyecto ya hecho de Microchip para manejar una sonda por la librería SNMP con monitoreo desde NAGIOSAntes de nada he de decir que yo no soy ningún ingeniero ni nada por le estilo, soy técnico especialista en electrónica y un simple aficionado que le apasiona este mundo de los sistemas embebidos, después de pelearme con este proyecto, ha sido una pelea dura ya que el manual que proporciona Microchip es escaso y te explican las cosas como si uno mismo fuera el que inventó la librería, pues me he decidido a compartir el trabajo, e invito a cualquiera que quiera sumarse a este manual y aportar sus conocimientos, y que no quepa duda que si he cometido algún error en mis explicaciones pues corregir me.
Voy a enumerar los pasos para utilizar las librerías
TCP/IP y editar el fichero
CustomSNMPApp.c para adaptarlo a nuestro desarrollo.
La librería que estoy utilizando es la
Microchip Libraries For Applications Version: v2013-06-15 que está para su descarga en la página oficial del fabricante y se instala como cualquier programa en windows.
Una vez instalada ya podemos ver su contenido que está formada por muchas carpetas, cada una de esas carpetas hace referencia a diferentes librerías que a su vez tienen proyectos de demostración ya armados y listo para compilar, Microchip lo hace de esta manera para enseñarnos como utilizar sus librerías, a nosotros la librería que nos interesa es la
TCP/IP, en la imagen está marcado con una elipse roja
Dentro de la carpeta
TCP/IP a su vez encontrarás varios proyectos de demostración de diferentes hardwares, para las demos Microchip ha utilizado el hardware que comercializa, lógico ¿no?.
Mi consejo es que utilices uno de ellos, el que más se asemeje a tu hardware y lo adaptes a tus necesidades.
Por ejemplo, yo he utilizado un microcontrolador
PIC18F67J50 con un controlador de Ethernet
ENC28J60 que yo llamo “la tarjeta de red”, el proyecto demo que he utilizado para adaptarlo a mi hardware es el
C18-PICDN2-ENC28.mcp éste demo está pensado para utilizar un PIC18F97J60 ósea un pic de la misma familia que el que yo voy a usar.
¡¡OJO!! Antes de ponerte a la faena lo que te aconsejo es que no utilices las librerías que están instaladas por si cometes un error poder restablecer el proyecto sin tener que volver a instalarlas, yo lo que hago es copio la carpeta TCPIP y la carpeta Microchip a una ubicación nueva y trabajo sobre ella, así si la lío siempre me queda una copia limpia y original en donde se instaló la librería Ahora vas a abrir un proyecto de la librería, para ello abres el
MPLABX o
MPLAB IDE, con cualquiera valdría y con el compilador C18, estas librerías funciona con este compilador si quieres usar el XC8 ya hay que adaptarlas y eso no sé como es “
todavía”.
Para generar un nuevo proyecto desde una demo yo utilizo en MPLAB IDE, una vez abierto vas a la barra superior y seleccionamos
Project, se nos despliega una ventana y seleccionamos
Open
Se abre otra ventana donde verás muchos proyectos de demostración ya armados y selecciona el que te interesa.
Ya tienes cargado el demo y quieres hacer tu propio proyecto, pues tendrás que guardar éste proyecto con un nombre diferente de tu invención, por ejemplo yo he utilizado
C18-PIC18F67J50_ENC28.mpc, para guardar te vas a la barra superior
Project/Save Project Ass… eliges tu nombre y lo guardas
Ahora lo adaptas a tus necesidades, lo primero es elegir el chip, nos vamos a la barra superior y seleccionamos
Configure/Select Device.
Y selecciona tu chip
Ahora tienes que crear las carpetas adecuadas en la raíz del proyecto, ósea en la carpeta
/.../TCPIP/Demo App ahí dentro de esa carpeta creas las carpetas:
Hex-PIC18F67J50_ENC28
Obj-PIC18F67J50_ENC28Ahora vas a configurar las rutas, macros y demás cosillas, recuerda que hemos creado una carpeta nueva fuera de las librerías instaladas y hay que indicarles al software donde está, nos vamos a la barra de la parte superior, pulsamos en
Project/Build Options/Project.
Se nos abre una ventada donde tendremos que cambiar varias cosas, lo primero como dije son las rutas, te vas a
Directories y en el desplegable seleccionas
Output Directory seleccionas la carpeta
Hex-PIC18F67J50_ENC28 en esta carpeta se almacenará los archivos compilados.
En el desplegable ahora seleccionas
Intermediary Directory y seleccionas la otra carpeta,
Obj-PIC18F67J50_ENC28 en esta carpeta se almacenaran los archivos intermedios para obtener el hex
En el desplegable ahora seleccionas
Include Search Path, ahí van las librerías del proyecto, las tipo .h, las rutas son en la misma carpeta del proyecto, ¿recuerdas la carpeta
Microchip que rescataste del las librerías originales y las copiaste en tu propio proyecto?, pues esa es la que tienes que seleccionar, y luego en otra línea seleccionas una que hay dentro llamada
include, y yo tengo otra ruta más que es las librerías genéricas del compilador, ósea en el compilador buscas la .h y la seleccionas
Ahora sin cerrar la ventana vamos a configurar las macros, Microchip utiliza unas macro para adaptar el mismo proyecto a diferentes hardware, para ello utiliza dos archivos uno donde almacena las configuraciones del hardware del PIC ósea la definición de puertos, los fuses, la velocidad del cristal, etc, etc que lo llama
HWP xxxxxx y otro que es donde se configura los módulos que quieres utilizar en tu proyecto, como podría ser el servedor
HTTP,
TELNET y el que a ti te interesa en este momento que es el
SNMP, este archivo se llama
TCPIP xxxxxxxxx ¡¡¡nota!!! lo de las xxxxxx es un nombre que tu quieras poner para llamarlo, como yo lo tengo en la imagen de ejemplo.
Te vas a la pestaña
MPLAB C18 y añadimos un nombre de tu invención a la ventana de
Preprossesor Macros, si hay alguna seleccionada la borras y pones la que tu te inventes, recuerda la por que ese nombre lo vas a utilizar en otro archivo.
Haces lo mismo en la pestaña de
MPASM Assembler.
Aceptas y sales. Ahora te vas a editar esos ficheros para que las macros funcionen. Abres el archivo
HardwareProfile.h, no suele estar incluido en el árbol del proyecto pero si está dentro de la carpeta
Demo App, lo abres y lo editas para incluir tu configuración de hardware, un ejemplo:
En azul es la macro que añadimos antes y en naranja es el archivo de configuración del hardware de tu proyecto.
Ahora tienes que editar el archivo
TCPIPConfig.h de igual manera que el anterior para añadir nuestra configuración del sistema y de igual manera no está en el árbol del proyecto pero si en la misma carpeta que el anterior.
Una última cosa muy importante antes de probar a compilar tu nuevo proyecto, es incluir en el archivo de cabecera una macro que hace que el compilador encuentre los fuses de tu hardware y no el de otro y es una línea llamada
#define THIS_IS_STACK_APPLICATION que nos encontramos al inicio del archivo principal del proyecto, el MainDemo, esta línea hace referencia a otra localizada en el inicio de tu archivo
HWP XXXXXX con el nombre
#if defined(THIS_IS_STACK_APPLICATION), así que si te crear tu archivo de configuración no te olvides de incluir esto.
Para preparar un proyecto tendrás que seleccionar los módulos que quieres incluir en el, lo puedes hacer de dos maneras, o comentando y descomentando líneas en el archivo de cabecera
TCPIP xxxxxxxx o utilizar una herramienta que Microchip nos proporciona en su librería llamada
TCPIP Configuration Wizard que la puedes encontrar en
Inicio.
Inicia el software, selecciona la carpeta donde tenemos el fichero, que suele estar en
/../Demo App/Configs y presiona
Next.
Se empiezan a abrir ventanas de configuración donde puedes elegir las diferentes opciones que quieras implementar, en mi caso he usado el servidor
WEB para poder subir un fichero en formato .bin a una memoria externa, ahí es donde estarán elementos que son necesarios para implementar el servidor
SNMP, esto ya lo explico más adelante, el servidor
TELNET también lo tengo implementado por que lo utilizo para la comunicación entre dos PIC.
No soy un experto en
SNMP y voy a intentar explicar lo poco que sé sobre este protocolo, si cometo errores pido perdón y estaría encantado de que me corrijan.
Por lo que yo sé a día de hoy hay varias versiones de este protocolo que consta de
SNMPv1 está desarrollada desde 1988 y es la primera versión y utiliza para la autenticación el nombre de comunidad, de ahí se desarrolló la versión
SNMPv2c que es una mejora de la 1 con un par de mejoras más, y por último es la versión
SNMPv3 que es mucho más seguro que la anterior por que utiliza protocolos de autenticación más elaborados.
En mi proyecto solo he utilizado la versión 1 y 2, la tres creo que no lo soporta los PIC de 8 bits, corrijan me si me equivoco.
Una ves selecciones lo que quieres usar es darle a
Next.
Ahora prueba a compilar y si lo hace sin errores ya estás listo para editar el servidor
SNMP y adaptarlo a tu proyecto.
Como dije en el encabezado de esta guía y repito ahora, es que no soy ningún experto en redes ni en este protocolo, yo lo que he hecho es leer sobre el protocolo y hacerme una idea de como funciona así que pido indulgencia y no me tiren piedras si meto la pata con algún concepto erróneo que tenga.
Lo que he hecho es modificar el proyecto de prueba que Microchip ha incluido, también he de decir que la información de la guía que trae estas librería es muy escasa y toca adivinar mucho.
La arquitectura consta de lo que se llama los
Componentes SNMP que son el o los
Administradores, los
Agentes y los dispositivos
Administrados.
Los administradores son los que controlan el sistema, pudiendo ser un servidor con NAGIOS o cualquier otro software de monitoreo, los agentes es el software que está en el interior de los dispositivos a administrar en este caso será el PIC y son los encargados de mantener las comunicación con el administrador y los dispositivos (PIC). El administrados SNMP envía una solicitud al AGENTE que a su ves pasa la solicitud a los dispositivos a administrar (SENSORES)
¿Y cómo el administrador habla con los equipos a administrar? Pues por medio de las
MIB y los
OIDs, las
MIB son los módulos donde estarán representados los
OIDs, los
OIDs o un
OID es el identificador de objetos y se hace por un número, esos objetos re refieren a leds, sondas, display, etc.., las
MIB es con lo que se construye el árbol de jerarquías que cargarás en el software de administración donde se ven un montón de carpetas enlazadas una debajo de la otra en forma de árbol y dentro de cada carpeta estarán los objetos que se identifican con un número.
El software de monitoreo que utiliza en sus ejercicios de ejemplo Microchip se llama
iReazoning MIB Browser, el circulo rojo es el
MIB y representa todas las carpetas en forma jerárquica y el circulo verde están los
OIDs, si pinchas sobre un objeto, el
Led5 en este caso, aparece en la ventana superior el número
OID que tiene ese objeto, lo tengo marcado con una elipse azul.
Ahora vamos al meollo del asunto, pues para poder montar todo esto, hay que hacerlo siguiendo unos determinados pasos, para ello Microchip incorpora a su librería un software para crear los
OIDs de los objetos y poder agregarlas al proyecto, el software se llama
mib2bib y se utiliza en líneas de comando, este software está en la ruta
/.../Microchip/TCPIP Stack/Utilities, pero vamos por pasos.
1. Edita el archivo
snmp.mib y añade o modifica un objeto de los que están, este archivo es el que utilizará
mib2bib para crear los
OIDs de los objetos, en la imagen puedes ver mi modificación y si te fijas ves los
OIDs de cada objeto como no se repiten, tienen una estructura y son consecutivos, tienes que fijarte bien en esto ya que será de vital importancia para modificar el archivo
mchip.mib y que se vean entre el administrador y el agente
El software lo que hace es formatearlo, “creo que se llama así” y generar dos archivos más, uno llamado
snmp.bib que lo tendremos que mover a la carpeta donde tenemos la página web y otro
min.h que tendremos que mover lo a la carpeta
Demo App para incluirlo en el árbol del proyecto.
Cuando generemos el archivo
.bin de la web para subirla a la memoria del chip incluirá este archivo y lo grabará a la memoria junto con la página web, y en el
min.h se generan los
OIDs de los objetos y quedan vinculados con el archivo
MIB grabado en la memoria, ejemplo de el archivo
min.h
2. Genera los archivos
snmp.bib y
mi.h con el software
mib2bib, para ello te vas a
inicio y en buscar programas escribe
cmd,se te abrirá la consola, ahora escribe la ruta donde tienes el software, por defecto lo encuentras en /
…./Tucarpetadeproyecto/Microchip/TCPIP Stack/Utilities. Y escribes
java -jar mib2bib.jar snmp.mib y listo, en consola verás la prueba de que ha terminado con éxito.
Carpeta y ruta de donde está el softwares
Consola con las rutas y el resultado de la ejecución del archivo
Ahora te preguntarás como modificar tu proyecto para poder leer los valores desde un software de administración. Antes de nada quiero que sepas que solo he implementado la lectura no la escritura entonces no sé como es el mecanismo de eso pero si alguien sabe y quiere aportar algo más a esta guía será bien venido, también he de decir que lo que voy a explicar a continuación no lo tengo claro del todo con lo cual estoy especulando así que si me equivoco sepan por lo que es.
En el archivo fuente
CustomSNMPApp.c hay varias funciones que tendremos que modificar para añadir nuestro objeto.
En la función
SNMPGetVar() es donde hay que implementar la modificación. Como yo ya tengo el proyecto de leer la sonda hecho y transformo el valor en un dato de cadena lo que hice fue ver como la demo trabaja con los datos del LCD que son también de cadena y cree una rutina utilizando el mismo formato que el del LCD, esto se maneja con un bucle switch desde la función
SNMPIdRecrdValidation() y ahí hay que añadir el define del objeto que te generó
mib2bib en el mi.h
y en
SNMPGetVar()
He buscado por todos lados en el archivo fuente principal del proyecto y he seguido la ruta del programa línea por línea pero no llego a descubrir como se llama a estas funciones, así que si alguien lo sabe y quiere compartirlo le estaría muy agradecido.
3. Ahora compila tu proyecto y tiene que terminar sin errores y grabalo en el chip
4. Ahora descarga el software
iReasoning si no los has hecho ya, lo puedes descargar desde enlace:
iReasoning MIB Browser 5. Prueba si todo lo que has hecho funciona, pero antes tendrás que modificar el archivo
mchip.mib para que coincida con las modificaciones que has realizado en los ficheros anteriores.
6. Ahora ejecuta el iReasoning y carga le el fichero mchip.mib que has modificado, en la barra superior en
file/load MIBs
Ahora puedes ver el árbol de tu proyecto, en
Address pones la
IP de tu
PIC, en la carpeta control tienes tu sonda, te pones encima seleccionas en
Operations la opción
Get y pulsas
Go y puedes ver el valor de la temperatura.
Ahora si quieres monitorear tu sonda desde un software de control yo lo estoy haciendo con NAGIOS, es software libre y lo tengo instalado en una máquina con ubuntu, mi idea es pasarlo a una raspberry pi que consume menos.
1. Instalamos NAGIOS, eso ya lo averiguas como hacerlo, en su página oficial están muy claros los pasos y son fáciles, se instala tal cual te lo indica y sin problemas.
Cómo Instalar Nagios 2. Ahora configura tu servidor para añadir tu PIC al monitoreo
Abre una terminal y ve a la ruta donde está instalado NAGIOS
usr/local/nagios/etc Ahora crea una carpeta donde estarán las configuraciones de los PICs y como usuario pasala a nagios
sudo mkdir hosts
sudo mchow nagios:nagios hosts Ahora entra en el archivo de configuración del servidor y añade la ruta de la carpeta que has creado para pus PICs.
3. Comprueba desde el servidor que puedes leer la sonda, en la terminal tipea esto:
watch -n 5 snmpget -v 1 -c public 192.168.1.10 .1.3.6.1.4.1.17095.1.3.7.0y tiene que dar este resultado
4. Ahora tienes que crear un comando nuevo para leer la sonda, en la carpeta objects/commands.cfg
ya en la carpeta objects tipea
$sudo nano commands.cfgY te vas al final del archivo y añade esto:
#################################################################################
#
# Definimos los comandos para monitorear los PIC
#
################################################################################
define command{
command_name TempDS1621
command_line /usr/local/nagios/libexec/check_snmp -H '$HOSTADDRESS$' -C 'public' -o 1.3.6.1.4.1.17095.1.3.7.0 -w$ARG1$ -c$ARG2$ -l temp
}
5. Ahora hay que añadir este comando en el archivo de configuración del chip, en la carpeta recién creada ósea hosts crea un nuevo fichero con un nombre que tu quieras, yo la he llamado pic.cfg
$sudo nano pic.cfgy dentro añades la configuración.
##################################################################
#
# HOST DEFINITION
#
##################################################################
# Define a host for the local machine
define host {
use linux-server ; Name of host template to use
; This host definition will inherit all variables $
; in (or inherited by) the linux-server host templ$
host_name pic
alias pic
address 192.168.1.10
check_period 24x7
}
##################################################################
#
#HOST GROUP DEFINITION
#
##################################################################
# Define an optional hostgroup for Linux machines
define hostgroup {
hostgroup_name pic-servers ; The name of the hostgroup
alias pic ; Long name of the group
members localhost ; Comma separated list of hosts that belong to thi$
}
##################################################################
#
# SERVICE DEFINITIONS
#
##################################################################
# Define a service to "ping" the local machine
define service {
use local-service ; Name of service template to use
host_name pic
service_description PING
check_command check_ping!100.0,20%!500.0,60%
}
# Monitoreo de la temperatura que marca la sonda DS1621
define service{
use generic-service
host_name pic
notifications_enabled 0
service_description Temperatura
check_command TempDS1621!26!30
} 6. Y por último reiniciamos apache y nagios
$sudo systemctl restart apache2.service
$sudo systemctl start nagios.service Ahora prueba si todo está funcionando, ve a NAGIOS y mira a ver.
