Opcje wyszukiwania (Strona 2 z 3)

Do komunikacji szeregowej w środowisku LabVIEW wykorzystujemy bloczki z grupy Instrument I/O -> Serial lub Instrument I/O -> VISA. Aby bloczki te były dostępne, należy upewnić się, że zainstalowane zostały sterowniki Device Drivers.

Zaczynamy od umieszczenia na diagramie blokowym kontrolek realizujących nawiązanie oraz zamknięcię sesji połączenia z portem szeregowym. Są to odpowiednio VISA Open oraz VISA Close dostępne w palecie VISA -> VISA Advanced.

Rysunek 1 kontrolki realizujące połączenie z portem szeregowym

Zastosowanie powyższych kontrolek spowoduje nawiązanie połączenia z użyciem domyślnych parametrów (baud rate: 9600, data bits: 8, parity: none, stop bits: 1, flow control: none).

Jeżeli chcemy komunikować się z wykorzystaniem parametrów transmisji innych niż domyślne, zamiast z VISA Open możemy skorzystać z kontrolki VISA Configure Serial Port, dostępnej w palecie Serial.

Rysunek 2 Konfiguracja parametrów portu szeregowego

Rysunek 3 Odbieranie danych z portu szeregowego

Aby zrealizować odbieranie danych z portu szeregowego, pomiędzy kontrolki otwarcia i zamknięcia sesji wstawiamy pętlę while, w której będziemy sprawdzać, czy w buforze portu znajdują się dane gotowe do odczytu. W tym celu stosujemy bloczek Bytes at port, dostępny w palecie Serial. Jeżeli wartość zwrócona przez ten bloczek jest większa od 0, przekazujemy ją do kontrolki VISA Read, co spowoduje odczytanie z portu takiej liczby bajtów, jaka aktualnie znajduje się w nim do odczytu. Odczytany w ten sposób komunikat możemy wyświetlić lub przesłać do dalszego przetwarzania.

Stosujemy w tym przypadku standardowy szablon aplikacji z pętlą while, z okresem taktowania określonym przez kontrolkę Wait until nex ms multiple, warunkiem stopu aktywnym w momencie naciśnięcia przez użytkownika przycisku Stop na panelu frontowym.

Odporność na błędy

Praktyka pokazuje, że taki sposób odczytu danych z portu szeregowego nie jest odporny na mogące pojawić się w trakcie komunikacji zakłócenia. Na przykład możliwa jest sytuacja, w której komunikat o całkowitej długości 10 bajtów, pojawi się w buforze w dwóch partiach, po 6 i 4 bajty. Wówczas kontrolka Bytes at port zwróci najpierw wartość 6, a w kolejnej iteracji wartość 4, co spowoduje odczytanie i przesłanie przez program do dalszego przetwarzania dwóch osobnych fragmentów, zamiast całego komunikatu. Może to spowodować błąd lub niepoprawne rozpoznanie treści komunikatu przez kolejne bloczki.

Aby uchronić się przed taką sytuacją, stosujemy podczas odczytu z portu szeregowego dodatkowy bufor, w którym przechowujemy dane do momentu otrzymania kompletnego komunikatu. W tym celu konieczne jest określenie, jakim znakiem kończy się dany komunikat, najczęściej jest to znak końca linii ‘\n’.

Aby zrealizować doklejanie każdego nowo odczytanego napisu do bufora, stosujemy mechanizm rejestru przesuwnego. Przed uruchomieniem pętli while jako wartość początkową rejestru ustawiamy stałą będącą pustym napisem (Empty String Constant). Każdorazowo odczytane dane z portu szeregowego doklejamy do bufora przy pomocy kontrolki Concatenate Strings. Jednocześnie sprawdzamy, czy ostatni znak odczytanego napisu jest równy znakowi końca linii. W tym celu stosujemy kontrolkę String Subset, której jako offset podajemy długość napisu określoną przez bloczek String Length, a następnie pomniejszoną o 1, a jako length wartość 1. Jeżeli stwierdzimy, że otrzymaliśmy cały komunikat, wyświetlamy go lub przesyłamy do dalszego przetwarzania, a do rejestru przesuwnego przesyłamy pusty napis. Jeżeli komunikat jeszcze nie jest kompletny, aktualnie znajdujące się w buforze dane nie są przetwarzane, lecz przesyłane poprzez rejestr przesuwny na wejście kolejnej iteracji pętli while.

Rysunek 4 Odbieranie danych z wykorzystaniem bufora

