/* Beispielprogramm 'reziproker Frequenzzaehler' mit GPS-Signal stabilisiert fuer ATmega162 und IAR-Kickstart: Berechnung mit 64-bit double! Funktionsbereich mit Vorteiler 0,004Hz - >50MHz bei 16MHz Prozessortakt Neben der üblichen Frequenzmessung an ICP1 wird zusätzlich über ICP3 die interne Taktfrequenz anhand eines 1pps GPS-Signals ermittelt und für die genaue Auswertung der Frequenz verwendet. Hierzu muß das GPS-Signal über min. 10 Sekunden stabil anliegen und wird über 10 Intervalle gefiltert. Fehlt dieses Signal, wird der zuletzt errechnete Wert von 'ref_frequenz' verwendet. Wird es wieder erfasst, muß es erneut ueber 10 Perioden stabil (+/- 100ppm) anliegen. Der Differenzwert ref_frequenz-F_CPU wird alle 10 Minuten ins EEPROM abgelegt und beim Einschalten mit als Startwert verwendet. Dieser Offset wird doppelt gespeichert und nur dann zurueckgelesen, wenn beide Werte identisch sind. Anderfalls wird der vorletzte Wert verwendet. Der schreib_zeiger fuer das EEPROM wird bei jedem Einschalten inkrementiert, sodass immer neue Speicherplaetze (modulo 64) verwendet werden. Das Programm ist mit IAR-Kickstart 5.0 entwickelt; die 'fuses' für XTAL (16MHz) müssen gesetzt und CKDIV8 gelöscht sein; BOD sollte auf 4,3V eingestellt sein. C_stack braucht 0x50 Bytes. http://www.mino-elektronik.de Alle Angaben wie immer ohne Gewaehr ! 2011-12-16 */ #define nTEST_LAUF // testweise die int. Taktfrequenz anzeigen #define F_CPU 16000000 // 16MHz ggf. an eff.Frequenz anpassen #define VORTEILER_FAKTOR 256 // fuer 74HC393 #define ENABLE_BIT_DEFINITIONS #include #include #define MIN_REF (F_CPU - (F_CPU/10000l)) // -100ppm #define MAX_REF (F_CPU + (F_CPU/10000l)) // +100ppm #define T3_FIL_LEN 10 // gleitenden Mittelwert ueber 10s bilden #define GPS_TIMEOUT 250 // Referenzfrequenz zu klein / fehlt #define GPS_TOTZEIT 50 // GPS-Signal nach Einschalten 5 Sekunden unterdruecken #define STELLEN 7 // angezeigte Stellen, max. Auflösung #define MESSZEIT 150 // max. 1,6 Messungen/Sek. (150 x 4,1ms) #define ZEIT_100MS 25 // 0,1 Sek. (25 x 4,1ms) #define FERTIG_LED_BIT 5 // PORTD.5 #define GPS_LED_BIT 6 // PORTD.6 #define VORTEILER_LED_BIT 7 // PORTD.7 #define VORTEILER_AKTIV (ACSR & (1< ca. 100ppm #define EE_SCHREIB_INTERVALL 600 // alle 10 Minuten #define EE_SCHREIB_ZEIGER 2 // ins EEPROM adr. 0x02 #define EE_ABLAGE_OFFSET 8 // ab adr. 0x08 #define EE_ADR_MASKE 0x3f #define EE_DATA_SIZE 4 enum status {MESSEN=0, AUSLESEN, AUSWERTEN}; // die Phasen der Messung #ifdef TEST_LAUF // zur Anzeige der int. Taktfrequenz char string[20]; char text1[]={"Fin"}; // 1.Zeile der Anzeige char text2[]={"Qu "}; // 2.Zeile der Anzeige #else char text1[]={"F.:"}; // 1.Zeile der Anzeige char text2[]={"P.:"}; // 2.Zeile der Anzeige #endif char f_dim[][4]={"GHz","MHz","kHz","Hz ","mHz","sek","ms ","us ","ns ","ps "}; // Dimensionen zum Messwert char stellen; double frequenz, ref_frequenz; // Ergebnis // 'volatile' zur Sicherheit volatile unsigned char messwert_vorhanden, // nur gueltige Messungen anzeigen mess_status, // Ablaufsteuerung sync_flag, // wird mit T1OV gesetzt fertig_led_cnt, // FERTIG-LED kurz aufleuchten lassen gps_led_cnt, // GPS-LED Blinken+Dauerlicht t3_tout_cnt, // T3 Messdauer bewerten t3_timeout, // 1Hz-Referenz fehlt t3_fertig; // wird mit ICP3 gesetzt volatile unsigned int zeit_low, // Timer1-Anteil zeit_high, // T1 Ueberlauf-Anteil t3_zeit_low, // Timer3-Anteil t3_zeit_high, // T3 Ueberlauf-Anteil mess_dauer, // minimale Wartezeit ueberlauf, // von T1 t3_ueberlauf, // von T3 ee_schreib_intervall; // alle 10 Minuten EEPROM schreiben volatile unsigned long //ref_frequenz, // gemessene interne Taktfrequenz start_ereignis, // Impulse zu Beginn der Messung end_ereignis, // Impulse am Ende der Messung start_zeit; // rel. Zeit: Beginn der Messung char t3_fil_cnt, // T3-Filter, Anzahl Werte t3_fil_index, // T3-Filter, Index auf Einzelwerte gps_totzeit, // Einschaltverzoegerung abwarten ee_schreib_zeiger; // nur 0 - 63 werden verwertet unsigned long t3_end_zeit, // Zeitpunkt der Auswertung end_zeit, // Zeitpunkt der Auswertung t3_start_zeit, // rel. Zeit: Beginn der Messung t3_fil[T3_FIL_LEN], // letzte Einzelwerte t3_fil_sum; // akt. Summe der Einzelwerte // Basis EEPROM-Routinen unsigned char ee_read_char(int adr) { while(EECR & 1<>8); } void schreibe_f_offset(unsigned int offset) // Offset-Wert 2x schreiben { int schreib_adresse = (ee_schreib_zeiger & EE_ADR_MASKE) * EE_DATA_SIZE + EE_ABLAGE_OFFSET; ee_write_int(schreib_adresse, offset); ee_write_int(schreib_adresse+2, offset); ee_write_char(EE_SCHREIB_ZEIGER, ee_schreib_zeiger); // auch schreib_zeiger speichern } unsigned int lese_f_offset(void) // Offset-Wert lesen, wenn beide Werte gleich sind { // andernfalls vorletzten Wert zuruecklesen int schreib_adresse, temp; ee_schreib_zeiger = ee_read_char(EE_SCHREIB_ZEIGER); // letzte adresse lesen schreib_adresse = (ee_schreib_zeiger & EE_ADR_MASKE) * EE_DATA_SIZE + EE_ABLAGE_OFFSET; temp = ee_read_int(schreib_adresse); if(temp != ee_read_int(schreib_adresse+2)) { // beide Werte vergleichen ee_schreib_zeiger--; // wenn ungleich, vorherigen Wert verwenden temp = ee_read_int(schreib_adresse-2); } return(temp); } // Routinen zur Ausgabe auf LCD 2x16 void warten(void) // Warteschleife fuer LCD-Init { __delay_cycles(50000); } void lcd_impuls(void) // Schreibimpuls mit Mindestlaenge { PORTA |= (1< PortA.3 temp |= c>>4; PORTA = temp; lcd_impuls(); } void lcd_out(char z,char mode) // Ausgabe von Daten (mode==1) oder CMDs (mode==0) { if(mode) PORTA |= (1<= 0.001) { // 1mHz ist Untergrenze if(zeige_periode) { x = 1/x; // Kehrwert bilden dimension=5; // und in Sekunden als Dimension } while(x<1.0) {x*=1000.0;dimension++;} // in den Hz-Bereich bringen while(x>=1000.0) {x*=0.001;dimension--;} while(x >= 10.0) { x *= 0.1; dez_punkt++; } } else { x = 0.0; // sonst 0.000000 Hz ausgeben } if(stellen == STELLEN) { // nur bei regulaerer Ausgabe x += 5e-7; // runden if(x >= 10.0) { // Ueberlauf bei Rundung x *= 0.1; dez_punkt++; if(dez_punkt > 2) { // Ueberlauf der Dimension dimension--; dez_punkt = 0; } } } for(i=0;i= ZEIT_100MS) { n = 0; sync_flag = 1; // ca. alle 100ms } if(fertig_led_cnt) { // 'Messung fertig' fertig_led_cnt--; // LED Einschaltdauer abzaehlen PORTD |= 1<= GPS_TIMEOUT) { // 1Hz-Referenz fehlt t3_tout_cnt = 0; t3_timeout = 1; // und registrieren } } #pragma vector = TIMER3_CAPT_vect __interrupt void t3capt_int() // Eingangsimpulse mit genauem Zeitpunkt erfassen { t3_zeit_low = ICR3; // capture-reg lesen: untere 16bit t3_zeit_high = t3_ueberlauf; // dazu die oberen 16bit if((ETIFR & 1< MIN_REF) { // im Bereich +/- 100ppm t3_fil_sum -= t3_fil[t3_fil_index]; // letzen Wert abziehen t3_fil_sum += temp_frequenz; // neuen Wert addieren t3_fil[t3_fil_index++] = temp_frequenz; // und ablegen if(t3_fil_index >= T3_FIL_LEN) t3_fil_index = 0; t3_fil_cnt++; // mitzaehlen, ob Filter 'gefuellt' if(t3_fil_cnt >= T3_FIL_LEN) { // Filter ist 'eingeschwungen' t3_fil_cnt = T3_FIL_LEN; // nicht weiter zaehlen ref_frequenz = ((double)t3_fil_sum) / T3_FIL_LEN; // Mittelwert verwenden gps_led_cnt = GPS_TIMEOUT; // Dauerlicht durch Nachtriggern ee_schreib_intervall++; if(ee_schreib_intervall >= EE_SCHREIB_INTERVALL) { ee_schreib_intervall = 0; // neu zaehlen offset = (int)(((ref_frequenz - (double)F_CPU) * F_OFFSET_SKAL)); schreibe_f_offset(offset); } } else { gps_led_cnt = GPS_TIMEOUT/3; // Blinken, wenn Filter noch nicht voll ist } } #ifdef TEST_LAUF // nur bedingt anzeigen lcd_cmd(ZEILE2+4); // 2.Zeile, 6.Spalte zeige_x(ref_frequenz,0,9); // Quarzfrequenz mit 8 Stellen anzeigen #endif } } // Hauptprogramm __task main(void) // fuer main() keine Register retten { char temp; unsigned long mess_zeit, mess_ereignisse; PORTE = 0x1; // Pullup ICP1-Eingang PORTD = 0x8; // Pullup ICP3-Eingang DDRA = 0x3f; // fuer Lc-Anzeige DDRD = 0xe0; // fuer LEDs TCCR0 = 0x07; // T0 zaehlt Impulse des Vorteilers init_lcd(); ref_frequenz = ((int)lese_f_offset()) / F_OFFSET_SKAL; // Nachkommastellen erzeugen ref_frequenz += F_CPU; // startwert ee_schreib_zeiger++; // fuer naechste Schreibadresse ACSR |= 1< 40) { // Vorteiler ab ca. 100kHz zuschalten PORTD |= 1<= MESSZEIT) { mess_status=AUSLESEN; // Auswertung starten mess_dauer = 0; // wieder Messzeit abwarten } TIMSK |= 1<