Crear Librerias Arduino

Las librerías son trozos de código hechos por terceros que usamos en nuestro sketch. Esto nos facilita mucho la
programación y permite la abstracción haciendo que nuestro programa sea más sencillo de hacer y de entender. En
este apartado veremos cómo escribir o modificar librerías.

Librerías Arduino: https://www.arduino.cc/en/Main/Libraries

El IDE de Arduino incluye una serie de librerías ya instaladas: https://www.arduino.cc/en/Reference/Libraries

Listado de librerías del playground de Arduino: http://playground.arduino.cc/Main/LibraryList, pero existen otras

muchas librerías creadas por usuarios o por los fabricantes de HW para facilitar el uso de esos dispositivos con
Arduino.

Este tutorial explica como crear una librería: http://arduino.cc/en/Hacking/LibraryTutorial. Explica cómo convertir la

función morse en en una librería.

Ejemplo ‘morse.ino’:

1 int pin = 13;

2  
3 void setup()
4 {
5   pinMode(pin, OUTPUT);
6 }
7  
8 void loop()
9 {
10   dot(); dot(); dot();
11   dash(); dash(); dash();
12   dot(); dot(); dot();
13   delay(3000);
14 }
15  
16 void dot()
17 {
18   digitalWrite(pin, HIGH);
19   delay(250);
20   digitalWrite(pin, LOW);
21   delay(250);
22 }
23  
24 void dash()
25 {
26   digitalWrite(pin, HIGH);
27   delay(1000);
28   digitalWrite(pin, LOW);
29   delay(250);
30 }

Para convertir en una librería de código morse, vemos que hay dos funciones dot() y dash() para iluminar un led
durante 250 ms y 1 segundo y  una variable que es ledPin que determina que pin usar. Este es un estilo de
programación clásico usando funciones en lugar de objetos.
Para una librería se necesitan al menos dos ficheros:

Un fichero de cabecera con la extensión .h. Este fichero tiene las definiciones de la librería, básicamente un
listado de todo lo que hay dentro de la librería
Un fichero fuente con la extensión .cpp. Este fichero el que contiene el código

En este caso la librería se va a llamar morse y generamos un fichero de cabecera llamado morse.h.

Veamos el código de morse.h donde se define la clase Morse donde tiene una línea por cada función o método y
también una línea por cada variable o propiedad de la clase.

1 class Morse
2 {
3   public:
4     Morse(int pin); //constructor
5     void dot();
6     void dash();
7   private:
8     int _pin;
9 };

Una clase es una colección de funciones (métodos) y variables (propiedades) que se guardan todas juntas en un solo
lugar. Las funciones pueden ser públicas (public), es decir, pueden llamarse por quien usa la librería o privadas
(private), es decir, que solo pueden llamarse desde dentro de la propia clase. Todas las clases tienen una función
llamada constructor, que es usada para crear una instancia de la clase. El constructor tiene el mismo nombre que la
clase y no tiene tipo de variable de devolución.

En el fichero de cabecera de una librería es necesario la declaración #include que de acceso a los tipos y constantes
estándar del lenguaje de Arduino (esto se añade automáticamente en los sketches pero no a las librerías). Esta
declaración debe ponerse antes de la definición de la clase. La declaración debe ser:

Versión IDE 1.x: #include “Arduino.h”

Versión IDE 0.x: #include “WProgram.h”

También es común poner todo el fichero de cabecera entre estas instrucciones:

1 #ifndef Morse_h
2 #define Morse_h
3  
4 // the #include statment and code go here...
5  
6 #endif

Esto evita problemas si alguien accidentalmente incluye dos veces la librería, lo que provocaría un error de
compilación. A esto se llama guardián de inclusión múltiple o include guard.

1 // Guardián de inclusión múltiple

2 #ifndef FICHERO_YA_INCLUIDO
3 #define FICHERO_YA_INCLUIDO
Así se evita que un compilador poco sofisticado abra otra vez el mismo conjunto de ficheros cuando se incluye un
fichero de cabecera dos o más veces. Puede darse el caso de no poner las inclusiones en el inicio de un fichero.

La directiva #include existe en dos versiones. En una se pone el nombre de fichero entre comillas, en la otra entre
paréntesis angulares (el signo menor y mayor como “comillas”).

