Tutorial Netduino Parte 7


 

 Netduino es una plataforma de desarrollo de código abierto integrado similar al Arduino, excepto que utiliza .NET Micro Framework para la programación.  La placa de desarrollo Netduino tiene el mismo factor que Arduino Uno, y por lo tanto la mayoría de los escudos de Arduino son también compatibles con Netduino.  Las placas de desarrollo Arduino se basan en 8 bits microcontroladores Atmel que corren a una velocidad máxima de reloj de 16 MHz en su versión primera. Por otra parte, el hardware Netduino usa potentes procesadores de 32 bits (en el caso de la primera versión un  Atmel SAM7x en Netduino, y STMicro STM32F4 en versiones Netduino Plus) y funciona a una velocidad mucho más rápida (48 MHz a 168 MHz).

El  siguiente tutorial  extraidos de http://embedded-lab.com/blog    tienen como objetivo proporcionar una amplia introducción a la plataforma Netduino  y asegurar que cualquier principiante, estudiante o aficionado, será rápidamente capaz de empezar a usarlo para sus propios proyectos y diseños embebidos. En todos los ejemplos se usa una placa  Netduino Plus ( es la versión mas antigua con NETMF 4,1) se utiliza para ilustrar la salida en estos experimentos.

Como continuación del curso básico de Netduino https://soloelectronicos.com/2015/02/24/tutorial-netduino-parte-6/    en esta   ocasión vamos   a tratar la  gestión de PWM

Pulse Width Modulation (PWM) es un método digital de la entrega de una cantidad variable de energía a una carga, y por lo tanto se puede utilizar para controlar el brillo de un LED o la velocidad de un motor de corriente continua. El control de la potencia, haremos este tutorial colorido usando un Azul Verde Rojo (RGB) LED. Cada segmento (plomo) de RGB-LED obtendrá una señal PWM a través de la clase RGBLED lo que nos permite iluminar el LED RGB con cualquier color definido por RGB. Esta clase también puede generar colores al azar. Utilización de la clase RGBLED, algunos colores estándar también se pueden enviar a un LED RGB.

Configuración de Circuito y Teoría

Para entender PWM, vamos a entender los términos que conforman unas señales de ancho de pulso modulado. El uno es muy importante pues es del ciclo de trabajo. En términos flexibles este ciclo de trabajo es un valor en porcentaje del estado ON en comparación con el estado OFF. A partir de la figura siguiente podemos ver la fórmula para calcular el ciclo de trabajo.

Ahora, vamos a ver como  co-relacionan lo anterior a nuestro proyecto. Digamos que nos gusta para producir un color “gris”. Conocemos el valor RGB para el gris es de 128, 128 y 128. Esto significa, si mezclamos el 50% de rojo (50% de 256 es 128), el 50% de verde y 50% de azul, vamos a obtener un color gris . El valor de 50% provino de 128/256 * 100%. Con respecto a la figura anterior, si T = el 50% para la pierna roja, T = el 50% de la pierna verde y T en = 50% de la pata azul de un LED RGB entonces vamos a tener un color gris a partir de un LED RGB- . El valor calculado es nada más que el ciclo de trabajo de un PWM. En la clase RGBLED, que básicamente ajustar el ciclo de trabajo para iluminar el LED RGB con un color deseado.

Asi se muestra  un ciclo de trabajo de hoja de cálculo Excel para entenderlo un poco mejor  y también la explicación de  la clase RGBLED.

 

Las conexiones no son tan difíciles. Pines digitales Netduino, 5, 6, 9 y 10 se pueden configurar como pines PWM, de los cuales vamos a configurar 5, 6 y 9. Las salidas de estos pines son alimentados a la base de un transistor NPN. Cuando el pulso es alta, el transistor entra en modo de saturación y permite el flujo desde el colector al emisor que está conectado nuestro RGB LED. Dado que el LED RGB usado en este tutorial es ánodo común, el plomo ánodo está conectado a + 5v. El diagrama del circuito siguiente muestra la conexión.

La imagen siguiente muestra la configuración de circuito en un circuito y sus conexiones con el Netduino.

 

 

C Programa # .NET

La utilización de la clase RGBLED es muy simple así que vamos a saltar todo por ahora y  centrarnos en la propia clase. El constructor de la clase toma cuatro argumentos, el número de pin para el rojo, verde y azul y  el último argumento es opcional para commonAnode lo cual es cierto por defecto (en el diagrama del circuito que no es demasiado importante si nos fijamos este valor a verdadero o falso).

En este método constructor nuevas instancias de la clase PWM están embalados luego una tabla de colores Hashtable se rellena con el color estándar.

 

