After my first and very simple Netduino project, the traffic lights, I wanted to get a little step further. So I’ve put together some lines of code to make the LEDs show the sequence red, yellow, green, off with a fixed interval in between. And I want this interval to be controllable with the Variable Resistor (POT).

The main goal was actually not to build some great light animation, but to learn more about the possibilities behind the scenes. You’ll find find the complete project in the attached ZIP file (see end of this posting), so I’ll focus on two simple, but helpful details in this posting.

The first one is that I encapsulated the access to the LEDs using a class which holds a reference to the output pin, the LED’s state (on/off) and provides the three methods On(), Off() and Toggle() to make it easier to interact with the LED in code. I’m pretty sure that I’ll use (and extend) this LED class in upcoming projects.

public class LED : IDisposable
{
    private OutputPort port;
    private bool state;

    public LED(FEZ_Pin.Digital pin)
        : this(pin, false)
    {
    }

    public LED(FEZ_Pin.Digital pin, bool initialState)
    {
        this.port = new OutputPort((Cpu.Pin)pin, initialState);
        this.state = initialState;
    }

    public void On()
    {
        this.port.Write(true);
        this.state = true;
    }

    public void Off()
    {
        this.port.Write(false);
        this.state = false;
    }

    public void Toggle()
    {
        if (this.state == true)
        {
            this.Off();
        }
        else
        {
            this.On();
        }
    }

    public bool State
    {
        get
        {
            return this.state;
        }
    }

    public void Dispose()
    {
        this.port.Dispose();
    }

}

The second class simplifies the Analog Input handling. When attaching the POT you normally create a static variable to hold the reference to the analog input and read its value when you think it might have changed and you then need to react to this change.

This might be a practical approach in many cases but sometimes it would be nice to be more event-based. So that’s where the class ActiveAnalog kicks in. It encapsules an analog input pin offers the event ValueChanged which provides the current value and the offset change from the previous value. Internally a thread is used to read the analog pin’s value every 20 milliseconds, compare the value with the previous value and fire the event if the value has changed. Nothing spectacular, but it makes it easier for some projects to react on analog pin value changes.

public class ActiveAnalog : IDisposable
{
    private const int READ_INTERVAL = 20;
    private AnalogIn analogPin;
    private Thread readThread;
    private bool active = true;
    private int previousValue;
    private int currentValue;

    public delegate void AnalogValueChange(int currentValue, int offset);

    public event AnalogValueChange ValueChanged;

    public ActiveAnalog(FEZ_Pin.AnalogIn pin)
        : this(pin, 100)
    {
    }

    public ActiveAnalog(FEZ_Pin.AnalogIn pin, int maxScale)
    {
        if (maxScale < 1)         {             maxScale = 1;         } else if (maxScale > 3300)
        {
            maxScale = 3300;
        }
        this.analogPin = new AnalogIn((AnalogIn.Pin)pin);
        this.analogPin.SetLinearScale(0, maxScale);
        this.readThread = new Thread(this.ReadValue);
        this.readThread.Start();
    }

    private void ReadValue()
    {
        this.currentValue = this.analogPin.Read();
        while (this.active)
        {
            this.previousValue = this.currentValue;
            this.currentValue = this.analogPin.Read();
            if (this.previousValue != this.currentValue)
            {
                if (this.ValueChanged != null)
                {
                    this.ValueChanged(this.currentValue, this.currentValue - this.previousValue);
                }
            }
            try
            {
                Thread.Sleep(READ_INTERVAL);
            }
            catch (Exception)
            {
            }
        }
    }

    public int CurrentValue
    {
        get
        {
            return this.currentValue;
        }
    }

    public int PreviousValue
    {
        get
        {
            return this.previousValue;
        }
    }

    public void Dispose()
    {
        this.active = false;
        this.readThread.Abort();
        this.readThread = null;
    }
}

The complete project is available for download at http://blog.jcoder.me/files/Netduino/NetduinoSwitchingLights.zip

Tagged with:
 

Comments are closed.