1 #include "fichero_con_comillas.h"
2 #include <fichero_entre_menor_y_mayor.h>

La versión con los paréntesis angulares busca los ficheros en todos los directorios que se han especificado en la
llamada al compilador – normalmente con la opción “-I”. Estos directorios se suelen rastrear por el fichero incluido en
el orden en que aparecen en la línea de comando.

Cuando se incluye un fichero entre comillas, entonces el compilador busca este fichero primero en el mismo directorio
que el fichero actualmente compilado y después en los demás directorios. Es decir, la versión con comillas se
diferencia de la versión con paréntesis angulares únicamente por buscar primero en el directorio del fichero
compilado. Tras no encontrarlo ahí actua igual.

Cuando se crea una librería se debe documentar poniendo un comentario al comienzo de la librerías con el nombre,
breve descripción, quien la ha escrito, fecha, licencia, etc…

El fichero de cabecera ‘Morse.h’ queda:

1 /*
2   Morse.h - Library for flashing Morse code.
3   Created by David A. Mellis, November 2, 2007.
4   Released into the public domain.
5 */
6 #ifndef Morse_h
7 #define Morse_h
8  
9 #include "Arduino.h"
10  
11 class Morse
12 {
13   public:
14     Morse(int pin);
15     void dot();
16     void dash();
17   private:
18     int _pin;
19 };
20  
21 #endif

Una vez hecho el fichero de cabecera hay que codificar el fichero fuente ‘Morse.cpp’.

Primero deben ponerse las declaraciones, esto da al resto de código acceso a las funciones estándar de Arduino y a
las definiciones del fichero de cabecera:

1 #include "Arduino.h"
2 #include "Morse.h"
Lo siguiente es poner el constructor de la clase. Esto define que ocurre cuando se crea una instancia de la clase. En
este caso el usuario debe especificar cual es el pin que se va a usar. Configuramos el pin como salida y los
guardamos en una variable privada para usarlo desde otras funciones.

1 Morse::Morse(int pin)
2 {
3   pinMode(pin, OUTPUT);
4   _pin = pin;
5 }

El código “Morse::” antes del nombre de la función indica que la función es parte de la clase Morse. Esto se ve en
todas las funciones de la clase. La variable llamada “_pin” es una variable privada tal y como se ha definido en el
fichero de cabecera y se pone el simbolo “_” delante por convención para indicar que es privada y para diferenciarlo
del argumento de la función, pero puede llamarse de cualquier forma mientras coincida con la definición en el fichero
de cabecera.

Después de definir el constructor, se deben definir las funciones o métodos de la clase. Son las funciones que se
habían definido anteriormente en el sketch:

1 void Morse::dot()
2 {
3   digitalWrite(_pin, HIGH);
4   delay(250);
5   digitalWrite(_pin, LOW);
6   delay(250); 
7 }
8  
9 void Morse::dash()
10 {
11   digitalWrite(_pin, HIGH);
12   delay(1000);
13   digitalWrite(_pin, LOW);
14   delay(250);
15 }

También es habitual añadir el comentario del fichero al principio del fichero. El fichero ‘Morse.cpp’ queda de la
siguiente forma:

1 /*
2   Morse.cpp - Library for flashing Morse code.
3   Created by David A. Mellis, November 2, 2007.
4   Released into the public domain.
5 */
6  
7 #include "Arduino.h"
8 #include "Morse.h"
9  
10 Morse::Morse(int pin)
11 {
12   pinMode(pin, OUTPUT);
13   _pin = pin;
14 }
15  
16 void Morse::dot()
17 {
18   digitalWrite(_pin, HIGH);
19   delay(250);
20   digitalWrite(_pin, LOW);
21   delay(250); 
22 }
23  
 24 void Morse::dash()
25 {
26   digitalWrite(_pin, HIGH);
27   delay(1000);
28   digitalWrite(_pin, LOW);
29   delay(250);
30 }

De esta forma ya tenemos una librería completa. Ahora para incluirla en nuestro IDE debemos crear un directorio
Morse dentro del subdirectorio “libraries” del directorio de nuestro entorno de trabajo definido en las propiedades del
IDE. Copiar Morse.h y Morse.cpp dentro del directorio Morse y abrir o reiniciar el IDE de Arduino. A partir de este
momento veremos nuestra librería disponible en el IDE y podremos incluirla en los sketches con la declaración
#include <Morse.h>. La librería será compilada por los sketches que la usen.