Odbieranie oraz wysyłanie danych

Jeżeli chcemy w programie umożliwić oprócz odbierania danych również ich nadawanie poprzez wysyłanie wpisywanych przez użytkownika komunikatów, możemy do tego celu wykorzystać strukturę zdarzeniową Event Structure.
Do odbierania danych wykorzystujemy zdarzenie Timeout, którego parametr czasowy określamy, tak jak poprzednio ustawiony okres taktowania pętli while.

Rysunek 5 Zdarzeniowe odbieranie danych

Wysyłanie danych z kontrolki tekstowej Message będzie realizowane po naciśnięciu przez użytkownika przycisku Send. W tym celu dodajemy do listy zdarzeń struktury Event zdarzenie „Send” : Mouse up. Wewnątrz diagramu dla tego zdarzenia umieszczamy bloczek VISA Write, na którego wejście przesyłamy wpisany przez użytkownika komunikat z doklejonymi znakami powrotu karetki oraz końca linii: „\r\n”. Dodatkowo przed wysłaniem komunikatu sprawdzamy, czy nie jest on pusty przy pomocy kontrolki Empty String/Path?. W przypadku zaistnienia takiej sytuacji zapis nie zostanie zrealizowany.

Rysunek 6 Zdarzeniowe wysyłanie danych

Propozycje ćwiczeń i modyfikacji
1.    Zmodyfikować program tak, aby zamiast wyświetlania ostatnio odczytanego komunikatu, wyświetlana była cała historia komunikacji z automatycznym przewijaniem w miarę otrzymywania kolejnych komunikatów.
2.    Przetestować komunikację pomiędzy dwoma instancjami programu uruchomionymi na jednym komputerze z wykorzystaniem emulatora portów szeregowych COM0COM.
3.    Do sprawdzenia ostatniego znaku komunikatu wykorzystać bloczek Slice String, znajdujący się w bibliotece OpenG, instalowanej przez program VI Package Manager.

Wstęp

Środowisko programistyczne LabVIEW znajduje zastosowanie w automatyce, robotyce, mechatronice, czyli w obszarach, w których mamy do czynienia z pomiarami, sterowaniem, akwizycją i przetwarzaniem danych oraz potrzebą integracji tych funkcji w jednym programie.

Cechy wyróżniające środowisko LabVIEW:

• Graficzny język programowania (G) – opracowanie programu sprowadza się do łączenia bloczków na diagramie blokowym,

• Programowanie wysokiego poziomu – LabVIEW wyposażone jest w dużą liczbę bibliotek i bloczków funkcyjnych, które pozwalają programiście skupić się na realizacji zadania stawianego przed programem, a nie na szczegółach implementacji (zarządzanie pamięcią, obsługa sterowników urządzeń),

• Szybkie prototypowanie – w LabVIEW jednocześnie powstaje zarówno diagram blokowy, określający logikę działania programu, jak również panel frontowy zawierający elementy interfejsu użytkownika. Takie podejście znacząco zwiększa efektywność tworzenia aplikacji i umożliwia powstanie pierwszego prototypu w bardzo krótkim czasie.

Instalacja środowiska programistycznego LabVIEW

Środowisko programistyczne LabVIEW można pobrać w pełni funkcjonalnej wersji 30-dniowej ze strony www.ni.com/labview. Dla studentów uczelni technicznych dostępne są specjalne klucze licencyjne, umożliwiające zniesienie ograniczeń czasowych i wykorzystywanie pełni możliwości środowiska do celów edukacyjnych. Producent LabVIEW – firma National Instruments – organizuje ponadto internetowe szkolenia wprowadzające w tematykę LabVIEW, podczas których również można otrzymać edukacyjny klucz licencyjny.

Z uwagi na dużą liczbę dostępnych pakietów i bibliotek dodatkowych, podczas instalacji warto wybrać jedynie te funkcje, które będą rzeczywiście wykorzystywane, aby niepotrzebnie nie obciążać systemu operacyjnego usługami działającymi w tle. W razie potrzeby dodatkowe biblioteki można doinstalować w każdej chwili.
Do nauki podstaw, wystarczająca jest instalacja samego środowiska, bez dodatkowych bibliotek (opcja LabVIEW Core podczas instalacji).

Pierwszy program w LabVIEW

Po uruchomieniu LabVIEW w wersji 2012, pojawia się następujący ekran startowy:

Rysunek 1 Ekran startowy LabVIEW

