Programowanie mikroprocesorów ( mikrokontrolerów )

Struktura programu

Poniżej przedstawiona została podstawowa struktura programu w C++ stosowana w programowaniu mikroprocesorów mikrokontrolerów z opisem poniżej kodu źródłowego:

Przykładowa struktura programu
  1. //
  2.  // AVRGCC1.c
  3.  //
  4.  // Created: 2012-01-04 18:51:35
  5.  //  Author: Pioter
  6.  //
  7.  
  8. // sekcja include
  9. #include <avr/io.h>
  10. #include <util/delay.h>
  11. #include <avr/interrupt.h>
  12. #include <stdlib.h>
  13.  
  14. // sekcja define
  15. #define F_CPU 8000000UL
  16. #define true 1
  17. #define false 0
  18. #define cbi(sfr,bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
  19. #define sbi(sfr,bit) (_SFR_BYTE(sfr) |= _BV(bit))
  20.  
  21. // sekcja deklaracji zmiennych
  22. unsigned char flaga_1,flaga_2;
  23. int c;
  24.  
  25. // sekcja podprogramów
  26. void zgas(void)
  27. {
  28. PORTD=0xff;
  29. flaga_2=false;
  30. }
  31.  
  32. void zapal (void)
  33. {
  34. PORTD=0x00;
  35. flaga_1=false;
  36. }
  37.  
  38. // sekcja przerwań
  39. ISR(TIMER0_OVF_vect)
  40. {
  41. c++;
  42.         if (c==200) flaga_1=true;
  43.         if (c==400)
  44.         {
  45.                 flaga_2=true;
  46.                 c=0;
  47.         }
  48. }
  49.  
  50. // sekcja programu głównego
  51. int main(void)
  52. {
  53. //sekcja startup
  54. PIND=PIND|0xff;
  55. DDRD=DDRD&0xff;
  56. PORTD=PORTD|0xff;
  57.  
  58. TCCR0|=(1<<CS02)|(1<<CS00);
  59. TIMSK|=(1<<TOIE0);
  60. TCNT0=0;
  61. sei();
  62.  
  63. // sekcja programu zapętlonego
  64.     while(1)
  65.     {
  66.  
  67.                 if (flaga_1)
  68.                 {
  69.                 zapal();
  70.                 }
  71.                        
  72.                 if (flaga_2)
  73.                 {
  74.                 zgas();
  75.                 }
  76.        
  77.         }
  78. }
  79.  

Powyżej został przedstawiony program migający diodą. Każdy program składa się z kilku podstawowych sekcji takich jak:

  1. sekcja komentarza (linie od 1 do 6)
  2. sekcja include (linie od 8 do 12)
  3. sekcja define (linie od 14 do 19)
  4. sekcja deklaracji zmiennych globalnych (linie od 21 do 23)
  5. sekcja podprogramów (linie od 25 do 36)
  6. sekcja obsługi przerwań (linie od 38 do 48)
  7. sekcja programu głównego (linie od 50 do 78)
    • sekcja programu startup (linie od 53 do 61)
    • sekcja programu zapętlonego (linie od 63 do 75)

Ad.1 Sekcja komentarza. Sekcja ta nie jest wymaganą sekcją do prawidłowego działania programu jednak warto ją dodać w celu opisania swojego programu dodatkowymi informacjami takimi jak data utworzenia nazwa projektu oraz wersja powstającego oprogramowania gdyż przy większej liczbie projektów może się wkraść zamieszanie i możemy nadpisać nowszą wersje jakiegoś urządzenia starszą i stracić owoce naszej ciężkiej pracy co nie należy do najmilszych doświadczeń.