public RgbLed(Cpu.Pin redPwmPin, Cpu.Pin greenPwmPin, Cpu.Pin bluePwmPin, bool commonAnode = true)
{
	RedLED = new PWM(redPwmPin);
	GreenLED = new PWM(greenPwmPin);
	BlueLED = new PWM(bluePwmPin);
	LEDs = new PWM[] { RedLED, GreenLED, BlueLED };
 
	CommonAnode = commonAnode;
	ColorTable = new Hashtable();
	ColorTable.Add(0, new byte[] { 0, 0, 0 });		// Off (~~ Black color)
	ColorTable.Add(1, new byte[] { 0, 100, 100 }); 	// Aqua
	ColorTable.Add(2, new byte[] { 0, 0, 100 });	// Blue
	ColorTable.Add(3, new byte[] { 100, 0, 100 });	// Fuchsia
	ColorTable.Add(4, new byte[] { 50, 50, 50 });	// Gray
	ColorTable.Add(5, new byte[] { 0, 50, 0 });		// Green
	ColorTable.Add(6, new byte[] { 0, 100, 0 });	// Lime
	ColorTable.Add(7, new byte[] { 50, 0, 0 });		// Maroon
	ColorTable.Add(8, new byte[] { 0, 0, 50 });		// Navy
	ColorTable.Add(9, new byte[] { 50, 50, 0 });	// Olive
	ColorTable.Add(10, new byte[] { 50, 0, 50 });	// Purple
	ColorTable.Add(11, new byte[] { 100, 0, 0 });	// Red
	ColorTable.Add(12, new byte[] { 75, 75, 75 });	// Silver
	ColorTable.Add(13, new byte[] { 0, 50, 50 });	// Teal
	ColorTable.Add(14, new byte[] { 100, 100, 100 });// Whilte
	ColorTable.Add(15, new byte[] { 100, 100, 0 });	// Yellow
}

Hay tres métodos públicos disponibles para el establecimiento de un color, el Turnit, escribir y métodos RandomColor. Tener color estándar, llamar al método Turnit y pasar el color estándar de color Enum. El método de escritura toma tres argumentos byte para el color rojo, verde y azul. Finalmente, RandomColor calculará número aleatorio para el valor de color rojo, verde y azul.

 

public void TurnIt(Color color)
{
	if (ColorTable.Contains((int)color))
	{
		colorArray = (byte[])ColorTable[(int)color];
		SetColor();
	}
	else
		throw new Exception("Color not found");
}
public void Write(byte red, byte green, byte blue)
{
	colorArray = new byte[] { (byte)(red * 100 / 255), (byte)(green * 100 / 255), (byte)(blue * 100 / 255) };
	SetColor();
}
public void RandomColor()
{
	Random random = new Random();
	colorArray = new byte[] { (byte)random.Next(100), (byte)random.Next(100), (byte)random.Next(100) };
	SetColor();
}
public override string ToString()
{
	colorString = string.Concat("RGB(", colorArray[0], ", ", colorArray[1], ", ", colorArray[2], ")");
	return colorString;
}

Todos los métodos públicos llaman internamente al método privado SetColor.Este  básicamente cambia el ciclo de trabajo de las instancias de PWM para cada pin de lectura, verde y azul.

 

private void SetColor()
{
	if (CommonAnode) colorArray = AdjustPolarityValue(colorArray);
	LEDs[0].SetDutyCycle((uint)colorArray[0]); // Red
	LEDs[1].SetDutyCycle((uint)colorArray[1]); // Green
	LEDs[2].SetDutyCycle((uint)colorArray[2]); // Blue
}
private byte[] AdjustPolarityValue(byte[] colorArray)
{
	return new byte[] { (byte)(100 - colorArray[0]), (byte)(100 - colorArray[1]), (byte)(100 - colorArray[2]) };
}

Aquí está la clase  del diagrama RGBLED :

Salida

Para demostrar el uso de cada tres métodos públicos, hay tres partes en el vídeo. Primero se muestra el color estándar entonces se muestra el espectro de colores de bucle a través de diferentes lazos de color y finalmente un poco de color al azar.

En este código   se busca mostrar algunos colores estándar

 

RgbLed led = new RgbLed(Pins.GPIO_PIN_D9, Pins.GPIO_PIN_D6, Pins.GPIO_PIN_D5, false   );
 
// Display standard colors
led.TurnIt(RgbLed.Color.Red);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Navy);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Purple);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Green);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Maroon);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Blue);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Fuchsia);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Teal);
WaitAndTurnOff(500, led);
 
led.TurnIt(RgbLed.Color.Yellow);
WaitAndTurnOff(500, led);

Para mostrar diferentes colores se utilizan tres bucles for  en forma de cascada:

 

for (int red = 0; red < 255; red += 50)
{
    for (int green = 0; green < 255; green += 50)
    {
        for (int blue = 0; blue < 255; blue += 50)
        {
            led.Write((byte)red, (byte)green, (byte)blue);
            Debug.Print(led.ToString());
 
            WaitAndTurnOff(100, led);
        }
    }
}

Y para generar los colores al azar (bucle 20 veces)  se utiliza  este código:

 

for (int i = 0; i < 20; i++)
{
    led.RandomColor();
    WaitAndTurnOff(500, led);
}
private static void WaitAndTurnOff(int time, RgbLed led, byte longerOn = 2)
{
    Thread.Sleep(time * longerOn);
    led.TurnIt(RgbLed.Color.Off);
    Thread.Sleep(time);
}

Y  por   último    un vídeo de salida rápida del código de seguridad.

 

Fuente   aqui

Anuncios

El primer libro de Netduino 2 en Español


En los últimos años, electrónica e informática han pasado de ser algo que sólo los ingenieros podían comprender, a estar accesible a todo el público en general sin necesitar demasiados conocimientos técnicos.