Pracę nad nowym programem najlepiej zacząć od utworzenia nowego projektu. Projekt ułatwia nam zapanowanie nad wszystkimi programami i podprogramami (a każdy z nich zapisywany jest w osobnym pliku na dysku), jak również jest niezbędny do tego, aby utworzyć dla opracowanej aplikacji plik exe.

W celu utworzenia nowego projektu, z menu File wybieramy opcję „Create Project…”. LabVIEW następnie wyświetla kreator, który umożliwia skorzystanie z dostępnych szablonów. Tym razem jednak zaczniemy od pustego projektu (opcja Blank Project).

W LabVIEW, każdy program i podprogram zapisywany jest w osobnym pliku o rozszerzeniu .vi (od Virtual Instrument). Mówiąc o programach LabVIEW, bardzo często używa się właśnie określenia „VI”.

Aby utworzyć nowy VI, z menu File projektu wybieramy opcję „New VI” lub klikamy prawym przyciskiem myszy na ikonę „My Computer” w drzewie projektu, a następnie z menu wybieramy opcje New -> VI.

Po wybraniu tej opcji LabVIEW wyświetli nam dwa okna. Na pierwszym z nich (Front Panel) zamieszczamy kontrolki odpowiadające za elementy interfejsu użytkownika. Drugie okno (Block Diagram) służy do opracowywania logiki działania programu w postaci diagramu blokowego.

Przydatne skróty klawiszowe:

• CTRL + E – przełączanie się pomiędzy oknami,

• CTRL + T – równomierne rozłożenie okien obok siebie na ekranie.

Rysunek 2 Panel Frontowy i Diagram Blokowy LabVIEW

Praca z LabVIEW polega na wybieraniu bloczków potrzebnych do zrealizowania programu z odpowiednich palet. Dostęp do palet uzyskujemy poprzez kliknięcie prawym przyciskiem myszy w pustym obszarze okna. Dla panelu frontowego będą to palety zawierające kontrolki interfejsu, dla diagramu blokowego – kontrolki funkcyjne.

Tworzenie nowego programu zaczniemy od umieszczenia dwóch kontrolek na panelu frontowym. Będzie to suwak, umożliwiający nastawienie określonej wartości oraz termometr, na którym ta wartość będzie wyświetlana.

W tym celu klikamy prawym przyciskiem myszy w puste pole panelu frontowego i umieszczamy na nim następujące kontrolki:

• Silver -> Numeric -> Vertical Pointer Slide

• Silver -> Numeric -> Thermometer

Po umieszczeniu kontrolek na panelu frontowym mamy możliwość dostosowania ich wielkości (wymaga to niekiedy bardzo precyzyjnego operowania myszą) oraz skali (w tym celu wystarczy kliknąć dwukrotnie w liczbę na skali, a następnie wpisać pożądaną wartość).

Wszystkie właściwości kontrolek możemy ponadto skonfigurować poprzez kliknięcie prawym przyciskiem myszy na kontrolce i wybranie opcji Properties.

Rysunek 3 Panel frontowy programu po dopasowaniu wielkości i skali kontrolek

Po umieszczeniu kontrolek na panelu frontowym zauważamy, że odpowiadające im bloczki pojawiły się automatycznie na diagramie blokowym.

Rysunek 4 Diagram blokowy po umieszczeniu kontrolek na panelu frontowym

Kontrolka „Vertical Pointer Slide” jest kontrolką wyjściową (taką, z której dane wypływają), co można poznać poprzez trójkątny konektor wyjściowy z jej prawej strony, jak również zamalowaną ramkę. Kontrolka „Thermometer” jest kontrolką wyświetlającą dane, co można poznać poprzez wejście z lewej strony, jak również niezamalowaną ramkę. Kolor pomarańczowy obu kontrolek oznacza, że są one przeznaczone do przechowywania liczb rzeczywistych, co jest również sygnalizowane literkami DBL (od „double”).

Aby umożliwić wyświetlanie przez termometr wartości nastawionej na suwaku, należy połączyć wyjście suwaka z wejściem termometru.

Rysunek 5 Połączenie między kontrolkami diagramu blokowego

Następnie możemy ustawić określoną wartość na suwaku, a po kliknięciu strzałki uruchamiającej program (Run) zauważymy, że wartość ta pojawiła się również na kontrolce wyjściowej – termometrze.

Rysunek 6 Przycisk uruchamiający program w LabVIEW

