Netduino – pierwszy projekt

Instalacja oprogramowania

Przed podłączeniem Netduino do komputera musimy zainstalować kilka niezbędnych narzędzi:

  1. Microsoft Visual Studio – do pisania kodu w C# (wystarczy darmowa wersja Express),
  2. NET Micro Framework SDK – wersja środowiska .NET na mikrokontrolery,
  3. Netduino SDK – ten pakiet od firmy Secret Labs umożliwi nam użycie kodu specyficznego dla Netduino, związanego bezpośrednio ze sprzętem.

Odpowiednie linki można znaleźć na stronie: http://netduino.com/downloads/. Proponowane tam wersje oprogramowania od Microsoftu to użyteczny zestaw minimum: Visual C# Express 2010 i .NET Micro Framework SDK 4.2. Można jednak użyć nowszych wersji, na dzień dzisiejszy to będzie: Visual Studio Express 2012 for Windows Desktop (http://www.microsoft.com/visualstudio/eng/downloads#d-express-windows-desktop) i .NET Micro Framework wersja 4.3 (http://netmf.codeplex.com/releases/view/81000).

Taki właśnie komplet został pomyślnie przetestowany na Windows 7 Professional 64-bity z modułem Netduino 2.

Całe to oprogramowanie powinno zostać zainstalowane w podanej wyżej kolejności. Tam gdzie to jest istotne zwracamy uwagę na wersję systemu Windows jakiej używamy (32 albo 64 bity). Następnie podłączamy nasz moduł Netduino do komputera i uruchamiamy Visual Studio.

Visual Studio – nowy projekt

Stworzymy teraz nowy projekt, żeby oswoić się z nowo zainstalowanymi narzędziami.

Uruchamiamy Visual Studio Express 2012 for Windows Desktop, z menu FILE wybieramy New Project… (albo skrót: Ctrl + Shift + N), otwiera się okno wyboru szablonu projektu:
Nowy projekt

Interesują nas szablony dla C#, z dostępnych wybieramy Micro Framework i ostatecznie jako typ projektu: Console Application. Wpisujemy jeszcze nazwę projektu (tutaj: HelloNetduino), ścieżkę gdzie nasz nowy projekt zostanie zapisany (tu: C:\projects\netduino) i wciskamy OK.

Zostanie utworzony nowy projekt razem z kilkoma plikami źródłowymi, pliki projektu są wyświetlone w okienku Solution Explorer:
Solution Explorer
Praktycznie cały wygenerowany kod przykładu znajduje się w pliku Program.cs:

using System;
using Microsoft.SPOT;

namespace HelloNetduino
{
    public class Program
    {
        public static void Main()
        {
            Debug.Print(Resources.GetString(Resources.StringResources.String1));
        }

    }
}

Możemy projekt skompilować i uruchomić w trybie Debug: menu DEBUG, następnie Start Debugging (albo skrót klawiszowy – F5). Program uruchomi się w dołączonym do środowiska emulatorze i jako jedyny ślad swojej działalności, wypisze w okienku Output komunikat „Hello World!” Jeśli nie interesuje nas debugowanie, uruchamiamy DEBUG > Start Without Debugging (odpowiedni skrót to tym razem: Ctrl + F5).

Przykład jest trywialny i tak naprawdę nie robi niczego interesującego jednak można tu obejrzeć typową strukturę programu w C# korzystającego z bibliotek .NET. Przede wszystkim mamy do czynienia z językiem obiektowym, zatem cały kod jest zamknięty w klasach – tutaj jedyna zdefiniowana klasa to Program. W klasie program mamy główną metodę naszego programu – Main, całość zamknięta w zadeklarowanej przestrzeni nazw HelloNetduino. Powyżej mamy jeszcze deklaracje użycia bibliotecznych przestrzeni nazw: System i Microsoft.SPOT. Odnoszą się one do dołączonych do projektu bibliotek i ułatwiają korzystanie z funkcji w nich zawartych.

Listę bibliotek dołączone do projektu można obejrzeć i modyfikować używając znanego już okienka Solution Explorer – węzeł References w drzewie reprezentującym zawartość naszego projektu HelloNetduino. Brak dołączonej do projektu odpowiedniej biblioteki jest bardzo częstym powodem błędów kompilacji programu, w którym używamy dodatkowych funkcji, np. tych dostarczonych przez producenta Netduino w pakiecie SDK.

Skasujmy teraz całą zawartość funkcji Main i przejdźmy do programowania naszego modułu. W najprostszym przykładzie użyjemy wbudowanych w Netduino 2 diody LED i przycisku programowalnego, tak żeby nie musieć od razu montować dodatkowych obwodów.

Powiedzmy, że zatrudnimy od razu oba te elementy i będziemy świecić diodą dopóki przycisk będzie wciśnięty. Nasza nowa funkcja Main będzie teraz wyglądać następująco:

public static void Main()
        {
            OutputPort led = new OutputPort(Pins.ONBOARD_LED, false);
            InputPort btn = new InputPort(Pins.ONBOARD_BTN, false, Port.ResistorMode.Disabled);

            bool btnState = false;

            while (true)
            {
                btnState = btn.Read();
                led.Write(btnState);
            }
        }