El anterior sketch quedaría ahora sustituido por:

1 #include <Morse.h>
2  
3 Morse morse(13);
4  
5 void setup()
6 {
7 }
8  
9 void loop()
10 {
11   morse.dot(); morse.dot(); morse.dot();
12   morse.dash(); morse.dash(); morse.dash();
13   morse.dot(); morse.dot(); morse.dot();
14   delay(3000);
15 }

Podemos ver que primero se llama a la declaración de la librería Morse. Esto hace que la librería esté disponible en el
sketch y lo incluye en el código enviado a la placa Arduino, lo que hace que si la librería es muy pesada, ocupe mucha
más memoria nuestro sketch y si no voy a usar una librería es mejor no incluirla para ahorrar espacio.

También observamos que creamos una instancia de la clase Morse llamada “morse”. Al ejecutar esta línea el
constructor de la clase es llamado pasando un argumento, creando así el objeto “morse” en nuestro sketch. Luego
podemos llamar a los métodos dot() y dash() precedidos del prefijo morse del nombre del objeto.

Es posible tener múltiples instancias de la clase Morse, cada una un pin diferente guardado en la variable privada
“_pin”.

Si creamos una librería es conveniente crear el fichero keywords.txt dentro del directorio Morse. De esta forma
conseguiremos resaltar las palabras clave que definamos en el fichero keywords. En cada línea del fichero
keywords.txt se indica el nombre de la palabra clave y seguido por un tabulador, el tipo de keyword.

Las clases deben ser del tipo KEYWORD1 que se resaltan en naranja.
Las funciones deben ser del tipo KEYWORD2 que se resaltan en marrón

Para que el fichero keywords.txt se aplique al IDE es necesario reiniciar el IDE.

El fichero keywords.txt quedaría:

Morse KEYWORD1

dash KEYWORD2

dot KEYWORD2

Recomendación de uso de KEYWORDS:

Datatypes and Classes (KEYWORD1)

Methods and Functions (KEYWORD2)
Instances (KEYWORD2)
Class (KEYWORD3)
Constants (LITERAL1)

Type ID Purpose Color

KEYWORD1 Datatypes Brown #cc6600,plain

KEYWORD2 Method and function names Brown #cc6600,plain

KEYWORD3 setup, loop, Serial, and a few more Brown, bold #cc6600,bold

LITERAL1 Constants Blue #006699,plain

LITERAL2 Apparently, not used Blue #006699,plain

Las KEYWORDS predefinidas en Arduino están en el fichero C:\Program Files (x86)\Arduino\lib

Más explicación de keywords: https://spencer.bliven.us/index.php/2012/01/18/arduino-ide-keywords/

También es aconsejable ofrecer ejemplos de uso de la librería para que los posibles usuarios sepan usarla. Esto se
hace creando un directorio “examples” dentro del directorio Morse y añadir en el subdirectorio los sketches de
ejemplos que serán visibles desde el IDE.

La librerías morse con los ejemplos y el fichero keywords.txt se puede descargar

en: http://www.arduino.cc/en/uploads/Hacking/Morse.zip

Para más información sobre la creación de librerías con un buen “estilo Arduino”, ver la Guía de Estilo de API. Guia de
estilo para escribir librerías: http://arduino.cc/en/Reference/APIStyleGuide

IMPORTANTE: Como se ve en el código de una librería usamos código de de Arduino y por lo tanto podría la librería
funcionará con cualquier placa compatible. Pero generalmente las librerías tienen código a bajo nivel que puede que
solo valga para un tipo de procesadores y en ese caso habrá que adaptar la librería a las instrucciones del
microprocesador con el que queramos usar la librería.
Para saber la arquitectura soportada por una librería ver https://arduinolibraries.info

Librería adaptada para Arduino y ESP8266: https://github.com/adafruit/Adafruit_NeoPixel donde se ha creado el

fichero esp8266.c para que cuando compile con una placa ESP8266 o ESP32 sea compatible.

Más información:

https://www.arduino.cc/en/Hacking/LibraryTutorial
https://www.arduino.cc/en/Reference/APIStyleGuide

Ejemplo Librería Semáforo

Para crear una clase semáforo que representa un semáforo y cuyo programa de uso es:

1 #include <Semaforo.h>
2  
3 Semaforo miSemaforo(2,3,4,12);
4  
5 void setup() {
6 }
7  
8 void loop() {
9   miSemaforo.Verde();
10   delay(3000);
11   miSemaforo.Rojo();
12   delay(3000);
13 }

semaforo.h

1 /*
2 Semaforo.h - Libreria para control de luces de un Semaforo
3 Por Leo Lamolda, marzo de 2018, para LMDAPPS
4 experimentosconarduino.blogspot.es.com
5 */
6 #ifndef Semaforo_h
7 #define Semaforo_h
8  
9 #include "Arduino.h"
10  
11 class Semaforo
12 { 
13  public:
14   Semaforo(int rojo, int amarillo, int verde, int buzzer);
15   void Rojo();
16   void Verde();
17   void Cambia();
18   bool EsRojo();
19   bool EsVerde();
20  private:
21         int _rojo;
22         int _amarillo;
23         int _verde;
24         int _buzzer;
25 } ;
26  
27 #endif

Semaforo.cpp
 1 /*
2 Semaforo.h - Libreria para control de luces de un Semaforo
3 Por Leo Lamolda, marzo de 2018, para LMDAPPS
4 experimentosconarduino.blogspot.es.com
5 */
6  
7 #include "Semaforo.h"
8  
9 Semaforo::Semaforo(int rojo, int amarillo, int verde, int buzzer)
10 {
11  pinMode(rojo,OUTPUT);     digitalWrite(rojo,LOW);
12     pinMode(amarillo,OUTPUT); digitalWrite(amarillo,LOW);
13     pinMode(verde,OUTPUT);    digitalWrite(verde,LOW);
14     pinMode(buzzer,OUTPUT);   digitalWrite(buzzer,LOW);
15    _rojo = rojo;
16    _amarillo=amarillo;
17    _verde=verde;
18    _buzzer=buzzer;            
19 }
20  
21 void Semaforo::Rojo(){
22  digitalWrite(_rojo,LOW);
23   digitalWrite(_verde,LOW);
24   for (int i=0;i<5;i++){
25         digitalWrite(_amarillo,HIGH);
26         digitalWrite(_buzzer,HIGH);
27         delay(200);
28         digitalWrite(_amarillo,LOW);
29         digitalWrite(_buzzer,LOW);
30         delay(200);
31     }
32  digitalWrite(_rojo,HIGH);
33 }
34  
35 void Semaforo::Verde(){
36     digitalWrite(_rojo,LOW);
37     digitalWrite(_amarillo,LOW);
38     digitalWrite(_verde,HIGH);
39 }
40  
41 void Semaforo::Cambia(){
42  if (EsVerde()) Rojo();
43   else Verde();
44 }
45  
46 bool Semaforo::EsRojo(){
47  return digitalRead(_rojo);
48 }
49  
50 bool Semaforo::EsVerde(){
51  return digitalRead(_verde);
52 }

Y si tenemos dos semáforos podemos hacer:

1 #include <Semaforo.h>
2  
3 Semaforo miSemaforo1(2,3,4,12);
4 Semaforo miSemaforo2(8,9,10,12);
5  
6 void setup() { 
7 }
8  
9 void loop() {
10   miSemaforo1.Rojo();
11   delay(500);
12   miSemaforo2.Verde();
13   delay(3000);
14   miSemaforo2.Rojo();
15   delay(500);
 16   miSemaforo1.Verde();
17   delay(3000);
18 }

Más información:  http://experimentosconarduino.blogspot.com/2018/04/un-clasico-semaforo-con-arduino-y.html

Otros Ejemplos de Librerías

Ver ejemplos simples de librerías:

https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio03-Librerias
https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio44-Test_Library
https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio56-Libreria_Morse

Librería para el manejo de una API: https://github.com/jecrespo/apisiar_arduino/tree/master/apisiarlib

Guía de estilo para escribir una librería de Arduino

Para facilitar el entendimiento de las librerías o APIs de Arduino y hacer que el entorno de Arduino sea más
homogéneo, desde arduino.cc dan unas pautas para escribir librerías al “estilo Arduino”. Algunas de estas prácticas
van en contra de la programación programación profesional, pero esto hace posible a los principiantes comenzar a
trabajar de forma sencilla con Arduino.
 Se amable con el usuario. Tener una modelo claro del concepto que va tratar la librería y las funciones que se
