Actualizar la fecha y hora actual en Netduino Plus


Cada vez que se inicia el Netduino o hasta que se reinicie, usted encontrará que la fecha y la hora vuelve a los valores por defecto. Desde el lanzamiento de Netduino Plus, con conexión ethernet , este  ofrece una solución bienvenida a esta cuestión.

El Protocolo de Tiempo de Red (NTP) proporciona una manera fácil de sincronizar un dispositivo (por ejemplo, el equipo de Windows) con un servidor de hora de red. Al invocar un servidor NTP en el arranque, el Netduino colocará automáticamente su DateTime.

En el código siguiente se proporciona en el blog de Michael Schwarz y ligeramente modificado para aceptar un adicional (zona horaria) de parámetros:

using System;

using System.Net;
using System.Net.Sockets;
public static class Ntp
{
    public static bool UpdateTimeFromNtpServer(string server, int timeZoneOffset)
    {
        try
        {
            var currentTime = GetNtpTime(server, timeZoneOffset);
            Microsoft.SPOT.Hardware.Utility.SetLocalTime(currentTime);
            return true;
        }
        catch
        {
            return false;
        }
    }
    /// <summary>
    /// Get DateTime from NTP Server
    /// Based on:
    /// </summary>
    /// <param name="timeServer">Time Server (NTP) address</param>
    /// <param name="timeZoneOffset">Difference in hours from UTC</param>
    /// <returns>Local NTP Time</returns>
    private static DateTime GetNtpTime(String timeServer, int timeZoneOffset)
    {
        // Find endpoint for TimeServer
        var ep = new IPEndPoint(Dns.GetHostEntry(timeServer).AddressList[0], 123);
        // Make send/receive buffer
        var ntpData = new byte[48];
        // Connect to TimeServer
        using (var s = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
        {
            // Set 10s send/receive timeout and connect
            s.SendTimeout = s.ReceiveTimeout = 10000; // 10,000 ms
            s.Connect(ep);
            // Set protocol version
            ntpData[0] = 0x1B;
            // Send Request
            s.Send(ntpData);
            // Receive Time
            s.Receive(ntpData);
            // Close the socket
            s.Close();
        }
        const byte offsetTransmitTime = 40;
        ulong intpart = 0;
        ulong fractpart = 0;
        for (var i = 0; i <= 3; i++)
            intpart = (intpart << 8) | ntpData[offsetTransmitTime + i];
        for (var i = 4; i <= 7; i++)
            fractpart = (fractpart << 8) | ntpData[offsetTransmitTime + i];
        ulong milliseconds = (intpart * 1000 + (fractpart * 1000) / 0x100000000L);
        var timeSpan = TimeSpan.FromTicks((long)milliseconds * TimeSpan.TicksPerMillisecond);
        var dateTime = new DateTime(1900, 1, 1);
        dateTime += timeSpan;
        var offsetAmount = new TimeSpan(timeZoneOffset, 0, 0);
        var networkDateTime = (dateTime + offsetAmount);
        return networkDateTime;
    }
}

He aquí una breve lista de algunos servidores NTP:

