Blog

 Code :

:-) PepLluis,

Una vez más y por segunda ocasión... el pasado 5 de Abril Gadgeteer visita el País de los Pirineos.

Y para que conste una muestra de alguna de las conversaciones en las que evidenciamos y pudimos plasmar ese especial interés y curiosidad que se despierta entorno a Microframework y pequeños cacharros electrónicos, sin ninguna duda un escenario único donde la electrónica y la programación se dan la mano.

Gracias a Luis Franco en representación del grupo de Usuarios AndorraDotNet y su asociación de informáticos, por su amable acogida y esfuerzo para que este tipo de eventos continúen siendo posibles.

Saludos!

Atendiendo a una consulta de Raul,

Después de poner el FEZ Panda II en modo CDC no puede acceder a la tarjeta.

En Microframework debe fijarse el puerto bien sea un puerto Serie o USB para poder realizar el “deployment” y "debug", en versiones anteriores algunos fabricantes intentaron liberar drivers USB que de forma dual pudieran acometer ambas funciones.

En las versiones actuales se ha descartado implementar dicha funcionalidad, pues ha sido una fuente de conflictos por su complejidad.

En el caso que nos ocupa, si nuestra aplicación configura el USB inicialmente asignado al “Debug” como CDC, automáticamente al reiniciar, el driver USB del fabricante utilizado deja de ser reconocido pues nuestra “Panda” necesita otro driver que cumpla con la dualidad descrita.

En esta situación deberemos instalar el nuevo driver.

Debido a ser un tema bastante antiguo, os facilito esta información de memoria, con cariño y generalizando, pero no puedo certificar que vaya a funcionar en vuestro caso especifico.

GHI Interface + CDC

Saludos,
PepLluis,

El siguiente ejemplo, demuestra la facilidad para generar pulsos modulados utilizando una de las salidas especializadas del procesador. 

En este ejemplo utilizaremos el Led conectado a la salida de pulsos numero 2...

Private BlueLed As PWM = New PWM(Cpu.PWMChannel.PWM_2, 10, 0.1, False)
Public Sub
    ProgramStarted()
    BlueLed.Start()
    Debug.Print("Program Started")
End Sub

El resultado: el de siempre... un led parpadeando a una fercuencia de 10hz, no por nada somos los blinking mans! jajajaja.

Saludos,
PepLluis,

CerbuinoBee, Como leer el sensor de temperatura en C#?

    public partial class Program
    {
        void ProgramStarted()
        {
            temperatureHumidity.MeasurementComplete += new TemperatureHumidity.MeasurementCompleteEventHandler(temperatureHumidity_MeasurementComplete);
            GT.Timer timer = new GT.Timer(1000);
            timer.Tick += new GT.Timer.TickEventHandler(timer_Tick);
            timer.Start();
            Debug.Print("Program Started");
        }
 
        void temperatureHumidity_MeasurementComplete(TemperatureHumidity sender, double temperature, double relativeHumidity)
        {
            Debug.Print("Temperature :" + temperature.ToString());
            Debug.Print("Humidity : " + relativeHumidity.ToString());
        }
 
        Boolean blink = false;
        void timer_Tick(GT.Timer timer)
        {
            Mainboard.SetDebugLED(blink);
            blink = !blink;
            temperatureHumidity.RequestMeasurement();
        }
    }

