Instalación del TinyBooterDecompressor paso a paso


Como paso previo antes de flashear su Netduino Plus a la version 4.2  debe instalar en este el TinyBooterDecompressor como paso previo ,pues de no hacerlo al intentar flashear el Netduino “directamnte” al final fallaría al hacer el deploy  .

Para empezar descargue e instale  el software de  SAM-BA 2,12 CDC para Windows (XP, Vista, W7s) de esta página de descarga( tendrá que registrarse para descargarlo, pero no hay coste).

Para obtener los mejores resultados actualizar el controlador de Windows (utilizando el Administrador de dispositivos) para los controladores ubicados en Archivos de programa (según el sistema) \ ATMEL Corporation \ sam-ba_2.12 \ drv ANTES de utilizar esta herramienta.

Despues  de  haber instalado el sw de Atmel,debe resetear  su  Netduino mediante la conexión de +3,3 V al cuadrado de metal  que hay debajo Digital I / O pin 0, mientras que el Netduino está encendido.
Imagen

Ahora  conecte el Netduino al PC, instalandose  un nuevo  driver  de un puerto COM emulado.

Inicie la herramienta SAM-BA. Si un driver para un puerto COM emulado no está instalado en un equipo con Windows 7 x64-máquina, trate de esta página wiki .

Seleccione el puerto serial (puerto COM) está conectado a la Netduino, seleccione el chip adecuado para su Netduino y haga clic en “Conectar”.

La informacion del chip de información para su Netduino esta en el propio dispositivo, teniendo  el chip estampado  “Atmel” él, y el chip tendrá un identificador como “at91sam7x512-ek” (el valor real dependerá de la version de  Netduino  que tenga).
Imagen

Ahora tenemos que ejecutar dos scripts. En primer lugar, seleccione  “Boot from Flash (GPNVM2)” , es decir arrancar desde Flash (GPNVM2) y haga clic en “Ejecutar”.
ImagenLuego tenemos que hacer lo mismo con el script ” Enable Flash access” , es decir activar acceso a  Flash  ” .

Ahora asegúrate de que estamos enla pestaña  “Flash”, y en  “Send File Name” seleccione el archivo   “TinyBooterDecompressor.bin” y haga clic en “Send File”. (este archivo se encuentra en el nuevo  firmware del archivo ZIP de la version de Netduino  que tenga )
Imagen

Entonces  obtendremos un mensaje sobre regiones bloqueadas. Haga clic en “No”
Imagen

Después de haber lanzado este ultimo script  podemos cerrar la herramienta SAM-BA y probar si está hecho en realidad,para ello, vuelva a conectar el Netduino y ejecute el MDFDeploy.exe.

Seleccione USB y el Netduino, a continuación, haga clic en Ping, y ahora debería responder con la nueva  versión.
Imagen

Ahora ya está listo para  cambiar la version del firmware

Fuente  aqui  http://wiki.netduino.com/Installing-the-TinyBooterDecompressor-step-by-step.ashx

Netduino sobre Windows 8


Si tiene usted un Netduino o Netduino Plus  (con firmware antiguo 4.1 )  y  desea desarrollar sobre la plataforma Netduino  con su nuevo pc con Windows 8, inevitablemente tendrá que actualizar el Firmware  de su  viejo netduino o netduino plus  a la  versión: 4.2.0 Update 1 (versión 4.2.0.1) o bien utilizar directamente un nuevo  Netduino Plus versión 2.

Este  nuevo firmware requiere el uso del . NET Micro Framework SDK v4.2 (qfe2) y Netduino 4.2.0.1 SDK .

Con este firmware, tendrá los siguientes recursos disponibles para el código:

  • 64KB flash
  • Más de  42KB de RAM (RAM 50% más que en 4.1.0.6)
  • Actualización de PWM de corrección de errores (periodo / frecuencia ahora ajustada correctamente)

Este firmware también incluye las actualizaciones previas siguientes:

  •  50% más de memoria RAM: 42KB (4.2.0.0) vs 28KB (4.1.0.6)
  • Visual Basic es ahora un lenguaje compatible con. NET MF
  • Nuevo núcleo AnalogInput y clases de PWM, compatibles con versiones anteriores clases disponibles a través de add-on asambleas.
  • Nuevos drives  WinUSB  (para poner remedio a los problemas BSOD en 4.2 beta)
  • Recolector de basura ahora totalmente colecciona objetos antiguos
  • Ir a la paagina  netmf.codeplex.com para los detalles completos de todas las correcciones de errores

Para encontrar la versión exacta  del firmware  actual de su Netduino o  Netduino Plus   haga lo siguinte:

  1.  Ir al menú Inicio> Programas> Microsoft. NET Micro Framework 4.2 Herramientas>
  2.  Ejecutar MFDeploy.exe. Tenga cuidado de no ejecutar MFDeploy.exe y MFDeploy.exe.config (como las extensiones de archivos están ocultos por defecto)
  3. Conecte su Netduino Plus a su PC usando un cable Micro USB.
  4.  En la sección de dispositivos en la parte superior, seleccione USB en lugar de serie. Su Netduino Plus debe aparecer en la lista desplegable, y si no es así, seleccionelo.
  5. Seleccione el menú  “Target”  ,seleccione  “Device  Capabilities”,
  6.  En el cuadro de salida, buscar  el valor de  “SolutionReleaseInfo.solutionVersion” : esta será precisamente  la versión del firmware de su Netduino.

