Laboratorium wirtualne 1/Moduł 2 - ćwiczenie 2/część 1

Z Studia Informatyczne
< Laboratorium wirtualne 1 | Moduł 2 - ćwiczenie 2
Wersja z dnia 19:52, 26 sie 2006 autorstwa Tomaszw (dyskusja | edycje)
(różn.) ← poprzednia wersja | przejdź do aktualnej wersji (różn.) | następna wersja → (różn.)
Przejdź do nawigacjiPrzejdź do wyszukiwania

wersja beta

LABORATORIUM WIRTUALNE 1

Ćwiczenie 2 - Środowisko programistyczne LabWindows/CVI

Część 1

Plan prezentacji.

W obecnych czasach sporą część systemów pomiarowych realizuje się w postaci tzw. przyrządów wirtualnych. Przyrząd wirtualny bazuje na określonym systemie komputerowym oraz zestawie wybranych urządzeń pomiarowych stanowiących urządzenia I/O systemu komputerowego. Można zdefiniować go jako rodzaj inteligentnego przyrządu pomiarowego powstałego w wyniku sprzężenia pewnego sprzętu nowej generacji z mikrokomputerem osobistym ogólnego przeznaczenia i przyjaznym dla użytkownika oprogramowaniem, które umożliwia użytkownikowi współpracę z mikrokomputerem na zasadach takich jakby obsługiwał tradycyjny przyrząd pomiarowy. Można powiedzieć że oprogramowanie przyrządu pomiarowego integruje działanie całości w celu realizacji określonych zadań pomiarowych. Istotnym składnikiem programu jest graficzny interfejs użytkownika (GUI) zawierający elementy zadające (pokrętła, przełączniki, przyciski itp.) oraz elementy prezentacyjne (wyświetlacze numeryczne, graficzne itp.) zapewniający interakcyjną współpracę z użytkownikiem. Budowanie przyrządów wirtualnych nie jest rzeczą prostą ale dzięki specjalistycznemu oprogramowaniu pozwalającemu na wizualne budowanie większości kodu aplikacji przyrządu pomiarowego umożliwiają metrologom czy specjalistą z danej dziedziny zbudować przyrząd bez zawansowanej znajomości jeżyka programowania. Przykładem takiego środowiska jest LabWindows/CVI firmy National Instruments. Środowisko wyposażone jest w wizualny edytor do budowania interfejsu użytkownika oraz automatyczny generator kodu pozwalający na wygenerowanie prawie całego kodu aplikacji. Można powiedzieć że większość kodu aplikacji buduje się za pomocą myszki. Środowisko wykorzystuje język ANSI C do budowania kodu aplikacji i wyposażone jest w niezbędne biblioteki i funkcje służące pozyskiwaniu danych i ich przetwarzaniu, prezentacji oraz udostępnianiu poprzez sieć komputerową. Środowisko współpracuje z modułami zbierającymi dane o charakterze analogowym i cyfrowym, z autonomicznymi przyrządami pomiarowymi wyposażonymi w jeden z interfejsów: GPIB, RS-232 czy USB. Posiada więc wszystkie elementy pozwalające na tworzenie przyrządów wirtualnych.

Do uczestniczenia w ćwiczeniu jest potrzebne środowisko LabWindows/CVI które można pobrać ze strony producenta pakietu www.ni.com. W celu pobrania wersji demonstracyjnej środowiska należy zarejestrować się na stronie producenta. Stworzone konto pozwala nie tylko na pobranie wersji demonstracyjnych różnych pakietów ale też na zgłaszanie chęci uczestnictwa w bezpłatnych seminariach czy konferencjach na temat sprzętu i oprogramowania firmy National Instruments. Pozwala też na branie udziału w webcastach czy dyskusjach. Prezentacja wykonana została w oparciu o najnowszą dostępną wersję środowiska (wersja 8.0.1). Załączone w prezentacji programy czy zrzuty ekranowe mogą nieznacznie różnić się od wersji używanych przez uczestników. Ewentualne różnice są jednak bez znaczenia dla zrozumienia działania środowiska czy budowy aplikacji i oczywiście treści merytorycznej. W trakcie ćwiczeń zaleca się używania wersji co najmniej 6.x.x ze względu na różnice występujące w interfejsie środowiska.