Netduino  como  tantas veces  se ha  hablado en  este blog,  precisamente ha crecido hasta convertirse en una parte de esta revolución, proporcionando en una placa del tamaño de una carta un potente entorno gracias a la depuración de programación basada en eventos, multi-threading, ejecución línea a línea, inserción de puntos de interrupción, etc, permitiendo tanto capturar como controlar dispositivos desde Internet de una manera mucho más sencilla y rápida comparada con otras plataformas basadas en   hardware. abierto.

portada libro

 

A propósito del libro , EL PRIMER LIBRO SOBRE NETDUINO 2 EN ESPAÑOL: Proyectos domóticos paso a paso para todos los niveles, por el momento disponible  en formato kindle  en  Amazon  ,pero muy pronto tambien disponible en papel ( en color y también  en versión eco de bajo coste),   éste intenta cubrir un vacío que existe en el mundo hispano-hablante respecto a  la  plataforma   Netduino 2+ intentando ser una referencia, tanto a las personas que ya manejen esta plataforma para profundizar en algunos aspectos, como aquellas otras que se inician por primera vez, para que de forma paulatina, vayan empezando a entender los entresijos de la programación en c# y su relación con el mundo físico.

La lectura de este nuevo  libro comienza intentando comprender el hardware  de Netduino y su evolución hacia Netduino 2+, este último sobre el que se centrará el resto del libro, explicando con detalle cómo instalar las herramientas necesarias.
Una vez el entorno preparado, lo primero es probar la comunicación y, tras esto, ya podemos a empezar a escribir nuestro propio primer programa haciendo encender o apagar un led (cap. 2 y 3).
Cuando controlamos salidas binarias lo siguiente es manejar las entradas binarias, lo cual se ilustra con un ejemplo que usará el pulsador interno (cap. 4).
Otro tema interesante puede ser PWM (cap. 5) que puede usarse en infinidad de aplicaciones y que, como ejemplo, usaremos para variar el brillo de un led.

En los capítulos siguientes se tratan los diferentes sensores que podemos utilizar en domótica empezando por los sensores de ruido (cap.6) para lo cual necesitaremos el procesamiento de señales analógicas que se trata con un ejemplo. Otro aspecto interesante son los sensores de posición que también se tratan con un ejemplo real (cap. 7).
En domótica aparte de las entradas y salidas binarias también se usan sensores de variables físicas como por ejemplo los sensores de temperatura, de luz o de movimiento que se tratan en los cap. 8,9 y 10 (terminando también cada uno con un ejemplo).
Una mención especial lo ocupa el cap.11 donde se tratan los sensores de consumo eléctrico tan usuales para monitorizar y optimizar nuestro consumo energético. Como no podría ser menos, también se proponen varios ejemplos de manejo real de éstos.
Una vez tratados la mayoría de los sensores, se explica cómo conectar Netduino 2 con un display LCD compatible con el estándar HD44780 para desplegar información en éste que nos interese viéndolo con dos ejemplos reales (cap12).
En los siguientes capítulos se describen cómo es posible acceder a todos los sensores y actuadores descritos (y por supuesto todos los que el lector decida) de forma remota, gracias a la conectividad tcp-ip que integra la misma placa Netduino 2 plus.
En primer lugar se trata de explicar los entresijos una aplicación que instalaremos en Netduino 2 plus que hace de servidor web, el cual nos va a permitir interactuar de forma remota con éste.
Y hablando de control ¿qué mejor que desarrollar una app para permitirnos controlar Netduino 2 a distancia? Pues para ello, se tratara primero de las generalidades de MIT App Inventor (cap14), entorno que nos va a permitir desarrollar una app móvil de una forma muy sencilla desde la nube.

Finaliza  el libro con el desarrollo de una aplicación móvil real que será capaz de interactuar desde Internet con todo el hw descrito en capítulos anteriores , haciendo de colofón del libro ,mostrando de esta forma cómo es posible hacer aplicaciones móviles que interactúen de forma remota con N2 plus de una forma sencilla

 

Espero   que   este libro  pueda  ayudar a comprender  y a  usar esta estupenda plataforma  como es Netduino+

 

Más  información  aqui

M2M con Netduino y Yaler


Netduino puede  ser  accesible desde cualquier lugar a través de la infraestructura de retransmisión Yaler.Como requisitos previos  para la configuración de su dispositivo requiere un Framework   que puede instalarse uno mismo   en un servidor Linux  o Windows  o si no lo dispone puede registrarse en Yaler para obtener una cuenta gratis para conseguir uno.
Para  hacerlo  funcionar usaremos la  biblioteca Gsiot.Server de Cuno Pfister que se ejecuta en   Netduino Plus , Netduino Plus 2 , Mountaineer y otra spalacas   NET Micro Framework. .

Siga estos pasos en el equipo de Windows para asegurarse de que DHCP del Netduino está activado y una dirección MAC está establecida:

  1. Inicio MFDeploy.exe situado en
      C:.. \ Archivos de programa (x86) \ Microsoft NET Micro Framework \ v4 x \ Tools \ MFDeploy.exe
  2. Seleccione el tipo de dispositivos USB
  3. Conecte su Netduino a través de USB
  4. Haga clic en el botón Ping hasta que el Netduino responde con
      Haciendo ping a ...  TinyCLR
  5. Para abrir el cuadro de diálogo de configuración de red, seleccione el menú
      Target> Configuración> Conexiones de red
  6. Asegúrese de que la casilla de verificación Habilitar DHCP se comprueba
  7. Asegúrese de que la dirección MAC es la misma que la dirección impresa en la etiqueta en su Netduino
  8. Haga clic en Actualizar para guardar los cambios en el Netduino
  9. Reinicie el Netduino desenchufando y enchufando el cable USB
  10. Hecho.

