Instalacja niezbędnego oprogramowania
Przed podłączeniem Netduino do komputera musimy zainstalować kilka niezbędnych narzędzi:
- Microsoft Visual Studio – do pisania kodu w C# (wystarczy darmowa wersja Express),</li>
- NET Micro Framework SDK – wersja środowiska .NET na mikrokontrolery,</li>
- Netduino SDK – ten pakiet od firmy Secret Labs umożliwi nam użycie kodu specyficznego dla Netduino, związanego bezpośrednio ze sprzętem.</li>
Odpowiednie linki można znaleźć na stronie: netduino.com
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 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.
Nowy projekt w Visual Studio
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:
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:
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).
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).
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….
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.