Przy pierwszym uruchomieniu środowiska LabWindows/CVI możemy wybrać jeden z dwóch typów obszarów roboczych: zintegrowany obszar roboczy lub klasyczny obszar roboczy.

Jak już zasygnalizowano wcześniej do wyboru mamy dwa obszary robocze: zintegrowany i klasyczny. Jeżeli praca w jednym z obszarów roboczych nie będzie odpowiadała użytkownikowi zawsze może go zmienić na drugi typ. Dokonuj e się tego z poziomu menu aplikacji:

Help > Workspace View Selection …

Który wybrać i dlaczego jeden jest lepszy od drugiego pozostawiamy użytkownikowi. Poniżej zamieszczono krótki opis obszarów roboczych.

  • Klasyczny obszar roboczy – jego geneza sięga najstarszych wersji pakietu. Jak każde rozwiązanie ma on sporo zalet i wad. Jego zasadniczym atutem a może i wadą jest to że każde okno (interfejs użytkownika, kod C, główne okno projektu, formularze i kreatory) środowiska jest świetlane w osobnym oknie na ekranie komputera. Możemy szybko przechodzić do poszczególnych okien czy formularzy. Każde okno posiada swoje menu i przyciski szybkiego dostępu. W przypadku dużej ilości otwartych okien środowiska można się w pewnym momencie trochę pogubić. Jednakże gdy do dyspozycji mamy pojedynczy monitor lub niską rozdzielczość pozwala nam na swobodną pracę w oknie bez potrzeby ciągłego przewijania obszaru okna. Praca staje się całkiem przyjemna w przypadku posiadania dwóch monitorów gdzie można zdefiniować gdzie mają pojawiać się poszczególne okna.
  • Zintegrowany obszar roboczy – pojawił się od wersji 6.0 i przypomina inne środowiska programistyczne. W początkowej fazie raczej denerwował osoby które przyzwyczaiły się do obszaru roboczego w poprzednich wersjach pakietu. Zmianie uległy tez ikony na paskach co wprowadzało dodatkowy dyskomfort. Dla osób które zaczynają pracę w środowisku jest on zazwyczaj bardziej intuicyjny od klasycznego modelu gdyż nawiązuje do przyjętych standardów w innych pakietach programistycznych. Jego atutem jest to że obszar roboczy zawiera wszystkie okna (interfejs użytkownika, kod C, główne okno projektu, formularze i kreatory) dzięki czemu nie mamy otwartych dziesiątek okien na pulpicie komputera i pasku zadań. Menu i przyciski funkcyjne zmieniają się dynamicznie w trakcie wybierania odpowiedniego okna.

W czasie korzystania z pakietu zaleca się aby wypróbować każdy z obszarów roboczych. Każdy użytkownik znajdzie coś co go zainteresuje i ułatwi mu pracę.

W czasie tworzenia materiałów do ćwiczenia „Środowisko programistyczne LabWindwos/CVI” przyjęto zasadę że informacje pojawiają się stopniowo wraz ze wzrostem doświadczenia użytkownika. Część informacji jest uzupełniana stopniowo w kolejnych modułach, a nauka obsługi środowiska i budowania aplikacji odbywa się na konkretnych przykładach.

W czasie pracy ze środowiskiem LabWindows/CVI mamy do dyspozycji szereg dokumentacji ułatwiającej poznawanie środowiska czy wyszukiwanie konkretnych informacji na interesujący nas temat. Pakiet zawiera także interfejs do wyszukiwania przykładów realizujących konkretne zadanie.

Jedną z najobszerniejszych dokumentacji pozwalająca dogłębnie poznać środowisko jest podręcznik użytkownika User Guide oraz Getting Started w formie dokumentu PDF. Dokument można wydrukować i używać jak klasyczną książkę. Zawiera ona przegląd wszystkich funkcji dostępnych w środowisku. Dostęp do dokumentu uzyskuje się z poziomu menu głównego i pozycji:

Help > Contents

W zakładce Spis treści znajdują się linki do ww. dokumentów.