Wykonanie programu w ten sposób jest jednak jednorazowe. Po przesłaniu wartości do termometru program kończy swoje działanie. Aby umożliwić działanie programu w sposób ciągły, należy skorzystać z dostępnych w LabVIEW pętli. Do sterowania działaniem programu do momentu aż użytkownik zechce zakończyć jego pracę służy pętla While. Petlę while umieszczamy na diagramie blokowym, wybierając ją z palety Programming -> Structures -> While Loop, a następnie otaczając nią te elementy diagramu blokowego, które chcemy zapętlić.

Rysunek 7 Diagram blokowy z pętlą while

Po wstawieniu pętli możemy zauważyć, że programu nie da się uruchomić. Przycisk uruchamiania programu przybiera postać złamanej strzałki, co sygnalizuje obecność błędów. Klikając ten przycisk otrzymujemy okno z informacjami o błędach. Z tego okna możemy odczytać zarówno na czym polegają poszczególne błędy, możemy również klikając dwukrotnie na poszczególne pozycje na liście, przejść do fragmentów diagramu blokowego, które są źródłem błędu.

Rysunek 8 Lista błędów w LabVIEW

W tym przypadku błąd polega na tym, że pętla while nie ma ustalonego warunku stopu, nie wiadomo więc kiedy ma zakończyć swoje działanie. W celu ustalenia warunku stopu pętli while, wystarczy umieścić w programie przycisk STOP, a następnie podpiąć go do terminala warunkowego pętli, znajdującego się w jej prawym dolnym rogu. Taki efekt można uzyskać na różne sposoby, najprostszą metoda jest kliknięcie prawym przyciskiem myszy na wejściu terminala warunkowego na diagramie blokowym, a następnie wybranie opcji Create Control. Możemy również na panelu frontowym z palety Boolean wybrać kontrolkę Stop Button, a następnie na diagramie blokowym wciągnąć ją do pętli while i podpiąć jej wyjście do wejścia terminala warunkowego pętli.

Rysunek 9 Pętla while z warunkiem stopu

Po wykonaniu tej operacji i uruchomieniu programu widzimy, że działa on już w sposób ciągły. Wartości ustawiane na suwaku są wyświetlane na termometrze do momentu, aż użytkownik zakończy działanie programu przyciskiem STOP.
LabVIEW umożliwia również podejrzenie kolejności wykonania poszczególnych operacji programu. W tym celu należy kliknąć przycisk żarówki „Highlight Execution”, dostępny w oknie diagramu blokowego. Uruchomienie programu z załączoną opcją podglądu powoduje wykonanie go w zwolnionym tempie z animacją przepływu poszczególnych danych.

Rysunek 10 Podgląd wykonania programu

Program z pętlą while działa tak szybko, na ile pozwala mu system operacyjny, co może powodować zbyt częste odczytywanie danych z kontrolek wejściowych niż jest to rzeczywiście potrzebne. Efekt ten możemy zaobserwować poprzez umieszczenie kontrolki wyświetlającej wartość aktualnej iteracji pętli while. W tym celu należy utworzyć kontrolkę wyświetlającą dane z konektora „i”, widocznego w lewym dolnym rogu pętli while. Najszybciej można to zrealizować poprzez kliknięcie prawym przyciskiem myszy na ten konektor i wybranie opcji „Create Indicator”.

Aby ograniczyć szybkość działania programu, korzystamy z bloczka „Wait until next ms multiple”, dostępnego w palecie „Timing” na diagramie blokowym. Bloczek ten należy umieścić wewnątrz pętli, której czas wykonania ma kontrolować, a na jego wejście należy podpiąć wartość numeryczną, odpowiadająca liczbie milisekund, z jaką ma wykonywać się każda iteracja pętli. Najszybszym sposobem na podłączenie stałej na wejście tej kontrolki jest kliknięcie na jej wejściu prawym przyciskiem myszy, wybranie opcji „Create Constant”, a następnie wpisanie pożądanej wartości. Do uzyskania płynności działania interfejsu użytkownika, wystarczająca jest wartość 25 milisekund.

Po umieszczeniu tych kontrolek na diagramie blokowym możemy zauważyć, że mają one kolor niebieski. Kolorem takim w LabVIEW oznaczane są liczby całkowite.

Rysunek 11 Program z kontrolą czasu wykonania pętli while