Posteo este codigo SOLO PARA EL ESTUDIO y como soporte a la pregunta de Raul, Pertenece a partes de otro driver por lo que debe ser adaptado y evidentemente nunca podra utilizarse directamente.

 Saludos,

        GTI.PWMOutput m_Pwm1;
        OutputPort m_Direction1;
        int m_lastSpeed1 = 0;
 
        public Motor_Controlador()
        {
            // asignar aqui i crear manualmente el socket
            m_Pwm1 = new GTI.PWMOutput(socket, Socket.Pin.Seven, this);
            m_Direction1 = new OutputPort(socket.CpuPins[9], false);
            m_Pwm1.Set(1000, 0);
 
            this.input = new GTI.InterruptInput(socket, GT.Socket.Pin.Three, GTI.GlitchFilterMode.On, GTI.ResistorMode.PullUp, GTI.InterruptMode.RisingAndFallingEdge, this);
            this.input.Interrupt += new GTI.InterruptInput.InterruptEventHandler(this._input_Interrupt);
        }
 
        private void _input_Interrupt(GTI.InterruptInput input, bool value)
        {
            this.OnMotorControllerEvent(this, value ? ControllerState.Low : ControllerState.High);
        }
 
        private GTI.InterruptInput input;
        public bool IsHigh
        {
            get
            {
                return this.input.Read();
            }
        }
 
        public enum ControllerState
        {
            Low = 0,
            High = 1
        }
 
        /// <summary>
        /// Represents the desired motor to use.
        /// </summary>
        public enum Motor
        {
            /// left
            Motor1 = 1,
            /// right motor
            Motor2 = 0,
        }
 
        /// <summary>
        /// Used to set a motor's speed.
        /// </summary>
        public void MoveMotor(Motor _motorSide, int _newSpeed)
        {
            // Make sure the speed is within an acceptable range.
            if (_newSpeed > 100 || _newSpeed < -100)
                new ArgumentException("New motor speed outside the acceptable range (-100-100)", "_newSpeed");
 
            if (_motorSide == Motor.Motor1)
            {
                // Save our speed
                m_lastSpeed1 = _newSpeed;
                // Determine the direction we are going to go.
                if (_newSpeed < 0)
                {
                    // Set direction and power.
                    m_Direction1.Write(true);
                    m_Pwm1.Set(1000, (byte)(100 - System.Math.Abs(_newSpeed)));
                }
                else
                {
                    // Set direction and power.
                    m_Direction1.Write(false);
                    m_Pwm1.Set(1000, (byte)_newSpeed);
                }
            }
        }
 
        public void MoveMotorRamp(Motor _motorSide, int _newSpeed, int _rampingDelayMilli)
        {
            int temp_speed = m_lastSpeed1;;
            int startSpeed = m_lastSpeed1;;
            int lastSpeed  = m_lastSpeed1;;
 
            int timeStep;
            int deltaTime = 0;
 
            // Determine how long we need to wait between move calls.
            timeStep = _rampingDelayMilli / (_newSpeed - lastSpeed);
            // Rampa
            while (_newSpeed != temp_speed)
            {
                // If we have been updating for the passed in length of time, exit the loop.
                if (deltaTime >= _rampingDelayMilli)
                    break;
                // If we are slowing the motor down.
                if (temp_speed > _newSpeed)
                {
                    temp_speed += ((startSpeed - _newSpeed) / timeStep);
                }
                // If we are speeding the motor up.
                if (temp_speed < _newSpeed)
                {
                    temp_speed -= ((startSpeed - _newSpeed) / timeStep);
                }
                // Set our motor speed to our new values.
                MoveMotor(_motorSide, temp_speed);
                // Increase our timer.
                deltaTime += System.Math.Abs(timeStep);
                // Wait until we can move again.
                Thread.Sleep(System.Math.Abs(timeStep));
            }
        }
 
        private struct tMovement
        {
            public Motor m_motorSide;
            public int m_newSpeed;
            public int m_rampingDelayMilli;
        }
 
        public void MoveMotorRampNB(Motor _motorSide, int _newSpeed, int _rampingDelayMilli)
        {
            movement = new tMovement();
            movement.m_motorSide = _motorSide;
            movement.m_newSpeed = _newSpeed;
            movement.m_rampingDelayMilli = _rampingDelayMilli;
            Thread moveThread = new Thread(new ThreadStart(this.MoveMotorRampThreadStart));
            moveThread.Start();
        }
 
        private tMovement movement;
        private void MoveMotorRampThreadStart()
        {
            MoveMotorRamp(movement.m_motorSide, movement.m_newSpeed, movement.m_rampingDelayMilli);
        }
 
        public delegate void MotorControllerEventHandler(Motor_Controlador sender, ControllerState state);
        public event MotorControllerEventHandler MotorControllerHigh;
        public event MotorControllerEventHandler MotorControllerLow;
        private MotorControllerEventHandler onMotorController;
        protected virtual void OnMotorControllerEvent(Motor_Controlador sender,ControllerState MotorControllerState)
        {
            if (this.onMotorController == null)
            {
                this.onMotorController = new MotorControllerEventHandler(this.OnMotorControllerEvent);
            }
 
            if (Program.CheckAndInvoke((MotorControllerState == ControllerState.High ? this.MotorControllerHigh : this.MotorControllerLow), this.onMotorController, sender, MotorControllerState))
            {
                switch (MotorControllerState)
                {
                    case ControllerState.High:
                        this.MotorControllerHigh(sender, MotorControllerState);
                        break;
                    case ControllerState.Low:
                        this.MotorControllerLow(sender, MotorControllerState);
                        break;
                }
            }
        }