Instalación de la biblioteca Gsiot.Server

Siga estos pasos para agregar la biblioteca Gsiot.Server de Cuno Pfister para Visual Studio.

  1. Para Netduino Plus, descarga
      Proyectos + V20110526 ...  . Zip

    Para Netduino Plus 2 o tableros Mountaineer, descarga

      Muestras Gsiot + + para + NETMF 4.2 ...  . Zip
  2. En Windows, abra el ZIP y copiar las carpetas Gsiot.Server y HelloWeb (y, si están disponibles, Oberon.Netmf.Compatibility)para
      C: \ Users \ nombre_usuario \ Documents \ Visual Studio 2012 \ Projects
  3. Hecho.

Ejecución de un ejemplo de servicio Web

  1. En Windows en Visual Studio, abra el proyecto
      HelloWeb
  2. Reemplace <insertar su dominio de retransmisión here> con su dominio de retransmisión, por ejemplo, para el relé de dominio gsiot-ffmq-ttd5 que sería
      RelayDomain = "gsiot-ffmq-ttd5",
  3. Reemplace <insertar su here> clave secreta con su clave, por ejemplo, para la claveo5fIIZS5tpD2A4Zp87CoKNUsSpIEJZrV5rNjpg89 eso sería
      RelaySecretKey = "o5fIIZS5tpD2A4Zp87CoKNUsSpIEJZrV5rNjpg89",
  4. Construir y cargar el código de ejemplo a su Netduino
  5. Hecho. Ahora, ver cómo acceder a su dispositivo desde un navegador Web o con Curl (añadir /hello para que funcione).

Fuente aqui

Flashear sin peligro tu Netduino plus a Netduino Plus V2


Flashear siempre es un riesgo en casi todos los dispositivos programables básicamente porque en el 99% de las veces ira bien y como fruto tendremos un sistema actualizado ,pero desgraciadamente  puede haber un 1% donde no ira bien y el resultado no sera agradable “bricked”   pues por desgracia no siempre se podra arreglar

En el caso de contar con el netduino con 4.1.0 (version anterior) podria estar más que justificado realizar  laa actualizacion ,pues el nuevo firmware 4.2.1  incluye las siguientes actualizaciones :

  1. Corrección de errores PWM (periodo / frecuencia ahora ajustada correctamente)
  2. 64Kb flash  y 50% más de memoria RAM: 42KB (4.2.0.0) vs 28KB (4.1.0.6)
  3. Visual Basic es ahora un lenguaje soportado por. NET MF
  4. Nuevas clases AnalogInput y PWM básicos; clases compatibles con versiones anteriores disponibles a través de add-on asambleas.
  5. Nuevos drivers WinUSB (para remediar problemas BSOD en 4.2 beta)
  6. Recolector de basura ahora recoge plenamente objetos antiguos
  7. Ver netmf.codeplex.com para los detalles completos de todas las correcciones de errores

Para empezar ,para encontrar la versión actual de su firmware Netduino Plus:

  1.  Ir al inicio Menú> Programas> Microsoft. NET Micro Framework 4.2> Herramientas
  2. Ejecute MFDeploy.exe. Tenga cuidado al ejecutar MFDeploy.exe y no MFDeploy.exe.config (como las extensiones de archivo están ocultas de manera predeterminada)
  3. Conecte su Netduino Plus a su PC usando un cable USB Micro.
  4. En la sección de dispositivos en la parte superior, seleccione USB en lugar de en serie. Su Netduino Plus debe aparecer en la lista desplegable, si no, seleccionarlo.
  5. Seleccione la opción de menú Target, Capacidades de dispositivo.
  6. En el cuadro de salida, encontrar el valor “SolutionReleaseInfo.solutionVersion”. Esta es la versión del firmware.

Si su version es la antigua (4.1,x)  puede seguir  bajo su responabilidad los siguintes pasos  para actualizar   el firmware:

TinyBooterDecompressor

Para empezar necesitara  descargar e instalar SAM-BA 2.12 CDC para Windows (XP, Vista, W7) de esta página de descarga(Usted tendrá que registrarse para descargar, pero no hay ningún coste). Para obtener los mejores resultados actualizar el controlador de Windows (utilizando el administrador de dispositivos) para los controladores ubicados en (dependiendo de su sistema) Archivos de programa \ Atmel Corporation \ sam-ba_2.12 \ drv ANTES de utilizar esta herramienta. Si esto no funciona para usted, algún éxito ha estado utilizando el SAM-BA 2.9 no CDC disponible aquí .

Restablecer completamente su Netduino conectando 3,3 V hasta la plaza de metal debajo de E / S digital pin 0, mientras que el Netduino está encendido como se  muestra en la foto .
Imagen

Ahora  reconectar el Netduino al PC. Se instalará un controlador para un puerto COM emulado. Inicie la herramienta SAM-BA. Si un controlador de un puerto COM emulado no está instalado en una máquina x64 de Windows 7, pruebe esta página wiki .