version_netduino

Los usuarios de la versión de firmware 4.2.0.0 + no es necesario que actualizan TinyBooter.

El nuevo  firmware se  puede conseguir aqui:  http://wiki.netduino.com/Firmware.ashx

firmware

Los usuarios de la versión de firmware 4.2.0.0 RC5 o anteriores pueden actualizar TinyBooter de la siguiente manera:

  1. Ejecutar el TinyCLR utilizando MFDeploy v4.2 +
  2.  Haga clic en “Examinar …” y seleccione los archivos TinyCLR (ER_CONFIG y ER_FLASH)
  3.  Pulse el botón “Deploy”. Tomará unos minutos para actualizar su Netduino.
  4.  Desconecte y vuelva a conectar su Netduino (apagar y encender)

Después de parpadear, para establecer la configuración de red utilizando MFDeploy siga estos pasos :

  1. Comience su Netduino Plus en modo TinyBooter manteniendo el pulsador mientras que conectarlo a su PC mediante un cable microUSB.
  2. Seleccione el Destino> Configuración> menú de red. Vuelva a introducir los ajustes de la dirección IP y la dirección MAC.
  3. Desconecte y vuelva a conectar su Netduino Plus (apagar y encender)

Mas información  aquí  url  http://wiki.netduino.com/Flashing-new-firmware-step-by-step.ashx]

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

Sensor de sonido para netduino


Aquí  se explica como usar un simple piezo eléctrico para detectar el sonido, lo que nos permitirá usarlo como un sensor para golpes o “toques” (puedes pegar el piezo eléctrico a una superficie por ejemplo). Para esto podemos aprovechar la capacidad de leer señales análogas del CAD – convertidor análogo a digital. Estos conversores leen el valor de un voltaje y lo transforman en un valor entre 0 y 1024. 0 representa 0 V y 1024 representa 5 V en la entrada de uno de los 6 pines análogos.

Como sabreis , un piezo eléctrico no es otra cosa que un dispositivo electrónico que suele  usarse  para reproducir o detectar tonos. En este ejemplo hemos conectado el piezo eléctrico en el pin de entrada análoga número3, que puede leer un valor entre 0 V y 5 V, y no solamente HIGH o LOW (pines digitales).

Un punto importante es que los piezo eléctricos tienen polaridad, la cual, en los dispositivos comerciales, se indica normalmente con un cable rojo y uno negro para saber cómo conectarlo a la placa. Debemos conectar el negro en la tierra y el rojo en el pin de entrada. Además debemos conectar una resistencia en el rango de los Megaomhnios en paralelo al piezo; en el ejemplo lo hemos hecho directamente en los conectores hembra.

El siguiente código capturará el tono y si sobrepasa cierto límite, pintara por la consola  el mensaje “Se ha sobrepasado el umbral de sonido”

Sensor de golpes.

//Sensor de sonidos

//By CRN

//@2012