Jeżeli potrzebujemy informacji na temat pola formularza czy funkcji wystarczy nacisnąć przycisk F1 aby otworzyć okno pomocy. Możemy też wyszukiwać dowolny opis interesującej na funkcji korzystając z indeksu haseł czy wyszukać określone słowa w opisach funkcji.

Jak już wspomniano wcześniej środowisko posiada interfejs do wyszukiwania przykładów realizacji konkretnych zadań. Możemy wyszukiwać według kategorii bądź według słowa kluczowego. Wymagane jest jednak połączenie z Internetem gdyż większość przykładów znajduje się na serwerze producenta środowiska. Jeżeli znajdziemy interesujący nas przykład możemy go wczytać i uruchomić. Uzyskujemy tez dostęp do edycji interfejsu i kodu źródłowego. Jest to potężna baza informacji na temat sposobu wykonywania konkretnych zadań.

Zanim zaczniemy przygodę ze środowiskiem warto zaznajomić się z nazewnictwem stosowanym w dalszej części prezentacji. Po uruchomieniu środowiska pojawia się tzw. Główne okno projektu (wybrano zintegrowany obszar roboczy). Jeżeli wcześniej stworzyliśmy już jakiś projekt to zostanie on wczytany automatycznie. Na slajdzie możemy wyróżnić pięć obszarów czy elementów interfejsu środowiska:

  1. Menu główne projektu. Ulega ono dynamicznym zmianom w zależności od wybranego okna w obszarze roboczym.
  2. Przyciski funkcyjne. Pozwalające na szybki dostęp do wybranych funkcji programu. Ulega on też dynamicznym zmianom w zależności od wybranego okna w obszarze roboczym.
  3. Obszar roboczy środowiska. Jest to przestrzeń w który znajdują się wszystkie otwarte okna aplikacji: interfejs użytkownika, kod aplikacji, formularze funkcji i kreatory.
  4. Pliki projektu. Okno zawierające wszystkie pliki przynależne do bieżącego projektu i podlegające kompilacji i konsolidacji.
  5. Podręczna biblioteka funkcji umożliwia szybki dostęp do funkcji zgrupowanych w hierarchicznym katalogu lub tez do funkcji zainstalowanych przyrządów pomiarowych czy kart i kontrolerów.

Naukę tworzenia aplikacji wirtualnych przyrządów pomiarowych przeprowadzimy na przykładach. W pierwszej kolejności poznamy sposób budowania szkieletu aplikacji. Aplikacja nie będzie realizowała na początku żadnych zadań poza możliwością zakończenia działania. Celem poniższego przykładu jest nabycie przez słuchacza umiejętności utworzenia projektu, interfejsu użytkownika oraz wygenerowanie niezbędnego kodu w języku ANSI C i oczywiście uruchomienie aplikacji.

Proces tworzenia aplikacji w środowisku LabWindows/CVI można podzielić na następujące etapy:

  1. Utworzenie projektu – krótko mówiąc jest to czysty obszar roboczy.
  2. Utworzenie interfejsu użytkownika zawierającego podstawową funkcjonalność. Występują tutaj dwie szkoły, a mianowicie jedna z nich mówi że w początkowej fazie na interfejsie użytkownika umieszczamy jak najmniej elementów (np. tylko podstawowe przyciski funkcyjne jak Wyjście, Start czy wł/wył) oraz druga szkoła która zakłada umieszczenie na interfejsie wszystkich elementów. Drugi sposób sprawdza się głównie w przypadku prostych aplikacji, bądź gdy zaprzęgniemy w projekcie inżynierię oprogramowania i zanim zaczniemy budować aplikacje znamy wszystkie funkcje aplikacji i elementy interfejsu. W czasie poznawania środowiska wskazane jest stopniowe budowanie aplikacji, tak aby zamknąć jeden etap przed rozpoczęciem następnego.
  3. Generacja kodu źródłowego – za pomocą generatora kodu i na podstawie zbudowanego interfejsu użytkownika wygenerowany zostanie kod aplikacji w języku ANSI C.
  4. Rozbudowa aplikacji o wymaganą funkcjonalność – dodanie niezbędnych funkcji do programu celem realizacji założonych celów i funkcjonalności. Generator kodu wygeneruje jedynie szkielet programu oraz funkcje obsługi zdarzeń. Resztę trzeba oprogramować samodzielnie (często jedynie za pomocą myszki).
  5. Uruchomienie aplikacji – kompilacja i uruchomienie zbudowanej aplikacji. Często ten proces wymaga usunięcia drobnych błędów.
  6. Testowanie aplikacji – jest to dość istotny etap budowy a właściwie już przygotowania do wdrożenia aplikacji. Wymaga on sprawdzenia czy wszystkie funkcje programu działają prawidłowo i czy użytkownik nie stworzy sytuacji w której aplikacja zachowa się nieprzewidywalnie. Często zbudowanie i uruchomienie przyrządu wirtualnego to dopiero połowa drogi a testowanie i poprawianie zajmuje więcej czasu niż kodowanie i uruchamianie.