Seleccione el puerto serie (puerto COM) emulado  del Netduino al que se conectara(normalmente sera  el com10), seleccione el chip adecuado para su Netduino (la información del chip del procesador “Atmel” que  tendrá un identificador como “AT91SAM7X512-ek.”,aunque el valor real dependerá del Netduino particular que usted tenga) y finalmente  haga clic en “Conectar”.
Imagen

Ahora tenemos que ejecutar dos scripts. En primer lugar, seleccione “Inicio desde flash (GPNVM2)” y haga clic en “Ejecutar”.
Imagen

Luego tenemos que hacer lo mismo con la opción “Habilitar el acceso de Flash”-script.

Ahora asegúrese  de que estamos en la lengüeta de “Flash”. Por “Send File Name”, seleccione el archivo “TinyBooterDecompressor.bin” y haga clic en “Enviar Archivo”. Este archivo se encuentra en el archivo ZIP Netduino Firmware en el último hilo del foro
Imagen

Entonces nos hará un pregunta sobre  sobre regiones bloqueadas. Haga clic en “No”
Imagen

Después de que podemos cerrar la herramienta SAM-BA  tenemos que  probar si funciona,para lo  cual vuelva a conectar el Netduino y ejecute  MFDeploy.exe. Seleccione USB y el Netduino, a continuación, haga clic en Ping.
Imagen

Ahora ya está listo para grabar el firmware

GRABAR EL FIRMWARE

En primer lugar, ejecutar MFDeploy. Seleccione USB, el Netduino y luego haga clic en “Ping” para verificar que el dispositivo está disponible:

Imagen
Ahora haga clic en “Browse” y seleccione tanto el archivos ER_FLASH ER_CONFIG y. (Mantenga presionada la tecla “Ctrl” para seleccionar el segundo archivo)

Imagen
Cuando se seleccionan dos archivos, haga clic en DEPLOY (Implementar) pudiendo tomar unos 4  o 5 minutos  máximo …
Imagen

Una vez acabados el Deploy ( mensaje  SIGNATURE PASS)  , retire el conector  y vuelva a colocar su Netduino mediante el cable microUSB para completar la operación de flash.

Después de parpadear y reiniciar el Netduino, ahora puede comprobar la versión del firmware actual seleccionando la opción de menú “Target-> Capacidades de dispositivo”
Imagen

Esto seria un ejemplo  de resultado:

HalSystemInfo.halVersion: 4.2.0.0
HalSystemInfo.halVendorInfo: Netduino Plus (v4.2.0.1) by Secret Labs LLC
HalSystemInfo.oemCode: 34
HalSystemInfo.modelCode: 177
HalSystemInfo.skuCode: 4097
HalSystemInfo.moduleSerialNumber: 00000000000000000000000000000000
HalSystemInfo.systemSerialNumber: 0000000000000000
ClrInfo.clrVersion: 4.2.0.0
ClrInfo.clrVendorInfo: Netduino Plus (v4.2.0.1) by Secret Labs LLC
ClrInfo.targetFrameworkVersion: 4.2.0.0
SolutionReleaseInfo.solutionVersion: 4.2.0.0
SolutionReleaseInfo.solutionVendorInfo: Netduino Plus (v4.2.0.1) by Secret Labs LLC
SoftwareVersion.BuildDate: Sep 19 2012
SoftwareVersion.CompilerVersion: 410894
FloatingPoint: True
SourceLevelDebugging: True
ThreadCreateEx: True
LCD.Width: 0
LCD.Height: 0
LCD.BitsPerPixel: 0
AppDomains: True
ExceptionFilters: True
IncrementalDeployment: True
SoftReboot: True
Profiling: False
ProfilingAllocations: False
ProfilingCalls: False
IsUnknown: False

RESTABLECER CONFIGURACION DE RED

 Después de flashear  un Netduino Plus, tendrá que restablecer la configuración de red .
Como ejecuta el firmware 4.2  es necesario mantener pulsado el botón de la placa Netduino  mientras se conecta el USB para poner el dispositivo en modo de arranque.
Ahora, lanzar MFDeploy, que se puede encontrar en el menú Programas del menú Inicio en “Microsoft. NET Micro Framework x”, donde x es la versión del marco de su ‘usando. Luego, en el menú Herramientas.
Imagen
Seleccione USB y su Netduino Plus desde el menú despegable.Imagen

Pulse ahora el botón “Ping” para asegurarse de que su Netduino está funcionando correctamente, debería ver algo así como “Haciendo ping … TinyCLR” después de un momento en la mitad inferior de la pantalla.

Imagen

Desde el menú Destino seleccione Configuración, Red

Imagen

Esto abrirá la ventana de configuración de red que contiene todos los valores de red de su Netduino Plus. Desde aquí se puede configurar una dirección IP estática o habilitar DHCP, también puede configurar la dirección MAC y los ajustes de DNS para su Netduino,pero sobre todo restituya el valor de la  direccion MAC  que encontrará en la pegatina de la parte posterior de su placa  Netduino

Imagen

Cambie los ajustes que necesita y pulse Actualizar y configuración Netduino Plus y ‘se actualizará.

!Respire ya ha concluido!

 

Fuente aqui

 