Sorteamos un "Netduino"

Entre todos los usuarios que efectuen su registro en SaveComm y participen en el taller!

Crea tus propios gadgets, prototipos y cacharros!

El taller es gratuito y tendrá lugar el día 20 de febrero a las 18:15 h. En Vic Barcelona.
Si estáis cerca os podéis inscribir en el taller en el formulario de inscripciones.. si quieres ampliar información:  (leer noticia)

Saludos!
PepLluis,

Una buena forma de empezar, es poder disponer un "paso" a "paso". Atendiendo a la consulta de un lector, me complace compartir con vosotros un punto de entrada para leer la temperatura y la humedad con un "Cerbuino Bee"

Una vez lanzado Visual Studio 2010 con los SDK's de netmf QFE2 y el SDK 4.2 de GHI, desde el menú 'Archivo' >

·     Nuevo Projecto>Visual Basic>Gadgeteer>Net gadgeteer Application (NETMF 4.2)>Asignar nombre>Aceptar

Una vez en el diseñador y desde el 'toolbox' pestaña 'Gadgeteer Mainboars' seleccionar : Fez Cerbuino Bee, Luego desde la pestaña "seeed" arrastrar y soltar el modulo 'TemperatureHumidity', según la siguiente imagen :

En el editor Seleccionar la pestaña "Program.vb". Copiar/Pegar el siguiente código.

Imports GT = Gadgeteer
Imports GTM = Gadgeteer.Modules
Imports Gadgeteer.Modules.Seeed
 
' Ejemplo de lectura de temperatura / humedad 
 
Partial Public Class Program
 
    Private WithEvents timer As GT.Timer = New GT.Timer(1000)
 
    Public Sub ProgramStarted()
        timer.Start()
        Debug.Print("Program Started")
    End Sub
 
 
    Private blink As Boolean
    Private Sub timer_Tick(timer As Gadgeteer.Timer) Handles Timer.Tick
        Mainboard.SetDebugLED(blink)
        blink = Not blink
        temperatureHumidity.RequestMeasurement()
    End Sub
 
 
    Private Sub temperatureHumidity_MeasurementComplete(sender As Gadgeteer.Modules.Seeed.TemperatureHumidity, temperature As Double, relativeHumidity As Double) Handles temperatureHumidity.MeasurementComplete
        Debug.Print("Temperature :" + temperature.ToString())
        Debug.Print("Humidity : " + relativeHumidity.ToString())
    End Sub

End Class

y en la ventana de 'Debug' podreis visualizar los resultados de la captura :-)

Espero que os sea útil,
Feliz Año!
PepLluis,

Un punto de entrada para probar que todo esta bien después de actualizar a QFE2.

using System.Threading;
using Microsoft.SPOT.Hardware;
using Mountaineer.Netmf.Hardware;
 
public class BlinkingLed
{
    public static void Main()
    {
        var Rojo = new OutputPort(OnboardIO.LedRed, false);
        var Verde = new OutputPort(OnboardIO.LedGreen, false);
        var Azul = new OutputPort(OnboardIO.LedBlue, false);
 
        while (true)
        {
            Rojo.Write(true);
            Thread.Sleep(500);
            Verde.Write(true);
            Thread.Sleep(500);
            Azul.Write(true);
            Thread.Sleep(1000);
            Rojo.Write(false);
            Thread.Sleep(500);
            Verde.Write(false);
            Thread.Sleep(500);
            Azul.Write(false);
            Thread.Sleep(100);
        }
    }
}

Saludos,
PepLluis.