Lekce 3. Světelný had neboli běžící světlo

Dneska si ukážeme jak pomocí LED diod vytvořit běžící světlo. Pro začátek vytvoříme pole výstupních portů LedBar, nad kterými budeme provádět v cyklu změny hodnot a tím zhasínat a rozsvěcet jednotlivé ledky. Toto pole inicializujeme v metodě Init a do každé jeho buňky vytvoříme novou instanci výstupního portu. Jako parametr použijeme jednu z hodnot pole PinList, která obsahuje názvy jednotlivých pinů, ke kterým jsme ledky připojily. Na ukázku zde uvádím dvě metody WormMove a KnightRider.

WormMove posouvá rozsvícenou Led diodu zleva doprava a jakmile narazí na konec, tak začne od začátku. Metoda KnightRider na konci řady ledek otočí směr a posouvá světlo na druhou stranu. Zpoždění mezi jednotlivými změnami je možné nastavit konstantou Speed.

Zapojení:
Do nepájivého pole zapojíme osm super svítivých LED diod, tak aby jejich katoda byla zapojena do minusové lišty. Anody propojíme s NetDuinem a každou zapojíme do jednoho digitálního výstupu od D6 po D13. Nakonec propojíme zem s minusovou napájecí lištou nepájivého pole.
Sestavení tohoto zapojení Vám nezabere více než tři minuty.

Video:

Zdrojový kód:

namespace Lekce03
{
    using System;
    using Microsoft.SPOT.Hardware;
    using SecretLabs.NETMF.Hardware.NetduinoPlus;

    public class Program
    {
        private const int Speed = 100;

        private static readonly Cpu.Pin[] PinList = new Cpu.Pin[]
            {
                Pins.GPIO_PIN_D13,
                Pins.GPIO_PIN_D12,
                Pins.GPIO_PIN_D11,
                Pins.GPIO_PIN_D10,

                Pins.GPIO_PIN_D9,
                Pins.GPIO_PIN_D8,
                Pins.GPIO_PIN_D7,
                Pins.GPIO_PIN_D6
            };

        private static readonly OutputPort[] LedBar = new OutputPort[8];

        private static DateTime nextStep;

        private static int idx = 0;

        private static bool direction = true;

        public static void Main()
        {
            Init();

            while (true)
            {
                WormMove();
                // KnightRider();
            }
        }

        private static void Init()
        {
            for (int n = 0; n < LedBar.Length; n++)
            {
                LedBar[n] = new OutputPort(PinList[n], false);
            }
            nextStep = DateTime.Now;
        }

        private static void KnightRider()
        {
            if (nextStep < DateTime.Now)
            {
                if (direction)
                {
                    LedBar[idx].Write(false);
                    idx++;
                    LedBar[idx].Write(true);
                }
                else
                {
                    LedBar[idx].Write(false);
                    idx--;
                    LedBar[idx].Write(true);
                }

                idx = idx % LedBar.Length;
                if (idx == 0 || idx == LedBar.Length - 1)
                {
                    direction = !direction;
                }

                nextStep = DateTime.Now.AddMilliseconds(Speed);
            }
        }

        private static void WormMove()
        {
            if (nextStep < DateTime.Now)
            {
                LedBar[idx].Write(false);
                idx++;
                idx = idx % LedBar.Length;
                LedBar[idx].Write(true);
                nextStep = DateTime.Now.AddMilliseconds(Speed);
            }
        }
    }
}

V dalším díle se podíváme jak zjistit stav tlačítka.

Zdrojové kódy ze všech lekcí jsou dostupné na https://csharpduino.codeplex.com/

Budu rád za každý komentář a konstruktivní kritiku.

Lekce 2. Zapojení LED diody mimo desku a tři druhy zpoždění

V minulé lekci jsme si ukázali jak rozblikat LED diodu, která je na desce NetDuina. Jak připojit a rozblikat diodu, kterou připojíme k NetDuinu? To bude náplní této lekce.

Zapojení LED diod
NetDuino má 14 digitálních pinů na které můžeme zapisovat logické hodnoty, nebo číst jejich stav.

Můžeme jim tedy přiřazovat hodnotu Log 0 (0V), nebo Log 1 (3,3V).
V této ukázce budeme používat piny Pins.GPIO_PIN_D4 a Pins.GPIO_PIN_D5. LED diod je spousta druhů a typů. Mají různé velikosti a tvary. Mimo to ještě různé napětí a proud, které je rozsvítí. Dneska Vám představím dvě varianty jak diodu k NetDuinu připojit.
První z nich je obyčejná červená LED dioda, která k rozsvícení potřebuje napětí 2V. Pokud bychom ji připojili na výstupní port, který má napětí 3,3V, dioda by to přežila, ale nedělalo by jí to dobře. Proto se do série k ní zapojuje předřadný odpor, který zajistí aby se dioda cítila pohodlně. Velikost tohoto odporu spočítáme podle Ohmova zákonu a parametrů, které zjistíme v katalogu k naší diodě.
Druhý způsob je vhodný pro tak zvané "super svítivé diody", ty mají napájecí napětí 3,2V jako např. tato modrá. Ta tedy nepotřebuje žádný předřadný odpor a je možné ji připojit na výstup přímo.
Důležitou informací při zapojování je polarita. Jelikož ledka není jen malá žárovka, ale polovodičová dioda, záleží na který vývod připojíme kladné napětí a kam záporné. Aby se to nepletlo a dobře pamatovalo, tak na Katodu nepřipojíme Kladné, ale Záporné napětí a na Anodu připojíme Kladné.