Generación de nuevo Firmware para Netduino Plus 2 version 4.2 con Yagarto


¿Por qué construir firmware? ¿No es el lanzamiento oficial lo suficientemente bueno?

Por supuesto que lo es, pero es posible que desee:

  • Tener el poder para arreglar las cosas
  • Extenderla a hacer otras cosas
  • Ser capaz de depurar a bajo nivel con JTAG

¿Por GCC? ¿No es RVDS (la cadena de herramientas utilizada para construir el oficial) lo suficientemente buenos?

Por supuesto que lo es, pero es posible que desee:

  • No gaste $ 5,000
  • Tener más de 30 días para realizar su trabajo antes de que la versión de prueba gratuita se agota
  • Tomar ventaja de su conocimiento del trabajo en cualquiera de los millones y millones de otras plataformas en las que se ha utilizado
  • Encontrar una alternativa, socialmente más accesible, salida para el masoquismo

Esta página pretende ayudar si sus metas son similares a cualquiera de los anteriores, a excepción de la última línea de la lista. Para ello, usted debe tener en cuenta lo siguiente para ser un “alerón” y no siga leyendo. No es un masoquista? Aceptar, seguir …

¿Qué conjunto de herramientas usaar?

Hay tantos! Las dos primeras letras en Yagarto lo  reflejan :’Yet another (‘Otro …’). El autor lo elegío porque es popular y es reciente. Principalmente todos funcionan de la misma forma , pero en la práctica, no lo hacen – especialmente para compiladores cruzados, que se construyen  para una plataforma de acogida y tienen un tiempo de ejecución para una plataforma de destino. A continuación, se complica debido a la cantidad de dependencias.

¿Cómo hacerlo?

Ayudandose de un paquete, que se adjunta a esta página, que contiene:

  • Una guía de “inicio rápido” para la pesonas más  ansiosa
  • Una guía más detallada paso a paso para el interesado
  • Un fichero de parche que contiene todo lo necesario cambiado
  • Aarchivo auxiliar para aquellos que no les gusta archivos de revisión, y algunos binarios preconstruidos

Obtenga el archivo adjunto buildingfirmware-NP2-4.2.1.2-yag46-20130115a.zip y descomprimir y todas las partes jugosas están en él contenida. También obtener el firmware SecretLabs adjunto, netduinoplus2firmware-SecretLabs-4.2.1.2.zip

El resto de esta página será el contenido de la guía de “inicio rápido”, ya que parece más apropiado para una página wiki. De lo contrario, no sería demasiado ‘wiki’.  De todos modos, aquí va, ¡buena suerte!

Inicio Rápido – 2 Firmware versión 4.2.1.2 con Yagarto 4.6 13 de enero 2013 Edificio Netduino Plus

Esto debería proporcionar una guía paso a paso mínimo global de la imagen de la mencionado de firmware para el Netduino Plus 2 de construcción.

1 – Obtener herramientas instaladas:

  • MicroSoft VisualStudio 2010 .Iinstalalo r como de costumbre, la versión express también debería estar bien
  • . NETMF Framework SDK 4.2 QFE1
  • Netduino SDK

Los elementos anteriores probablemente ya estén instalados para su normal desarrollo de aplicaciones. La siguiente es la cadena de herramientas:

  • Yagarto 4.6.0 (2011-04-29) :obtener la versión de 20110429   aqui NOTA IMPORTANTE: no / NO / usar la ubicación de instalación por defecto (que  se encuentra en los archivos de programa … árbol), pero el cambio a una ruta sin espacios. Se debe  utilizar C: \ yagarto.

Usted necesitará algunas herramientas de flash para el propio chip:

  • Herramientas ST Microelectronics ‘DfuSe Demo’ :Estos se utilizan para construir una imagen de firmware, flash de borrado, y quemar la imagen que producen. La usamos para extraer un Tinybooter del firmware, también.

2 – Configure el árbol de código fuente:

  • NETMF Porting Kit 4.2 QFE1 de http://netmf.codeplex.com/releases/view/82448 .Es decir vaya  aqui (el fichero se llama PK.zip ),instalelo, a continuación, realice inmediatamente una copia que se le modificando. Por ejemplo un directorio es C:\Experiments\netduino\netduino_plus_2
  • Netduino Plus 2 firmware v4.2.1 fuente 
    http://netduino.com/downloads/
    Estas modificaciones son exactamente y precisamente por esta versión de los SecretLabs
    firmware. Descomprimir en la parte superior del directorio de trabajo de manera efectiva ‘fusionar’
    los cambios.
    EDIT: esta versión (4.2.1.2) ya no está en la página de descargas (que sólo tiene la versión actual), por lo que he adjuntado a este artículo. Los mods del autor  pueden / trabajar en la versión curent sin editar, pero lo dudo, por lo que seguir adelante y obtener la versión correcta para el que se escribió este artículo (4.2.1.2) y ahorrar un poco de dolor de cabeza.
  • mis mods 
    El autor proporciona un fichero de parche ‘mychanges-np2-4.2.1.2-20130113a.patch’, que usted puede aplicar con su herramienta preferida (o incluso manualmente es posible si se debe). Por otra parte, el autor  creó manualmente un archivo que puede ser desplegado en la parte superior del árbol de código fuente. De cualquier manera, debe obtener esos cambios dentro.