  • pool.ntp.org (en realidad es una colección de servidores detrás de una única dirección)
  • time.nist.gov
  • tiempo-a.nist.gov
  • tiempo-b.nist.gov

Pase uno de estos nombres de servidor como una cadena y llama durante su proyecto principal () de método:

 

private static bool SetTime()

{
    var result = Ntp.UpdateTimeFromNtpServer("time.nist.gov", -4);  // Eastern Daylight Time
    Debug.Print(result ? "Time successfully updated" : "Time not updated");
    return result;
}
Es una pena que el Netduino no es compatible con  Microsoft.SPOT.ExtendedTimeZone.SetTimeZone () para permitir una zona de tiempo especificado (eliminando así la necesidad de que extra «timezoneOffset» parámetro añadí a dos de los métodos) o incluso el Microsoft . SPOT.Time.TimeService.UpdateNow (), lo que haría que todo el código anterior obsoleto. Sin embargo, es comprensible que algunas bibliotecas necesarias para ser despojado debido a las limitaciones de tamaño de memoria
Fuente

aqui

Ampliación para Netduino


Multiplexación con BitShift-CI

Desde el momento en que conseguí mi tarjeta de microprocesador Netduino Estaba pensando, ¿cuáles son sus limitaciones y cómo se puede trabajar alrededor de ellos? Una de las limitaciones más evidentes es la cantidad de entrada / salida (E / S). Esta imagen muestra lo que la junta es capaz de:

Como  puede verse   en la placa hay 13 puertos  de E / S digitales.
Quería ver una forma de evitar esta limitación con bastante éxito. Mediante la adición de múltiples BitShift IC es que es posible obtener prácticamente ilimitadas I / O-ports. La única limitación de esto es la velocidad de reloj, pero no he llegado a esta limitación todavía.
He utilizado dos tipos de circuitos integrados, serial-in/parallel-out un 74HC595, llamadas y parallel-in/serial-out un llamado 74HC165. Pueden ser utilizados en las cadenas, por lo que al añadir más circuitos integrados, usted no necesitará utilizar más puertos I / O de la placa Netduino. En mi ejemplo a continuación me dieron 32 puertos I / O por sólo ocupa 5 I / O en la netduino.
El esquema es muy simple, he usado botones con resistencia pull-up para representar las entradas y leds para representar salidas. La idea básica es que cada añadido IC añade 8 entradas o puertos de salida.

Entonces llegamos a la parte del código. Conexión de cosas es una cosa, hacer que funcione es otra. El Netduino está lleno de código compilado de C # y utiliza el MicroFramework. NET.
Este marco tiene un par de clases incorporadas, por ejemplo, OutputPort, InputPort y InterruptPort. Hice copias de esas clases incorporadas para trabajar con el BitShift la IC, por lo que sería un uso sencillo que el resto de la estructura.
La única diferencia es que tenemos que definir la configuración de la IC en primer lugar. Así que tenemos dos de entrada y dos de IC de salida IC. Definimos las cadenas conectadas en primer lugar:
?
1
2
Ic74HC165Chain ChainIn = new Ic74HC165Chain (SPI_Devices.SPI1, Pins.GPIO_PIN_D10, 2);
Ic74HC595Chain ChainOut = new Ic74HC595Chain (SPI_Devices.SPI1, Pins.GPIO_PIN_D9, 2)
Ambas cadenas de CI están conectados a la SPI Netduino de autobuses (pines 11 a 13) y el uso de un chip diferente Select-pin, en este ejemplo los pins 9 y 10. Ambas cadenas contienen 2 IC.
Cuando las cadenas se definen, tenemos que hacer que las interfaces para la del IC. Esto se hace por la presente:
?
1
2
3
4
Ic74HC165 IcIn1 = new Ic74HC165 (ChainIn, 0);
Ic74HC165 IcIn2 = new Ic74HC165 (ChainIn, 1);
Ic74HC595 IcOut1 = new Ic74HC595 (ChainOut, 0);
Ic74HC595 IcOut2 = new Ic74HC595 (ChainOut, 1);
La enumeración comienza en 0 como se puede ver. 0 es la primera IC de la cadena, la segunda 1, 2 de la tercera, etcétera.
Ahora podemos definir nuestra entrada / salida / InterruptPort clases. Ellos tienen los mismos parámetros que las clases regulares a excepción de la primera, que define el IC está conectado a:
?
1
2
InterruptPortShift Button0 = InterruptPortShift nuevo (IcIn1, Ic74HC165.Pins.GPI_PIN_D0, falso, Port.ResistorMode.Disabled, Port.InterruptMode.InterruptEdgeBoth);
OutputPortShift Led0 = new OutputPortShift (IcOut1, Ic74HC595.Pins.GPO_PIN_D0, false);
Aquí hemos definido una InterruptPort OutputPort y uso de registros BitShift. Desde esta parte, el código que sigue es exactamente la misma que se utiliza a bordo de la E / S de los puertos.

Fuente original

Licencia Creative Commons
solo-electronicos por Carlos Rodriguez Navarro se encuentra bajo una Licencia Creative Commons Atribución-NoComercial-CompartirIgual 3.0 Unported.