LabVIEW udostępnia nam wiele innych dodatkowych kontrolek i funkcji. Możemy na przykład umieścić na panelu frontowym diodę, która będzie sygnalizować nam sytuację, gdy odczytywana wartość przekroczy zadany próg alarmowy.
Aby zrealizować taką funkcję, na panelu frontowym umieszczamy kontrolkę LED. Kontrolce tej zmieniamy nazwę na „Alarm”, a we właściwościach możemy dopasować jej kolor (np. czerwony).

Następnie na diagramie blokowym umieszczamy kontrolkę „Greater” z palety „Comparison”. Do górnego z jej wejść podpinamy wartość odczytywaną z suwaka, dolne wejście natomiast podłączamy do kontrolki lub stałej ustalającej wartość progową. Wyjście kontrolki „Greater” podłączamy na wejście diody LED, umieszczonej wcześniej wewnątrz pętli while.

Rysunek 12 Program z sygnalizacją przekroczenia progu alarmowego

LabVIEW pozwala nam również w prosty sposób wizualizować odczytywane dane na wykresach. W tym celu możemy na panelu frontowym umieścić kontrolkę „Waveform Chart”. Następnie na diagramie blokowym do wejścia tej kontrolki podpinamy wartość odczytywaną z suwaka.

Rysunek 13 Program z wizualizacją danych na wykresie

Rysunek 14 Panel frontowy ostatecznej wersji programu

Na podstawie opracowanego w ten sposób programu, możemy utworzyć plik wykonywalny exe, którego uruchomienie będzie możliwe na komputerze nie wyposażonym w środowisko LabVIEW.

W tym celu w oknie projektu klikamy prawym przyciskiem myszy na „Build Specifications” i wybieramy opcję New -> Application (EXE). Kreator tworzenia pliku wykonywalnego posiada wiele opcji, jednak aby utworzyć taki plik wystarczy w grupie „Source Files” wskazać ten VI, który ma zostać wywołany przy uruchomieniu programu. W naszym przypadku taki VI jest jeden.

Rysunek 15 Konfiguracja pliku wykonywalnego EXE

Po poprawnym skonfigurowaniu i kliknięciu przycisku „Build”, na dysku zostanie utworzony plik wykonywalny, który następnie możemy uruchomić tak, jak każdy inny program w systemie operacyjnym. Program taki również możemy uruchomić na innym komputerze. W zależności od tego, jak dużo komponentów LabVIEW używa program, do jego uruchomienia może okazać się konieczna instalacja bibliotek uruchomieniowych „LabVIEW Runtime Engine”, dostępnych na stronie producenta.

Fusion Charts Free

Sencha Ext JS

Google Charts

Znajomość bardziej zaawansowanych opcji, może dodatkowo zaoszczędzić nam czas podczas debugowania.

Run to cursor

Uruchomiliśmy w trybie debugowania prosty program i w danej chwili nasz kursor znajduje się na pierwszej pętli for:

Załóżmy, że nie chcemy przechodzić przez wszystkie iteracje tej pętli (czasem może ich być sporo), tylko chcielibyśmy od razu przejść do debugowania drugiej pętli.

Moglibyśmy to zrobić wstawiając obok drugiej pętli breakpoint i wciskając przycisk F5 (Continue):

Prostszym sposobem (dodatkowo nie wymagającym późniejszego czyszczenia tego breakpointa) jest kliknięcie prawym przyciskiem myszy w miejscu, do którego chcemy dotrzeć i wybranie opcji "Run To Cursor". Cały kod zostanie wykonany aż do tego miejsca.

Set Next Statement

Opcja ta pozwala nam zmienić kolejność wykonywania programu.

Załóżmy na przykład, że nasz program odczytuje dane z pliku.
Po długiej interakcji z programem (wybór opcji z menu, wpisanie nazwy pliku...) stwierdzamy podczas debugowania, że pliku nie udało się otworzyć - program wszedł od razu w warunek wyświetlający komunikat o błędzie:

Szybko zauważamy, że powód jest banalny - zapomnieliśmy umieścić plik we właściwym katalogu.

Naprawiamy ten błąd, wgrywając plik we właściwe miejsce.

Aby nie trzeba było zatrzymywać działania programu, uruchamiać go od nowa i raz jeszcze przechodzić całej procedury interakcji z programem (wybór z menu, wpisywanie nazwy), możemy kliknąć prawym przyciskiem myszy na linii kodu, do której chcielibyśmy wrócić i wybrać polecenie "Set Next Statement".

Kursor debuggera zostanie przestawiony w to miejsce i będziemy mieć możliwość ponownego przejścia przez ten fragment kodu.

