/************************************************************* * * Beschimpfungsdrucker * * Autor : Finger * * Controller : Microchip 18F6720, 40 Mhz * *************************************************************/ #include #include #include #include #include #include #include // #include #include "logo_224x200_hor.c" #define XTAL_FREQ 4MHZ // Völliger Quark. Muß erstmal so bleiben ! #define MHZ *1000 // number of kHz in a MHz #define DelayUs(x) { unsigned int _dcnt; \ _dcnt = (x)/(12MHZ/(XTAL_FREQ))|1; \ while(--_dcnt != 0) \ continue; } #define Empfangspuffergroesse 15 #define TRUE 1 #define FALSE 0 #define UART1 0 // Drucker #define UART2 1 // Chipkartenleser #define SCL RC3 // Pin SCL am EEPROM #define SDA RC4 // Pin SDA am EEPROM #define SDA_PORT 16 // Port C.4 #define SCL_PORT 8 // Port C.3 #define READ FALSE #define WRITE TRUE #define I2CTimeout 100 #define RELAIS PORTDbits.RD1 #define RELAIS2 PORTDbits.RD0 //--------------- // Uart-Schmotze //--------------- char usart_empfangspuffer [2] [Empfangspuffergroesse]; // Puffer für empfangene Zeichen char usart_schreibzeiger [2] = { 0 , 0 }; // Zeiger auf den Empfangspuffer (schreiben) char usart_lesezeiger [2] = { 0 , 0 } ; // Zeiger auf den Empfangspuffer (lesen) char cdummy; // Empfangsregister auslesen char zeiger = 0; // Lasst uns in die Zukunft schauen.... char SendeString [50]; // An Displayontroller zu sendende Zeichenkette char SendeStringCounter = 0; // Zähler auf Null char Uart2Busy = FALSE; // Hat der Bursche etwa gerade Arbeit? //---------------------------------------------------------- // Rückgabepuffer für INT -> ASCII-Wandlung und Textausgabe //---------------------------------------------------------- char buf [40]; char puffer [300]; //-------------- // Timer und Co //-------------- volatile unsigned long SystemTicker = 0; volatile int MSTicker = 0; volatile int Sekundenzaehler = 0; // Verwendete Karten char Kartendaten [10]; // Statistik long GesamtAnzahlbeschrimpfungen = 856; // Wie oft wurde geschimpft? int GesamtAnzahlBekannterKarten = 0; // Wieviele Karten sind im System bekannt? int MaximaleAnzahlBeschimpfungenproBenutzer = 0; // Wer ist der Spitzenreiter? volatile long LaufZeitinSekunden = 0; // Zeit seit Powerup int AnzahlBeschimpfungenproStunde = 0; // Mittelwert der Beschimpfungen pro Stunde int AnzahlvorhandenerBeschimpfungen = 0; // Wieviele hat die Kiste? int AktuelleBeschimpfung; // Welche wurde gerade ausgekotzt? volatile int AutoStatistikZaehler = 0; // Nach n Sekunden Statistik drucken int AusgegebeneAnzahlbeschrimpfungen = 0; // Wie oft hast du gemeckert? //--------------------------------- // Konfiguration des Controllers //--------------------------------- __CONFIG(1, OSCSEN & HS); // Quarz 10 Mhz mit PLL = 40 Mhz __CONFIG(2, WDTEN); // Wachköter *kläff* __CONFIG(4, LVPDIS & STVREN); // Kein LowVoltageProgramm, Reset bei StackOverflow /************************************************* * * USART-ISR, hängt im Main in der zentralen ISR * *************************************************/ void isr_usart (void) { //---------------------------- // Receive complete-Interrupt //---------------------------- //------- // UART 0 //------- if (RC1IF) { // Nächste Schreibposition ermitteln zeiger = usart_schreibzeiger [0]; zeiger++; if (zeiger == Empfangspuffergroesse) zeiger = 0; // Ist das Pufferende erreicht ? Dann Zeichen verwerfen if (zeiger == usart_lesezeiger [0]) cdummy = RCREG1; else { usart_empfangspuffer [0] [usart_schreibzeiger [0] ] = RCREG1; // Zeichen speichern usart_schreibzeiger [0] = zeiger; // Neuen Zeiger setzen } } // From if (RCIF) //------- // UART 1 //------- if (RC2IF) { // Nächste Schreibposition ermitteln zeiger = usart_schreibzeiger [1]; zeiger++; if (zeiger == Empfangspuffergroesse) zeiger = 0; // Ist das Pufferende erreicht ? Dann Zeichen verwerfen if (zeiger == usart_lesezeiger [1]) cdummy = RCREG2; else { usart_empfangspuffer [1] [usart_schreibzeiger [1] ] = RCREG2; // Zeichen speichern usart_schreibzeiger [1] = zeiger; // Neuen Zeiger setzen } } // From if (RCIF) } /*************** * * Zentrale ISR * ***************/ interrupt void INT_(void) { //------------------ // USART-Behandlung //------------------ isr_usart (); //-------------------- // Timer 1 Überlauf ? //-------------------- if (TMR1IF) { //------------------- // Ablauf alle 10 ms //------------------- TMR1IF=0; // Clear Interrupt-Flag TMR1H=0xF3; // n = 2^16 - t [s] * 625000 TMR1L=0xCB; // Timer 1 neu vorladen (10 ms) SystemTicker++; //--------------------- // Ablauf jede Sekunde //--------------------- Sekundenzaehler++; if (Sekundenzaehler >= 100) { Sekundenzaehler = 0; LaufZeitinSekunden++; AutoStatistikZaehler++; } } // From Timer 1 Überlauf return; // Zurück zum Hauptprogramm } /************************ * * Systemticker auslesen * ************************/ unsigned long GetTicker (void) { return (SystemTicker); } /************************************* * * Verzögern im Millisekundenbereich * *************************************/ void Delayms (int time) { unsigned long ticker; ticker = GetTicker (); while ( (ticker + (time / 10)) > GetTicker () ) { CLRWDT (); } } /******************************* * * String nach USART2 schreiben * *******************************/ void debug (const char *data) { char xdummy; // Dummyaufnahme des Empfangsregister if (FERR2) xdummy = RCREG2; if (OERR2) { CREN2=0; CREN2=1; } do { while (!TRMT2); TXREG2 = *data; data++; } while ( *data ); } /***************************************************************************************************************** * * String nach USART schreiben, nicht ISR-gesteuert * *****************************************************************************************************************/ void print (const char *data) { char xdummy; // Dummyaufnahme des Empfangsregister if (FERR1) xdummy = RCREG1; if (OERR1) { CREN1=0; CREN1=1; } do { while (!TRMT1); TXREG1 = *data; data++; } while ( *data ); } /***************************************************************************************************************** * * Char nach USART schreiben, nicht ISR-gesteuert * *****************************************************************************************************************/ void printchar (char data) { char ydummy; // Dummyaufnahme des Empfangsregister if (FERR1) ydummy = RCREG1; if (OERR1) { CREN1=0; CREN1=1; } while (!TRMT1); TXREG1 = data; } /***************************************************************************************************************** * * Zeichen aus USART abholen, liefert 0, falls kein Zeichen vorhanden * *****************************************************************************************************************/ char get_char (char UARTNo) { char dummy = 0; // Sind überhaupt Zeichen vorhanden ? if (usart_lesezeiger [UARTNo] != usart_schreibzeiger [UARTNo]) { dummy = usart_empfangspuffer [UARTNo] [usart_lesezeiger [UARTNo] ]; usart_lesezeiger [UARTNo]++; if (usart_lesezeiger [UARTNo] == Empfangspuffergroesse) usart_lesezeiger [UARTNo] = 0; return (dummy); } else return (0); } /***************************************************************************************************************** * * Char nach USART schreiben, nicht ISR-gesteuert * *****************************************************************************************************************/ void printchardebug (char data) { char ydummy; // Dummyaufnahme des Empfangsregister if (FERR2) ydummy = RCREG2; if (OERR2) { CREN2=0; CREN2=1; } while (!TRMT2); TXREG2 = data; } /***************************************************************************************************************** * * Puffer leeren * *****************************************************************************************************************/ void flushusart (char UARTNo) { usart_lesezeiger [UARTNo] = usart_schreibzeiger [UARTNo]; } /***************************************************************************************************************** * * UART initialisieren * *****************************************************************************************************************/ void UARTInit (void) { SPBRG1=16; // USART1: 9600 Baud bei 10MHZ @ PLL - 8Bit-Mode mit BRGH=0 SPBRG2=64; // USART2: 9600 Baud bei 10MHZ @ PLL - 8Bit-Mode mit BRGH=0 // Statusregister TXSTA1=0x20; // UART1 : BRGH=1 / TXEN=1 TXSTA2=0x20; // UART2 : TXEN=0 RCSTA1=0x90; // UART1 : SPEN=1 / CREN=1 RCSTA2=0x90; // UART2 : SPEN=1 / CREN=1 BRGH1 = 1; BRGH2 = 1; RC1IF=0; // Flag=0; RC2IF=0; // Flag=0; TX1IF = 0; TX2IF = 0; RC2IE = 1; } /*********************************************************************************** * * Schaltet SDA und SCL als Eingang und macht die Schnittstelle startklar * ***********************************************************************************/ void i2c_init (void) { TRISC |= SDA_PORT; // SDA = RC4 = Input TRISC |= SCL_PORT; // SCL = RC3 = Input SSPCON1 = 0b00001000; // Master-Mode, Clock : SSPADD SSPEN = 1; // Enable SSPIF = 0; // Interruptflag rücksetzen SSPADD = 0x39; // I2C-Clock = 100Khz } /************************************************************************************* * * Adressiert einen Slave, liefert TRUE falls dieser mit ACK antwortet, sonst FALSE * Richtung TRUE = Schreiben zum Slave, FALSE = Lesen vom Slave * *************************************************************************************/ char i2c_open (char Adresse, char Richtung) { #define I2CTimeout 100 char Timeout = 0; // Timeout-Zähler SEN = 1; // Start-Condition generieren // Warten, bis die Start-Condition fertig ist while ( (!SSPIF) && (Timeout < I2CTimeout) ) { DelayUs (50); Timeout++; } SSPIF = 0; // Flag rücksetzen if (Richtung) SSPBUF = Adresse; else SSPBUF = Adresse+1; // Adresse senden // Warten auf das setzen des Interrupt-Flags Timeout = 0; while ( (!SSPIF) && (Timeout < I2CTimeout) ) { DelayUs (50); Timeout++; } SSPIF = 0; // Flag rücksetzen if (!(ACKSTAT)) return (TRUE); else // Prüfen auf ACK vom Slave return (FALSE); } /************************************************************************************* * * Erzeugt die Stop-Condition * *************************************************************************************/ void i2c_close (void) { #define I2CTimeout 100 char Timeout = 0; PEN = 1; // Start-Condition generieren // Warten, bis die Start-Condition fertig ist while ( (PEN) && (Timeout < I2CTimeout) ) { DelayUs (50); Timeout++; } SSPIF = 0; // Flag rücksetzen } /************************************************************************************* * * Schreibt ein Byte via i2C, liefert TRUE bei ACK vom Slave, sonst FALSE * *************************************************************************************/ char i2c_writebyte (unsigned char wert) { #define I2CTimeoutWrite 500 int Timeout = 0; SSPBUF = wert; // Warten auf das setzen des Interrupt-Flags while ( (!SSPIF) && (Timeout < I2CTimeoutWrite) ) { DelayUs (50); Timeout++; } SSPIF = 0; // Flag rücksetzen if (!(ACKSTAT)) return (TRUE); else // Prüfen auf ACK vom Slave return (FALSE); } /*********************************************************************************** * * Liest ein Byte via i2C, erzeugt bei ACK ein Acknowledge * ***********************************************************************************/ char i2c_readbyte (char ACKn) { #define I2CTimeoutRead 500 int Timeout = 0; RCEN = 1; // Receive einschalten // while (RCEN); while ( (RCEN) && (Timeout < I2CTimeoutRead) ) { DelayUs (30); Timeout++; } ACKEN = ACKn; // Acknowledgeerzeugung bei Bedarf einschalten // Warten, bis ein Byte drin ist Timeout = 0; while ( (!SSPIF) && (Timeout < I2CTimeoutRead) ) { DelayUs (40); Timeout++; } SSPIF = 0; // Flag rücksetzen return (SSPBUF); // Wert übergeben } /******************* * * Bon abschneiden * *******************/ void FullCut (void) { buf [0] = 0x1B; buf [1] = 0x69; buf [2] = 0; print ( buf); } /******************** * * Volle Druckdichte * ********************/ void DoubleStrike (void) { buf [0] = 0x1B; buf [1] = 0x47; buf [2] = 0x01; buf [3] = 0; print ( buf); } /******************** * * Leerzeilen * ********************/ void LineFeed (char Anzahl) { int i; for (i=0; i < Anzahl; i++) buf [i] = 0x0D; buf [i+1] = 0; print ( buf); } /******************** * * Zentrieren * ********************/ void Center (void) { buf [0] = 0x1B; buf [1] = 0x61; buf [2] = 0x01; buf [3] = 0x00; print ( buf); } /*********************** * * Druckt ein Logo aus * ***********************/ void definelogo (void) { unsigned int i; // char outpbuf [50]; #define xpixel 200 // Pixel #define ypixel 224 #define size 5600 // Anzahl Bytes debug ("Definiere Logo\n\r"); // Reset printer printchar (0x1B); printchar ('@'); buf [0] = 0x1D; buf [1] = '*'; buf [2] = xpixel / 8; buf [3] = ypixel / 8; buf [4] = 0x00; print (buf); for (i=0; i < size; i++) { printchar (data_logo_224x200_bmp [i]); CLRWDT(); } // Pieper ansteuern printchar (0x1B); printchar (0x07); } /********************************** * * Druckt das definierte Logo aus * **********************************/ void printlogo (void) { debug ("Drucke Logo\n\r"); DoubleStrike (); Center (); // Hau raus den Dreck.... printchar (0x1D); printchar ('/'); printchar (0x03); } /************************************************* * * Holt eine Beschimpfung von einer Speicherkarte * *************************************************/ void LadeBeschimpfung (void) { char zeichen; int i; char buff [20]; RC2IE = 0; GIE = 0; debug ("Lade: "); i2c_open (0xA0, FALSE); // Zum Lesen öffnen // Vortasten zur nächsten zeichen = 0; while (zeichen != '#') zeichen = i2c_readbyte (TRUE); // Einladen zeichen = 0; i = 0; while ((zeichen != '#') && ( i < 290)) { zeichen = i2c_readbyte (TRUE); sprintf (buff, "%d ", i);debug (buff); if ( (zeichen != '\n') && (zeichen != '\r') && (zeichen != 0xFF)) { puffer [i] = zeichen; i++; } } puffer [i-1] = '\0'; zeichen = i2c_readbyte (FALSE); i2c_close (); // Schliessen debug (puffer); debug ("\n\r"); RC2IE = 1; GIE = 1; } /************************* * * Beschimpfung erzeugen * *************************/ void Beschimpfung (void) { char zeiger = 0; char Leerposition = 0; char Laenge = 0; char Zeilenlaenge = 0; LadeBeschimpfung (); print ("Ihr Anschiss:\n\r"); // Doppelte Größe printchar (0x1D); printchar (0x21); printchar (0x11); //------------------------- // Zeilenumbrüche einbauen //------------------------- // Führende Leerzeichen weghauen while (puffer [0] == ' ') { Laenge = strlen (puffer); for (zeiger=0; zeiger < Laenge; zeiger++) puffer [zeiger] = puffer [zeiger+1]; } Laenge = strlen (puffer); Zeilenlaenge = 0; /* while (zeiger < Laenge) { // Sonderzeichen filtern if (puffer [zeiger] == 0x27) puffer [zeiger] = ' '; if (puffer [zeiger] == ' ') Leerposition = zeiger; if (Zeilenlaenge == 21) { puffer [Leerposition] = '\r'; Zeilenlaenge = 0; } zeiger++; Zeilenlaenge++; } // Von while (zeiger < Laenge) */ // Indizes und Zähler unsigned int lastspace = 0; unsigned int NumInLine = 0; unsigned int iChar = 0; // Länge der Zeichenkette unsigned int len; unsigned int LineMax = 21; // ################################################################################################################################################################## // Eigentliche Funktion len = (unsigned int) strlen(puffer); for( iChar = 0; iChar < len; iChar++) { if( isspace(puffer[iChar]) ) // Whitespaces finden { lastspace = iChar; } // vorhandener Zeilenumbruch setzt Zähler zurück if( puffer[iChar] == '\n' || puffer[iChar] == '\r') { NumInLine = 0; lastspace = 0; } NumInLine++; if( NumInLine > LineMax ) // Mehr als N Zeichen in einer Zeile { // Nur wenn es Leerzeichen ind er Zeile gibt, können diese auch durch Zeilenumbrüche ersetzt werden if( lastspace > 0 ) { puffer[lastspace] = '\n'; // Zeichenzähler zurücksetzen if( iChar < lastspace ) // Überlaufen abfangen { NumInLine = 0; } else // Normalfall, so sollte es immer sein... { // der Zeichenzähler für die neue Zeile fängt ggf. nicht bei 0 an (wenn das letzte Leerzeichen einige Positionen zurück liegt) NumInLine = iChar-lastspace; } lastspace = 0; } else { // zu langes Wort, nichts unternehmen, wird der Drucker schon richten... // alternativ: memmove um ein Zeichen und an aktueller Stelle ein \n einfügen } } } int i; for (i=0; i < len; i++) { printchar (puffer [i]); if (puffer [i]== '\n') printchar ('\r'); } // print (puffer); // ######################################################################################################################################################################## printchar (0x1D); printchar (0x21); printchar (0x00); print ("\n\r"); AktuelleBeschimpfung++; } /******************************* * * Würgt eine Testseite hervor * *******************************/ void Testdruck (void) { Center (); DoubleStrike (); printlogo (); print ("Mistkacke\r"); print ("38400 BPS\r"); print ("Systemstart\r"); Center (); print ("Center\r"); print ("Fingers-welt.de 2017\r"); print ("Startlappen gedruckt\r"); print ("Boot meldet seeklar\r"); DoubleStrike (); LineFeed (10); FullCut (); debug ("Testdruck beendet\n\r"); } /************* * * Statistik * *************/ void LaufendeStatistik (void) { char outpbuf [50]; char i; Center (); print ( "\n\rStatistik\r"); print ( "---------\n\n\r"); print ("Kartennummer: "); for (i=0; i < 10; i++) { sprintf (outpbuf, "%02X", Kartendaten [i]); print (outpbuf); } print ("\n\r"); sprintf (outpbuf, "Beschimpfung No.:%d\r", AktuelleBeschimpfung); print ( outpbuf); sprintf (outpbuf, "%ld Beschimpfungen verfuegbar\r", GesamtAnzahlbeschrimpfungen); print ( outpbuf); sprintf (outpbuf, "Laufzeit: %ld s\r", LaufZeitinSekunden); print ( outpbuf); print ( "\n\rSie wurden beschimpft von: "); print ( "\rwww.fingers-welt.de\n\r"); print ( "\rIhr individueller Anschiss\n\r"); print ( "\rDU ARSCHLOCH\n\r"); LineFeed (5); FullCut (); } void Konsolentest (void) { char zeiger = 0; char Leerposition = 0; char Laenge = 0; char Zeilenlaenge = 0; strcpy (puffer, "Bei deiner Geburt hat der Arzt dich geschrieen: Schnell einen Hammer, sonst wirds ein Fahrrad!\0"); debug ("Ihr Anschiss: "); debug (puffer); debug ("\n\r"); //------------------------- // Zeilenumbrüche einbauen //------------------------- // Führende Leerzeichen weghauen while (puffer [0] == ' ') { Laenge = strlen (puffer); for (zeiger=0; zeiger < Laenge; zeiger++) puffer [zeiger] = puffer [zeiger+1]; } Laenge = strlen (puffer); Zeilenlaenge = 0; /* while (zeiger < Laenge) { // Sonderzeichen filtern if (puffer [zeiger] == 0x27) puffer [zeiger] = ' '; if (puffer [zeiger] == ' ') Leerposition = zeiger; if (Zeilenlaenge == 21) { puffer [Leerposition] = '\r'; Zeilenlaenge = 0; } zeiger++; Zeilenlaenge++; } // Von while (zeiger < Laenge) */ debug ("Ohne Sonderzeichen: "); debug (puffer); debug ("\n\r"); // Indizes und Zähler unsigned int lastspace = 0; unsigned int NumInLine = 0; unsigned int iChar = 0; // Länge der Zeichenkette unsigned int len; unsigned int LineMax = 21; // ################################################################################################################################################################## // Eigentliche Funktion len = (unsigned int) strlen(puffer); for( iChar = 0; iChar < len; iChar++) { if( isspace(puffer[iChar]) ) // Whitespaces finden { lastspace = iChar; } // vorhandener Zeilenumbruch setzt Zähler zurück if( puffer[iChar] == '\n' || puffer[iChar] == '\r') { NumInLine = 0; lastspace = 0; } NumInLine++; if( NumInLine > LineMax ) // Mehr als N Zeichen in einer Zeile { // Nur wenn es Leerzeichen ind er Zeile gibt, können diese auch durch Zeilenumbrüche ersetzt werden if( lastspace > 0 ) { puffer[lastspace] = '\n'; // Zeichenzähler zurücksetzen if( iChar < lastspace ) // Überlaufen abfangen { NumInLine = 0; } else // Normalfall, so sollte es immer sein... { // der Zeichenzähler für die neue Zeile fängt ggf. nicht bei 0 an (wenn das letzte Leerzeichen einige Positionen zurück liegt) NumInLine = iChar-lastspace; } lastspace = 0; } else { // zu langes Wort, nichts unternehmen, wird der Drucker schon richten... // alternativ: memmove um ein Zeichen und an aktueller Stelle ein \n einfügen } } } int i; debug ("Fertiger String: "); for (i=0; i < len; i++) { printchardebug (puffer [i]); if (puffer [i]== '\n') printchardebug ('\r'); } debug ("\n\r"); while (1); // print (puffer); // ######################################################################################################################################################################## printchar (0x1D); printchar (0x21); printchar (0x00); print ("\n\r"); AktuelleBeschimpfung++; } /*************************** * * Initialisierungsroutinen * ***************************/ void sysinit (void) { char zeiger = 0; char Leerposition = 0; char Laenge = 0; char Zeilenlaenge = 0; //-------------------- // IO-Ports klarmachen //-------------------- // Alle Ports initialisieren bzw. auf Null setzen PORTA = 0; PORTB = 0; PORTC = 0xFF; PORTD = 0; PORTE = 0; PORTF = 0; //------------------------- // Comperatoren abschalten //------------------------- CMCON = 0x07; // Ein- Ausgangsdefinitionen, 0 = Output, 1 Input, siehe Schaltplan. Nicht benutztes auf Ausgang TRISA = 0b00000000; // A0 = Batterienomitor TRISB = 0b00001111; // B0= Handy, B2-B3=Drehgeber, B1 = Drucktaster, B4 = Licht einschalten TRISC = 0b00011000; // Alles Ausgang TRISD = 0b00000000; // D0=E, D1=RW, D2=RS, D4-D7=Datenbus LCD TRISE = 0b00000000; // TRISF = 0b00000000; // TRISG = 0b00000100; // RELAIS2 = TRUE; //----------------- // UARTS klarmachen //----------------- UARTInit (); //---------------- // I2C klarmachen //---------------- i2c_init (); //------------------------------------- // Timer 1 als Systemticker einrichten //------------------------------------- TMR1IE=1; // enable Interrupt of TMR1 T1CON=49; // Prescaler=1:8 + Timer on (49) //-------------------- // Alle Interrupts an //-------------------- PEIE=1; // Peripherie Int=on GIE=1; // Define Interupts //--------------------- // Sach ma Beschaid ey //--------------------- debug ( "\n\rStart\n\n\r"); definelogo (); //------------------- // Variablen belegen //------------------- GesamtAnzahlBekannterKarten = 0; MaximaleAnzahlBeschimpfungenproBenutzer = 0; LaufZeitinSekunden = 0; AnzahlBeschimpfungenproStunde = 0; AnzahlvorhandenerBeschimpfungen = 350+397; AusgegebeneAnzahlbeschrimpfungen = 0; // Konsolentest (); Testdruck (); debug ("System bereit\n\r"); } /************************************ * * Erstellt ein Beschimpfungsticket * ************************************/ void Bondruck (void) { Center (); DoubleStrike (); LineFeed (5); printlogo (); Beschimpfung (); LaufendeStatistik (); AutoStatistikZaehler = 0; } /************************************************* * * True wenn eine neue Karte identifiziert wurde * *************************************************/ char Kartegelesen (void) { char zeichen; char bufa [10]; int i; int Ausfallcounter; zeichen = get_char (UART2); // Beginn einer Sequenz gefunden? if (zeichen == 0x02) { i = 0; debug ("Kartendaten: "); Delayms (100); Ausfallcounter = 0; while ((zeichen != 0x03) && (i < 10) && (Ausfallcounter < 1000)) { zeichen = get_char (UART2); sprintf (bufa, "%02X ", zeichen); debug (bufa); Kartendaten [i] = zeichen; i++; Ausfallcounter ++; } } flushusart (UART2); if (i==10) { debug (" Karte erkannt\n\r"); return (TRUE); } else return (FALSE); } /******************* * * Mach mal Show * ******************/ void AutoStatistik (void) { char outpbuf [50]; Center (); DoubleStrike (); LineFeed (5); printlogo (); print ( "Autostatistik\n\r"); print ( "-------------\n\n\r"); sprintf (outpbuf, "%ld Beschimpfungen verfuegbar\n\r", GesamtAnzahlbeschrimpfungen); print ( outpbuf); sprintf (outpbuf, "Laufzeit: %ld s\n\r", LaufZeitinSekunden); print ( outpbuf); sprintf (outpbuf, "Durchschnittlich vorhandene Fussnaegel: 10\n\r"); print ( outpbuf); sprintf (outpbuf, "Alphakoeffizient: 0.43154\n\r"); print ( outpbuf); sprintf (outpbuf, "Energieverbrauch: marginal\n\r"); print ( outpbuf); sprintf (outpbuf, "Kalibrierdaten: FE 02 A0 BC 01 00 A1\n\r"); print ( outpbuf); sprintf (outpbuf, "Modulversion: 0.99alpha\n\r"); print ( outpbuf); sprintf (outpbuf, "Datenerzeugung: komisch (E0)\n\r"); print ( outpbuf); sprintf (outpbuf, "Verteilfaktor: Dezimale 17\n\r"); print ( outpbuf); sprintf (outpbuf, "Raumtemperatur: Woher soll ich das wissen?\n\r"); print ( outpbuf); /* Memory Summary: Program space used 52FEh ( 21246) of 20000h bytes ( 16.2%) Data space used BFEh ( 3070) of F00h bytes ( 79.9%) Configuration bits used 3h ( 3) of 7h words ( 42.9%) EEPROM space used 0h ( 0) of 400h bytes ( 0.0%) ID Location space used 0h ( 0) of 8h nibbles ( 0.0%) */ print ( "\n\rSie werden zwangsbeglueckt von: "); print ( "\n\rwww.fingers-welt.de\n\r"); LineFeed (15); FullCut (); } /************* * * Main * *************/ void main (void) { CLRWDT(); //---------------------- // System initialisieren //---------------------- sysinit (); while (1) { debug ("."); CLRWDT(); // Wurde eine neue Karten eingelesen? if (Kartegelesen ()) Bondruck (); // Nach n Sekunden Inaktivität ein wenig Aufmerksamkeit erregen #define AUTOZAEHLERSTATISTIKMAX 1800 if (AutoStatistikZaehler > AUTOZAEHLERSTATISTIKMAX) { AutoStatistikZaehler = 0; AutoStatistik (); } } // Von while (1) } /* Achtung: Das ist das Ende des Codes. Sie sind jetzt auf sich gestellt. Viel Glück ! _.--""--._ / _ _ \ _ ( (_\ /_) ) _ { \._\ /\ /_./ } /_"=-.}______{.-="_\ _ _.=("""")=._ _ (_'"_.-"`~~`"-._"'_) {_" "_} */