3 – Contextualizacion:

  • configuración env vars 
    En el directorio de trabajo
    setenv_base.cmd GCC4.6 PUERTO C: \ yagarto
  • iniciar la construcción 
    MSBuild Solutions \ NetduinoPlus2 \ dotnetmf.proj / T: reconstruir / p: flavor = liberación; tcp_ip_stack = lwip / FileLogger

Después de 10 minutos, se debe hacer. Habrá 20 advertencias sobre las importaciones redundantes  y  0 errores.

El sistema de construcción creará un ‘BuildOutput‘con un  subárbol que contendrá los diferentes productos de generación. Las piezas del firmware de interés están en formato. \ BuildOutput \ thumb2 \ GCC4.6 \ le \ Flash \ release \ NetduinoPlus2 \ bin y son

  • Tinybooter.bin
  • tinyclr.bin / ER_CONFIG
  • tinyclr.bin / ER_FLASH

Utilice el “DFU Administrador de archivos” de aplicaciones de la ‘demostración DfuSe’, para extraer un binario de un DFU, para extraer las piezas del firmware oficial (sólo necesitamos el Tinybooter). Es decir netduinoPlus2_Firmware_4.2.1.2_00_08000000.bin

Utilice el “DFU Administrador de archivos” de aplicaciones de la ‘demostración DfuSe’, para generar un DFU desde múltiples archivos bin. Como se trata de un fichero bin, tendrá que especificar su ubicación en flash.

Los direcciones de memoria  a  utilizar son:

08000000 para NetduinoPlus2_Firmware_4.2.1.2_00_08000000.bin 

0800c000 para ER_CONFIG 

08020000 para ER_FLASH 

A continuación, usted genera de los DFU, y que es su nueva imagen de firmware.

Para Flashear  , como de costumbre   con la aplicación ‘DfuSe Demo’ ‘Demostración DfuSe’

Paso 1 Descargue e instale el “DfuSe dispositivo USB firmware upgrade STMicroelectronics extensión” de

Paso 2 Descargue el archivo zip del firmware más reciente y extraer alguna parte. Debe contener tinyclr.dfu

Paso 3 Coloque el Netduino  en el modo de gestor de arranque. Para ello, pulse el botón de reinicio y mientras se presiona el botón, conéctelo a USB. Ahora se instalará el “Dispositivo de STM en modo DFU” conductor.

Paso 4 Inicie la herramienta “Demostración DfuSe”. En el panel “Actualizar o Verificar Acción” click “Elegir …” y busque el archivo tinyclr.dfu y haga clic en “Actualizar”. Obtendrá un mensaje “El dispositivo se conecta en modo DFU. Continuar sin embargo?”. Pulse Sí.

Ahora a esperar hasta que los Estados de la barra de estado verde “actualización correcta”. El dispositivo está ahora al día! Desconecte y vuelva a conectar el dispositivo a tener en marcha y funcionando de nuevo.

Fuente original aqui

Actualizacion de Netduino Version 4.2.2.2


Este nuevo  firmware para ttu Netduino  Plus    requiere el uso de. NET Micro Framework SDK v4.2 (qfe2) o posterior y. Netduino SDK 4.2 o más reciente.

Con este firmware, tendrá los siguientes recursos disponibles para el código:
384KB flash
+ RAM 100KB

Este firmware incluye las siguientes actualizaciones:
1. . NET MF 4.2 qfe2 correcciones de errores

Este firmware también incluye las actualizaciones anteriores:
1. Corrección de error: Configuración SPI reloj de ralentí elevada Ahora apoyado
2. Netduino 1 proyectos Plus se pueden actualizar sin cambiar HardwareProvider
3. Ahora compatible con el legado SecretLabs AnalogInput y clases de PWM
4. Corrección de errores: SPI selección de chip momento corregida
5. Corrección de errores: PWM de frecuencia corregida
6. Nuevo: más fiable reiniciar durante la implementación
7. Static IP funciona ahora (además de por defecto DHCP)
8. Las direcciones MAC se cargan ahora por TinyCLR
9. Adicional de corrección de errores I2C – pines ve obligado a la configuración adecuada

Para encontrar la versión actual del firmware Netduino:
1. Ir al menú Inicio> Programas> Microsoft. NET Micro Framework 4.2> Herramientas
2. Ejecutar MFDeploy.exe. Tenga cuidado al ejecutar MFDeploy.exe y no MFDeploy.exe.config (como las extensiones de archivos están ocultos de manera predeterminada)
3. Conecte su Netduino a su PC usando un cable Micro USB.
4. En la sección de dispositivos en la parte superior, seleccione USB en vez de serie. Su Netduino debe aparecer en la lista desplegable, si no, seleccionarlo.
5. Seleccione el menú Destino, opción de funciones de dispositivos.
6. En la casilla de salida, encontrar el valor de “SolutionReleaseInfo.solutionVersion”. Esta es la versión del firmware.