Najpierw tworzymy dwa obiekty (pamiętamy: C# to język obiektowy, wszystko jest obiektem) odpowiadające diodzie i przyciskowi, klas OutputPort i InputPort. Odpowiednie porty identyfikujemy posługując się predefiniowanymi stałymi Pins.ONBOARD_LED i Pins.ONBOARD_BTN. Pomocniczo definiujemy jeszcze flagę logiczną btnState, która reprezentuje stan naszego przycisku. Ostatecznie w wiecznej pętli – while(true) – odczytujemy stan przycisku (metoda btn.Read()) i odpowiednio zapalamy/gasimy diodę (metoda led.Write()).

Ponieważ użyliśmy kodu z biblioteki Netduino SDK na początku pliku dokładamy jeszcze deklarację użycia odpowiedniej przestrzeni nazw:

using SecretLabs.NETMF.Hardware.Netduino;

Kod mamy już przygotowany do uruchomienia, pozostaje skonfigurowanie projektu i dołączenie odpowiednich bibliotek.

Opcje projektu możemy poustawiać po zaznaczeniu w oknie Solution Explorer naszego projektu (HelloNetduino), przyciśnięciu prawego przycisku myszki i wybraniu z menu kontekstowego Properties. Otwiera się okno z ustawieniami naszego projektu. W zakładce Application upewniamy się, że jako Target Framework został wybrany .NET Micro Framework 4.2 (tu musimy się dopasować do zainstalowanej uprzednio wersji Netduino SDK).

properties - application

Następnie musimy zaznaczyć, że skompilowany kod ma zostać wysłany do naszego Netduino podłączonego do portu USB. Przenosimy się na zakładkę .NET Micro Framework tego samego okna z ustawieniami projektu i jako Deployment Transport wybieramy z listy USB a jako Device nasz podłaczony moduł (tutaj: Netduino2_Netduino).

properties - netmf
Dokonane zmiany w ustawieniach zatwierdzamy zapisując plik z opcjami projektu – Ctrl – S.

Pozostała sprawa dołączenia odpowiednich bibliotek z obu pakietów SDK: .NET Micro Framework i Netduino.

Użyliśmy bibliotecznego kodu, musimy więc odpowiednie biblioteki dołączyć do naszego projektu. Bibliotekami zarządzamy w okienku Solution Explorer, zaznaczamy węzeł References w naszym projekcie, prawym przyciskiem myszy rozwijamy kontekstowe menu i wybieramy z niego Add Reference….

add reference

W zakładce .NET znajdziemy potrzebne pliki. Następujące biblioteki muszą być dołączone do naszego projektu:

  • Microsoft.SPOT.Hardware,
  • Microsoft.SPOT.Native,
  • SecretLabs.NETMF.Hardware,Netduino – ta ostatnia zależy od wersji programowanego modułu, taka będzie odpowiednia dla Netduino 2.

To już wszystko, ustawienia projektu zostały odpowiednio skonfigurowane, biblioteki dołączone, naciśnięcie Ctrl + F5 powinno spowodować kompilację źródeł, wysłanie binarnego kodu do Netduino i uruchomienie naszego programu. Po restarcie urządzenia, program zaczyna działać w wiecznej pętli i naciśnięcie przycisku zapala diodę LED, po jego zwolnieniu dioda gaśnie.

Następny krok – dodatkowa LED

W pierwszym projekcie ograniczyliśmy się do napisania kodu wykorzystując sprzęt wbudowany w Netduino. Nic nie stoi na przeszkodzie, żeby zmontować typowy pierwszy układ zewnętrzny (mikrokontrolerowe „Hello World”) czyli dioda LED podłączona do jednego z wyjść cyfrowych. Odpowiedni projekt wygląda bardzo podobnie jak w Arduino, dioda z obowiązkowym szeregowo podłączonym rezystorem włączona między wyjście cyfrowe modułu (uwaga na właściwą polaryzację diody) i masę (minus zasilania). Jest jednak jedna istotna różnica: zgodnie ze specyfikacją Netduino (http://netduino.com/netduino2/specs.htm) wyjścia cyfrowe w stanie wysokim mają tylko 3,3 V, zamiast typowych 5 V jak w Arduino. Wydajność prądową portów producent określił na 25 mA (przynajmniej w modułach Netduino 2, w starszych modułach Netduino było mniej), przy zastrzeżeniu maksymalnej wartości 125 mA na cały mikrokontroler – dla naszej dodatkowej, pojedynczej diody wystarczy aż nadto.

W testowym zestawie przy użyciu niebieskiej LED i typowych rezystorach 220 omów (takich samych jak w starter kicie Arduino) prąd płynący przez diodę wynosi niewiele ponad 1 mA. Wystarcza to jednak do zaświecenia samej diody, chociaż oczywiście do pełnej jasności świecenia jeszcze daleko. Dla lepszego efektu można zastosować mniejszy rezystor.

Odpowiedni kod wygląda następująco:


        public static void Main()
        {
            OutputPort led = new OutputPort(Pins.ONBOARD_LED, false);
            InputPort btn = new InputPort(Pins.ONBOARD_BTN, false, Port.ResistorMode.Disabled);

            OutputPort outd3 = new OutputPort(Pins.GPIO_PIN_D3, true);

            bool btnState = false;

            while (true)
            {
                btnState = btn.Read();
                led.Write(btnState);
                outd3.Write(!btnState);
            }
        }

Wykorzystujemy poprzedni przykład, dokładamy tylko zewnętrzną diodę (podłączoną do portu trzeciego) i zaświecamy ją odwrotnie do wbudowanej LED, tzn. świeci gdy przycisk nie jest naciśnięty.

Tworzymy dodatkowy obiekt reprezentujacy port numer 3 i inicjalizujemy go stanem wysokim:

OutputPort outd3 = new OutputPort(Pins.GPIO_PIN_D3, true);

Następnie zapisujemy go wykorzystując zanegowaną flagę reprezentującą stan przycisku:

outd3.Write(!btnState);

To wszystko, po naciśnięciu Ctrl – F5 (czyli uruchomienie bez debugowania) i odczekaniu chwili na kompilację i przesłanie programu do urządzenia możemy przetestować nasze poprawki.