Edycja kodu w trakcie działania programu

Załóżmy, że debugujemy prosty program:

Podczas debugowania zdajemy sobie sprawę, że w pętli for, która właśnie ma zacząć działanie, chodziło nam tak naprawdę o zwiększenie elementów tablicy o 3, a nie o 2.

Aby to poprawić, nie musimy wyłączać programu, możemy zmienić kod od razu i kontynuować debugowanie - każdy element tablicy zostanie zwiększony o 3.

Edycja wartości zmiennej w trakcie działania programu

Jeżeli w trakcie debugowania programu zauważymy, że któraś z naszych zmiennych przyjmuje nieprawidłową wartość, a chcemy sprawdzić pozostałą część kodu, możemy zmienić wartość tej zmiennej klikając w nią dwukrotnie w oknie Locals, Watch lub w okienku, które pojawia się po najechaniu na jej nazwę.

W Visual Studio w jednej solucji (rozwiązaniu) może znaleźć się klika projektów.

Na przykład jednym z takich projektów może być biblioteka dll, zawierająca funkcje odpowiadające za logikę programu, a drugim projektem może być aplikacja z interfejsem okienkowym, korzystająca z tych funkcji.

Na początku pracy z Visual Studio będziemy mieć z reguły do czynienia z jednym projektem w solucji. Podczas tworzenia projektu, Visual Studio domyślnie tworzy również solucję o takiej samej nazwie. Efektem tego jest pojawienie się wielu folderów o tych samych nazwach.

Jeżeli na przykład utworzymy nowy projekt i nazwiemy go "Program 1" to zobaczymy, że w miejscu, gdzie go utworzyliśmy, powstał folder "Program 1", a w nim kolejny folder "Program 1". Pierwszy z nich to właśnie folder dla solucji "Program 1", a drugi dla projektu "Program 1".

W folderze solucji umieszczane są pliku konfiguracyjne dla solucji (zawierające niewiele opcji, przede wszystkim to, który projekt jest projektem startowym).

W folderach projektów umieszczane są pliki konfiguracyjne projektu, kody źródłowe, tu również tworzone są foldery z pośrednimi plikami, jakie powstają podczas kompilacji.

Podczas przetwarzania obrazów, możemy chcieć wykonać kilka operacji pod rząd na jednym obrazie, na przykład:

negatyw(&obraz);
progowanie(&obraz);
obrot(&obraz);
zapisz(&obraz, "wynik.pgm");

Jeżeli każdą z tych funkcji zadeklarujemy tak, że będzie zwracała wskaźnik na przetworzony obraz (lub NULL w przypadku błędu), możliwe będzie wywołanie ich w następujący sposób:

zapisz(obrot(progowanie(negatyw(&obraz))), "wynik.pgm");

(warto to przećwiczyć pod kątem przyszłej nauki łańcuchowego wywoływania metod w C++)

Jeżeli w systemie operacyjnym mamy do typu plików PGM przyporządkowany jakiś program (np. Irfan View), możemy przyspieszyć sprawdzanie efektów działania programu wykorzystując następujące polecenie:

system(nazwa_pliku);

Wywołanie to będzie analogiczne z dwukrotnym kliknięciem w plik.

Przykład użycia:

negatyw(&obraz);
zapisz(obraz, "tmp.pgm");
system("tmp.pgm");

Splot obrazu (ang. image convolution) sprowadza się do przetworzenia obrazu w następujący sposób:

1. Przygotowujemy sobie tzw. jądro splotu (ang. kernel) o wielkości 3x3 piksele (stosowane są również większe, np. 5x5).
2. Poszczególne piksele obrazu przeliczamy w ten sposób, że dla każdego piksela przemnażamy każdą wartość z kernela przez każdą wartość odpowiadającego temu pikselowi fragmentu obrazu o wielkości takiej jak kernel.
3. Następnie sumujemy poszczególne wyniki, a jeżeli suma elementów jądra jest większa od 1, dzielimy sumę naszych mnożeń przez sumę elementów jądra i zaokrąglamy do wartości całkowitej.
4. Jeżeli otrzymany w ten sposób wynik przekracza dopuszczalną skalę szarości, przycinamy go odpowiednio do jej dolnej lub górnej wartości granicznej - czyli jak jest ujemny to do 0, jak za duży to do maksymalnego poziomu szarości obrazu (można również stosować bardziej złożone sposoby normalizacji wyników wyjściowych).
5. Ostateczny wynik umieszczamy w wynikowej tablicy pikseli (nie można wpisać go od razu do tablicy źródłowej, ponieważ w kolejnej iteracji zostałby wzięty do obliczeń, z uwagi na to, że po obrazie przemieszczamy się okienkiem wielkości 3x3).