Budowę aplikacji zaczynamy od stworzenia nowego projektu. W tym celu z menu głównego wybieramy:

File > New > Project (*.prj)

Jest to nic innego jak stworzenie pustego obszaru roboczego oraz pliku zawierającego informacje o plikach składowych projektu. Na pewno nasuwa się pytanie jakie pliki wchodzą w skład typowego projektu:

  • plik projektu (Project) opisany rozszerzeniem prj,
  • plik interfejsu użytkownika (User Interface) opisany rozszerzeniem uir,
  • plik z kodem źródłowym (Source) opisany rozszerzeniem c,
  • plik nagłówkowy stowarzyszony z interfejsem użytkownika opisany rozszerzeniem h; jest on tworzony automatycznie w czasie budowania interfejsu i generacji kodu; użytkownik nie ma wpływu na jego zawartość a ewentualne modyfikacje wykonuje jedynie środowisko.

Kolejnym etapem o którym była mowa wcześniej jest zbudowanie interfejsu użytkownika. W przykładach kursu będziemy starali się stosować zasadę umieszczania jak najmniejszej ilości elementów na interfejsie użytkownika przed procesem generacji kodu aplikacji. Pozwala ona stopniowe dodawanie funkcjonalności a co za tym idzie na częste uruchamianie programu po wykonaniu drobnych zmian. Prawdopodobieństwo pomylenia zmiennych jest znacznie mniejsze niż w przypadku generacji kodu z całego interfejsu. Pozwala tez na szybkie wykrycie błędów i ich usunięcie – co ma szczególne znaczenie w przypadku niedoświadczonych użytkowników. Aby utworzyć interfejs użytkownika wybieramy z menu głównego:

File > New > User Interface (*.uir)

Po wybraniu opcji utwórz nowy interfejs użytkownika (w skrócie nazywany UI) w obszarze roboczym otwiera się okno zawierające panel interfejsu użytkownika. W przyszłości na panelu będą umieszczane różnego rodzaju zadajniki (przyciski, pokrętła, suwaki, itp.) i wskaźniki (diody, wyświetlacze graficzne, pola tekstowe czy numeryczne).

Zanim przejdziemy dalej należy określić pewne właściwości panelu interfejsu użytkownika. Aby wejść we właściwości panelu należy na nim (w obszarze szarego tła) dwukrotnie kliknąć lewym przyciskiem myszy. Na następnym slajdzie przedstawiony zostanie opis poszczególnych właściwości.

Formularz właściwości panelu interfejsu użytkownika (panel UI) zawiera następujące grupy właściwości:

  • Source Code Connection – są to właściwości opisujące (identyfikujące) panel UI w kodzie programu.
  • Panel Settings – ustawienia interfejsu użytkownika zawierające między innymi nazwę wyświetlaną na górnym pasku aplikacji, położenie i rozmiar panelu UI oraz sposób umiejscowienia okna w czasie uruchomienia aplikacji.
  • Attributes for Child Panels – sposób zachowania się okien (paneli i komunikatów) podrzędnych i wywoływanych z poziomu kodu tego panelu.
  • Okno podglądu umożliwiające oglądanie wprowadzanych zmian.

Poszczególne właściwości zostaną omówione na dalszych slajdach.