van a implementar.
Organizar las funciones pública alrededor de los datos y funcionalidades que el usuario quiere.
Frecuentemente el conjunto de comandos para un módulo electrónico son demasiado complicado, pero
podemos reorganizar las funciones desde un punto de vista de uso a alto nivel. Pensar en lo que hace la
mayoría de las personas y organizar la API en función de ese uso. Un ejemplo es la
librería https://github.com/adafruit/Adafruit-BMP085-Library. La función readPressure() hace todos los pasos
para obtener la presión final, siendo transparente para el usuario todos los complejos pasos intermedios. Esto
abstrae al usuario no solo de los comandos I2C necesarios, sino de de los cálculos intermedios.
Usar palabras claras para escribir la librerías. Usar nombres de funciones y variables claros que expresen
claramente lo que son o hacen y no usar términos técnicos.
Evitar palabras que tengan diferente significado para el público en general.
Documentar todo. Al escribir ejemplos usar esta guía: http://www.arduino.cc/en/Reference/StyleGuide
Usar las librerías del core de Arduino y su estilo:
Usar read() para leer entradas y write() para escribir salidas
Usar las librerías Stream.h y print.h cuando se estén manejando byte streams. Si no es posible al
menos intentar usar su modelo de API.
Para aplicaciones de redes, usar las librerías de Client y Server como base.
Usar begin() para inicializar unas instancia de una librería, normalmente con unos parámetros de
configuración. Usar end() para finalizarla.
Usar funciones camel case, no con guión bajo. Por ejemplo analogRead en lugar de analog_read. Esto es una
adopción de processing por motivos de facilidad la lectura.
No usar nombre de constantes largos que son difíciles de leer.
Evitar usar argumentos booleanos. En su lugar es preferible ofrecer dos funciones diferentes con nombres que
describan la diferencia entre ellas.
No asumir conocimiento de punteros. Los principiantes en C suelen encontrar dificultades con el uso de & y *,
en la medida de lo posible tratar de evitar el uso de punteros.
Al usar la comunicación serie de cualquier tipo, permitir al usuario especificar el objeto de stream en lugar de
solo “Serial”, esto hará la librería compatible con los los puertos del Arduino Mega y Due y también poder usar
interfaces alternativos como el SoftwareSerial. ver el uso de begin(Stream &serial) en las
librerías https://github.com/firmata/arduino y https://github.com/andrewrapp/xbee-arduino
Cuando se escriba una librería que ofrezca comunicación byte-stream heredada de la la clase Stream de
Arduino, de forma que la librería pueda ser usada por otras librerías que acepte objetos Stream: si es posible,
el método read() inmediatamente accede a los datos del buffer sin esperar a que lleguen más datos y si es
posible el método write() debe guardar los datos al buffer de transmisión, pero debe esperar si el buffer no tiene
suficiente espacio para guardar inmediatamente todo los datos salientes. La función yield() debe llamarse
mientras se espera. De esta forma mantenemos compatibilidad con el restos de librerías Stream.

Unos ejemplos de librerías que definen realmente bien las funciones de alto nivel son:

https://github.com/adafruit/Adafruit-BMP085-Library
https://github.com/adafruit/DHT-sensor-library

Viendo los métodos públicos que definen es muy fácil entender que es lo que hacen.
Otro buen ejemplo de abstracción de la librerías wire (I2C) se puede ver en: https://github.com/adafruit/RTClib donde
con una serie de métodos obtengo los datos del RTC siendo totalmente transparente para el usuario el uso de la
librería wire.

Es frecuente que nos encontremos que algunas librerías se quedan cortas para algunas funcionalidades avanzadas,
puesto que como se ha visto en la guía de estilo se tiende a simplificar. Un ejemplo de esto es la librería ethernet
donde muchas de las funcionalidades del Wiznet 5100 no están implementadas en la librería, pero esto no impide que
nosotros podamos añadirlas.

Más información: https://www.arduino.cc/en/Reference/APIStyleGuide

Modificar librerías

Es habitual que al usar una librería necesitemos una propiedad o un método que no esté implementado o queramos
modificar el comportamiento, para ello podemos modificar localmente la librería que tengamos instalada en nuestro
IDE.

