' 241230D1.BAS Update: Ergaenzung vor while true mit warteschleife und ' Zaehlerabfrage Pin5/Port3 8x um sporadische Fehler zu vermeiden==8.8sec ' Falls Fehler im Durchflussmesser auftritt wird innerhalb 8.8 sec abgeschaltet ' 1120 Basic Bytes, 0 Sys Bytes; 26 RAM Bytes ' 230124D4 Bas Finale Version ohne unntze Programmteile ' 994 Bytes, 0 Sys Bytes; 24 RAM Bytes ' 230124D3.BAS Finale Version mit allen Programmteilen noch 1334Byte,0Syst;24RAM ' Beschreibung:Es wird der Durchfluss von einem 1" Durchflussmesser ' ausgewertet an Pin5/Freq1; falls Durchfluss ausreichend gross, ' geht Port4 =H und gibt ueber Transistor u. Relais Freigabe Wrmepumpe ' Datenausgabe erfolgt ueber Pin7/Port1== serielle RS232 und LCD ' Die LCD Datenausgabe erfolgt an Pin2/Port6/SDA und Pin3/Port5/SCL an ein ' LCD 0804;2Zeilen je 8 Zeichen; ausgegeben werden folgende Daten z.B. ' 1 2 3 4 5 6 7 8 LCD Spalten ' I m p L i / h ' 2 5 5 1 6 5 9 z.B. ' z.B. 255 Impulse/sec und 1659 Liter/Stunde ' Berechnet wird mit 24 Bit Rechnung ' ' Pin Belegung ' Pin2==PTA5 (PORT[6], SDA gelb) ' Pin3=PTA4 (PORT[5], SCL gruen ' Pin4=Port4=ist ein Schaltausgang, Durchfluss > 100 dann Port3=H ' Pin5=Port3=Freq1, Signaleingang fr Impulse des Durchflussmessers ' Pin6=Port2=ADC2; ungenutzt ' Pin7=Port1= serielle Schnittstelle zu RS232 ' LCD0804 = 2 Zeilen x 8 Zeichen LCD ' -------------------------------------------------------------------------- ' LCD ueber I2C-Bus mittels Portexpander PCF8574 ansteuern ' In OCBASIC fuer Open-Micro, Open-Mini und Open-Midi von Dietmar Harlos. ' --------------------------------------------------------------------------- ' Das LCD ist mit dem PCF auf die gleiche Weise verbunden wie auf dem ' I2C-LCD von Conrad Electronic (Bestellnr. 198330). Eine kleine Platine ' fuer das LCD u. dem PCF8574 mit Verbindung an Pin3=PTA4 (PORT[5], SCL gruen) und ' Pin2==PTA5 (PORT[6], SDA gelb) der Open-Micro wurde auf einem Stueck Lochrasterplatine ' aufgebaut. ' ' PCF8574 | LCD Belegung ' ---------------------------------------------------------------------- ' Bez Pin : an ' A0 1 : GND dies ist IIC-Adresse ' A1 2 : GND ' A2 3 : GND ' P0 4 | DB4 11 \ ' P1 5 | DB5 12 \ die oberen 4 Bits ' P2 6 | DB6 13 / vom 8-Bit-Datenbus ' P3 7 | DB7 14 / ' P4 9 | R/W 5 -- Lesen (1) oder Schreiben (0) ' P5 10 | RS 4 -- Daten (1) oder Instruktion (0) uebermitteln ' P6 11 | EN 6 -- Daten bei fallender Flanke (1 nach 0) uebernehmen ' P7 12 | EN2 -- reserviert fuer 2. Enable-Leitung einiger LCDs ' --------------------------------------------------------------------------- INCLUDE "om.def" 'Definitionen fuer Open-Micro und Open-Mini ' ***************** Definition der Variablen ************** DEFINE Flag_1 BYTE 'Flagbyte Define Flag1 Bit[1] OF Flag_1 ' wird benoetigt bei Zeitabfrage DEFINE Ar_a3 BYTE 'H_Byte 1-ter Eingabewert;!!1 Reihenfolge beachten!!! DEFINE Ar_a2 BYTE 'Mid_B !!! ansonsten entsteht Fehler bei Arithmetik DEFINE Ar_a1 BYTE 'Low_Byte Operationen, auch bei ' weiteren Befehlen hier DEFINE Ar_b3 BYTE 'H_byte 2-ter Eingabewert DEFINE Ar_b2 BYTE 'Mid byte DEFINE Ar_b1 BYTE 'L_Byte DEFINE Ar_c3 BYTE 'H_Byte benutzt bei div. Berechnung und Ausgabe DEFINE Ar_c2 BYTE 'Mid_Byte bzw. Middle Byte von 24Bit wie oben DEFINE Ar_c1 BYTE 'L_Byte wie oben DEFINE tem5 BYTE DEFINE tem4 BYTE DEFINE tem3 BYTE ' benutzt bei Ausgabe DEFINE tem2 BYTE DEFINE tem1 BYTE DEFINE Imp_v BYTE ' Zaehlimpulse bei Procedure und Frequenzabfrage DEFINE Sec_a BYTE ' Sec_kundenwert a_ktuell beim Start DEFINE temp Byte 'benoetigt in LCD Ausgabe DEFINE i_v BYTE 'Zaehlvariable for next schleife Define Ze_1 Byte 'Ziffernausgabe bei LCD Zeile 2 Define Ze_2 Byte Define Ze_3 Byte Define Ze_5 Byte Define Ze_6 Byte Define Ze_7 Byte Define Ze_8 Byte '*************** Definition Konstanten ************* Define Stei_h 02 'Steigung Berechnungsformel 587 ==> high byte= d02 Define Stei_l 75 'Steigung Berechnungsformel 587 ==> low byte= d75 Define T_w_h 83 'T-Wert der Formel 21500 ==> high byte =d 83 Define T_w_l 252 'T-Wert der Formel 21500 ==> low byte = d252 Define Divis 100 'Berechnungsformel Divisor ' --------------------------------------------------------------------------- '*************** Definition der Schaltports *********** Define Sch_WP4 Port[4] ' Schaltet Pin4=Port= auf ON wenn Imp_v>100 ist ' ------------------------------------------------------------- '********** Programm Start ***** PrintSpc=ON End2Host=ON Sch_WP4 = ON ' Sec_a =0 ' Repeat ' Pause 50 'Wartepause 1 sec ' Print "Sec_a=",Sec_a ' Sec_a=Sec_a+1 ' Until Sec_a>69 'Wert sollte > 60 sekunden sein, da WP nach 60sec Einschaltet ' Print "Sec_a=",Sec_a Flag1=on WHILE TRUE #Zeit ' Berechnung der Durchflussmenge aus Imp_v ' PRINT ' PRINT ' PRINT "Eingabe Imp_v" ' INPUT Imp_v Ar_a3=0:Ar_b3=0:Ar_a2=0:Ar_b2=0:Ar_a1=0:Ar_b1=0: ' Print '*********Leerzeile FOR i_v=1 TO 8 '******* Uebertrag von additionsergebnis von Ar_a in Ar_b Ar_b3=Ar_a3:Ar_b2=Ar_a2:Ar_b1=Ar_a1 ' Print "Ar_b_321",Ar_b3,Ar_b2,Ar_b1 Ar_a3=0:Ar_a2=0 'Werte zuruecksetzen Freq=50 'Einschalten Frequenzzaehler mit Zeitbasis 1 sec ' Pause 10 Imp_v=Freq 'Uebergabe der impulse, werte bereich 0 bis 255 ' Print "Imp_v_a",Imp_v ' Addition des Messwert 8x um sporadische Fehler auszuschliessen Ar_a1=Imp_v ' wird 8 mal addiert GOSUB addieren Pause 5 ' 0.1 sec wartezeit bis zur nchsten abfrage NEXT i_v '************ Berechnung von Mittelwert./.8 und uebrgabe Eregbnis an Imp_v ' Print "Ar_a2=";Ar_a2,"Ar_a1=";Ar_a1 GOSUB divid_8 ' Division durch 8 um Mittelwert zu bilden Imp_v = Ar_a1 ' Print "Imp_v_mittelwert",Imp_v ' Pause 150 'nur zum testzweck IF Imp_v >100 THEN Sch_WP4=ON ELSE Sch_WP4=OFF If Flag1=on Then 'LCD Ausgabe alle 10 sekunden If Second Mod 10=0 Then GOTO Zeit ELSE Flag1=off ENDIF ELSE IF Second MOD 10<>0 Then GOTO Zeit ELSE Ar_a3=0:Ar_b3=0:Ar_a2=0:Ar_b2=0 Flag1=ON 'alle 10 sek eine LCD-Anzeige und RS232 Ausgabe Ar_a1=Imp_v 'Uebergabe 8 Bitzahl Zahl Imp_v 'Procedur aufruf ohne Gosub Ze_1=tem3+48:Ze_2=tem2+48:Ze_3=tem1+48 'Zuweisung LCD Zeile 2 Ar_b2=Stei_h:Ar_b1=Stei_l ' Steigungs wert Uebergabe ' PRINT "Imp_v=Eingabe_Ar_a=";Ar_a1,"Ar_b=";Ar_b2,Ar_b1 GOSUB multi_16x16 'Ergebnis in Ar_c Ar_a3=Ar_c3:Ar_a2=Ar_c2:Ar_a1=Ar_c1 ' zuweisung der ergebnisse ' PRINT "Ausgabe_Mul_a*a=quadrat" ' GOSUB anzeigen ' PRINT ' PRINT "Addition 21500" Ar_b3=0:Ar_b2=T_w_h:Ar_b1=T_w_l 'Uebergabe T_wert Gosub addieren ' PRINT "Ausgabe_addieren" ' GOSUB anzeigen Ar_b1=Divis 'Uebergabe Divisor GOSUB div_8b Ar_a3=Ar_c3:Ar_a2=Ar_c2:Ar_a1=Ar_c1 'Ergebnis in Ar_c zuweisen Ar_a Ar_b3=Ar_c3:Ar_b2=Ar_c2:Ar_b1=Ar_c1 'Ergebnis in Ar_c zuweisen Ar_b 'fuer print16_tem ' PRINT ' PRINT "Ausgabe Wert/100" ' PRINT "Ostemp=";ostemp,"Rem_H_vor=";tem3,"Rem_H_nach=";tem2 ' GOSUB anzeigen ' Ar_a3=Ar_b3:Ar_a2=Ar_b2:Ar_a1=Ar_b1 'Ergebnis in Ar_b zuweisen Ar_a Gosub print16_tem ' PRINT ' Print "Ausgabe tem:",tem4,tem3,tem2,tem1 Ze_5=tem4:Ze_6=tem3:Ze_7=tem2:Ze_8=tem1 ' Print "LCD_Z2=";Imp_v," ",Ze_5,Ze_6,Ze_7,Ze_8 'ASCCI Zeichen Ar_a3=Ar_b3:Ar_a2=Ar_b2:Ar_a1=Ar_b1 'Ergebnis in Ar_b zuweisen Ar_a Print "A",Imp_v, Gosub print16 PRINT ,"E" ' PRINT GOSUB LCD_ausg ENDIF ENDIF ' Pause 255 Wend End ' ******* ab hier nur noch Subroutine ***** ' ******* Ausgabe Zahlenwert an LCD **** #LCD_ausg ' Werte an LCD ausgeben lcd_init 'I2C-Bus initalisieren, PCF anmelden, lcd_cls PAUSE 1 ' LCD initialisieren und loeschen ' 1. Zeile beschreiben lcd_writecmd &h80 'Kommando "Set DD-RAM address" zum LCD senden lcd_writechar "I" '1 lcd_writechar "M" '2 lcd_writechar "P" '3 lcd_writechar "_" '4 lcd_writechar "L" '5 lcd_writechar "i" '6 lcd_writechar "/" '7 lcd_writechar "h" '8 ' 2. Zeile beschreiben lcd_writecmd &hc0 'Kommando "Set DD-RAM address" zum LCD senden lcd_writechar Ze_1 '1 lcd_writechar Ze_2 '2 lcd_writechar Ze_3 '3 lcd_writechar " " '4 lcd_writechar Ze_5 '5 lcd_writechar Ze_6 '6 lcd_writechar Ze_7 '7 lcd_writechar Ze_8 '8 Pause 1 i2c_stop 'schliesslich PCF vom I2C-Bus abmelden Return ' ****************************** PROCEDURE zahl(Imp_v) 'Subroutine zur drei-stelligen Zahlenausgabe tem3=(Imp_v/100 MOD 100) tem2=(Imp_v/10 MOD 10) tem1=(Imp_v MOD 10) RETURN END PROCEDURE ' ******************************************************************* ' ab hier 24Bit Arithmetik ' Subroutinen Multiplikation,Addition von 21500, dann division /100 ' '******************************************************************** ' Subroutine zur 24-Bit-Addition ' Eingabewerte_1 muess in Ar_a1 bis Ar_a3 sein ' Eingabewerte_2 muess in Ar_b1 bis Ar_b3 sein ' Ausgabewerte sind in Ar_a1 bis Ar_a3 PROC addieren INLASM ! lda Ar_a1 ' lowest byte in accu ! add Ar_b1 ! sta Ar_a1 ! lda Ar_a2 ! adc Ar_b2 ! sta Ar_a2 ! lda Ar_a3 ' highest byte in accu ! adc Ar_b3 ! sta Ar_a3 ! rts END PROC ' Subroutine fuer 16 bit Zahl; Division durch 2 oder 4 oder 8 etc. mit Rundung ' hier Division ./.8 eingestellt ' Eingabewert muss in Ar_a1 bis Ar_a2 sein ' Ausgabewerte in Ar_a1 bis Ar_a2 PROC divid_8 INLASM ! lda Ar_a1 ' Nun halben divisor zu dividend addiert zwecks Rundung ! add #4 ' halben Teilerwert addieren z.B. div_8 == 4 ! sta Ar_a1 ! lda Ar_a2 ! adc #0 ' falls carry dann uebertrag von carry ! sta Ar_a2 'Ende vorbereitung fuer Rundung des Ergebnisses ! lda #3 ' division :/.2==#1 oder ./.4==#2; ./.8==#3; ./.16==#4 etc. einfuegen #Div_schl ' divisionsschleife ! lsr Ar_a2 ' MSB verschoben um eins nacht rechts; Bit0= in carry ! ror Ar_a1 ' carry in Bit 7 von Ar_a+2 =in = erstes byte ! dbnza Div_schl 'wiederholt div. bis accu = 0 ist ! rts END PROC ' --------------------------------------------------------------------------- ' Schnelle Multiplikation 16Bit Wordvariable mit 16Bit Word Variable mit 24-Bit-Ergebnis ' von Josef Fenk So. 22.02.2015 ' Eingabewerte_1=Multilpikand muess in Ar_a1 bis Ar_a2 sein ' Eingabewerte_2=Multiplikator muess in Ar_b1 bis Ar_b2 sein ' Ausgabewerte=Produkt sind in Ar_c1 bis Ar_c3 ' Verfahren der Multiplikation s. auch ATMEL application note AVR201 ' Prod Eingabe_A Eingabe_B Ergebnisse ' A_H:A_L x B_H:B_L C_H C_ML C_ML C_L '---------------------------------------------------------------------- ' 1-te Mul. A_L x B_L ==> P1_H P1_L ' 2-te Mul. A_H x B_L ==> P2_H P2_L ' 3-te Mul. A_L x B_H ==> P3_H P3_L ' 4-te Mul. A_H x B_H ==> P4_H P4_L '------------------------------------------------------------------------- ' Summation der 4 Multiplikationen C_MH:C_ML:C_L ' uebertragen in Ar_c3:Ar_c2:Ar_c1 ' C_H bzw. P4_H wird nicht beruecksichtigt, da max. 24 Bit genutzt wird PROC multi_16x16 INLASM ! lda Ar_a1 ' Eingabe a1 low byte in accu ! ldx Ar_b1 ' Eingabe b1 low byte in x register ! mul ' Mul_1 P1_L in accu; P1_H byte in x ! sta Ar_c1 ' P1_L low byte in Ausgabe Ar_c1 ! stx Ar_c2 ' P1_H high byte in Ar_c2 ! lda Ar_a2 ' Eingabe a2 high byte in accu ! ldx Ar_b1 ' Eingabe b1 low byte in x ! mul ' Mul_2 P2_L low byte in accu; P2_H high byte in x-register ! stx Ar_c3 ' P2_H high byte in Ausgabe Ar_c3 highest byte abspeichern ! add Ar_c2 ' P1_H zwischengespeichert in Ar_c2 zu P2_L low byte in accu addieren ! bcc noinc_1 ' wenn carry bit nicht gesetzt springen zu noinc ! inc Ar_c3 ' carry uebertragen auf 3-tes byte Ausgabe #noinc_1 ! sta Ar_c2 ' additionsergebnis accu in Ausgabe mittel byte speichern ' 3-te Multiplikation ! lda Ar_a1 ' Eingabe a1 low byte in accu ! ldx Ar_b2 ' Eingabe b2 high byte in x register ! mul ' Mul_3 P3_L low byte in accu; P3_H high byte in x ! pshx ' P3_H Ergebnis high byte in Stack zwischenspeichern statt in Ar_c3 ! add Ar_c2 ' P3_L + (P2_L+P1_H) addition ! bcc noinc_2 ' wenn carry bit nicht gesetzt springen zu noinc ! inc Ar_c3 ' carry uebertragen auf 3-tes byte Ausgabe #noinc_2 ! sta Ar_c2 ' additionsergebnis accu in Ausgabe mittel byte speichern ' 4-te Multiplikation ! lda Ar_a2 ' Eingabe high byte in accu ! ldx Ar_b2 ' Eingabe b1 high byte in x ! mul ' Mul4 P4_L low byte in accu; P4_H high byte in x-register, wird nicht mehr genutzt ! add Ar_c3 ' P2_H in Ar_c3 zwischengespeichert nun zu P4_L in accu addieren ' P2_H+P4H mit ev. carry von vorherigen Additionen in Ar_c2 ! adc 1,SP ' Zwischengespeichertes Ergebnis P3_H aus stack dazu addiert ! sta Ar_c3 ' additionsergebnis accu in Ausgabe Ar_c3 high byte speichern ! ais #1 ' loeschen von 1 stack bytes ! rts END PROC ' ******************************************************************* ' hier 24Bit Arithmetik Division durch 8 BitDivisor mit Div Befehl u. Rundung '******************************************************************** ' Subroutine zur 24-Bit-Division; 3Byte-Wert/1Byte-wert=Ergebnis Ar_c ' geaendert Sa. 14.03.2015 von JF, um integerzahlen ohne neg. Werte zu erhalten ' Wertebereich fuer Ausgabe begrenzt ' auf 2^24 = 16.777.215==Hex: ff ff ff ' Urversion von Dietmar Harlos ADPC am 29. Juni 2006 in 32BITASM.BAS PROC div_8b INLASM ! mov Ar_a1,Ar_c1 'Akkumulator a nicht veraendern ! mov Ar_a2,Ar_c2 ! mov Ar_a3,Ar_c3 ! ldx Ar_b1 '#100 ' divisior = 10 in x register laden ! clr OSTEMP #print10_2 ! inc OSTEMP ' zaehlt hoch ! clrh ' high byte of dividend =0 gesetzt ! lda Ar_c3 ' lade dividend higest byte in accu ! div ' Division ;quotient in accu; remainder in H ! sta Ar_c3 ! lda Ar_c2 ! div ! sta Ar_c2 ! lda Ar_c1 ! div ' ergebnis in accu und remainder in H ! sta Ar_c1 ! pshh ' remainder in stack ! pula ' nun in accu ! sta tem3 ' nun h-register in tem3 ! txa ' x-registor= divisor in accu ! lsra ' accu inhalt um 1 nach rechts, divisor halbiert ! add tem3 ' divisor/2 + tem3== divisor/2 + remainder ! clrh ' H register loeschen ! div ' quotient in accu, remainder in H ! add Ar_c1 ' ! sta Ar_c1 ' ergebnis accu zurueck in Ar_c+3 ! pshh ' remainder in stack ! pula ' nun in accu ! sta tem2 ' h-register nach rundung in tem2 ! rts END PROC ' ************************************** ' Subroutine zur dezimalen Ausgabe von 16-Bit-Zahlen ohne Vorzeichen ' geaendert Sa. 14.03.1015 von JF, um integerzahlen ohne neg. Werte zu erhalten ' Urversion von Dietmar Harlos ADPC am 29. Juni 2006; 32BITASM.BAS PROC print16 INLASM ! mov Ar_a1,Ar_c1 'Akkumulator a nicht veraendern ! mov Ar_a2,Ar_c2 ! ldx #10 ! clr OSTEMP #print16_2 ! inc OSTEMP ! clrh ! lda Ar_c2 ! div ! sta Ar_c2 ! lda Ar_c1 ! div ! sta Ar_c1 ! pushh ! ora Ar_c2 ! bne print16_2 #print16_3 ! popa 'Ziffern ausgeben ! add #"0" ! jsr FwPutSci ! cli ! dbnz OSTEMP,print16_3 ! rts END PROC ' ********************************* ' Subroutine zur dezimalen Ausgabe von einer 16-Bit-Zahlen ohne Vorzeichen ' in die Variable tem4 bis tem1 fuer Display Ausgaben ' geaendert Mo. 23.01.2017 ' Urversion von Dietmar Harlos ADPC am 29. Juni 2006; 32BITASM.BAS PROC print16_tem INLASM ! mov Ar_a1,Ar_c1 'Akkumulator a nicht veraendern ! mov Ar_a2,Ar_c2 ! lda #39 ' fuer 9999 ! sta tem2 ! lda #15 ! sta tem1 ! ldhx tem2 'das funktioniert, Ar_d2 und d1 werden in H:X geladen ! cphx Ar_a2 'das funktioniert Compare H:X mit Ar_a; carry set if Ar_a > H:X ! bcs Aus_e ' sobald Ar_a_2_1 > HX_2_1 ist wird zu #Aus_e verzweigt ! ldx #10 ! clr OSTEMP #print16_2tem ! inc OSTEMP ! clrh ! lda Ar_c2 ! div ! sta Ar_c2 ! lda Ar_c1 ! div ! sta Ar_c1 ! pushh ! ora Ar_c2 ! bne print16_2tem ! lda #" " 'Leerzeichen abspeichern um bei Display ausgabe richtige anzeige ! sta tem3 'alle 3 leerzeichen, damit nicht falsche Wert angezeigt werden ! sta tem2 ! sta tem1 ! popa 'im obersten Stack die letzte Ziffer, im ersten die 4-te ! add #"0" ! sta tem4 '4 stelle in tem4 ! dec OSTEMP ' reduziert OSTEMP um -1 ! beq Aus_e 'falls nur einmal gepusht wurde ! pula ' holt die nchste 3-te Ziffer vom Stack ! add #"0" ! sta tem3 ' Zwischenspeichern in tem3 ! dec OSTEMP ! beq Aus_e ! pula ! add #"0" ! sta tem2 ! dec OSTEMP ! beq Aus_e ! pula ! add #"0" ! sta tem1 #Aus_e 'Ausgabe endet ! rts END PROC ' --------------------------------------------------------------------------- ' Die LCD-Routinen haben die gleiche Struktur wie auf der C-Control 1.1 ' --------------------------------------------------------------------------- PROCEDURE lcd_init 'Vorgeschriebene Verzoegerung fuer das LCD PAUSE 2 'I2C-Bus initialisieren i2c_init 'PCF ueber I2C-Bus aktivieren i2c_start IF NOT i2c_write(&h40) THEN 'I2C-Adresse vom PCF8574 = 0100 0000 PRINT "NACK" : END END IF '8-Bit-Modus aktivieren lcd_writecmd &h38 'mit 8-Bit-Command in 4-Bit-Modus umschalten i2c_write &b01000010 'EN auf high i2c_write &b00000010 'EN auf low 'ab jetzt 4-Bit-Modus lcd_writecmd &h28 lcd_writecmd &h0c 'LCD loeschen lcd_cls RETURN END PROCEDURE PROCEDURE lcd_cls lcd_writecmd &h02 lcd_writecmd &h01 RETURN END PROCEDURE ' Im folgenden wird die Assemblerroutine i2c_write per SYS- statt mit dem ' GOSUB-Befehl aufgerufen. Das spart einen Stackeintrag auf dem Aufruf-, ' bzw. GOSUB-Stack und ist etwas schneller. PROCEDURE lcd_writecmd (temp) SYS i2c_write (temp shr 4 or &b01000000) 'High-Nibble, EN auf high SYS i2c_write (temp shr 4 ) 'High-Nibble, EN auf low SYS i2c_write (temp and &h0f or &b01000000) ' Low-Nibble, EN auf high SYS i2c_write (temp and &h0f ) ' Low-Nibble, EN auf low RETURN END PROCEDURE PROCEDURE lcd_writechar (temp) SYS i2c_write (temp shr 4 or &b01100000) 'High-Nibble, EN auf high SYS i2c_write (temp shr 4 or &b00100000) 'High-Nibble, EN auf low SYS i2c_write (temp and &h0f or &b01100000) ' Low-Nibble, EN auf high SYS i2c_write (temp and &h0f or &b00100000) ' Low-Nibble, EN auf low RETURN END PROCEDURE ' --------------------------------------------------------------------------- ' Die I2C-Routinen einbinden ' --------------------------------------------------------------------------- INCLUDE "om_i2c.pro" ' --------------------------------------------------------------------------- ' Die Firmware-Routinen einbinden ' --------------------------------------------------------------------------- INCLUDE "om_fw.pro"