Najlepiej taką operację przedstawić obrazowo:

(wynik otrzymany na powyższym obrazku powinien jeszcze zostać dopasowany do skali szarości)

Inny przykład (w wersji interaktywnej powinno być jeszcze dzielenie przez sumę z kernela):
http://www.olympusmicro.com/primer/java … index.html

Wynik tak przeprowadzonej filtracji obrazu zależy od tego, jakie wartości umieścimy w jądrze splotu.

W ten sposób możemy zrealizować np. rozmycie, wyostrzenie, wykrycie krawędzi, uwypuklenie itp.

Przy tego typu przetwarzaniu pojawia się pytanie: co zrobić na krawędzi obrazu?

Najlepszym rozwiązaniem jest tymczasowe powiększenie tablicy o 1 piksel w każdą stronę i przepisanie do tak powstałej krawędzi wartości sąsiednich pikseli. Rozmiar tego powiększenia zależy od tego, jakiej wielkości filtrami chcemy się przemieszczać po obrazie, przykład dla filtrów 5x5:
http://zone.ni.com/reference/en-XX/help … e_borders/

Ponieważ do splotu stosować możemy różne filtry, dobrym rozwiązaniem może być napisanie funkcji realizującej splot, która tablicę z jądrem splotu przyjmuje jako argument wywołania, np:

splot(struct Obraz* o, int[3][3] jadro);

Kod wyjściowy, niepodzielony:

#include <stdio.h>
#include <stdlib.h>

struct Macierz {
    int wys;
    int szer;
    double** liczby;
};

void wyswietl(struct Macierz mac) {
    int i,j;
    for(i=0; i<mac.wys; i++) {
        for(j=0; j<mac.szer; j++) {
            printf("%lf ",mac.liczby[i][j]);
        }
        printf("\n");
    }
}

void wypelnij(struct Macierz* ma, double w) {
    int i,j;
    for(i=0; i<(*ma).wys; i++) {
        for(j=0; j<(*ma).szer; j++) {
            (*ma).liczby[i][j] = w;
        }
    }
}

void main() {

    struct Macierz m;
    int i;
        
    m.wys = 10;
    m.szer = 5;
    m.liczby = (double**)calloc(m.wys, sizeof(double*));
    for (i=0; i<m.wys; i++) {
        m.liczby[i] = (double*)calloc(m.szer, sizeof(double));
    }
    wypelnij(&m, 3.0);
    wyswietl(m);
}

Plik macierz.h - tworzymy w folderze "Header files", zawiera: deklarację struktury, deklaracje funkcji, tutaj również umieszczamy dokumentację struktur i funkcji, pamiętamy też o "strażniku nagłówka", chroniącym przed wielokrotnym includowaniem:

#ifndef MACIERZ_H
#define MACIERZ_H
/**
 * Struktura reprezentujaca macierz
 */
struct Macierz {
    int wys;
    int szer;
    double** liczby;
};

/* 
 * Wyswietla macierz
 * \param mac macierz wejsciowa
 */
void wyswietl(struct Macierz mac);
/* 
 * Wypelnia macierz
 * \param ma macierz wejsciowa
 * \param w wartosc, ktora macierz zostanie wypelniona
 */
void wypelnij(struct Macierz* ma, double w);

#endif

Plik macierz.c - tworzymy w folderze "Source files", załącza macierz.h i wszystkie biblioteki potrzebne do kompilacji, zawiera definicje funkcji

#include <stdio.h>
#include <stdlib.h>
#include "macierz.h"

void wyswietl(struct Macierz mac) {
    int i,j;
    for(i=0; i<mac.wys; i++) {
        for(j=0; j<mac.szer; j++) {
            printf("%lf ",mac.liczby[i][j]);
        }
        printf("\n");
    }
}

void wypelnij(struct Macierz* ma, double w) {
    int i,j;
    for(i=0; i<(*ma).wys; i++) {
        for(j=0; j<(*ma).szer; j++) {
            (*ma).liczby[i][j] = w;
        }
    }
}

Plik main.c - program główny. Jeżeli oprócz funkcji main() zawiera dodatkowe funkcje, to tutaj umieszczamy do nich dokumentację.