En el caso que queramos colaborar en una librería hecha, podemos hacer un fork de esa librería en nuestra cuenta de
github y añadir una nueva funcionalidad o corregir ese fallo e incluso podemos hacer un pull request para que se
añada en la librería original nuestra modificación. También podemos tener nuestra propia librería como un fork de la
librería original.

Un pull request es una petición que el propietario de un fork de un repositorio hace al propietario del repositorio
original para que este último incorpore los commits que están en el fork. Explicación de pull
request: http://aprendegit.com/que-es-un-pull-request/

Para modificar la librería time y añadir una funcionalidad, lo primero es hacer un fork del
código https://github.com/PaulStoffregen/Time en tu repositorio, en mi caso en https://github.com/jecrespo/Time y
luego clonarlo en el ordenador para modificarlo.

Ejemplo de librería Ethernet modificada: https://github.com/jecrespo/Aprendiendo-

Arduino/tree/master/Otros/Ethernet%20Modificada

Añado los métodos:

uint8_t *getRemoteIP(uint8_t remoteIP[]);//adds remote ip address

uint8_t *getRemoteMAC(uint8_t remoteMAC[]);
uint16_t getRemotePort();

Ejercicios Librerías

Hacer Librería Morse

Ejercicio: Hacer la librería Morse y probarla con los leds del montaje.

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino/tree/master/Ejercicio15-
Libreria_Morse

Hacer Librería Detecta Flanco

Ejercicio: Hacer una librería que detecte un flanco basado en la clase detecta flanco del
ejercicio https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino/tree/master/Ejercicio12-
Clase_Detecta_Flanco_cpp .

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino/tree/master/Ejercicio18-
Libreria_Detecta_Flanco

Hacer Librería Coche

Ejercicio: Hacer la librería coche para aplicar en un sketch como el visto

en https://aprendiendoarduino.wordpress.com/2017/07/08/clases-y-objetos/

1 #include “Coche.h”
2   
3 Coche MiCocheRC(6,7)
4   
5 void setup() {
6 MiCoche.Arranca()
7 }
8   
9 void loop() {
10 char valor = leeBluetooth();
11   
12 switch (valor) {
13     case ‘F’:
14       MiCoche.Adelante();
15       break;
16     case ‘R’:
17       MiCoche.Derecha();
18       break;
19     case ‘L’:
20        MiCoche.Izquierda();
21       break;
22     case ‘B’:
23        MiCoche.Atras();
24       break;
25     case ‘S’:
26        MiCoche.Para();
27       break;
28   }
29 }

Crear los métodos y configurarlos:

Arranca()
Adelante()
Derecha()
 Izquierda()
Atras()
Para()
MuestraGasolina()
EchaGasolina()
EncidendeLuces()
ApagaLuces()
Pita()

Solución: https://github.com/jecrespo/aprendiendoarduino-Curso_Programacion_Arduino/tree/master/Ejercicio13-
Libreria_Coche

Crear una librería para NTP

Ejercicio: A partir del ejemplo de Arduino para obtener la hora de un servidor

NTP https://www.arduino.cc/en/Tutorial/UdpNtpClient, crear una librería para obtener de forma sencilla la hora con una
llamada a la función readNTP().

Ver Ejercicio39-NTP para obtener fecha y hora en Arduino sin necesidad de un RTC usando
NTP: https://github.com/jecrespo/Aprendiendo-Arduino/tree/master/Ejercicio39-NTP

Basado en:

https://github.com/PaulStoffregen/Time  TimeNTP example  
https://www.arduino.cc/en/Tutorial/UdpNtpClient
http://playground.arduino.cc/Code/NTPclient

Protocolo:

https://es.wikipedia.org/wiki/Network_Time_Protocol
https://en.wikipedia.org/wiki/Network_Time_Protocol
epoch converter: http://www.epochconverter.com/

Las firmas de tiempo que se usan en NTP, son de 32 bits indicando la parte entera en segundos desde  el 1 de Enero
de 1900, y una parte fraccionaria también de 32 bits. Por ello la resolución teórica de NTP sería de 232 segundos
=136 años, y una resolución teórica de 2E-32 segundos, o sea 0,233 nanosegundos.

Nota: Ojo al llamar al constructor de algo p.e. ethernet sin hacer el begin ethernet antes.

Solución: https://github.com/jecrespo/simpleNTP