Właściwości znajdujące się w grupie „Source Code Connection” są podstawowymi i najważniejszymi właściwościami jakie identyfikują dany element interfejsu w kodzie programu. Za pomocą CONSTANT NAME jest on identyfikowany na interfejsie użytkownika oraz rozpoznawany w kodzie programu. Constant name jest niczym innym jak wskaźnikiem do danego elementu. Jeżeli na panelu o constant name PANEL umieszczony zostaje inny element posiadający constant name WJSCIE to bezwzględna nazwa identyfikująca element na interfejsie ma postać PANEL_WYJSCIE. Środowisko automatycznie łączy nazwy za pośrednictwem znaku „_” stąd tez pewne zasady nazewnictwa przedstawione na następnym slajdzie.

Pole Callback Function zawiera nazwę funkcji jaka ma zostać wywołana gdy zachodzi interakcja użytkownika z danym elementem.

Na podstawie tych danych generator kodu tworzy kod źródłowy aplikacji.

Zaleca się używanie następujących reguł przy tworzeniu nazw elementów i zmiennych:

  1. CONSTANT NAME piszemy dużymi literami i nie używamy w nazwach podkreślenia gdyż może to powodować nieczytelność kodu bądź błędną interpretację elementów interfejsu. Przykłady pisowni nazw: WYJSCIE, POMIAR, LED1, GRAPH. W nazwach nie wolno stosować polskich znaków i znaków spacji. Ograniczenie to wynika z specyfikacji języka ANSI C.
  2. Callback Function – pierwsza literę nazwy funkcji piszemy duża a pozostałe małymi, np. Wyjscie, Pomiar, Strat, NazwaElementu, Inicjuj_Karte itp. W nazwach funkcji nie można stosować polskich liter i znaków spacji.
  3. Nazwy zmiennych piszemy bez polski liter i bez znaków spacji. Zazwyczaj stosuje się małe litery, np. wartość, rms, avg.

Powyższe zasady spotyka się we wszystkich przykładach i instrukcjach producenta. Nie są one obowiązkowe ale polepszają czytelność kodu, funkcji i zmiennych. Przykładem może być tutaj pokrętło ustawiające jakąś wartość w programie. Przykładem stosowanego nazewnictwa dla tego elementu może być:

  • CONSTANT NAME: WARTOSC
  • Callback Function: Wartosc
  • Nazwa zmiennej odczytywanej z elementu: wartosc

Zastosowanie omawianego wcześniej nazewnictwa pozwala szybko zorientować się że funkcja czy zmienna odnosi się do elementu WARTOSC.

Stosując się do poznanych zasad określamy następujące właściwości panelu interfejsu użytkownika:

  • w polu CONSTANT NAME wpisujemy PANEL (domyślnie środowisko powinno wpisać tą nazwę),
  • w polu Panel Title wpisujemy Program pierwszy (w oknie podglądu powinien ukazać się zmieniony napis na pasku górnym interfejsu),
  • zaznaczamy pola Auto Center Vertically i Auto Center Horizontally powodujące wyśrodkowanie okna interfejsu na pulpicie w momencie startu aplikacji.

Resztę właściwości pozostawiamy bez zmian i naciskamy przycisk OK zatwierdzający wprowadzone zmiany.

Kolejnym etapem budowy interfejsu użytkownika będzie dodanie przycisku kończącego działanie aplikacji. Skoro mówione było wcześniej że umieszczamy na interfejsie jak najmniej elementów to dlaczego umieszczamy przycisk Wyjście? Wynika to z właściwości kreatora kodu który umożliwia automatyczne wygenerowanie kodu dla przycisku kończącego działanie aplikacji dodając w funkcji obsługi zdarzenia odpowiednią funkcję zamykającą interfejs (a tym samym kończącą działanie aplikacji). W celu dodania do interfejsu przycisku Wyjście należy z menu głównego wybrać polecenie Create a następnie Command Button i wybrać Square Command Buton (oba sposoby dodawania zostały zaprezentowane na następnym slajdzie). Jest to typowy przycisk funkcyjny jaki można spotkać we wszystkich aplikacjach dla Windows. Po naciśnięciu go przez użytkownika zostaje wywołane zdarzenie obsługi, ale o tym w dalszej części kursu.