#include <stdio.h>
#include <stdlib.h>
#include "macierz.h"

void main() {

    struct Macierz m;
    int i;
        
    m.wys = 10;
    m.szer = 5;
    m.liczby = (double**)calloc(m.wys, sizeof(double*));
    for (i=0; i<m.wys; i++) {
        m.liczby[i] = (double*)calloc(m.szer, sizeof(double));
    }
    wypelnij(&m, 3.0);
    wyswietl(m);
}

W Visual Studio strażnik nagłówka można zrobić w inny sposób, w pierwszej linijce pliku wpisując:

#pragma once

Wówczas nie potrzeba już żadnych #ifndef itd... To rozwiązanie jest wspierane przez różne kompilatory, nie tylko VS.

Jeżeli podczas uruchomienia programu otrzymujemy tego typu błąd, to najczęściej oznacza on, że w programie wyszliśmy gdzieś za daleko w pamięć.

Sytuacja taka może nastąpić podczas nieprawidłowego indeksowania tablic.

Musimy pamiętać, że tablice w C indeksowane są od zera, czyli dla 10-elementowej tablicy zadeklarowanej jako:

int tab[10];

pierwszy element to tab[0], a ostatni tab[9].

Na przykład dla poniższego programu:

int main(void) {
    int i;
    int tab[10];
    for (i=0;i<=10;++i) {
        tab[i] = i + 1;
    }
    return EXIT_SUCCESS;
}

W trakcie działania pętli for, zmienna "i" osiągnie wartość 10, co spowoduje próbę odwołania do elementu tablicy tab[10], który jest już poza zarezerwowanym dla tablicy obszarem pamięci.

Jeżeli otrzymujemy tego typu błędy, należy dokładnie przejrzeć program w poszukiwaniu tego typu sytuacji, tym bardziej, że taki błąd może pojawić się dopiero na końcu działania programu, a nie w chwili kiedy rzeczywiście nastąpiło błędne odwołanie do pamięci.

W przypadku podanego wyżej przykładu, należy zmienić warunek stopu pętli for:

int main(void) {
    int i;
    int tab[10];
    for (i=0;i<10;++i) {
        tab[i] = i + 1;
    }
    return EXIT_SUCCESS;
}

Jeżeli po dokonaniu zmian w programie od razu próbujemy go uruchomić wciskając F5, to w pewnej sytuacji może okazać się, że nie zauważymy żadnej zmiany w działaniu programu.

W normalnej sytuacji Visual Studio pyta, czy przebudować program, jeżeli zauważa, że zostały w nim dokonane zmiany.

Jeżeli natomiast podczas budowania wystąpią błędy, pyta czy uruchomić ostatnią poprawną wersję pliku exe.

W pojawiających się oknach dialogowych można jednak zaznaczyć prośbę o nie wyświetlanie ich ponownie i bardzo prawdopodobne, że ktoś (lub my sami) już kiedyś taką opcję mniej lub bardziej świadomie zaznaczył.

Wówczas Visual nie zapyta o nic, tylko w najgorszej sytuacji po naciśnięciu F5 uruchomi od razu poprzednią wersję programu.

Dlatego zalecam (szczególnie na komputerach w laboratorium) zawsze najpierw kompilować program przez CTRL + F7, a dopiero potem jeżeli widzimy, że nie ma żadnych błędów, uruchamiać go klawiszem F5.

Ponadto jest istotna różnica pomiędzy uruchamianiem przy pomocy F5 a CTRL+F5. Pierwsza z opcji uruchamia program z debuggerem, czyli możemy śledzić jego wykonanie, wstawiać breakpointy i analizować instrukcje linijka po linijce. Skutkiem ubocznym jest jednak natychmiastowe zniknięcie okienka konsoli po zakończeniu działania programu.

Przy uruchamianiu przez CTRL+F5 okienko nie znika, jednak jednocześnie nie działa debugger, dlatego zalecam uruchamiać program klawiszem F5, a jeżeli chcemy zatrzymać okienko konsoli, możemy zrobić to bezpośrednio w programie.

Można to zrobić na przykład instrukcją system("pause"), która ma to do siebie, że działa tylko pod Windowsem i wyświetla standardowy komunikat z prośbą o naciśnięcie dowolnego klawisza, więc nie każdemu może się to rozwiązanie podobać, ale komunikaty z funkcji system można przekierować w nicość pisząc:

system("pause > null");