Zpoždění
No a teď bych chtěl ještě probrat několik variant jak zpozdit změnu stavu a tím způsobit blikání. Ve zdrojovém kódu ukazuji tři možnosti.
1. možnosti je nejpohodlnější a to je uspaní vlákna ve kterém se program vykonává na požadovanou dobu. Tato varianta má tu nevýhodu, že během čekání se nevykonává ani nic jiného. Což nám může vadit.
2. možností je nepoužít uspání vlákna, ale for cyklus. Ale výsledek je pořád stejný. Zatím co program běží v prázdném for cyklu, ostatní kód se neprovádí.
3. varianta je podle mě nejlepší. Změna stavu se provede pouze pokud je splněna podmínka že již uběhl čas kdy se má změna provést. To nám umožní v nekonečné smyčce provádět další smysluplný kód a ne jen čekat na zahřmění.

Podívejte se na výsledek této lekce v následujícím videu

Zdorjový kód

namespace Lekce02
{
    using System;
    using System.Threading;
    using Microsoft.SPOT.Hardware;
    using SecretLabs.NETMF.Hardware.NetduinoPlus;

    public class Program
    {
        private static readonly OutputPort Led4 = new OutputPort(Pins.GPIO_PIN_D4,false);
        private static readonly OutputPort Led5 = new OutputPort(Pins.GPIO_PIN_D5, false);

        private static DateTime t = DateTime.Now;
        private static DateTime next = t.AddMilliseconds(500);

        public static void Main()
        {
            while (true)
            {
                // Blikej1();

                // Blikej2();

                Blikej3();
            }
        }

        private static void Blikej2()
        {
            SwapState();
            for (int i = 0; i < 20000; i++)
            {
            }
        }

        private static void Blikej1()
        {
            SwapState();
            Thread.Sleep(500);
        }

        private static void Blikej3()
        {
            if (DateTime.Now > next)
            {
                SwapState();
                next = DateTime.Now.AddMilliseconds(500);
            }
        }

        private static void SwapState()
        {
            Led4.Write(!Led4.Read());
            Led5.Write(!Led5.Read());
        }
    }
}

V dalším díle se podíváme jak rozblikat několik LED diod a ukážeme si pár efektů.

Zdrojové kódy ze všech lekcí jsou dostupné na https://csharpduino.codeplex.com/
Budu rád za každý komentář a konstruktivní kritiku.

Zdroje:
http://www.casemodding.wu.cz/view.php?cisloclanku=2007020002
http://zajimavebastleni.sweb.cz/ledky.html

Lekce 1. Blikání LEDkou na desce [NetDuino Plus]

NedDuino Plus má na svojí desce několik LED diod. Jedna slouží jako kontrolka napájení, další tři ukazují stav ethernetového portu a poslední je dostupná pro vlastní použití.
Aby bylo možné s LEDkou pracovat nejprve si pro ni musíme inicializovat výstupní port. To uděláme pomocí třídy OutputPort, které předáme název pinu a výchozí hodnotu. V našem případě to bude OnBoard_Led a výchozí stav bude false - nesvítí.
Aby se nám LEDka rozblikala je potřeba na výstupní port posílat střídavě Log0 a Log1 v nekonečné smyčce. Toho nejjednodušeji dosáhneme tak, že budeme její hodnotu invertovat. Protože má ale procesor kmitočet 48MHz, tak musíme přidáme do smyčky ještě zpoždění, aby bylo blikání vůbec vidět. Hodnota zpoždění je v milisekundách a proto jedné vteřině pak odpovídá hodnota 1000 ms.

Na výsledek se můžete podívat na tomto videu:

Zdrojový kód:

namespace Lekce01
{
    using System.Threading;
    using Microsoft.SPOT.Hardware;
    using SecretLabs.NETMF.Hardware.NetduinoPlus;

    public class Program
    {
        private static readonly OutputPort LedPin = new OutputPort(Pins.ONBOARD_LED, false);

        public static void Main()
        {
            while (true)
            {
                LedPin.Write(!LedPin.Read());
                Thread.Sleep(1000);     
            }
        }
    }
}

V dalším díle se podíváme na zapojení Ledky mimo desku a na několik způsobů zpoždění blikání.

Zdrojové kódy ze všech lekcí jsou dostupné na https://csharpduino.codeplex.com/
Budu rád za každý komentář a konstruktivní kritiku. S psaním blogu a točením videí teprve začínám, tak to asi hned od začátku na Oskara nebude.