Primeros pasos con Netduino

Lo primero de todo es una toma de contacto con el entorno y una primera prueba de interacción con el Netduino.
Las pruebas y el desarrollo se están realizando en Windows 7 32bits SP1 con Visual Studio 2010 Professional.
La instalación no ha tenido ningún tipo de problema.
  • Instalar NET Micro Framework 4.1 SDK
  • Instalar NET Micro Framework 4.0 Porting Kit (creo que no hace falta)
  • Instalar Netduino SDK v4.1.0 (32-bit)
  • Conectar el Netduino al USB y esperar a que Windows instale automáticamente los drivers.
Para la toma de contacto he realizado un programita simple que hace lo siguiente:
  • Hace parpadear el LED de la placa. Si se pulsa el botón que hay en la placa el LED deja de parpadear.
  • Hace que un LED conectado a través de la salida digital 5 incremente y decremente su brillo en un ciclo indefinido.
Para el montaje he usado un LED de alta luminosidad el cual aguanta perfectamente los 3,3v que da la salida digital del Netduino. Si hubiese usado un LED “normal” debería haberle puesto una resistencia para no quemarlo.
El esquema de conexión es el siguiente:
El código del programa es el siguiente:
public class Program
    {
        // Variable para saber si el botón está pulsado o no
        private static bool pressed = false;

        // Variable para controlar el LED externo (salida analógica simulada mediante PWM)
        private static PWM externalLED = null;

        // Variable para controlar el LED interno (salida digital)
        private static OutputPort internalLED = null;

        public static void Main()
        {
            // Inicializo el LED externo
            externalLED = new SecretLabs.NETMF.Hardware.PWM(Pins.GPIO_PIN_D5);

            // Inicializo el LED interno de la placa
            internalLED = new OutputPort(Pins.ONBOARD_LED, false);

            // Inicializo el pulsador de la placa y me suscribo al evento de pulsación
            InterruptPort button = new InterruptPort(Pins.ONBOARD_SW1, false, Port.ResistorMode.Disabled, Port.InterruptMode.InterruptEdgeBoth);
            button.OnInterrupt += new NativeEventHandler(port_OnInterrupt);

            // Creo y lanzo un hilo que va a gestionar el LED interno de la placa
            ThreadStart tStart = new ThreadStart(InternalLEDManager);
            Thread thead = new Thread(tStart);
            thead.Start();

            while (true)
            {
                // Aumentamos desde un 0% a un 100% la potencia (0v a 3.3v)
                for (byte i = 0; i <= 100; i++)
                {
                    externalLED.SetDutyCycle(i);
                    // Después de cada cambio hacemos una pausa para que no sea demasiado rápido
                    Thread.Sleep(10);
                }

                // Disminuimos desde un 100% a un 0% la potencia (3.3v a 0v)
                for (byte i = 100; i > 0; i--)
                {
                    externalLED.SetDutyCycle(i);
                    // Después de cada cambio hacemos una pausa para que no sea demasiado rápido
                    Thread.Sleep(10);
                }
            }
        }

        /// <summary>
        /// Método que se encarga de hacer parpadear el LED interno de la placa
        /// </summary>
        private static void InternalLEDManager()
        {
            while (true)
            {
                // Si está presionado se espera para evitar sobre-ocupar la CPU. Sino lo hacemos parpadear
                if (!pressed)
                {
                    // Encendemos el LED
                    internalLED.Write(true);
                    // Esperamos un poco
                    Thread.Sleep(200);
                    // Apagamos el LED
                    internalLED.Write(false);
                    // Esperamos un poco
                    Thread.Sleep(100);
                }
                else
                    Thread.Sleep(100);
            }
        }

        /// <summary>
        /// Evento que se lanza si se pulsa el botón
        /// </summary>
        /// <param name="data1"></param>
        /// <param name="data2">0 si está pulsado y 1 si no lo está</param>
        /// <param name="time"></param>
        static void port_OnInterrupt(uint data1, uint data2, DateTime time)
        {
            pressed = (data2 == 0);
        }
    }
Tras las pruebas un detalle a comentar:
  • Me ha llamado la atención algo que pensándolo bien es lógico pero no había caído y es que si ejecutamos este programa desde el Visual Studio (VS) se mete en el Netduino por lo que a partir de ese momento en cuanto conectemos el Netduino al USB (aunque no esté abierto el VS) el programa arranca y hace lo que estuviese programado la última vez. Digamos que no hay forma de “apagar” el Netduino más que quitandole la corriente.

Adjuntos

11 pensamientos en “Primeros pasos con Netduino

  1. Muy bueno Oscar,
    Deberías hacer algun tutorial más. Quería dejarte un mensaje privado pero no funciona la página de contacto…¿Cómo podemos contactar?
    Saludos,

    • Hola, gracias por el aviso del formulario de contacto. Ya funciona.

      De todas formas el tema del Netduino lo abandoné hace tiempo y de momento está en un cajón con lo que no se si podré ayudarte mucho.

  2. Estimado, muy buen articulo para los que se inician, consulta en Raspberry uno puede instalar un SO linux, pero en NetDuino se puede instalar algun SO ya sea windows o linux. Gracias.

    • No, no tiene nada que ver. Rasperry viene a ser un ordenador con lo que puedes instalar un SO, pero Netduino es un microcontrolador. Simplemente puedes meter un programa compilado en .NET Micro Framework.

      Son dos aparatos distintos. Rasperry es infinitamente más potente y Netduino tiene unos requerimientos energéticos tremendamente inferiores. Depende del proyecto te vendrá bien uno u otro.

        • No, depende del proyecto. Si vas a hacer un dispositivo que por ejemplo controle un sistema de riego, algo de domótica o algo similar es mejor Netduino porque es más barato, consume muchísimo menos y es mucho más simple.

          Si por el contrario quieres montar un robot complejo, algo que necesite mucha potencia de calculo como algún proyecto que procese video o algo así entonces Rasperry, porque es muchísimo más potente, pero también más complejo.

  3. Me gustaría saber si al hacer el debug en mi netduino tantas veces pueda dañar algo en la placa pues estoy aprendiendo y me gusta probar lo que realizo, podrias darme algun consejo

    De antemano muchas gracias

    • Haciendo debug no te vas a cargar nada, puedes cacharrear lo que quieras. Lo único que tienes que tener cuidado es con lo que conectas físicamente y como lo conectas. Voltajes, polaridades, etc…

  4. Hola! me llamo Enrique …que tal?…gracias por tu aportación, estoy intentando utilizar un palpador 3D que da un todo y nada en una tarjeta netduino, para recibir una señal digital en mi pc, mi pregunta es… ¿debo conectarla igualmente como lo as conectado tu?

    Gracias de antemano y un saludo

    Enrique

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Loading Facebook Comments ...