Slajd prezentuje sposób dostępu do przycisku typu Command Buton. Na slajdzie przy okazji możemy zaobserwować też inne grupy elementów jakie możemy dodać na panelu UI. Poszczególne grupy przedstawiają:

  • Numeric – elementy o wartościach numerycznych umożliwiające wyświetlanie wartości oraz nastawy różnych wartości; w grupie tej znajdują się różnego rodzaju pokrętła, suwaki i wyświetlacze numeryczne,
  • Text – elementy wyświetlające teksty,
  • Command buton – przyciski funkcyjne,
  • Toggle Buton – przyciski dwustanowe: wciśnięty, nie wciśnięty,
  • LED – diody sygnalizacyjne
  • Binary switch – przełączniki dwustanowe,
  • Ring – elementy podobne do elementów z grupy Numeric umożliwiające definiowanie wartości dowolnego typu na pokrętłach i suwakach,
  • Lists & Tablets – elementy do wyświetlania list i tabelek,
  • Decoration – elementy służące do grupowania i wydzielania elementów interfejsu,
  • Graph – elementy do wyświetlania sygnałów
  • Picture – elementy służące do wyświetlania obrazków,
  • Timer – element symboliczny 9nie widoczny na interfejsie) służący do wykonywania czynności co określony czas,
  • Canavas – grafika wektorowa
  • Spliter – paski podziału,
  • Tab – element do grupowania elementów na interfejsie użytkownika.

Można też wgrać własną kontrolkę stworzoną dla LabWindows/CVI lub jako element ActiveX. Jest tez pozycja umożliwiająca stosowanie kontrolek starego typu (z poprzednich wersji CVI).


Przycisk Command Button umieszczamy w prawym dolnym rogu.

Następnie przechodzimy do właściwości elementu (poprzez dwukrotne klikniecie lewym przyciskiem myszy na elemencie). W oknie podglądu powinniśmy zobaczyć widok przycisku. Jeżeli go nie widać to znaczy że niechcący kliknęliśmy inny element np. Panel.

Zmieniamy następujące własciwości przycisku:

  • Constant Name – wpisujemy WYJSCIE
  • Określamy funkcję Controll Callback jaka ma być wywoływana po naciśnięciu przycisku Wyjście – wpisujemy Wyjscie.
  • Zmieniamy etykietę jak ma być wyświetlana na przycisku Label na __Wyjście.

W czasie definiowania etykiety (pole Label) przed napisem Wyjście można zauważyć dwa znaki podkreślenia „__”. Znaki te definiują klawisz szybkiego dostępu (skrót klawiaturowy – w tym wypadku CTRL + W) do przycisku wyjście. Jeżeli chcemy zdefiniować np. literę „y” jako skrót to etykietę wpisujemy w następujący sposób: W__yjście. Wprowadzoną zmianę możemy podejrzeć w oknie podglądu.

Zdefiniowanie skrótu klawiaturowego nie oznacza ze będzie on działał – jest to tylko oznaczenie litery skrótu na wyświetlanym elemencie. Kod obsługi skrótu trzeba oprogramować oddzielnie.

Wprowadzone zmiany w formularzu właściwości zatwierdzamy przyciskiem OK. Widok panelu UI powinien wyglądać podobnie jak przedstawiony na slajdzie.

Przystępujemy do generacji kodu C aplikacji. W tym celu w przestrzeni roboczej wybieramy okno zawierające interfejs użytkownika. W menu głównym będzie dostępna pozycja Code z której wybieramy:

Code > Generale > All Code

Spowoduje to otworzenie formularza określającego właściwości generowanego kodu aplikacji. Zanim jednak do tego przejdziemy należy zachować poszczególne pliki projektu – o czym środowisko nas poinformuje.

Jeżeli do tej pory nie zapisaliśmy pliku interfejsu użytkownika to pojawi się monit o wykonanie tej czynności. Po naciśnięciu przycisku Yes pojawi się okno w którym możemy wybrać lokalizację katalogu gdzie ma zostać zapisany plik interfejsu. Zaleca się aby utworzyć katalog dla tworzonego projektu. Pozwala to na zachowanie porządku i łatwą identyfikacje plików należących do konkretnego projektu.

