dynamische Anpassung F_CPU

ich kann delay.h kopieren und die Konstante durch eine Variable 
ersetzen, die mit F_CPU vorbelegt ist.

Besser wäre es über den Makefile. Das ist ja auch Programmcode, in dem 
Variablen abgearbeitet werden:

1

ifeq ($(MCU), atmega644)

2

  #FUSE_BITS = -u -U lfuse:w:0xff:m -U hfuse:w:0xdf:m

3

  HEX_FILE_NAME = MEGA644

4

endif

5

ifeq ($(MCU), atmega32)

6

  #FUSE_BITS = -u -U lfuse:w:0xff:m -U hfuse:w:0xdf:m

7

  HEX_FILE_NAME = MEGA32

8

endif

HEX_FILE_NAME ist eine Variable, die vor dem Programmstart abgearbeitet 
wird. Wie bekomme ich Werte aus einer Datei auf dem PC in den Makefile?

Jeder avr bekommt dann eine Nummer der eine individuelle Taktrate auf 
dem PC zugeordnet ist.

Mich würde interessieren, welches Problem damit eigentlich gelöst werden 
soll.


Mal ganz grundsätzlich kann man beim Aufruf von make auch Variablen 
setzen. Etwa mit "make target F_CPU=121324" was dann beim Aufruf des 
Compilers auch mit "-D " übergeben werden muss.

Man kann auch in eine beliebige Header-Datei mit Perl oder Python 
irgendeine Definition reinschreiben. Damit wäre ein Wert von irgendeiner 
Instanz auf dem PC in den Code für den AVR transportiert.

Ganz ähnlich könnte ein Perl- oder Python-Script auch ein Makefile 
erzeugen, wenn die Zieldatei einen individuellen Namen haben soll.
Oder etwa in der Regel für das Hex-File (oder was auch immer) nach, der 
Erzeugung eben des Hex-Files, dieses noch einmal in eine Datei mit 
individuellem Namen kopieren, der make in der Kommandozeile übergeben 
worden ist.


Bemerkung:
Make-Dateien werden nicht ausgeführt sondern interpretiert. Auch werden 
Variablen nicht ausgeführt. Den Unterschied sollte man gedanklich 
berücksichtigen, denke ich.

Theor schrieb:
> Mich würde interessieren, welches Problem damit eigentlich gelöst werden
> soll.

Ich hab ca. 10 nanos rumfliegen, auf die unterschiedliche Programme 
aufgespielt werden. Jeder soll mit dem gleichen Programmcode laufen. Die 
Lösung: eine Datei fcpu.h, die von main.h nach Setzen von #define 
board_nr x aufgerufen wird.

1

#define F_CPU 8000000

2

3

#if boar_nr == 1

4

#define F_CPU 7900000

5

#endif 

6

....

die Kalibrierung:

1

if(min==0){//hou

2

//+++++++++++++++ hou ++++++++++++++++++++

3

if(!smh_korrektur_sperre){  

4

5

u16 smh_abweichung;

6

7

8

if (ds1307gefunden==0){

9

  kk_ds1307_getAll_to_global_struct_zt();

10

11

12

  if(min>30){//59... mcu zu schnell

13

//  smh_abweichung=1;

14

      smh_abweichung=(60-min)*60-sec;

15

      if(smh_abweichung>19){

16

        var_ocr0a++;

17

        eeprom_update_byte(eep_ocr0a_adr,var_ocr0a);

18

        OCR0A = var_ocr0a;

19

      }

20

21

22

23

//      lg(4,9);

24

//      lw("+");li(smh_abweichung);lw("+");li(var_ocr0a);lw("+");

25

  }

26

  else {//mcu zu langsam

27

//  smh_abweichung=0;

28

    smh_abweichung=min*60+sec;

29

      if(smh_abweichung>19){

30

        var_ocr0a--;

31

        eeprom_update_byte(eep_ocr0a_adr,var_ocr0a);

32

        OCR0A = var_ocr0a;

33

      }

34

  //    lg(4,9);

35

  //    lw("-");li(smh_abweichung);lw("-");li(var_ocr0a);lw("-");

36

  }  

37

38

39

}

40

41

42

43

44

//sec = sec - smh_korrektur;

45

smh_korrektur_sperre=1;

46

}

Nach jeweils einer Stunde Laufzeit wird durch Abgleich mit der RTC der 
Timer kalibriert. Der Wert des jeweiligen nanos in fcpu.h eingetragen.

Was noch fehlt ist die Berechnung der Taktfrequenz aus der 
Timerabweichung.

Garnicht auszumalen was sich Apple dort für Probleme schafft wenn die an 
der CPU Geschwindigkeit drehen zum Stromsparen...

Welcher Apple läuft denn mit einem AVR?

Rolf M. schrieb:
> Dir ist aber klar, dass #if vom Präprozessor ausgeführt wird, der deine
> Variable board_nr nicht sehen kann?

deswegen vorher
#define board_nr x

Falk B. schrieb:
> Meine Lösung, dein Problem!


war jedenfalls hilfreich, über das ganze noch mal nachzudenken. Die 
nanos haben ja einen 16 Mhz Quarz. Da ich 3,3V Peripherie benutze soll 
die mcu auch mit 3,3v arbeiten können. Deshalb  ist der 16mhz 
ungeeignet.

Dass man avrs kalibrieren kann, muss man wissen. Habe ich noch nicht 
gemacht und hatte das zumindest nicht present. Werde ich ausprobieren. 
Auch hier stellt sich noch die Frage der systematischen Messung der 
Ausgangsfrequenz und Umrechnung auf OSCCAL.

Wenn alles nicht hilft, bliebe noch Auslöten von 16mhz und Ersatz durch 
8mhz.

Peter D. schrieb:
> Und nach dem Reset schaltest Du auf /2 um, das ergibt dann die
> gewünschten 8MHz.

Danke, das wäre die perfekte Lösung. Aber wie schalte ich auf /2 um?

CLKPR = 0x80; CLKPR = 0x1; // Vorteiler / 2

Peter D. schrieb:


danke, ich hab ja inzwischen einige Erfahrung mit avrs, aber man lernt 
nie aus.


Danke für alle Beiträge und alle Anregungen. War - wieder mal - sehr 
hilfreich.

Hallo,
sehr interessant !!!!

Aber an welcher Stelle setze ich den Befehl
""clock_prescale_set(clock_div_2); "" genau ins Programm ein.

Wenn ich ihn direkt am Anfang der "int main(void)" einsetze funktioniert 
die serielle Ausgabe erst wenn ich die vordefinierte Baudrate der 
Software Uart von 9600 auf die Hälfte, 4800 setze.

Oder doch einfacher den Quarz 8MHz gegen 4MHz austauschen ?

Moin peda,
in der Tat ist es so einfacher, selbst mit einem HC49U-S Quarz.

Reale Taktrate des Quarz = 8MHz

Eintragung in F_CPU
F_CPU = 4000000

und hier

int main(void)
{
 clock_prescale_set(clock_div_2);// Clock Divisor Faktor 2


So wird auch mit der definierten 9600 Baudrate die richtige Anzeige über 
die Software Uart erreicht.

Manchmal hilft ein Tag Abstand

DANKE DIR !!!!!!