Ad.2 Sekcja include. W sekcji tej dodajemy biblioteki zewnętrzne z których korzystać będzie nasz program. Biblioteki zewnętrzne mogą zawierać gotowe funkcje takie jak np opóźnienie czasowe to jest funkcja _delay_ms(X) (gdzie x jest wartością opóźnienia w ms) zawartą w bibliotece delay.h dostarczonej najczęściej ze środowiskiem programistycznym w jakim pracujemy np. WinAVR. Dzięki bibioteką możemy zaoszczędzić czasu oraz siły przy pewnych często wykorzystywanych powtarzających się funkcjach. Możemy również stworzyć sobie swoje biblioteki z własnymi autorskimi funkcjami. Możemy spotkać również biblioteki od obsługi standardowych protokołów, sprawdzania CRC, obsługi różnych urządzeń jak np wyświetlacze ciekłokrystaliczne które zawierają zestawy funkcji ułatwiających obsługę. Aby dołączyć bibliotekę do programu wpisujemy następującą komendę: #include <ścieżka dostępu z nazwą biblioteki>. np. #include <util/delay.h>


Ad.3 Sekcja define.W sekcji tej możemy sobie zdefiniować pewne przezwania komend lub zmiennych tzn. kompilator w czasie kompilacji będzie zamieniał naszą tymczasową nazwę na pewien zdefiniowany ciąg znaków którym jest np komenda albo jakaś wartość parametru. Konstrukcja komendy jest następująca: #define nasza_nazwa nazwa_która_zostanie_podstawiona_do_kompilacji np. #define true 1. Jest to jedna z najprostrzych definicji dzięki której każde użyte przez nas słowo true zostanie zastąpione przed kompilacją cyfrą 1. Rozpatrzmy teraz trochę bardziej skomplikowaną definicjejaką jest #define cbi(sfr,bit) (_SFR_BYTE(sfr) &= ~_BV(bit)) . W definicji tej dodatkowo występują dwa parametry "sfr" oraz "bit" które wykorzystujemy do przekazania parametrów z naszej definicji do funkcji właściwej. Dzięki tej definicji możemy zastąpić skomplikowany zapis operacji bitowej (_SFR_BYTE(sfr) &= ~_BV(bit)) skróconym zapisem cbi(sfr,bit) wymyślonym przez nas. Przed kompilacją nasza fraza cbi(sfr,bit) zostanie zastąpiona prawidłową operacją bitową (_SFR_BYTE(sfr) &= ~_BV(bit)) i skompilowana.


Ad.4 Sekcja deklaracji zmiennych globalnych. W sekcji tej deklarujemy używane przez nas zmienne w programie. Określamy ich typ oraz nazwę np unsigned char flaga_1,flaga_2;. Zmienne tych samych typów możemy wymieniać oddzielając ich nazwy przecinkami. Zmienne globalne deklarowane w tej sekcji dostępne są w obrębie całego programu tzn. we wszystkich podprogramach, obsłudze przerwań itd. Natomiast zmienne deklarowane lokalnie w podprogramie lub przerwaniu dostępne są tylko w jego obrębie tzn. nie mamy do nich dostępu z innego podprogramu lub programu głównego.


Ad.5 Sekcja podprogramów. W sekcji tej zamieszczamy podprogramy do których odwołuje się program główny. Podprogramy tworzone są w celu zwiększenia przejrzystości kodu programu głównego, ułatwiają analizę kodu oraz umożliwiają w pewnym stopniu parametryzację dzięki czemu możemy wykorzystać jeden podprogram w kilku miejscach programu do wykonania określonych funkcji. Więcej o podprogramach w sekcji "PROGRAMOWANIE->PODPROGRAMY"


Ad.6 Sekcja obsługi przerwań. W sekcji tej zamieszczamy obsługę przerwań dla poszczególnych elementów procesora. Przerwania opisane zostaną szerzej w sekcji "PROGRAMOWANIE->PRZERWANIA"


Ad.7 Sekcja programu głównego. Sekcje programu głównego podzielić możemy na dwie części. W pierwszej części zamieszczamy elementy które mają wykonać się raz przy starcie programu. Po wykonaniu komend startowych program wchodzi w nieskończoną pętlę w której zamieszczony zostanie program właściwy sterujący pracą mikroprocesora mikrokontrolera.





 
Wszelkie prawa zastrzeżone! Kopiowanie, powielanie i wykorzystywanie zdjęć, treści oraz jej fragmentów bez zgody autora zabronione.
© mikroprocesory.info.pl@gmail.com 2013.