logo elektroda
logo elektroda
X
logo elektroda
Adblock/uBlockOrigin/AdGuard mogą powodować znikanie niektórych postów z powodu nowej reguły.

atmega32[C]solar-sieć 230V monitorowanie i sterowanie

margas4542 08 Sie 2010 11:29 3550 21
  • #1 8376485
    margas4542
    Poziom 16  
    Witam szanownych forumowiczów.Z zawodu elektronik, wiek 50 lat, od dwu miesięcy posiadacz zestawu EvB4.3 z atmegą32 na której udało mi się uruchomić parę zmodyfikowanych programów napisanych w C w którym nie jestem orłem. Mam projekt nad którym chciałbym popracować kolejno uruchamiając (scalone później w całość) następujące bloki programowe;
    - pomiar napięcia 2 kanały z możliwością ustawienia dwu progów ZAŁ jeżeli napięcie mniejsze od X i WYŁ jeżeli napięcie większe od X
    - sterowanie kodem BCD multipleksera analogowego PORTB piny 1,2,3,4 wyjście Y na PIN5 sprawdzający czy stan"1" na którymś z 8 wejść i ustawiający "1" jeżeli ma uaktywnić którejś z 8 wyjść
    - wyświetlanie danych na LCD 4x20 z hierarchią (wartości napięć orientacyjne)
    SOL 12,52 AK1 11,57
    PTS 16,26 AK2 12,72
    KAN IN x xxxxx xx
    KAN OUT x x
    - komunikacja z drugą atmegą32
    Moje pytanie dotyczy struktury programu czy ma to być jeden plik np; ster.c czy rozbić na kilka np; main.c , lcd.c , multi.c , uart.c . Czy zdefiniowanie na początku tablicy zmiennych do której zapisywane będą wyniki pomiarów ADC oraz informacja o statusie kanału WŁ/WYŁ , stany wejść multipleksera gdy Y=1 do czasu aż kolejny rozkaz nie zmieni stanu na "0" jest dobrym pomysłem czy lepiej definiować to inaczej (sugestie mile widziane). Mam kilka działających podprogramów ale to raczej luźne wersje eksperymentalne aby połapać się w ich działaniu. Do kolegów mam prośbę o ocenę mojego może trochę nazbyt zaawansowanego jak na moją wiedzę programu dlatego będę wdzięczny za wskazówki , sugestie , przykłady w C , na podstawie poszerzę moją wiedzę. Pozdrawiam wszystkich
  • #2 8376638
    tmf
    VIP Zasłużony dla elektroda
    To czy wszystko wrzucisz do jednego pliku czy podzielisz na osobne to zależy od wielkości programu i twoich nawyków - tu nie ma sztywnych reguł. Oczywiście sensowniej jest wydzielić pewne moduły do osobnych plików. Łatwiej potem coś znaleźć. Co do tablicy zmiennych - jak rozumiem chodzi ci raczej o globalną strukturę, zawierającą parametry pracy sterownika. Najlepiej tak to zrobić, struct i potem interesujące cię zmienne. Pamiętaj tylko, żeby deklarację zrobić w pliku nagłówkowym, a definicję umieścić w pliku źródłowym - najlepiej static. W deklaracji nie zapomnij także o extern. Wtedy z poszczególnych modułów inkludujesz tylko nagłówek i możesz się swobodnie odwoływać do globalnej struktury.
  • #3 8378060
    margas4542
    Poziom 16  
    ..nawyków jeszcze nie mam bo dopiero co zaczynam pisać w C i są rzeczy z którymi się jeszcze borykam. Jest faktem że zmiennych to tam trochę będzie i nie za bardzo wiem jak sobie to poukładać.....na razie walczę z dwoma ADC podającymi dane na LCD w pierwszej linijce VCC1 (wynik pomiaru1) VCC2 (wynik pomiaru) i zaczyna i pękać głowa. Coś złe robię ale nie wiem co...czytam manuala niby OK a jednak nie.. przykładów codu w C jak na lekarstwo bo wszyscy piszą w bascomie...i kombinuje jak koń pod górkę.....pozdrawiam
  • #4 8378402
    czmi3l
    Poziom 14  
    tmf napisał:
    ... Najlepiej tak to zrobić, struct i potem interesujące cię zmienne. Pamiętaj tylko, żeby deklarację zrobić w pliku nagłówkowym, a definicję umieścić w pliku źródłowym - najlepiej static. W deklaracji nie zapomnij także o extern. Wtedy z poszczególnych modułów inkludujesz tylko nagłówek i możesz się swobodnie odwoływać do globalnej struktury.


    Ale jak zrobimy ją static to chyba będzie średnio globalna dla całego programu?
  • #5 8378495
    TomT25
    Poziom 10  
    itoa(buf,ic,10);					// Int=>char
    	LCD_WriteText((char*)ic);


    proszę o to prosty przykład jak wypisać zmienną (int) na lcd
    gdzie zmienna buf to dana zmienna (int), a ic to już tablica (char)
    dodatkowo korzystam z funkcji bibliotecznej wypisującej char na LCD
    mam nadzieje że pomogłem:)
  • #6 8378567
    tmf
    VIP Zasłużony dla elektroda
    czmi3l napisał:
    tmf napisał:
    ... Najlepiej tak to zrobić, struct i potem interesujące cię zmienne. Pamiętaj tylko, żeby deklarację zrobić w pliku nagłówkowym, a definicję umieścić w pliku źródłowym - najlepiej static. W deklaracji nie zapomnij także o extern. Wtedy z poszczególnych modułów inkludujesz tylko nagłówek i możesz się swobodnie odwoływać do globalnej struktury.


    Ale jak zrobimy ją static to chyba będzie średnio globalna dla całego programu?


    Bo definicja nie ma być globalna. Tylko deklaracja ma być globalna, a to ci daje extern.
  • #7 8380123
    margas4542
    Poziom 16  
    witam ponownie....kombinuje i kombinuje bo moja wiedza jest zbyt skromna a sposobów pisania definicji tyle ilu piszących. Na podstawie przykładów i sugestii po wielu modyfikacjach złożyłem do kupy coś takiego co w sumie nie do końca jest dla mnie jasne dlatego wytknięcie błędów i kilka wskazówek co "sknociłem" było by wskazane....pozdrawiam
    
    //---------------------------------------------------------------
    // >>>>>>>>>>>>  moje alpejskie kombinacje z C  <<<<<<<<<<<<<<<<<
    //---------------------------------------------------------------
    //################## procesor ATmega 16Mhz ######################
    //--------------------------------------------------------------- 
    #include <avr/io.h>
    #include <stdlib.h>
    #include <avr/interrupt.h>
    #include <avr/pgmspace.h>
    
    //	>>>>>>>>>>>>>> definicje stałych i zmiennych <<<<<<<<<<<<<<<<
      #define PORT_AD PORTA		// port z wejściami analogowymi 
      #define DDR_AD DDRA			
    
      unsigned int licznik;		// Zmienna do zliczania obiegów pętli
      unsigned int pomiar1;		// Zmienna do przechowywania wyniku pomiaru1
      unsigned int pomiar2;		// Zmienna do przechowywania wyniku pomiaru2
      char buffer_n[4];    	    // Bufor do przechowywania wyniku konwersji z "unsigned int" na ASCII
    
    //	>>>>>>>>>>>>>> multiplexer IN/OUT <<<<<<<<<<<<<<<<<<<<<<<<<<<
    //
    // jescze nie napisałem obsługi na DDRB pin1,2,3,4 podają BCD 
    // na analogowy multiplekser 1z16 (wymagany dwukierunkowy)
    // 
    //	>>>>>>>>>>>>>> pomiar dwu anapięć <<<<<<<<<<<<<<<<<<<<<<<<<<<
    
    	void Inicjalizacja(void)
    {
    	DDR_AD=0x00;				// port jako wejścia
    	PORT_AD=0x00;				// port A wejścia bez podciągania
    	
    	ADMUX |= _BV(REFS0);		// Wybranie wewnętrznego żródła napięcia odniesienia		
    	ADMUX |= _BV(REFS1);
    	ADMUX |= _BV(ADLAR);		// zapisu wyniku z wyrównaniem do lewej (8 starszych bitów wyniku w rejestrze ADCH)		
    	ADCSRA |= _BV(ADEN);		// zezwolenie na konwersję			
    	ADCSRA |= _BV(ADPS0);		// set f_adc przetwornika podział (1/128) 	 
    	ADCSRA |= _BV(ADPS2);
    	sei();
    }
    
       int main(void)
    {
    	  ADCSRA |= _BV(ADSC);         		// Rozpoczęcie przetwarzania - wybrany był kanał 0
       while(bit_is_set(ADCSRA,ADSC))		// Oczekiwanie na zakończenie przetwarzania
    	    {};	
    	  pomiar1=ADCH;			     		// zapis starszych 8 bitów wyniku konwersji w kanale 0 do zmiennej "pomiar1"
    	  ADMUX |= _BV(0);					// wybranie kanału 1
    	  ADCSRA |= _BV(ADSC);         		// rozpoczęcie przetwarzania
       while(bit_is_set(ADCSRA,ADSC))		// oczekiwanie na zakończenie przetwarzania
    	    {};	
    	  pomiar2=ADCH;			     		// zapis starszych 8 bitów wyniku konwersji w kanale 1 do zmiennej "pomiar2"
    	  ADMUX &= ~_BV(0);
    	  ADMUX |= _BV(1);
    	  ADCSRA |= _BV(ADSC);         		// Rozpoczęcie przetwarzania
       while(bit_is_set(ADCSRA,ADSC))		// Oczekiwanie na zakończenie przetwarzania
    	  
          utoa(pomiar1, buffer_n, 10);  	// konwersja liczby unsigned int do ascii
          utoa(pomiar2, buffer_n, 10);  	// konwersja liczby unsigned int do ascii	 
      }
      
    //	>>>>>>>>>>>>>> obsługa LCD <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    //  aktualnie podłączony LCD 2x16 na płytce testowej docelowo LCD 4x20
    {
    	LCD_Initalize();
    	LCD_Clear();				
     {
    	LCD_GoTo(0,0);						// kursor na początek 1 lini
    	LCD_WriteText(pomiar1);				// wyświetl w 1 lini 1 pola
    	LCD_GoTo(8,0);						//
        LCD_WriteText(pomiar2);				// wyświetl w 1 lini 9 pola
      }
    //	tu wyświtlać ma dane pobrane z ADC drugiej atmegi 
       {
        LCD_GoTo(0,1);						// kursor na początek drugiej linii
        LCD_WriteText("BAT2");				// wyświetl w 2 lini 1 pola
        LCD_GoTo(8,1);						//
        LCD_WriteText("PWM");				// wyświetl w 2 lini 9 pola
       }
    // tu wyświtlać ma dane o stanie wejść multiplexera 1
    //  {
    //    LCD_GoTo(0,1);						// kursor na początek trzeciej linii
    //    LCD_WriteText(" ");					// wyświetl w 3 lini 1 pola
    //    LCD_GoTo(8,1);						//
    //    LCD_WriteText(" ");					// wyświetl w 3 lini 11 pola
       }
    // tu wyświtlać ma dane o stanie wyjść multiplexera 2
    //  {
    //    LCD_GoTo(0,1);						// kursor na początek drugiej linii
    //    LCD_WriteText(" ");					// wyświetl w 4 lini 1 pola
    //    LCD_GoTo(8,1);						//
    //    LCD_WriteText(" ");					// wyświetl w 4 lini 11 pola
    //   } 
      return 0;
    }
    //	>>>>>>>>>>>>>>> wymiana danych UART <<<<<<<<<<<<<<<<<<<<<<<<<<<
    
    
    //	>>>>>>>>>>>>>>>>>>>>>>>>>END<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    
  • #8 8381017
    TomT25
    Poziom 10  
    jak konwertujesz unsigned int do char to albo odrazu wypisz na LCD albo przechowuj w 2 zmiennych, bo tak poprostu 2x wyświetlasz to samo(pomiar2)
  • #9 8381806
    janbernat
    Poziom 38  
    Witam.
    Wiódł ślepy kulawego...
    Ponieważ jestem jeszcze starszy niż Ty ale z praktyką w C niemowlęcą to pozwolę sobie na uwagi.
    Po pierwsze program się nie kompiluje- ma błędy.
    No bo LCD_Initalize(); itp. powinno być w funkcjj Inicjalizacja()- bo raz się inicjalizuje po włączeniu i już.
    Po drugie- program najpierw wchodzi w main- bo C zawsze wchodzi najpierw w main.
    A tam nigdzie nie nie widzę odwołania do funkcji inicjalizacja().
    Czyli inicjalizacji nie ma.
    Albo wstaw wszystkie początkowe ustawienia rejestrów w inicjalizacja() i do niej się odwołaj w main albo na początku main wstaw wszystkie ustawienia rejestrów i zrezygnuj z funkcj inicjalizacja().
    Po następne- w main nie masz pętli głównej dzięki której procesor pracuje "w kółko" nawet jak aktualnie nie ma nic do roboty.
    Po następne+ odczyt przetwornika można by zrobić w przerwaniu- ADC takowe wystawia.
    I w tym przerwaniu dopiero odczytać i przetworzyć informacje zeń płynące.
    Po następne++ nie rozumiem tego:
    "tu wyświtlać ma dane pobrane z ADC drugiej atmegi"
    Przecież ten procesor ma kilka kanałów ADC- po co dtuga ATmega?
    No i nigdzie nie widzę #include "HD44780.h" ani".....c"
    Pozdrawiam.
  • #10 8385415
    margas4542
    Poziom 16  
    ...no i właśnie namieszałem jak pijany zając...fakt przy przepisywaniu [kolejny raz] nie zwróciłem uwagi na brak biblioteki HD44780..szczerze to już się pogubiłem czytam kolejny raz manual i zamiast rozwiązań wszystko zakręca się jeszcze bardziej...po co druga atmega?...ano ana będzie 30m dalej monitorować akumulatory i zestaw ogniw słonecznych i żeby nie latać to chciałem mieć dane na LCD...ale obsługę UARTA to komuś zlecę bo sam na pewno nie dam rady....
  • #11 8385776
    janbernat
    Poziom 38  
    Na końcu funkcji main() daj pętlę nieskończoną:
    
            while(1)
    	{
    
    
    	}
    

    W której będziesz coś robił albo nie- jeszcze nie wiadomo.
    I na początek uporządkuj program tak, aby robił tylko to co konieczne- np. wyświetli ci stały napis "Witaj Stary".
    Potem dopisuj do tego poszczególne funkcje które wywołasz w głównej pętli albo w przerwaniu.
    Np. stan przetwornika ADC możesz wyświetlić w przerwaniu:
    
    ISR(ADC_vect)
    ..................
    

    I z niego wrócić do głównej pętli.
    Wogóle należy to pisać po kawałku- po sprawdzeniu działania "szkieletu" programu dopisujemy funkcję która ma coś zrobić i sprawdzamy działanie.
    A nie wszysto naraz.
  • #12 8386157
    margas4542
    Poziom 16  
    ...ok jak na dziś to mam już dosyć....wybaczcie ale naprawdę już nie myślę...
    
    //---------------------------------------------------------------
    // >>>>>>>>>>>>  moje alpejskie kombinacje z C  <<<<<<<<<<<<<<<<<
    //---------------------------------------------------------------
    //################## procesor ATmega 16Mhz ######################
    //--------------------------------------------------------------- 
    	#include <avr/io.h>
    	#include <stdlib.h>
    	#include <avr/interrupt.h>
    	#include <avr/pgmspace.h>
    	#include <HD44780.c>
    //	>>>>>>>>>>>>>> 								 <<<<<<<<<<<<<<<<
    	
    
    //	>>>>>>>>>>>>>> pomiar dwu anapięć <<<<<<<<<<<<<<<<<<<<<<<<<<<
    	#define PORT_AD PORTA		// port A z wejściami analogowymi 
    	#define DDR_AD DDRA			
    
    	int main(void)
    { 
    	while(1) 
     {
    	unsigned int licznik;		// Zmienna do zliczania obiegów pętli pomiaru napięc
    	unsigned int pomiar1;		// Zmienna do przechowywania wyniku pomiaru1 napięć
    	unsigned int pomiar2;		// Zmienna do przechowywania wyniku pomiaru2 napięć
    	char buffer_n[5];    	    // Bufor do przechowywania wyniku konwersji z "unsigned int" na ASCII
      }
      {	
    	DDR_AD=0x00;				// port jako wejścia
    	PORT_AD=0x00;				// port A wejścia bez podciągania
    	
    	ADMUX = _BV(REFS0);	    // wewnętrznego żródła napięcia odniesienia	2,56	
    	ADMUX = _BV(REFS1);
    	ADMUX = _BV(ADLAR);		// zapisu wyniku z wyrównaniem do lewej (8 starszych bitów wyniku w rejestrze ADCH)		
    	ADCSRA = _BV(ADEN);		// zezwolenie na konwersję			
    	ADCSRA = _BV(ADPS0);		// set f_adc przetwornika podział (1/128)
    	ADCSRA = _BV(ADPS1); 
    	ADCSRA = _BV(ADPS2);
    	sei();
    
    	  ADCSRA = _BV(ADSC);         		// Rozpoczęcie przetwarzania - wybrany był kanał 0
       while(bit_is_set(ADCSRA,ADSC))		// Oczekiwanie na zakończenie przetwarzania
    	    {};	
    	  pomiar1=ADCH;			     		// zapis starszych 8 bitów wyniku konwersji w kanale 0 do zmiennej "pomiar1"
    	  ADMUX = _BV(0);					// wybranie kanału 1
    	  ADCSRA = _BV(ADSC);         		// rozpoczęcie przetwarzania
       while(bit_is_set(ADCSRA,ADSC))		// oczekiwanie na zakończenie przetwarzania
    	    {};	
    	  pomiar2=ADCH;			     		// zapis starszych 8 bitów wyniku konwersji w kanale 1 do zmiennej "pomiar2"
    	  ADMUX = _BV(0);
    	  ADMUX = _BV(1);					// wybranie kanału 1
    	  ADCSRA = _BV(ADSC);         		// Rozpoczęcie przetwarzania
    	while(bit_is_set(ADCSRA,ADSC))		// Oczekiwanie na zakończenie przetwarzania
    	  
          utoa(pomiar1, buffer_n, 10);  	// konwersja liczby unsigned int do ascii
          utoa(pomiar2, buffer_n, 10);  	// konwersja liczby unsigned int do ascii	 
     }
    
    //	>>>>>>>>>>>>>>>>> obsługa LCD podłączony LCD 2x16 <<<<<<<<<<<<<<<<<<<<<
    //  
    	void Inicjalizacja(void)
    {
     LCD_Initalize();
      LCD_Clear();
       {
       LCD_GoTo(0,0);    		//
        LCD_WriteText("VB1 ");  //wyświetl tekst w 1 lini 1 pola a gdzie pomiar1 ?
       LCD_GoTo(8,0);    		//
        LCD_WriteText("VS  ");  //wyświetl tekst w 1 lini 9 pola a gdzie pomiar2 ?
       }
    
      }
      return 0;
     }
  • #13 8386942
    margas4542
    Poziom 16  
    ...przerobiłem dając na początku obsługę LCD a dopiero potem ADC....poprawiłem "byki"...no i teraz program się kompiluje wgrywam do proca i ....pusty wyświetlacz.......podeślijcie proszę do analizy prosto napisany w C działający przykład to może wreszcie załapię o co tam biega...
    
    //---------------------------------------------------------------
    // >>>>>>>>>>>>  moje alpejskie kombinacje z C  <<<<<<<<<<<<<<<<<
    //---------------------------------------------------------------
    //################## procesor ATmega 16Mhz ######################
    //---------------------------------------------------------------
    #include <avr/io.h>
    #include <stdlib.h>
    #include <avr/interrupt.h>
    #include <avr/pgmspace.h>
    #include <HD44780.c>
    //   >>>>>>>>>>>>>> definicje stałych i zmiennych <<<<<<<<<<<<<<<<
      #define PORT_AD PORTA				// port z wejściami analogowymi
      #define DDR_AD DDRA
              
      unsigned int licznik;      	// Zmienna do zliczania obiegów pętli
      unsigned int pomiar1;      	// Zmienna do przechowywania wyniku pomiaru1
      unsigned int pomiar2;      	// Zmienna do przechowywania wyniku pomiaru2
      char buffer_n[5];           	// Bufor do przechowywania wyniku konwersji z "unsigned int" na ASCII
    
    //   >>>>>>>>>>>>>> obsługa LCD 2 x 16 <<<<<<<<<<<<<<<<<<<<<<<<<<<
      int main(void)
    {
      while (1)
    
       LCD_Initalize();
       LCD_Clear();            
     {
       LCD_GoTo(0,0);                  // kursor na początek 1 lini
       LCD_WriteText(pomiar1);         // wyświetl w 1 lini 1 pola
       LCD_GoTo(8,0);                  //
       LCD_WriteText(pomiar2);         // wyświetl w 1 lini 9 pola
       }
    //   tu wyświtlać ma dane pobrane z ADC drugiej atmegi
       {
        LCD_GoTo(0,1);					// kursor na początek drugiej linii
        LCD_WriteText("BAT2");			// wyświetl w 2 lini 1 pola
        LCD_GoTo(8,1);					//
        LCD_WriteText("PWM");			// wyświetl w 2 lini 9 pola
       }
    
    //   >>>>>>>>>>>>>> pomiar dwu anapięć <<<<<<<<<<<<<<<<<<<<<<<<<<<
      
       void Inicjalizacja(void)
      {
       DDR_AD=0x00;						// port jako wejścia
       PORT_AD=0x00;					// port A wejścia bez podciągania
       
    	ADMUX |= _BV(REFS0);			// wewnętrznego żródła napięcia odniesienia      
    	ADMUX |= _BV(REFS1);			// 2.56V
    	ADMUX |= _BV(ADLAR);			// zapisu z wyrównaniem do lewej (8 starszych bitów wyniku w rejestrze ADCH)      
    	ADCSRA |= _BV(ADEN);			// zezwolenie na konwersję         
    	ADCSRA |= _BV(ADPS0);			// set f_adc przetwornika podział (1/128)
    	ADCSRA |= _BV(ADPS1);    
    	ADCSRA |= _BV(ADPS2);
       sei();
      }
         ADCSRA |= _BV(ADSC);               // Rozpoczęcie przetwarzania - wybrany był kanał 0
       while(bit_is_set(ADCSRA,ADSC))      	// Oczekiwanie na zakończenie przetwarzania
           {};   
         pomiar1=ADCH;                    	// zapis starszych 8 bitów wyniku konwersji w kanale 0 do zmiennej "pomiar1"
         ADMUX |= _BV(0);               	// wybranie kanału 1
         ADCSRA |= _BV(ADSC);               // rozpoczęcie przetwarzania
       while(bit_is_set(ADCSRA,ADSC))     	// oczekiwanie na zakończenie przetwarzania
           {};   
         pomiar2=ADCH;						// zapis starszych 8 bitów wyniku konwersji w kanale 1 do zmiennej "pomiar2"
         ADMUX &= ~_BV(0);
         ADMUX |= _BV(1);
         ADCSRA |= _BV(ADSC);				// Rozpoczęcie przetwarzania
       while(bit_is_set(ADCSRA,ADSC))		// Oczekiwanie na zakończenie przetwarzania
        
          utoa(pomiar1, buffer_n, 10);		// konwersja liczby unsigned int do ascii
          utoa(pomiar2, buffer_n, 10);		// konwersja liczby unsigned int do ascii   
    }
    
    
    //   >>>>>>>>>>>>>>>>>>>>>>>>>END<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
    
    
    
  • #14 8387156
    tmf
    VIP Zasłużony dla elektroda
    A jak ma nie być pusty skoro masz while (1) LCD_Initalize(); co w kółko i w nieskończoność wywłuje funkcję LCD_Initialize();
  • #15 8387975
    margas4542
    Poziom 16  
    ok wywaliłem while (1) program ruszył ale wyświetla mi tylko drugą linijkę [BAT1] [PWM]...wiec muszę zastanowić się co jest nie tak z pomiarem napięć......
  • #17 8389369
    margas4542
    Poziom 16  
    ......dopisałem i .... teraz mam kilka linijek komuników o błędach......
  • #18 8391170
    margas4542
    Poziom 16  
    ....litości co z tym jest nie tak....nie znam angielskiego na tyle żeby poczytać....a ci co wiedzą to piszą tak że zrozumieć trudno....no tak wszystko jest proste jak się już wie.....ja nie wiem ...nie rozumiem...dziękuje za chęć pomocy ale jak jestem w C przedszkolakiem i jeżeli nikt nie potrafi wytłumaczyć dlaczego gdzie i po co to chyba pora zamknąć ten wątek.....pozdrawiam.
  • #19 8394290
    tmf
    VIP Zasłużony dla elektroda
    Ale jak mamy ci pomóc skoro piszesz, że masz kilka linijek komunikatów o błędach, ale już nie piszesz jakich. To jednak istotne jeśli mamy ci pomóc. A skoro nie znasz C, ale chcesz się go nauczyć to masz w sieci pełno samouczków po Polsku, są też książki poświęcone C. Niespodziewaj się, że nauczysz się języka z kilku wypowiedzi na forum.
  • #20 8395430
    margas4542
    Poziom 16  
    ....może się mylę ale najlepiej uczy się na przykładach a tych napisanych w C jak na lekarstwo....króluje BASCOM...usiłuje odpalić ADC i choć znalazłem kilka wskazówek a nawet przepisałem na żywca jedyny ze znalezionych książkowych przykładów to program się nie kompiluje bo ma jakiś błąd którego nie potrafię skorygować..pomyła w druku ?...wiem że chcecie mi pomóc ale podpowiedzi gdzie wstawić polecenie lub znak nie rozwiązują problemu gdyż pojawia się kolejny bo kompilator doszukał się następnej "niezgodności"...tak nauczyć się wiele nie da...a jak już to może po jakimś miesiącu żonglerki kodem w końcu coś się "urodzi"...
  • #21 8402654
    percol
    Poziom 12  
    Wybacz Kolego ale można się załamać - nie znasz podstaw programowania!
    Weź sobie jakąkolwiek książkę do C i przeczytaj chociaż KILKA PIERWSZYCH ROZDZIAŁÓW...
    Bardzo uprzejmie proszę.

    Forum nie jest od nauczania C, nawet na przykładach!

    Najprostszy program ma postać:
    
    #include <stdlib.h>
    #include <stdio.h>
    
    int main(void){
    
    sleep(1);
    return 0;
    }
    


    Jak coś zapętlasz to z głową! To co jest w klamerce { musi kończyć się klamerką } i wszystko gra.
    Jeśli dasz (jak u siebie) pętle typu:

    
    
    while(1)
       sleep(1);
    printf("Koniec pętli while()\n");
    
    


    ... to wkółko będziesz wykonywał funkcję sleep() i nigdy nie osiągniesz funkcji printf()

    Twój program przerobiłbym w pierwszym rzucie na:

    
    
    //---------------------------------------------------------------
    // >>>>>>>>>>>>  moje alpejskie kombinacje z C  <<<<<<<<<<<<<<<<<
    //---------------------------------------------------------------
    //################## procesor ATmega 16Mhz ######################
    //---------------------------------------------------------------
    #include <stdlib.h>
    #include <avr/interrupt.h>
    #include <avr/pgmspace.h>
    //#include <HD44780.c>
    #include <compat/ina90.h>
    #include <avr/io.h>
    //   >>>>>>>>>>>>>> definicje stalych i zmiennych <<<<<<<<<<<<<<<<
      #define PORT_AD PORTA            // port z wejsciami analogowymi
      #define DDR_AD DDRA
             
      unsigned int licznik;         // Zmienna do zliczania obiegów petli
      unsigned int pomiar1;         // Zmienna do przechowywania wyniku pomiaru1
      unsigned int pomiar2;         // Zmienna do przechowywania wyniku pomiaru2
      char buffer_n[5];              // Bufor do przechowywania wyniku konwersji z "unsigned int" na ASCII
    
    //   >>>>>>>>>>>>>> obsługa LCD 2 x 16 <<<<<<<<<<<<<<<<<<<<<<<<<<<
    
    void Inicjalizacja(void){
    	DDRA=0x00;                  // port jako wejscia
    	PORTA=0x00;               // port A wejscia bez podciagania
       
    	ADMUX |= _BV(REFS0);         // wewnetrznego zródla napiecia odniesienia     
    	ADMUX |= _BV(REFS1);         // 2.56V
    	ADMUX |= _BV(ADLAR);         // zapisu z wyrównaniem do lewej (8 starszych bitów wyniku w rejestrze ADCH)     
    	ADCSRA |= _BV(ADEN);         // zezwolenie na konwersje         
    	ADCSRA |= _BV(ADPS0);         // set f_adc przetwornika podzial (1/128)
    	ADCSRA |= _BV(ADPS1);   
    	ADCSRA |= _BV(ADPS2);
    	sei();
    	return;
    	}
    
    void rob_to(void){
    //   >>>>>>>>>>>>>> pomiar dwu anapiec <<<<<<<<<<<<<<<<<<<<<<<<<<<
        ADCSRA |= _BV(ADSC);               // Rozpoczecie przetwarzania - wybrany byl kanal 0
    	while(bit_is_set(ADCSRA,ADSC));         // Oczekiwanie na zakonczenie przetwarzania
    
        pomiar1=ADCH;                       // zapis starszych 8 bitów wyniku konwersji w kanale 0 do zmiennej "pomiar1"
        ADMUX |= _BV(0);                  // wybranie kanalu 1
        ADCSRA |= _BV(ADSC);               // rozpoczecie przetwarzania
    	while(bit_is_set(ADCSRA,ADSC));        // oczekiwanie na zakonczenie przetwarzania
    
        pomiar2=ADCH;                  // zapis starszych 8 bitów wyniku konwersji w kanale 1 do zmiennej "pomiar2"
        ADMUX &= ~_BV(0);
        ADMUX |= _BV(1);
        ADCSRA |= _BV(ADSC);            // Rozpoczecie przetwarzania
    	while(bit_is_set(ADCSRA,ADSC));      // Oczekiwanie na zakonczenie przetwarzania
    
        utoa(pomiar1, buffer_n, 10);      // konwersja liczby unsigned int do ascii
        utoa(pomiar2, buffer_n, 10);      // konwersja liczby unsigned int do ascii   
    	return;
    	}
    
    int main(void){
    
    //   LCD_Initalize();
    //   LCD_Clear();           
    
    
       while (1){
    		rob_to();
    //		LCD_GoTo(0,0);                  // kursor na poczatek 1 lini
    //		LCD_WriteText(pomiar1);         // wyswietl w 1 lini 1 pola
    //		LCD_GoTo(8,0);                  //
    //		LCD_WriteText(pomiar2);         // wyswietl w 1 lini 9 pola
    
    //   tu wyswitlac ma dane pobrane z ADC drugiej atmegi
    //		LCD_GoTo(0,1);               // kursor na poczatek drugiej linii
    //		LCD_WriteText("BAT2");         // wyswietl w 2 lini 1 pola
    //		LCD_GoTo(8,1);               //
    //		LCD_WriteText("PWM");         // wyswietl w 2 lini 9 pola
    		}
    
    }
    
    
    //   >>>>>>>>>>>>>>>>>>>>>>>>>END<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
     
    


    Przy czym nie chodzi mi obsługa wyświetlacza (dlatego ją wyłączyłem) ale to juz sam musisz sobie dopracować...

    I naucz się SKŁADNI JĘZYKA C!
    Nigdy nie napiszesz poprawnie programu nie znając podstawowych reguł.
    Poprawiłem Ci kod na zachętę - można i da się trzeba tylko o drobinę wysiłku włożyć, a nie iść na łatwiznę - że ktoś wszystko za nas zrobi...

    Żeby działało skopiuj sobie pliki: defines.h hd44780.h hd44780.c
    Nie zapomnij ustawić w defines.h poprawną częstotliwość pracy mikrokontrolera.

    Tu masz zawartość pliku Makefile, zmień tylko TARGET z 'dupa' na swoją nazwę programu (bez rozszerzenia, np. dla 'moj_program.c' powinieneś wpisać 'TARGET=moj_program') i skompiluj w WinAVR - działa.

    
    
    # Hey Emacs, this is a -*- makefile -*-
    #----------------------------------------------------------------------------
    # WinAVR Makefile Template written by Eric B. Weddington, Jörg Wunsch, et al.
    #
    # Released to the Public Domain
    #
    # Additional material for this makefile was written by:
    # Peter Fleury
    # Tim Henigan
    # Colin O'Flynn
    # Reiner Patommel
    # Markus Pfaff
    # Sander Pool
    # Frederik Rouleau
    # Carlos Lamas
    #
    #----------------------------------------------------------------------------
    # On command line:
    #
    # make all = Make software.
    #
    # make clean = Clean out built project files.
    #
    # make coff = Convert ELF to AVR COFF.
    #
    # make extcoff = Convert ELF to AVR Extended COFF.
    #
    # make program = Download the hex file to the device, using avrdude.
    #                Please customize the avrdude settings below first!
    #
    # make debug = Start either simulavr or avarice as specified for debugging, 
    #              with avr-gdb or avr-insight as the front end for debugging.
    #
    # make filename.s = Just compile filename.c into the assembler code only.
    #
    # make filename.i = Create a preprocessed source file for use in submitting
    #                   bug reports to the GCC project.
    #
    # To rebuild project do "make clean" then "make all".
    #----------------------------------------------------------------------------
    
    
    # MCU name
    MCU = atmega32
    
    
    # Processor frequency.
    #     This will define a symbol, F_CPU, in all source code files equal to the 
    #     processor frequency. You can then use this symbol in your source code to 
    #     calculate timings. Do NOT tack on a 'UL' at the end, this will be done
    #     automatically to create a 32-bit value in your source code.
    #     Typical values are:
    #         F_CPU =  1000000
    #         F_CPU =  1843200
    #         F_CPU =  2000000
    #         F_CPU =  3686400
    #         F_CPU =  4000000
    #         F_CPU =  7372800
    #         F_CPU =  8000000
    #         F_CPU = 11059200
    #         F_CPU = 14745600
    #         F_CPU = 16000000
    #         F_CPU = 18432000
    #         F_CPU = 20000000
    F_CPU = 8000000
    
    
    # Output format. (can be srec, ihex, binary)
    FORMAT = ihex
    
    
    # Target file name (without extension).
    TARGET = dupa
    
    
    # Object files directory
    #     To put object files in current directory, use a dot (.), do NOT make
    #     this an empty or blank macro!
    OBJDIR = .
    
    
    # List C source files here. (C dependencies are automatically generated.)
    SRC = $(TARGET).c
    
    
    # List C++ source files here. (C dependencies are automatically generated.)
    CPPSRC = 
    
    
    # List Assembler source files here.
    #     Make them always end in a capital .S.  Files ending in a lowercase .s
    #     will not be considered source files but generated files (assembler
    #     output from the compiler), and will be deleted upon "make clean"!
    #     Even though the DOS/Win* filesystem matches both .s and .S the same,
    #     it will preserve the spelling of the filenames, and gcc itself does
    #     care about how the name is spelled on its command-line.
    ASRC =
    
    
    # Optimization level, can be [0, 1, 2, 3, s]. 
    #     0 = turn off optimization. s = optimize for size.
    #     (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
    OPT = s
    
    
    # Debugging format.
    #     Native formats for AVR-GCC's -g are dwarf-2 [default] or stabs.
    #     AVR Studio 4.10 requires dwarf-2.
    #     AVR [Extended] COFF format requires stabs, plus an avr-objcopy run.
    DEBUG = dwarf-2
    
    
    # List any extra directories to look for include files here.
    #     Each directory must be seperated by a space.
    #     Use forward slashes for directory separators.
    #     For a directory that has spaces, enclose it in quotes.
    EXTRAINCDIRS = 
    
    
    # Compiler flag to set the C Standard level.
    #     c89   = "ANSI" C
    #     gnu89 = c89 plus GCC extensions
    #     c99   = ISO C99 standard (not yet fully implemented)
    #     gnu99 = c99 plus GCC extensions
    CSTANDARD = -std=gnu99
    
    
    # Place -D or -U options here for C sources
    CDEFS = -DF_CPU=$(F_CPU)UL
    
    
    # Place -D or -U options here for ASM sources
    ADEFS = -DF_CPU=$(F_CPU)
    
    
    # Place -D or -U options here for C++ sources
    CPPDEFS = -DF_CPU=$(F_CPU)UL
    #CPPDEFS += -D__STDC_LIMIT_MACROS
    #CPPDEFS += -D__STDC_CONSTANT_MACROS
    
    
    
    #---------------- Compiler Options C ----------------
    #  -g*:          generate debugging information
    #  -O*:          optimization level
    #  -f...:        tuning, see GCC manual and avr-libc documentation
    #  -Wall...:     warning level
    #  -Wa,...:      tell GCC to pass this to the assembler.
    #    -adhlns...: create assembler listing
    CFLAGS = -g$(DEBUG)
    CFLAGS += $(CDEFS)
    CFLAGS += -O$(OPT)
    CFLAGS += -funsigned-char
    CFLAGS += -funsigned-bitfields
    CFLAGS += -fpack-struct
    CFLAGS += -fshort-enums
    CFLAGS += -Wall
    CFLAGS += -Wstrict-prototypes
    #CFLAGS += -mshort-calls
    #CFLAGS += -fno-unit-at-a-time
    #CFLAGS += -Wundef
    #CFLAGS += -Wunreachable-code
    #CFLAGS += -Wsign-compare
    CFLAGS += -Wa,-adhlns=$(<:%.c=$(OBJDIR)/%.lst)
    CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
    CFLAGS += $(CSTANDARD)
    
    
    #---------------- Compiler Options C++ ----------------
    #  -g*:          generate debugging information
    #  -O*:          optimization level
    #  -f...:        tuning, see GCC manual and avr-libc documentation
    #  -Wall...:     warning level
    #  -Wa,...:      tell GCC to pass this to the assembler.
    #    -adhlns...: create assembler listing
    CPPFLAGS = -g$(DEBUG)
    CPPFLAGS += $(CPPDEFS)
    CPPFLAGS += -O$(OPT)
    CPPFLAGS += -funsigned-char
    CPPFLAGS += -funsigned-bitfields
    CPPFLAGS += -fpack-struct
    CPPFLAGS += -fshort-enums
    CPPFLAGS += -fno-exceptions
    CPPFLAGS += -Wall
    CPPFLAGS += -Wundef
    #CPPFLAGS += -mshort-calls
    #CPPFLAGS += -fno-unit-at-a-time
    #CPPFLAGS += -Wstrict-prototypes
    #CPPFLAGS += -Wunreachable-code
    #CPPFLAGS += -Wsign-compare
    CPPFLAGS += -Wa,-adhlns=$(<:%.cpp=$(OBJDIR)/%.lst)
    CPPFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
    #CPPFLAGS += $(CSTANDARD)
    
    
    #---------------- Assembler Options ----------------
    #  -Wa,...:   tell GCC to pass this to the assembler.
    #  -adhlns:   create listing
    #  -gstabs:   have the assembler create line number information; note that
    #             for use in COFF files, additional information about filenames
    #             and function names needs to be present in the assembler source
    #             files -- see avr-libc docs [FIXME: not yet described there]
    #  -listing-cont-lines: Sets the maximum number of continuation lines of hex 
    #       dump that will be displayed for a given single line of source input.
    ASFLAGS = $(ADEFS) -Wa,-adhlns=$(<:%.S=$(OBJDIR)/%.lst),-gstabs,--listing-cont-lines=100
    
    
    #---------------- Library Options ----------------
    # Minimalistic printf version
    PRINTF_LIB_MIN = -Wl,-u,vfprintf -lprintf_min
    
    # Floating point printf version (requires MATH_LIB = -lm below)
    PRINTF_LIB_FLOAT = -Wl,-u,vfprintf -lprintf_flt
    
    # If this is left blank, then it will use the Standard printf version.
    PRINTF_LIB = 
    #PRINTF_LIB = $(PRINTF_LIB_MIN)
    #PRINTF_LIB = $(PRINTF_LIB_FLOAT)
    
    
    # Minimalistic scanf version
    SCANF_LIB_MIN = -Wl,-u,vfscanf -lscanf_min
    
    # Floating point + %[ scanf version (requires MATH_LIB = -lm below)
    SCANF_LIB_FLOAT = -Wl,-u,vfscanf -lscanf_flt
    
    # If this is left blank, then it will use the Standard scanf version.
    SCANF_LIB = 
    #SCANF_LIB = $(SCANF_LIB_MIN)
    #SCANF_LIB = $(SCANF_LIB_FLOAT)
    
    
    MATH_LIB = -lm
    
    
    # List any extra directories to look for libraries here.
    #     Each directory must be seperated by a space.
    #     Use forward slashes for directory separators.
    #     For a directory that has spaces, enclose it in quotes.
    EXTRALIBDIRS = 
    
    
    
    #---------------- External Memory Options ----------------
    
    # 64 KB of external RAM, starting after internal RAM (ATmega128!),
    # used for variables (.data/.bss) and heap (malloc()).
    #EXTMEMOPTS = -Wl,-Tdata=0x801100,--defsym=__heap_end=0x80ffff
    
    # 64 KB of external RAM, starting after internal RAM (ATmega128!),
    # only used for heap (malloc()).
    #EXTMEMOPTS = -Wl,--section-start,.data=0x801100,--defsym=__heap_end=0x80ffff
    
    EXTMEMOPTS =
    
    
    
    #---------------- Linker Options ----------------
    #  -Wl,...:     tell GCC to pass this to linker.
    #    -Map:      create map file
    #    --cref:    add cross reference to  map file
    LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
    LDFLAGS += $(EXTMEMOPTS)
    LDFLAGS += $(patsubst %,-L%,$(EXTRALIBDIRS))
    LDFLAGS += $(PRINTF_LIB) $(SCANF_LIB) $(MATH_LIB)
    #LDFLAGS += -T linker_script.x
    
    
    
    #---------------- Programming Options (avrdude) ----------------
    
    # Programming hardware
    # Type: avrdude -c ?
    # to get a full listing.
    #
    AVRDUDE_PROGRAMMER = bsd
    
    # com1 = serial port. Use lpt1 to connect to parallel port.
    AVRDUDE_PORT = lpt1
    
    AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex
    #AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
    
    
    # Uncomment the following if you want avrdude's erase cycle counter.
    # Note that this counter needs to be initialized first using -Yn,
    # see avrdude manual.
    #AVRDUDE_ERASE_COUNTER = -y
    
    # Uncomment the following if you do /not/ wish a verification to be
    # performed after programming the device.
    #AVRDUDE_NO_VERIFY = -V
    
    # Increase verbosity level.  Please use this when submitting bug
    # reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude> 
    # to submit bug reports.
    #AVRDUDE_VERBOSE = -v -v
    
    AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)
    AVRDUDE_FLAGS += $(AVRDUDE_NO_VERIFY)
    AVRDUDE_FLAGS += $(AVRDUDE_VERBOSE)
    AVRDUDE_FLAGS += $(AVRDUDE_ERASE_COUNTER)
    
    
    
    #---------------- Debugging Options ----------------
    
    # For simulavr only - target MCU frequency.
    DEBUG_MFREQ = $(F_CPU)
    
    # Set the DEBUG_UI to either gdb or insight.
    # DEBUG_UI = gdb
    DEBUG_UI = insight
    
    # Set the debugging back-end to either avarice, simulavr.
    DEBUG_BACKEND = avarice
    #DEBUG_BACKEND = simulavr
    
    # GDB Init Filename.
    GDBINIT_FILE = __avr_gdbinit
    
    # When using avarice settings for the JTAG
    JTAG_DEV = /dev/com1
    
    # Debugging port used to communicate between GDB / avarice / simulavr.
    DEBUG_PORT = 4242
    
    # Debugging host used to communicate between GDB / avarice / simulavr, normally
    #     just set to localhost unless doing some sort of crazy debugging when 
    #     avarice is running on a different computer.
    DEBUG_HOST = localhost
    
    
    
    #============================================================================
    
    
    # Define programs and commands.
    SHELL = sh
    CC = avr-gcc
    OBJCOPY = avr-objcopy
    OBJDUMP = avr-objdump
    SIZE = avr-size
    AR = avr-ar rcs
    NM = avr-nm
    AVRDUDE = avrdude
    REMOVE = rm -f
    REMOVEDIR = rm -rf
    COPY = cp
    WINSHELL = cmd
    
    
    # Define Messages
    # English
    MSG_ERRORS_NONE = Errors: none
    MSG_BEGIN = -------- begin --------
    MSG_END = --------  end  --------
    MSG_SIZE_BEFORE = Size before: 
    MSG_SIZE_AFTER = Size after:
    MSG_COFF = Converting to AVR COFF:
    MSG_EXTENDED_COFF = Converting to AVR Extended COFF:
    MSG_FLASH = Creating load file for Flash:
    MSG_EEPROM = Creating load file for EEPROM:
    MSG_EXTENDED_LISTING = Creating Extended Listing:
    MSG_SYMBOL_TABLE = Creating Symbol Table:
    MSG_LINKING = Linking:
    MSG_COMPILING = Compiling C:
    MSG_COMPILING_CPP = Compiling C++:
    MSG_ASSEMBLING = Assembling:
    MSG_CLEANING = Cleaning project:
    MSG_CREATING_LIBRARY = Creating library:
    
    
    
    
    # Define all object files.
    OBJ = $(SRC:%.c=$(OBJDIR)/%.o) $(CPPSRC:%.cpp=$(OBJDIR)/%.o) $(ASRC:%.S=$(OBJDIR)/%.o) 
    
    # Define all listing files.
    LST = $(SRC:%.c=$(OBJDIR)/%.lst) $(CPPSRC:%.cpp=$(OBJDIR)/%.lst) $(ASRC:%.S=$(OBJDIR)/%.lst) 
    
    
    # Compiler flags to generate dependency files.
    GENDEPFLAGS = -MMD -MP -MF .dep/$(@F).d
    
    
    # Combine all necessary flags and optional flags.
    # Add target processor to flags.
    ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS) $(GENDEPFLAGS)
    ALL_CPPFLAGS = -mmcu=$(MCU) -I. -x c++ $(CPPFLAGS) $(GENDEPFLAGS)
    ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
    
    
    
    
    
    # Default target.
    all: begin gccversion sizebefore build sizeafter end
    
    # Change the build target to build a HEX file or a library.
    build: elf hex eep lss sym
    #build: lib
    
    
    elf: $(TARGET).elf
    hex: $(TARGET).hex
    eep: $(TARGET).eep
    lss: $(TARGET).lss
    sym: $(TARGET).sym
    LIBNAME=lib$(TARGET).a
    lib: $(LIBNAME)
    
    
    
    # Eye candy.
    # AVR Studio 3.x does not check make's exit code but relies on
    # the following magic strings to be generated by the compile job.
    begin:
    	@echo
    	@echo $(MSG_BEGIN)
    
    end:
    	@echo $(MSG_END)
    	@echo
    
    
    # Display size of file.
    HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex
    ELFSIZE = $(SIZE) --mcu=$(MCU) --format=avr $(TARGET).elf
    
    sizebefore:
    	@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); \
    	2>/dev/null; echo; fi
    
    sizeafter:
    	@if test -f $(TARGET).elf; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); \
    	2>/dev/null; echo; fi
    
    
    
    # Display compiler version information.
    gccversion : 
    	@$(CC) --version
    
    
    
    # Program the device.  
    program: $(TARGET).hex $(TARGET).eep
    	$(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH) $(AVRDUDE_WRITE_EEPROM)
    
    
    # Generate avr-gdb config/init file which does the following:
    #     define the reset signal, load the target file, connect to target, and set 
    #     a breakpoint at main().
    gdb-config: 
    	@$(REMOVE) $(GDBINIT_FILE)
    	@echo define reset >> $(GDBINIT_FILE)
    	@echo SIGNAL SIGHUP >> $(GDBINIT_FILE)
    	@echo end >> $(GDBINIT_FILE)
    	@echo file $(TARGET).elf >> $(GDBINIT_FILE)
    	@echo target remote $(DEBUG_HOST):$(DEBUG_PORT)  >> $(GDBINIT_FILE)
    ifeq ($(DEBUG_BACKEND),simulavr)
    	@echo load  >> $(GDBINIT_FILE)
    endif
    	@echo break main >> $(GDBINIT_FILE)
    
    debug: gdb-config $(TARGET).elf
    ifeq ($(DEBUG_BACKEND), avarice)
    	@echo Starting AVaRICE - Press enter when "waiting to connect" message displays.
    	@$(WINSHELL) /c start avarice --jtag $(JTAG_DEV) --erase --program --file \
    	$(TARGET).elf $(DEBUG_HOST):$(DEBUG_PORT)
    	@$(WINSHELL) /c pause
    
    else
    	@$(WINSHELL) /c start simulavr --gdbserver --device $(MCU) --clock-freq \
    	$(DEBUG_MFREQ) --port $(DEBUG_PORT)
    endif
    	@$(WINSHELL) /c start avr-$(DEBUG_UI) --command=$(GDBINIT_FILE)
    
    
    
    
    # Convert ELF to COFF for use in debugging / simulating in AVR Studio or VMLAB.
    COFFCONVERT = $(OBJCOPY) --debugging
    COFFCONVERT += --change-section-address .data-0x800000
    COFFCONVERT += --change-section-address .bss-0x800000
    COFFCONVERT += --change-section-address .noinit-0x800000
    COFFCONVERT += --change-section-address .eeprom-0x810000
    
    
    
    coff: $(TARGET).elf
    	@echo
    	@echo $(MSG_COFF) $(TARGET).cof
    	$(COFFCONVERT) -O coff-avr $< $(TARGET).cof
    
    
    extcoff: $(TARGET).elf
    	@echo
    	@echo $(MSG_EXTENDED_COFF) $(TARGET).cof
    	$(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof
    
    
    
    # Create final output files (.hex, .eep) from ELF output file.
    %.hex: %.elf
    	@echo
    	@echo $(MSG_FLASH) $@
    	$(OBJCOPY) -O $(FORMAT) -R .eeprom -R .fuse -R .lock $< $@
    
    %.eep: %.elf
    	@echo
    	@echo $(MSG_EEPROM) $@
    	-$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
    	--change-section-lma .eeprom=0 --no-change-warnings -O $(FORMAT) $< $@ || exit 0
    
    # Create extended listing file from ELF output file.
    %.lss: %.elf
    	@echo
    	@echo $(MSG_EXTENDED_LISTING) $@
    	$(OBJDUMP) -h -S -z $< > $@
    
    # Create a symbol table from ELF output file.
    %.sym: %.elf
    	@echo
    	@echo $(MSG_SYMBOL_TABLE) $@
    	$(NM) -n $< > $@
    
    
    
    # Create library from object files.
    .SECONDARY : $(TARGET).a
    .PRECIOUS : $(OBJ)
    %.a: $(OBJ)
    	@echo
    	@echo $(MSG_CREATING_LIBRARY) $@
    	$(AR) $@ $(OBJ)
    
    
    # Link: create ELF output file from object files.
    .SECONDARY : $(TARGET).elf
    .PRECIOUS : $(OBJ)
    %.elf: $(OBJ)
    	@echo
    	@echo $(MSG_LINKING) $@
    	$(CC) $(ALL_CFLAGS) $^ --output $@ $(LDFLAGS)
    
    
    # Compile: create object files from C source files.
    $(OBJDIR)/%.o : %.c
    	@echo
    	@echo $(MSG_COMPILING) $<
    	$(CC) -c $(ALL_CFLAGS) $< -o $@ 
    
    
    # Compile: create object files from C++ source files.
    $(OBJDIR)/%.o : %.cpp
    	@echo
    	@echo $(MSG_COMPILING_CPP) $<
    	$(CC) -c $(ALL_CPPFLAGS) $< -o $@ 
    
    
    # Compile: create assembler files from C source files.
    %.s : %.c
    	$(CC) -S $(ALL_CFLAGS) $< -o $@
    
    
    # Compile: create assembler files from C++ source files.
    %.s : %.cpp
    	$(CC) -S $(ALL_CPPFLAGS) $< -o $@
    
    
    # Assemble: create object files from assembler source files.
    $(OBJDIR)/%.o : %.S
    	@echo
    	@echo $(MSG_ASSEMBLING) $<
    	$(CC) -c $(ALL_ASFLAGS) $< -o $@
    
    
    # Create preprocessed source for use in sending a bug report.
    %.i : %.c
    	$(CC) -E -mmcu=$(MCU) -I. $(CFLAGS) $< -o $@ 
    
    
    # Target: clean project.
    clean: begin clean_list end
    
    clean_list :
    	@echo
    	@echo $(MSG_CLEANING)
    	$(REMOVE) $(TARGET).hex
    	$(REMOVE) $(TARGET).eep
    	$(REMOVE) $(TARGET).cof
    	$(REMOVE) $(TARGET).elf
    	$(REMOVE) $(TARGET).map
    	$(REMOVE) $(TARGET).sym
    	$(REMOVE) $(TARGET).lss
    	$(REMOVE) $(SRC:%.c=$(OBJDIR)/%.o)
    	$(REMOVE) $(SRC:%.c=$(OBJDIR)/%.lst)
    	$(REMOVE) $(SRC:.c=.s)
    	$(REMOVE) $(SRC:.c=.d)
    	$(REMOVE) $(SRC:.c=.i)
    	$(REMOVEDIR) .dep
    
    
    # Create object files directory
    $(shell mkdir $(OBJDIR) 2>/dev/null)
    
    
    # Include the dependency files.
    -include $(shell mkdir .dep 2>/dev/null) $(wildcard .dep/*)
    
    
    # Listing of phony targets.
    .PHONY : all begin finish end sizebefore sizeafter gccversion \
    build elf hex eep lss sym coff extcoff \
    clean clean_list program debug gdb-config
    
    
    
    
    
    


    Masz tu jeszcze link do krótkiego kursu języka C z przykładami dla mikrokontrolerów rodziny AVR: Kurs języka C dla AVR
    Po polsku, dla ułatwienia. ;-)

    Przerób sobie obsługę wyświetlacza na bazie kodu, który tam zaserwowali i powinno pójść bez problemów. :-)

    A.. nie sprawdzałem czy poprawnie "mieszasz" bitami od przetwornika ADC ale na pierwszy rzut oka może być. Tylko staraj się nie pisać bezpośrednio 'PORTx=0x00;' albo 'DDRx=0xFF;' itp. bo przez przypadek możesz przestawić funkcję innych pinów danego portu, co potem może być trudno wykryć.

    Nie zrażaj się i powodzenia!
  • #22 8404112
    margas4542
    Poziom 16  
    ...dziękuje za wskazówki po informacje z tego kursu już sięgałem ale fakt faktem mam kłopoty ze składnią która łatwa do opanowania nie jest...zgodnie z sugestią na początek popracuje nad LCD na zasadzie wyświetlania znaków i liczb w odpowiednim wierszu i pozycji w wierszu...przypuszczam że gdyby pogrzebać w sieci to znalazłbym podobne rozwiązanie ale gotowiec nie załatwia sprawy bo choć jestem laikiem i tworze futurystyczne nie trzymające się ładu linijki kodu to staram się to jakoś uporządkować również dzięki wam dziękując za wyrozumiałość bo zapewne głowa "gorała" gdy przyglądaliście się efektom moich poczynań...pozdrawiam i obiecuje że się poprawię.... :)...
REKLAMA