Para actualizar el firmware:
1. Separe su Netduino
2. Pulse y mantenga pulsado botón de su Netduino mientras que enchufarlo vía USB, lo que lo pondrá en modo bootloader.
3. Borrar el firmware de su Netduino utilizando el Tester aplicación STDFU v3.0.1
> A. Seleccione la pestaña “Protocolo”
> B. Pulse el botón “Crear desde Map”
> C. Seleccione el botón de opción “Borrar”
> D. Pulse el botón “Go”
> E. Espere a que el proceso de borrado para completar
4. Flash en el archivo adjunto. DFU con el Demostrador DfuSe v3.0.2 aplicación ST (incluido con STDFU Tester)
> A. Localice el panel “Actualizar o Verificar Acción” (panel inferior derecho)
> B. Pulse el botón “Elegir …” y seleccione el archivo adjunto DFU
> C. Marque la opción “Verificar después de la descarga”
> D. Pulse el botón “Actualizar”. Tomará unos minutos para actualizar su Netduino.
> E. Desconecte y vuelva a conectar el Netduino (apagar y encender) o pulse “Agregar el modo DFU”

Después de parpadear, para establecer la configuración de red utilizando MFDeploy:
1. Seleccione el destino> Configuración> menú Redes. Vuelva a introducir la configuración de la dirección IP y la dirección MAC

Puede descargar    STDU tester y el St Dfu Demostrator    en este enlace y el nuevo firmware   aqui ( necesitara tener usuario en la comunidad de Netduino)

 

 

Fuente aqui.

Cómo actualizar Netduino con firmware 4.2 en Windows 8 y Visual Studio 2012


Cómo hacerlo bien

DESISTALE LO VIEJO (SI ES QUE LO TIENE INSTALADO)

  1. Desinstale el. NET Micro Framework SDK v4.1.
  2. Desinstale el Netduino SDK v4.1.0.

CONSIGUA  NUEVO SOFTWARE

  1. Instalar Visual Studio 2012, si no lo ha hecho
  2. Descargar e instalar la última versión . NET Micro Framework SDK 4.3 .
    (El 4.2 disponible en Netduino no soporta VS 2012)
  3. Descargar e instalar el SDK Netduino v4.2.1.0 .
    (32 bits o 64 bits según la versión de Windows)
  4. Descargar e instalar SAM-BA 2.12 para Windows .
    (Usted tendrá que registrarse y abrir una sesión, pero es gratis)
  5. Descargue y descomprima el nuevo firmware Netduino .

BORRE SU NETDUINO

  1. Conecte su Netduino   con  un cable usb para  que este alimentado con 5V.
  2. Encontrar un cable de puente y conecte un extremo a la clavija de 3V3 y tocar la pequeña plaza de oro al lado del 0 pin GPIO con el otro extremo. Mantenga pulsado durante al menos 2 a 3 segundos.
    ADVERTENCIA: Este borra completamente la Netduino y no se puede deshacer. Si usted hace esto, la única manera de que vuelva a funcionar es completar con éxito el resto de los pasos.
  3. Desconecte el Netduino, espere unos segundos y vuelva a conectarlo.

Ahora hay que reconocer a Windows como un nuevo dispositivo llamado GPS Detectar cámara. No hacemos más que ignorar esto y seguir adelante.

CARGAR LA IMAGEN TINYBOOTERDECOMPRESSOR

  1. Inicie la herramienta SAM-BA 2.12.
    (Debe estar en C: \ Archivos de programa (x86) \ Atmel \ sam-ba_2.12 \ sam-ba.exe)
  2. Seleccione la conexión.
    (Para mí era sólo una opción disponible)
  3. Seleccione su tablero.
    (Debe ser AT91SAM7X512-ek para el Netduino regular)
  4. Pulse en Conectar.
  5. Ejecute la ‘Bota de Flash’ script.
  6. Ejecute el script ‘Habilitar el acceso Flash’.
  7. Asegúrese de que está en la ficha Flash y enviar el archivo ‘TinyBooterDecompressor.bin’.
    (Vino con el firmware Netduino ha descargado anteriormente)
  8. Seleccione “No” en la pregunta sobre regiones bloqueadas.
  9. Cuando termine, cierre la herramienta SAM-BA.
  10. Desconecte y vuelva a conectar el Netduino.

INSTALE EL NUEVO FIRMWARE

  1. Inicie la herramienta MFDeploy.
    (Debe estar en C:. \ Archivos de programa (x86) \ Microsoft NET Micro Framework \ v4.3 \ Tools \ MFDeploy.exe)
  2. Seleccione USB como el dispositivo y usted debe obtener un dispositivo Netduino_Netduino.
  3. Haga clic en el botón Ping para ver si responde.
    (Debe responder con TinyBooter)
  4. Examinar y seleccionar tanto el los archivos ER_FLASH bajo Archivo de Imagen yER_CONFIG y haga clic en Deploy (tarda un tiempo).
    (Vino con el firmware Netduino has descargado antes. Utilice la tecla Ctrl para seleccionar los dos archivos en el diálogo de archivo)
  5. Por último, desconecte y vuelva a conectar el Netduino.

Para confirmar la actualización, con la herramienta MFDeploy, vaya al menú de destino y seleccione Funciones de dispositivos. Usted debe conseguir montón de información, y entre los que algo que dice “Netduino (v4.2.0.1) por Secret Labs LLC”. Y eso debería ser.Todos salieron entonces es abrir el proyecto en Visual Studio Netduino y cambiando el marco objetivo de 4,1 a 4,2 en la configuración del proyecto.

 

 

Fuente  Torleif Berger