Po zapisaniu plików otworzy się formularz właściwości dla generowanego kodu aplikacji. Na początku zajmiemy się wyjaśnieniem znaczenia poszczególnych pól formularza.

  • Target file – określa sposób zachowania kreatora. Do wyboru są dwie opcje: Create New Project aby utworzyć cały kod od początku lub Add to Current Project aby dodać do istniejącego projektu kod. Zastosowanie pierwszej opcji powoduje zastąpienie wszystkich dotychczas utworzonych funkcji nowymi co w przypadku gdy już coś napisaliśmy spowoduje utratę kodu (kreator celem zabezpieczenia przed utratą danych zapyta się czy na pewno che zastąpić utworzony wcześniej kod nowym) . Druga opcja pozwala na dodanie do już istniejącego pliku nowych funkcji.
  • Target Type – określa czy kod generowany ma być aplikacją czy biblioteka funkcji.
  • Project i Source Filename – określa ścieżkę i nazwę dla tworzonego projektu i kodu źródłowego.
  • Generale WinMain() instead of main() – określa czy chcemy jako punkt wejściowy utworzyć funkcje WinMain czy main. Ma to znaczenie przy generacji bibliotek, tutaj lepiej wybrać WinMain – użycie biblioteki będzie prostsze.
  • Select Panels to load and display at startup – umożliwia wybór panelu jaki ma zostać automatycznie wczytany I wyświetlony w czasie startu aplikacji.
  • Panel Variable Name – jest to nazwa zmiennej przechowująca wskaźnik do panelu. W większości przypadków pozostawiamy bez zmian.
  • Program Termination – określa która z funkcji ma kończyć działanie programu. Kreator sam dostawi niezbędne funkcje potrzebne do zakończenia działania aplikacji.

W naszym przypadku należy podać następujące dane:

  • Target file – wybieramy opcję: Create New Project.
  • Target Type – ponieważ ma to być aplikacja wybieramy Executable.
  • Project i Source Filename – pozostawiamy bez zmian.
  • Generale WinMain() instead of main() – zaznaczamy aby kreator wygenerował funkcję WinMain ().
  • Select Panels to load and display at startup – mamy jeden panel więc go zaznaczamy.
  • Panel Variable Name – pozostawiamy domyślną nazwę panelHandle.
  • Program Termination – zaznaczamy funkcję Wyjście aby generator wstawił funkcję kończąca działanie aplikacji.

Po wprowadzeniu zmian naciskamy przycisk OK co spowoduje przejście do kolejnego etapu.

Ostatnią czynnością jaką trzeba wykonać przed wygenerowaniem kodu jest ustawienie właściwości dla nowo tworzonego projektu (ponieważ taką opcje wybraliśmy w polu Target File). Zaznaczmy Create Project In New Workspace celem zdefiniowania nowej przestrzeni roboczej dla projektu. Z ustawień poprzedniego projektu przenosimy jedynie opcje Build Options.

Zatwierdzamy zmiany przyciskiem OK. W tym momencie powinien zostać wygenerowany kod C aplikacji.

W obszarze roboczym projektu pojawiło się nowe okno zawierające kod C aplikacji. Wygenerowany plik z kodem został automatycznie dodany do plików projektu.

Wygenerowany kod aplikacji można podzielić na trzy części które dokładnie zostaną omówione na następnym slajdzie.

opis slajdu

W poprzednich krokach został zbudowany interfejs użytkownika oraz wygenerowany kod C aplikacji. Na tym etapie można już uruchomić aplikację. Na slajdzie przedstawione zostały dwa sposoby uruchamiana aplikacji w środowisku LabWindows/CVI.

Zbudowany został szkielet do budowy dowolnej aplikacji. Funkcjonalność jest obecnie ograniczona jedynie do przycisku Wyjście kończącego działanie programu.

W pierwszej części kursu pt. „Środowisko programistyczne LabWindows/CVI” został zaprezentowany sposób budowy szkieletu aplikacji a słuchacz nabył niezbędne wiadomości potrzebne do zbudowania interfejsu użytkownika, wygenerowania kodu programu oraz uruchomienia aplikacji.

Źródło: „https://wazniak.mimuw.edu.pl/index.php?title=Laboratorium_wirtualne_1/Moduł_2_-_ćwiczenie_2/część_1&oldid=29191”