public static void Main()
{

var voltagePortSonido = new SecretLabs.NETMF.Hardware.AnalogInput(Pins.GPIO_PIN_A2); //configura entrada temperatura

…..

sonido(voltagePortSonido, apiKey, feedId, out sonidoC); //captura medidad de temperatura

if (sonidoC> umbral)

{

Debug.Print(“Se ha sobrepasado el umbral de sonido”);

}

……
static void sonido(SecretLabs.NETMF.Hardware.AnalogInput vport, string apikey, string feedId, out double tt)
{

tt = 0;
for (int aa = 0; aa < 100; aa++) //100lecturas
{
int rawValue = vport.Read();
float voltage = rawValue ;// 3300; ///lectura en mv si usamos referecnica de 3.3v

if (tt < voltage)
{
tt = voltage;//toma el maximo
}
}

fuente original :http://arduino.cc/es_old/Tutoriales/SensorKnock

Primeros Pasos con Netduino como webserber


En estas lineas vamos a mostrar cómo crear un pequeños servidor web, que ejecutaremos en nuestro Netduino (+). El servidor web debe responder ante cada petición HTTP con un “Hola Mundo”.

Empezamos creando un nuevo proyecto de tipo Netduino Plus en nuestro Visual Studio–> Botón derecho sobre el proyecto y elige “Añadir nuevo elemento”. –>Añade una nueva clase llamada WebServer.cs.
Aquí presentamos una versión muy simple de nuestro servidor web  que se mantiene a la escucha, atendiendo las peticiones, y respondiendo “Hola Mundo” mientras hace parpadear el led de nuestro Netduino Plus.
public class WebServer : IDisposable
{
   private Socket socket = null;
   private OutputPort led = new OutputPort(Pins.ONBOARD_LED, false);
   public WebServer()
  {
       //Inicializamos el socket
       socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
       //Conectamos el socket
       socket.Bind(new IPEndPoint(IPAddress.Any, 80));
      //Iniciamos la escucha
      socket.Listen(10);
      ListenForRequest();
 }
 public void ListenForRequest()
{
  while (true)
  {
     using (Socket clientSocket = socket.Accept())
     {
       //Aceptamos el cliente
       IPEndPoint clientIP = clientSocket.RemoteEndPoint as IPEndPoint;
       EndPoint clientEndPoint = clientSocket.RemoteEndPoint;
       int bytesReceived = clientSocket.Available;
       if (bytesReceived > 0)
      {
           //Obtenemos la petición
           byte[] buffer = new byte[bytesReceived];
           int byteCount = clientSocket.Receive(buffer, bytesReceived, SocketFlags.None);
           string request = new string(Encoding.UTF8.GetChars(buffer));
           Debug.Print(request);
         //Componemos la respuesta (Nota 1)
           string response = “Hola Mundo”;
           string header = “HTTP/1.0 200 OK\r\nContent-Type: text; charset=utf-8\r\nContent-Length: ” + response.Length.ToString() + “\r\nConnection: close\r\n\r\n”;
           clientSocket.Send(Encoding.UTF8.GetBytes(header), header.Length, SocketFlags.None);
           clientSocket.Send(Encoding.UTF8.GetBytes(response), response.Length, SocketFlags.None);
           //Parpadeo del led
           led.Write(true);
           Thread.Sleep(150);
           led.Write(false);
      }
    }
  }
}
#region IDisposable Members
~WebServer()
{
      Dispose();
}
public void Dispose()
{
     if (socket != null)
        socket.Close();
}
#endregion
}
El siguiente paso es añadir el siguiente código para iniciar el servidor web.
public static void Main()
{
    Microsoft.SPOT.Net.NetworkInformation.NetworkInterface.GetAllNetworkInterfaces()[0].EnableDhcp();
    WebServer webServer = new WebServer();
    webServer.ListenForRequest();
}
En el siguiente paso, tenemos que desplegar el código en nuestro Netduino haciendo click en las propiedades del proyecto.
Una vez cambiadas las propiedades del proyecto, seleccionamos la pestaña “.Net Micro Framework” y cambiamos las siguientes propiedades:
Transport: USB
Device: NetduinoPlus_NetduinoPlus
Ahora solo nos queda pulsar F5 para pasar nuestro código a Netduino ,esperar unos inst asegurando que  nuestro Netduino-plus esta conectado a internet   realizamos la siguiente petición mediante nuestro navegador.
http://192.168.1.2/ ( o la ip que le haya asignado nuestro router a nuestro netduino)

Plataforma Netduino plus


Carastericticas de la placa

● all 20 digital and analog pins: GPIO
● digital pins 0-1: UART 1 RX, TX
● digital pins 2-3: UART 2 RX, TX
● digital pins 5-6: PWM, PWM
● digital pins 7-8: UART 2 RTS, CTS
● digital pins 9-10: PWM, PWM
● digital pins 11-13: SPI MOSI, MISO, SPCK
● analog pins 4-5: I2C SDA, SCL

Red

● ethernet: 100 mbps
● network stack: lwIP

Almacenamiento

● micro sd (up to 2 GB)
● auto card detect

Netduino es una nueva plataforma abierta  basada en  Microsoft.NET Micro Framework. La versión  Netduino Plus ademas  es un poderoso Netduino junto con Ethernet integrado, así como el apoyo de una ranura para microSD en la misma tarjeta

Cuenta con un  potente microcontrolador de 32 bits integrado con un entorno de desarrollo estándar que está disponible gratuitamente a través de Microsoft (Visual Studio 2010).

La plataforma permite una fácil interconexión con switches, sensores, LEDs, dispositivos de serie, y mucho más. El Netduino combina 20 GPIO con SPI, I2C, UART 2 (1 RTS / CTS), 4 y 6canales de PWM ADC.

Microsoft. NET Micro Framework combina la facilidad de un lenguaje de programación de alto nivel (C #) con las características de los microcontroladores.

Disfrute de la depuración de programación basada en eventos, multi-threading, línea por línea,puntos de interrupción y mucho más!

Ademas se pueden añadir  mas accesorios ofreciendo estos una funcionalidades extra ( por ejemplo la ubicación GPS, el control de servos ,displays  de todo tipo).

Netduino es ademas   compatible pin a pin con la plataforma Arduino.

Para comenzar con el desarrollo Netduino debemos  instalar el siguiente software gratuito.

Recomiendo que instale todo en el mismo orden que aparecen  aqui.

  1.  Microsoft Visual C# Express 2010 (get it FREE here)
  2. .NET Micro Framework  (get it FREE here)
  3. Netduino SDK (Free download)Download 32-bit Netduino SDK v4.1.0Download 64-bit Netduino SDK v4.1.0
Ahora que usted tiene todo el software instalado, vamos a probar que todo funciona. Los controladores para su Netduino más que ya se han instalado con el SDK de Netduino. Si no aparece estar funcionando se puede descargar los controladores desde el Netduino website.
Una vez hecho esto usted estara listo para su primer proyecto de  Netduino .