/* * Schrittmotor.asm * * Created: 05.04.2021 17:50:57 * Author: Carsten * basteln-carsten@t-online.de */ .include "avr.inc" .include "m1284Pdef.inc" .equ F_CPU = 16000000 ;Systemtakt in Hz .equ Schrittweite = 127 ;63 ;(Schritte=Schrittweite +1) Bestimmt die Motorphasen .equ BAUD = 115200 ; Baudrate .equ UBRR_VAL = ((F_CPU+BAUD*8)/(BAUD*16)-1) ; clever runden .equ BAUD_REAL = (F_CPU/(16*(UBRR_VAL+1))) ; Reale Baudrate .equ BAUD_ERROR = ((BAUD_REAL*1000)/BAUD-1000) ; Fehler in Promille .equ PWM1 = OCR0A ;PB3 .equ PWM2 = OCR0B ;PB4 .equ PWM3 = OCR2A ;PD7 .equ PWM4 = OCR2B ;PD6 .equ PWM5 = OCR3AL ;PB6 ;nur eine Auswahl .equ Mot1 = 0 ;4 Wicklungen gleichzeitig - (1000 mal n Schritte) .equ Mot2 = 0 ;4 Wicklungen gleichzeitig - (500 mal n Schritte) .equ Mot3 = 0 ;2 Wicklungen gleichzeitig - (500 mal n Schritte) .equ Mot4 = 1 ;2 Phasen-Motor .equ Rtg = PD3 ;Eingang Richtung Vor/Zurück .equ SollM1 = 60 ;Anzahl der zu addierten Messungen 1. Zähler - Voreinstellung - Weg, Umdrehungen .equ SollM2 = 60 ;Anzahl der zu addierten Messungen 2. Zähler - Voreinstellung - Geschwindigkeit .equ DrAbfr =255 .equ DrWa =2000 ;Drehgeber Wartezeit A nach INT zur Entprellung ;ISP PORTB 5,6,7 ;JTAG PORTC 2,3,4,5 ;PORTA, 0 ;Poti ;PORTA, 1 ;Lade Speicherbereich 0 aus EEPROM ;PORTA, 2 ;Lade Speicherbereich 1 aus EEPROM ;PORTA, 3 ;Lade Speicherbereich 2 aus EEPROM ;PORTA, 4 ;Lade Speicherbereich 3 aus EEPROM ;PORTA, 5 ;Lade Speicherbereich 4 aus EEPROM ;PORTA, 6 ;Position ;PORTA, 7 ;Schrittgeber Geschwindigkeit ;PORTB, 0 ;zum Treiber H-Bruecke 1 ;PORTB, 1 ;Drehgeber B Für Richtung ;PORTB, 2 ;Drehgeber A INT2 ;PORTB, 3 ;PWM1 ;PORTB, 4 ;PWM2 ;PORTB, 5 ;ISP ;PORTB, 6 ;PWM5,ISP ;PORTB, 7 ;ISP ;PORTC, 0 ;zum Treiber H-Bruecke 2 ;PORTC, 1 ;Impuls- Ausgabe - 1 pro Schrittweite für externe Treiber ;PORTC, 2 ;JTAG ;PORTC, 3 ;JTAG ;PORTC, 4 ;JTAG ;PORTC, 5 ;JTAG ;PORTC, 6 ;Ausgang Richtung ;PORTC, 7 ;Ausgang Daten stoppen ;PORTD, 0 ;RX Serielle Schnittstelle ;PORTD, 1 ;TX Serielle Schnittstelle ;PORTD, 2 ;Externer Eingang Takt Motor ;PORTD, 3 ;Externer Eingang Richtung Motor ;PORTD, 4 ;zum Treiber H-Bruecke 3 ;PORTD, 5 ;zum Treiber H-Bruecke 4 ;PORTD, 6 ;PWM4 ;PORTD, 7 ;PWM3 ;Register mit Variablen ;R8 Position soll - niedrigstwertiges Byte ;R9 ;R10 ;R11 höchstwertiges Byte ;R12 Position ist - niedrigstwertiges Byte ;R13 ;R14 ;R15 höchstwertiges Byte .dseg .org SRAM_START Status: .byte 1 ;Bit 0= Timer 1 ein ;Bit1= Motor stoppen. zu kleine Geschwindigleit; Bit 2= alter Wert von Port A Bit7; Bit 3= alter Wert von Port A Bit6; Bit 7 Motor läuft bis soll-Ist gleich VR: .byte 1 ;letzte Vor-Rück - Richtung PWMAdr: .byte 2 ;Einsprungsadresse PWMAdrh: .byte 1 ;aktuelle PWM-Adresse PWMAdrl: .byte 1 ;aktuelle PWM-Adresse ZSchritt: .byte 1 ;Schrittweite (0-255)+1 PWMW: .byte 1 ;PWM-Wert - nur für 2-Phasen-Motor AZ: .byte 4 ;für laufe auf Position - Anzahl der Schritte Lurchl: .byte 4 ;Anzahl der Durchläufe Uel: .byte 1 ;Überlauf Pufferspeicher - Anfang wird Überschrieben ADstatus: .byte 1 ;Bit0 = erster Zähler fertig gemessen - Bit1 = zweiter Zähler fertig gemessen ADh: .byte 1 ;Werte ADC - eine Messung ADl: .byte 1 ADs: .byte 1 ;Anzahl der Messungen soll ADi: .byte 1 ;Anzahl der Messungen ist ADz: .byte 3 ;Zwischensumme Summenwerte aus ADi ADw: .byte 3 ;Addierter Wert aus ADs Messungen DPw: .byte 1 ;Multiplikator für Drehung mit Poti ADs2: .byte 1 ;Anzahl der Messungen soll ADi2: .byte 1 ;Anzahl der Messungen ist ADz2: .byte 3 ;Zwischensumme Summenwerte Geschwindigkeit ADw2: .byte 3 ;Addierter Wert aus ADs Messungen Geschwindigkeit ADRG: .Byte 2 ;ADC Wert bei Schalterbetätigung Geschwindigkeit ADRD: .Byte 3 ;ADC Wert bei Schalterbetätigung Distanz RPOS: .Byte 4 ;Positionswerte beim Tastendruck für Position durch Poti (R12...R15) ;Serialle Schnittstelle SerZ: .byte 2 ;Zeiger Pufferspeicher serielle Schnittstelle Anfang SerP: .byte 2 ;Zeiger Pufferspeicher serielle Schnittstelle Ende SerP2: .byte 2 ;Zeiger Pufferspeicher serielle Schnittstelle bei Zeichen ";" LZ: .byte 1 ;Letzten Steuer Zeichen LF, CR, ";" ZZ: .byte 2 ;Zeichenzähler für eingelesene Daten - zählt bis 0 runter ZS: .byte 1 ;Zeichen Status PL: .byte 1 ;Pufferspeicher 0=leer 1= nicht leer ;Semi: .byte 1 ;ist noch ein ; vorhanden? ZLF: .byte 1 ;ist noch ein LF vorhanden? Pu: .byte 1 ;Pufferspeicher genutzt -Flag Bit 0 PG: .byte 2 ;Pufferspeicher Größe Belegte Byte SerPZ: .byte 2 ;Pufferspeicher ZX: .byte 1 ;Wartezeit abbrechen Dezwert:.byte 11 ;Ausgabe dezimal 10 Stellen - Dezwert=L Dezwert+10=H + 0x00 für Textausgabe PM: .byte 1 ;Marke +- MEprom: .byte 1 ;Marke, ob ein Programm aus dem EEPROM geladen wurde PWMAdr1: .byte 1 PWMAdr2: .byte 1 Motb: .byte 3 ;Motor Betrieb - Schritte/U Moth: .byte 2 ;Motor Betrieb - Schritte/U / 100 Bmot: .byte 1 ;derzeitiger Motor Betriebsart .org 0x0200-32 ;Anfangsadresse Puffer Serielle Schnittstelle USARTS: .byte RAMEND-USARTS-256 ;Pufferspeicher Pufferende: .cseg .ORG 0 ;0 JMP Reset .ORG INT0addr; = 0x0002 ; External Interrupt Request 0 rjmp EXT_INT0 ; .ORG INT1addr; = 0x0004 ; External Interrupt Request 1 reti .ORG INT2addr; = 0x0006 ; External Interrupt Request 2 rjmp Dreh ;reti .ORG PCI0addr; = 0x0008 ; Pin Change Interrupt Request 0 reti .ORG PCI1addr; = 0x000a ; Pin Change Interrupt Request 1 reti .ORG PCI2addr; = 0x000c ; Pin Change Interrupt Request 2 reti .ORG PCI3addr; = 0x000e ; Pin Change Interrupt Request 3 reti .ORG WDTaddr; = 0x0010 ; Watchdog Time-out Interrupt reti .ORG OC2Aaddr; = 0x0012 ; Timer/Counter2 Compare Match A reti .ORG OC2Baddr; = 0x0014 ; Timer/Counter2 Compare Match B reti .ORG OVF2addr; = 0x0016 ; Timer/Counter2 Overflow reti .ORG ICP1addr; = 0x0018 ; Timer/Counter1 Capture Event reti .ORG OC1Aaddr; = 0x001a ; Timer/Counter1 Compare Match A rjmp MotorTakt ; reti .ORG OC1Baddr; = 0x001c ; Timer/Counter1 Compare Match B reti .ORG OVF1addr; = 0x001e ; Timer/Counter1 Overflow reti .ORG OC0Aaddr; = 0x0020 ; Timer/Counter0 Compare Match A reti .ORG OC0Baddr; = 0x0022 ; Timer/Counter0 Compare Match B reti .ORG OVF0addr; = 0x0024 ; Timer/Counter0 Overflow reti .ORG SPIaddr; = 0x0026 ; SPI Serial Transfer Complete reti .ORG URXC0addr; = 0x0028 ; USART0, Rx Complete rjmp UARTlesen ; reti .ORG UDRE0addr; = 0x002a ; USART0 Data register Empty reti .ORG UTXC0addr; = 0x002c ; USART0, Tx Complete reti .ORG ACIaddr; = 0x002e ; Analog Comparator reti .ORG ADCCaddr; = 0x0030 ; ADC Conversion Complete ; rjmp ADCcompl reti .ORG ERDYaddr; = 0x0032 ; EEPROM Ready reti .ORG TWIaddr; = 0x0034 ; 2-wire Serial Interface reti ; rjmp inttwi .ORG SPMRaddr; = 0x0036 ; Store Program Memory Read reti ;.ORG USART1_RXC ;=0x0038 ;USART1 RX Complete ; reti ;.ORG USART1_UDRE ;0x003A ; USART1,UDR Empty ; reti ;.ORG USART1_TXC ;0x003C ; USART1 TX Complete ; reti ;.ORG TIM3_CAPT ;0x003E ; Timer3 Capture ; reti ;.ORG TIM3_COMPA ;0x0040 ; Timer3 CompareA ; reti ;.ORG TIM3_COMPB ;0x0042 ; Timer3 CompareB ; reti ;.ORG TIM3_OVF ;0x0044 ; Timer3 Overflow ; reti ;rjmp Posit -Test- ;Zurueck: .ORG 0x0100 ; Adresse 0x200 MTab: .db 0,2,3,5,6,8,9,11,13,14,16,17,19,20,22,24,25,27,28,30,31,33,34,36,38,39,41,42,44,45,47,48 .db 50,51,53,55,56,58,59,61,62,64,65,67,68,70,71,73,74,76,77,79,80,82,83,85,86,88,89,91,92,94,95,96 .db 98,99,101,102,104,105,107,108,109,111,112,114,115,116,118,119,121,122,123,125,126,128,129,130,132,133,134,136,137,138,140,141 .db 142,143,145,146,147,149,150,151,152,154,155,156,157,159,160,161,162,164,165,166,167,168,169,171,172,173,174,175,176,178,179,180 .db 181,182,183,184,185,186,187,188,190,191,192,193,194,195,196,197,198,199,200,201,202,203,203,204,205,206,207,208,209,210,211,212 .db 213,213,214,215,216,217,218,218,219,220,221,222,222,223,224,225,225,226,227,228,228,229,230,230,231,232,232,233,234,234,235,235 .db 236,237,237,238,238,239,239,240,241,241,242,242,243,243,243,244,244,245,245,246,246,247,247,247,248,248,248,249,249,249,250,250 .db 250,251,251,251,251,252,252,252,252,253,253,253,253,253,254,254,254,254,254,254,254,255,255,255,255,255,255,255,255,255,255,255 EXT_INT0: ;Eingang Taktimpulse push AL in AL,SREG push AL push AH ;D2 Takt ;D4 Richtung cbi PORTC, 6 ;Richtung Ausgang =0 sbic PIND, 3 ;Richtung Eingang sbi PORTC, 6 ;Richtung Ausgang =1 call Schritt pop AH pop AL out SREG,AL pop AL reti ;------------------- ;fallende Flanke von "A" löst INT2 auf PB2 aus ;PB2 - Drehgeber "A" ;PB1 - Drehgeber "B" Dreh: push AL in AL,SREG push AL push AH ldi AL, LOW(DrWa) ;Wartezeit zur Entprellung ldi AH, High(DrWa) DW1: tst AL breq DW2 dec AL brne DW1 DW2: tst AH breq DW3 dec AH dec AL brne DW1 DW3: in AL, PINB andi AL, 0b00000100 ;Zurück, wenn Pegel 1 brne DWx cbi PORTC, 6 ;Setze Richtung auf 0 sbic PINB, 1 ;Richtung vom Drehgeber sbi PORTC, 6 ;Setze Richtung ldi AL, 43 ;2b + ;USART_Transmit: nur AL senden sbic PINC, 6 ldi AL, 45 ;2d - call USART_Transmit pushw z call Schritt popw z DWx: pop AH pop AL out SREG,AL pop AL reti ;------------------- MotorTakt: ;vom Timer 1 Mode 4 pushw z push AL in AL,SREG push AL push AH lds AL, Status ;lese Status Bit sbrc AL, 7 rjmp MotorTakt1 sbrc AL, 1 call Schritt sbrc AL, 5 rcall MW MotorTaktz: pop AH pop AL out SREG,AL pop AL popw z reti MotorTakt1: subi R20, 1 sbci R21, 0 sbci R22, 0 sbci R23, 0 brcc MotorTakt2 MotorTakt3: rcall Schritt ;letzter Schritt clr AL sts Status, AL rjmp MotorTaktz MotorTakt2: mov AL, R20 ;Prüfe auf 0 or AL, R21 or AL, R22 or AL, R23 breq MotorTakt3 rcall Schritt rjmp MotorTaktz MW: ;Zähle Takte runter für Warten mov AL, R20 ;Prüfe auf 0 or AL, R21 or AL, R22 or AL, R23 breq WM1 clr AH ;0 subi R20, 1 ;-1 sbc R21, AH sbc R22, AH sbc R23, AH ret WM1: clr AH ;0 sts Status, AH ret ;------------- ;INT_Schritt: ;INT_Z: ;Serielle Schnittstelle 0 UARTlesen: ;USART lesen pushw x push AL in AL,SREG push AL push AH lds R27, SerP lds R26, SerP+1 sbrc R27, 6 ;Skip if Bit in Register Cleared ist 0x40 erreicht? ldi R27, 2 ;dann X= 0x200 ; rcall ul ;setze Marker bei Pufferende erreicht und R27 = 2 lds AL, UDR0 ; empfangenes Byte (in AL, UDR0) cpi AL, 120 ;78 Hex "x" brne UZx sts ZX, AL UZx: st x+, AL sbrc R27, 6 ;Skip if Bit in Register Cleared ist 0x40 erreicht? ; ldi R27, 2 ;dann X= 0x200 rcall ul ;setze Merker und R27 auf 2 sts SerP,R27 ;speichere neue Position sts SerP+1,R26 clr AH st x, AH ;lösche kommendes Zeichen cpi AL, 10 ;"LF" 0x0A Zeilenvorschub breq UZ1 rjmp UZ2 UZ1: sts LZ, AL UZ2: lds AL, ZZ ;Zeichenzähler lds AH, ZZ+1 subi AH, 1 ;Zeichenzähler -1 sbci AL, 0 brcs UL3 ;springe, wenn kleiner 0 sts ZZ, AL ;sichern sts ZZ+1, AH rjmp UL5 UL3: sbic PORTC, 7 ;Sprung, wenn 0 rjmp PC+2 sbi PORTC, 7 ;Daten stoppen UL5: pop AH pop AL out SREG,AL pop AL popw x reti ul: ;Überlauf des Pufferspeichers erkannt - Merker setzen sts Uel, R27 ldi R27, 2 ;dann X= 0x200 ret ;---------------------------------------------- BMot1: ldi AL, LOW(MPa) ;setze Anfangsadreese PWM1 sts PWMAdrl, AL ldi AL, HIGH(MPa) sts PWMAdrh, AL clr AH out PWM1, AH sts PWM3, AH sts PWM5, AH ldi AH, 255 out PWM2, AH sts PWM4, AH ldi AL, 00 ;LOW 1F400 (128000) sts Motb, AL ldi AL, 0xF4 ;F4 Hex 1F400 (128000) sts Motb+1, AL ldi AL, 0x01 ;01 Hex 1F400 (128000) sts Motb+2, AL ldi AL, LOW (1280) ;Schritte/U durch 100 für Winkelberechnung sts Moth, AL ldi AL, HIGH (1280) ;Schritte/U durch 100 für Winkelberechnung sts Moth+1, AL ldi AL, 1 sts BMot, AL rcall CPos ;Position auf 0 ret BMot2: ldi AL, LOW(MP1) ;setze Anfangsadreese PWM1 hier Vollschritt sts PWMAdrl, AL ldi AL, HIGH(MP1) sts PWMAdrh, AL clr AH out PWM1, AH sts PWM3, AH sts PWM5, AH ldi AH, 255 out PWM2, AH sts PWM4, AH ldi AL, LOW (64000) ;0xFA00 sts Motb, AL ldi AL, HIGH (64000) sts Motb+1, AL clr AL sts Motb+2, AL ldi AL, LOW (640) ;Schritte/U durch 100 für Winkelberechnung sts Moth, AL ldi AL, HIGH (640) ;Schritte/U durch 100 für Winkelberechnung sts Moth+1, AL ldi AL, 2 sts BMot, AL rcall CPos ;Position auf 0 ret BMot3: ldi AL, LOW(MS1) ;setze Anfangsadreese PWM1 sts PWMAdrl, AL ldi AL, HIGH(MS1) sts PWMAdrh, AL clr AH out PWM2, AH sts PWM3, AH sts PWM4, AH sts PWM5, AH ldi AH, 255 out PWM1, AH ldi AL, LOW (32000) ;0xFA00 sts Motb, AL ldi AL, HIGH (32000) sts Motb+1, AL clr AL sts Motb+2, AL ldi AL, LOW (320) ;Schritte/U durch 100 für Winkelberechnung sts Moth, AL ldi AL, HIGH (320) ;Schritte/U durch 100 für Winkelberechnung sts Moth+1, AL ldi AL, 3 sts BMot, AL rcall CPos ;Position auf 0 ret ;------------------------------------------------------- BMot4: ;!!! 2 Phasen- Motor !!! ldi AL, LOW(M2P1) ;setze Anfangsadreese PWM1 sts PWMAdrl, AL ldi AL, HIGH(M2P1) sts PWMAdrh, AL clr AH sts PWMW, AH clr AH out PWM1, AH out PWM2, AH sts PWM3, AH ldi AH, 255 sts PWM4, AH cbi PORTB, 0 ;PWM1 mit Port B0 sbi PORTC, 0 ;PWM2 mit Port C0 sbi PORTD, 4 ;PWM3 mit Port D4 cbi PORTD, 5 ;PWM4 mit Port D5 ldi AL, LOW (51200) ;0xC800 sts Motb, AL ldi AL, HIGH (51200) sts Motb+1, AL clr AL sts Motb+2, AL ldi AL, LOW (512) ;Schritte/U durch 100 für Winkelberechnung sts Moth, AL ldi AL, HIGH (512) ;Schritte/U durch 100 für Winkelberechnung sts Moth+1, AL ldi AL, 4 sts BMot, AL rcall CPos ;Position auf 0 ret ;---------------------------------------------- CPos: clr R12 ;Position auf 0 clr R13 clr R14 ldi AL, 0x80 ;0x80000000 mov R15, AL ret ;---------------------------------------------- Init: ;Port Richtung setzen ldi AL, 0x00 ; 1= Ausgang out DDRA, AL ldi AL, 0b11111110 ;1= Pull up out PORTA, AL ldi AL, 0b1111001 ; 1= Ausgang out DDRB, AL ldi AL, 0b00000110 ;1 = Pull up out PORTB, AL ldi AL, 0b11111111 ; 1= Ausgang out DDRC, AL ldi AL, 0x01 ;Bit 0 Pull up out PORTC, AL ldi AL, 0b11110010 ; 1= Ausgang Motor: D2=Takt Eingang D3=Richtung Eingang out DDRD, AL ldi AL, 0b00111101 ;1= Pull up out PORTD, AL ldi AL, Schrittweite sts ZSchritt, AL clr AL sts Uel, AL ;Merker für Überschreiben Datenanfang auf 0 ldi AL, 128 ; Anfangsposition 80 00 00 00 Hex - Mitte des Weges (ff ff ff ff Hex) clr R8 clr R9 clr R10 mov R11, AL clr R12 clr R13 clr R14 mov R15, AL ldi AL, 1 ;Multiplikator für Drehung mit Poti speichern sts DPw, AL .if Mot1 rcall BMot1 .endif .if Mot2 rcall BMot2 .endif .if Mot3 rcall BMot3 .endif .if Mot4 rcall BMot4 .endif USART_Init: ; Set baud rate ldi AL, HIGH(UBRR_VAL) sts UBRR0H, AL ;out UBRR0H, AL ldi AL, LOW(UBRR_VAL) sts UBRR0L, AL ;out UBRR0L, AL ; Enable receiver and transmitter ldi AL, (1< senden rcall NDezwert ;lösche füllende nullen ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden call DEZ_ASC5 ;Dezimalwert spiegeln call ASC_DEZ ;ASCCII in Hex wandeln 10Byte SRAM Dezwert nach R20...R23 = 32Bit Hex -- R20=L R23=H -- Dezwert=L Dezwert+10=H or R21, R22 ;prüfe, ob 0 or R21, R23 brne EEPROMSx cpi R20, 7 breq EEPROMz brcc EEPROMSx EEPROMS1: mov AL, R20 rcall EEDS ;schreibe Bereich ldiw Z, Texte3*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> im EEPROM gespeichert rcall DaE ;laufe bis zum nächsten LF ret EEPROMSx: ;ungültiger Wert ldiw Z, Texte2*2 ;Anfang Pufferspeicher - Durchläufe - rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall DaE ;laufe bis zum nächsten LF ret EEPROMz: ;Lösche EEPROM ldi R19, 1 ldi R20, 0 clr R17 clr R18 EEPROMz1: rcall reprom ;erstmal lesen cpi AL, 0xff breq EEPROMz2 ;nicht schreiben, wenn 0xff ldi AL, 0xff rcall weprom EEPROMz2: add R18, R19 ;R17,R18 +1 adc R17, R20 cpi R17, 0x0E ;fertig? brne EEPROMz1 ldiw Z, Textex*2 ;Anfang Pufferspeicher - Daten gelöscht - rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall DaE ;laufe bis zum nächsten LF ret ;--------------------------------------- EEPROML: ;lese EEPROM ,schreibe ins SRAM ab 0x0200 rcall Zeingabe ;Eingabe Zahlen über UART ldiw Z, Textel*2 ;Anfang Pufferspeicher - EPROM Bereich - rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall NDezwert ;lösche füllende nullen ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden call DEZ_ASC5 ;Dezimalwert spiegeln call ASC_DEZ ;ASCCII in Hex wandeln 10Byte SRAM Dezwert nach R20...R23 = 32Bit Hex -- R20=L R23=H -- Dezwert=L Dezwert+10=H or R21, R22 ;prüfe, ob 0 or R21, R23 brne EEPROMSx cpi R20, 7 ;Datenspeicher anzeigen breq EEPROMA cpi R20, 8 ;zu groß brcc EEPROMSx mov AL, R20 rcall EEDL ret EEPROMA: ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textea*2 ;Datenspeicher anzeigen rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldi R31, 2 ;0x0200 ldi R30, 0 rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall DaE ;laufe bis zum nächsten LF ret ;--------------------- PSa: ;Pufferspeicher auf Anfang ldi AL, 2 ;Anfang Zeichenpuffer sts SerZ, AL sts SerP, AL ldi AL, 0 sts SerZ+1, AL sts SerP+1, AL sts PU, AL ;Anzahl der einzulesenden Daten sts PU+1, AL sts Lurchl, AL ;lösche Durchlaufzähler sts Lurchl+1, AL sts Lurchl+2, AL sts Lurchl+3, AL lds R27, SerP lds R26, SerP+1 clr AH st x+, AH ;lösche kommendes Zeichen st x, AH ldi AL, 0 sts ZZ+1, AL ;Anzahl der eingelesenden Daten ldi AL, 0x3b sts ZZ, AL ret ;--------------------- Texti: ldiw Z, Texta*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden ret ;--------------------- SWinkel: ;Laufe auf Winkel rcall Zeingabek ;Eingabe Zahlen über UART vorbereiten mit Komma ;Ausgabe UART ldiw Z, Textaw*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall NDezwertk ;lösche füllende nullen ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden call Kommaweg call DEZ_ASC5 ;Dezimalwert spiegeln call ASC_DEZ ;ASCCII in Hex wandeln 10Byte SRAM Dezwert nach R20...R23 = 32Bit Hex -- R20=L R23=H -- Dezwert=L Dezwert+10=H ;Neuen Winkel berechnen ;erstmal auf Winkel 0-3600 begrenzen mov R16, R20 mov R17, R21 mov R18, R22 mov R19, R23 lds R20, Motb lds R21, Motb+1 clr R22 clr R23 call udiv32 ;R19(H)...R16(L) / R23(H)...R20(L) Rest in R23..R20 ;Soll - Winkel mit einer Kommastelle in R20,R21 mov R4, R20 mov R5, R21 rcall Winkeld ;Nur Berechnung nach - R6,R7 mov R20, R6 mov R21, R7 sub R20, R4 sbc R21, R5 brcs SWinkela sbi PORTC, 6 ;Richtung ldi R22, 8 ;180 Grad ldi R23, 7 sub R22, R20 ;Weg >1800 sbc R23, R21 brcc SWinkelb ;36000 - Ist + soll ldi R20, 16 ;E10 hex - 3600 winkel ldi R21, 14 sub R20, R6 ;3600 - Ist Winkel sbc R21, R7 add R20, R4 ;+Soll Winkel adc R21, R5 cbi PORTC, 6 ;Richtung rjmp SWinkelb SWinkela: cbi PORTC, 6 ;Richtung + mov R20, R4 mov R21, R5 sub R20, R6 sbc R21, R7 ldi R22, 8 ;180 Grad ldi R23, 7 sub R22, R20 ;Weg >1800 sbc R23, R21 brcc SWinkelb ;36000 - Ist + soll ldi R20, 16 ;E10 hex - 3600 winkel ldi R21, 14 sub R20, R4 ;3600 - Ist Winkel sbc R21, R5 add R20, R6 ;+Soll Winkel adc R21, R7 sbi PORTC, 6 ;Richtung SWinkelb: clr R22 ;prüfe ob 0 or R22, R20 or R22, R21 breq SWinkel0 clr R22 clr R23 lds AL, Moth ;Schritte/U durch 100 lds AH, Moth+1 clr R18 clr R19 call umul32 ; R19,R18,R17,R16 = R17,R16 * R23,R22,R21,R20 ldi R20, 36 ; /36 clr R21 clr R22 clr R23 call urdiv32 ;R19(H)...R16(L) / R23(H)...R20(L) gerundet Ganzzahl - Positionsschritte ;in R16, R17 - relative Position lds R20, ZSchritt ;Schrittweite Motor clr R21 clr R22 clr R23 ldi R24,1 add R20, R24 ;+1 adc R21, R22 call urdiv32 ;R19(H)...R16(L) / R23(H)...R20(L) gerundet Ganzzahl - Mororschritte in R16 .. R19 mov R20, R16 mov R21, R17 mov R22, R18 mov R23, R19 ;Setze Status ldi AL, 0b10000000 sts Status, AL ;Motor soll laufen, bis R20..R23=0 sind SWinkelw: lds AL, Status ;Warte solange sbrc AL, 7 rjmp SWinkelw SWinkel0: rcall Winkel rcall DaE ;laufe bis zum nächsten LF ret ;--------------------- Winkel: ;Berechnung des Winlels von Position IST und Ausgabe USART ldiw Z, Textw*2 ;Winkel Textausgabe rcall USART_Transmitf rcall Winkeld ;Nur Berechnung nach - R6,R7 ;Winkel4: call hex_dez ;32 Bit Hex zu dezimal R20...R23 = 32Bit Hex nach 10Byte SRAM Dezwert -- R20=L R23=H -- Dezwert=L Dezwert+10=H call VDezwert ;Komma einsetzen ldiw Z, Dezwert rcall USART_Transmits ;ausgabe Winkel ldiw Z, Textwa*2 ;Grad CR rcall USART_Transmitf ldiw Z, Textu*2 ;Umdrehungen rcall USART_Transmitf mov R20, R0 mov R21, R1 mov R22, R2 mov R23, R3 call hex_dez ldiw Z, Dezwert rcall USART_Transmits ;ausgabe Umdrehungen ldiw Z, Textcr*2 ;CR rcall USART_Transmitf ldiw Z, Textcr*2 ;CR rcall USART_Transmitf ret ;------- Winkeld: ;errechnet den Winkel derzeitige Position nach R6(L),R7(H) sbrs R15, 7 rjmp Winkel1 ;negative Werte mov R16, R12 ;Position IST nach R19...R16 mov R17, R13 mov R18, R14 mov R19, R15 rjmp Winkel2 Winkel1: clr R16 ;neg. in pos. wandeln clr R17 clr R18 clr R19 sub R16, R12 sbc R17, R13 sbc R18, R14 sbc R19, R15 Winkel2: andi R19, 0b01111111 ;Vorzeichen löschen lds R20, Motb lds R21, Motb+1 lds R22, Motb+2 clr R23 call udiv32 ;R19(H)...R16(L) / R23(H)...R20(L) Rest in R23..R20 - Position/Schritte pro Umdrehung ;R19(H)...R16(L) = Umdrehungen ;R23(H)...R20(L) = Rest für Winkelberechnung mov R0, R16 ;retten mov R1, R17 mov R2, R18 mov R3, R19 ;Winkel = 36*R20..R23/220 ldi R16, 36 ;36*R20..R23 clr R17 call umul32 ;R19,R18,R17,R16 = R17,R16 * R23,R22,R21,R20 lds R20, Moth lds R21, Moth+1 clr R22 clr R23 call urdiv32 ;R19(H)...R16(L) / R23(H)...R20(L) gerundet Ganzzahl ;Winkel mit einer Kommastelle mov R6, R16 ;Istwerte Winkel sichern mov R7, R17 sbrc R15, 7 ;beim rücwärtslauf Winkel spiegeln rjmp Winkel3 ldi R20, 0x10 ;3600 ldi R21, 0x0E clr R22 clr R23 sub R20, R16 sbc R21, R17 sbc R22, R18 sbc R23, R19 mov R6, R20 ;Istwerte Winkel sichern mov R7, R21 ret Winkel3: mov R20, R16 ;= 1/10 Grad Winkel mov R21, R17 mov R22, R18 mov R23, R19 ret ;--------------------- ;verschiebe Dezwert und füge Komma ein VDezwert: ldi AH, 8 ldiw Z, Dezwert+1 ldiw x, Dezwert VDezwert1: ld AL, z+ st x+, AL dec AH brne VDezwert1 ldi AL, 44 ;"," st x, AL sbiw x, 1 ;Stelle vor dem Komma ld AL, x cpi AL, 32 ;20 Hex Leerzeichen? brne VDezwert2 ldi AL, 48 ;30Hex =0 st x, AL VDezwert2: ret ;--------------------- ;Lösche füllende Nullen am Anfang Dezwert NDezwertk: ;bis Kommastelle ldi AH, 7 ldiw x, Dezwert rjmp NDezwert1 NDezwert: ldi AH, 9 ldiw x, Dezwert NDezwert1: ld AL, x cpi AL, 48 ;0x30 "0" 46= Punkt brne NDezwertx ldi AL, 32 ;32=Leerzeichen, st x+, AL dec AH brne NDezwert1 NDezwertx: ret ;------------------------------------------------------------ TAP: ;Tasten Auswertung für Programm aus EEPROM in R18, PINA com R18 ;invertieren andi R18, 0b00111110 ;Tasten filtern brne TAP1 ;Taste gedrückt? sts MEprom, R18 ;keine Taste gedrückt speichern ret TAP1: lds AH, MEprom ;wurde ein Programm aufgerufen? tst AH breq TAP2 ret ;warte, bis keine Taste gedrückt ist TAP2: ldiw Z, TextT*2 ;Anfang Pufferspeicher - Daten aus EEPROM Speicher Nr. - rcall USART_Transmitf ;Text aus Programmspeicher --> senden sts MEprom, R18 ;Taste gedrückt speichern mov AL, R18 sbrc AL, 1 rjmp TAP3 sbrc AL, 2 rjmp TAP4 sbrc AL, 3 rjmp TAP5 sbrc AL, 4 rjmp TAP6 sbrc AL, 5 rjmp TAP7 ret TAP3: ;Taste Programm Nr.0 ldi AL, 48 ;Ausgabe 0 = 0x30 rcall USART_Transmit ;Text aus Programmspeicher --> senden ldiw Z, Textcr*2 ;Anfang Pufferspeicher - CR - rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldi AL, 0 rcall EEDL ret TAP4: ;Taste Programm Nr.1 ldi AL, 49 ;Ausgabe 1 = 0x31 rcall USART_Transmit ;Text aus Programmspeicher --> senden ldiw Z, Textcr*2 ;Anfang Pufferspeicher - CR - rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldi AL, 1 rcall EEDL ret TAP5: ;Taste Programm Nr.2 ldi AL, 50 ;Ausgabe 2 = 0x32 rcall USART_Transmit ;Text aus Programmspeicher --> senden ldiw Z, Textcr*2 ;Anfang Pufferspeicher - CR - rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldi AL, 2 rcall EEDL ret TAP6: ;Taste Programm Nr.3 ldi AL, 51 ;Ausgabe 3 = 0x33 rcall USART_Transmit ;Text aus Programmspeicher --> senden ldiw Z, Textcr*2 ;Anfang Pufferspeicher - CR - rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldi AL, 3 rcall EEDL ret TAP7: ;Taste Programm Nr.4 ldi AL, 52 ;Ausgabe 4 = 0x34 rcall USART_Transmit ;Text aus Programmspeicher --> senden ldiw Z, Textcr*2 ;Anfang Pufferspeicher - CR - rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldi AL, 4 rcall EEDL ret ;---------------------------------------------------------------------------------------------------------------------------------------------------- Reset: rcall Init sei Anfang: ;Hauptprogramm lds AH, Status ;lese Status Byte rcall ADCAuswertung rcall Tastenabfrage rcall SerAbfrage rcall TAP ;Tasten Auswertung für Programm aus EEPROM rjmp Anfang USARTAbfrage: rcall SerAbfrage Tastenabfrage: lds AH, Status ;lese Status Byte in AL, PINA sbrc AL, 7 rjmp TA1 sbrs AL, 6 ;sind beide Tasten gedrückt? rjmp MA sbrs AH, 2 rcall GW1 ;Nach dem Schalten erstmal Werte setzen ori AH, 0b00000101 ;Motor durch Timer 1 drehen sts Status, AH ;speichern rcall GS ret MA: ;ADC Anzahl der zu addierenden Messingen für Strecke lds R18, ADl ;lese ADC lds R19, ADh ror R19 ;nur 8 Bit in AL ror R18 ror R19 ror R18 sts ADs, R18 TA1: sbrc AL, 6 ;2.Taste abfragen rjmp TA2 sbrs AH, 3 rcall GW2 ;Nach dem Schalten erstmal Werte setzen ori AH, 0b00001001 ;Motor durch Timer 1 drehen sts Status, AH ;speichern rcall DP ;Berechne neue Soll- Position rcall PV ;Positionsvergleich - Setze Richtung und Schritt ret TA2: tst AH ;Textausgabe nur nach Tasten breq TAx rcall Text1 ;Ausgabe Position rcall Winkel ;Ausgabe Umdrehungen und Winkel TAx: ldi AH, 0 ;keine Taste gedrückt = Status 0 sts Status, AH ;speichern ret ;--------------------------------------------------- Durchlauf: ;Widerhole alle Befehle vom Anfang Pufferspeicher bis Befehl "Durchläufe" lds AL, Uel ;wurde der Pufferanfang überschrieben? tst AL ;Z? brne Durchlaufue lds AL, Lurchl ;Wiederholungszähler auf 0? lds AH, Lurchl+1 lds R18, Lurchl+2 lds R19, Lurchl+3 subi AL, 1 ;-1 sbci AH, 0 sbci R18, 0 sbci R19, 0 brcc Durchlaufb ;>0 rcall Zeingabe ;Eingabe Zahlen über UART ldiw Z, Textd*2 ;Anfang Pufferspeicher - Durchläufe - rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall NDezwert ;lösche füllende nullen ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden call DEZ_ASC5 ;Dezimalwert spiegeln call ASC_DEZ ;ASCCII in Hex wandeln 10Byte SRAM Dezwert nach R20...R23 = 32Bit Hex -- R20=L R23=H -- Dezwert=L Dezwert+10=H sts Lurchl, R20 sts Lurchl+1, R21 sts Lurchl+2, R22 sts Lurchl+3, R23 ldi AL, 2 ;Pufferanfang auf 0200 Hex sts SerZ, AL ldi AL, 0 sts SerZ+1, AL lds R27, SerP lds R26, SerP+1 clr AH st x, AH ;lösche kommendes Zeichen rjmp Durchlaufc Durchlaufa: ;fertig ldiw Z, Textd*2 ;Anfang Pufferspeicher - Durchläufe - rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldiw Z, Textcr*2 ;CR rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall DaE ;laufe bis zum nächsten LF ret Durchlaufue: ;Abbruch wegen Überschreiben Datenanfang ldiw Z, Textue*2 ;Anfang Pufferspeicher - keine weiteren Wiederholungen - rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall DaE ;laufe bis zum nächsten LF ret Durchlaufb: ;Wiederholungszähler war >0 mov R20, AL mov R21, AH mov R22, R18 mov R23, R19 sts Lurchl, AL sts Lurchl+1, AH sts Lurchl+2, R18 sts Lurchl+3, R19 or AL, AH ;Prüfe ob 0 or AL, R18 or AL, R19 breq Durchlaufx ;keine weiteren Durchläufe lds AL, ZX cpi AL, 120 ;"x" unterbrechung abfragen breq Abbr ldiw Z, Textd2*2 ;Anfang Pufferspeicher - noch - rcall USART_Transmitf ;Text aus Programmspeicher --> senden Durchlaufc: ;Hex_dez: ;32 Bit Hex zu dezimal R20...R23 = 32Bit Hex nach 10Byte SRAM Dezwert -- R20=L R23=H -- Dezwert=L Dezwert+10=H call Hex_dez rcall NDezwert ;lösche füllende nullen ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textd*2 ;Anfang Pufferspeicher - Wiederholungen - rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldi AL, 2 ;Pufferanfang auf 0200 Hex sts SerZ, AL ldi AL, 0 sts SerZ+1, AL ret Durchlaufx: ldiw Z, Textd1*2 ;Anfang Pufferspeicher - keine weiteren Wiederholungen - rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden clr AH st y, AH ;lösche kommendes Zeichen rcall DaE ;laufe bis zum nächsten LF ret Abbr: ;Abbruch durch "x" clr AL sts ZX, AL ;Lösche Flag "x" sts Lurchl, AL sts Lurchl+1, AL sts Lurchl+2, AL sts Lurchl+3, AL ldiw Z, Textx*2 ;Anfang Pufferspeicher - keine weiteren Wiederholungen - rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall DaE ;laufe bis zum nächsten LF ret ;--------------------------------------------------- Geschw: rcall Zeingabe ;Eingabe Zahlen über UART ldiw Z, Textg*2 ;Anfang Pufferspeicher - Geschwindigkeit - rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall NDezwert ;lösche füllende nullen ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden call DEZ_ASC5 ;Dezimalwert spiegeln call ASC_DEZ ;ASCCII in Hex wandeln 10Byte SRAM Dezwert nach R20...R23 = 32Bit Hex -- R20=L R23=H -- Dezwert=L Dezwert+10=H mov AL, R20 or AL, R21 or AL, R22 or AL, R23 breq Geschwi or R22, R23 ;gültig? brne Geschw1 neg R20 com R21 sts OCR1AH, R21 ;Mode 4 - Zeitgeber sts OCR1AL, R20 rjmp Geschwx rcall NDezwert ;lösche füllende nullen ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden Geschwi: ;Geschwindigkeit anzeigen ldiw Z, Textgi*2 ;Anfang Pufferspeicher - Geschwindigkeit - rcall USART_Transmitf ;Text aus Programmspeicher --> senden lds R21, OCR1AH lds R20, OCR1AL com R20 ;One’s Complement com R21 clr R22 clr R23 ldi AL, 1 add R20, AL clr AL adc R21, AL adc R22, AL adc R23, AL ;Hex_dez: ;32 Bit Hex zu dezimal R20...R23 = 32Bit Hex nach 10Byte SRAM Dezwert -- R20=L R23=H -- Dezwert=L Dezwert+10=H call Hex_dez rcall NDezwert ;lösche füllende nullen ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rjmp Geschwx Geschw1: ldiw Z, Textgu*2 ;Anfang Pufferspeicher - Geschwindigkeit zu niedrig - rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden Geschwx: rcall DaE ;laufe bis zum nächsten LF ret ;--------------------------------------------------- Vta: ;Vorteiler Taktgrber rcall Zeingabe ;Eingabe Zahlen über UART ;Ausgabe UART ldiw Z, Textv*2 ;Anfang Pufferspeicher - Vorteiler - rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall NDezwert ;lösche füllende nullen ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden call DEZ_ASC5 ;Dezimalwert spiegeln call ASC_DEZ ;ASCCII in Hex wandeln 10Byte SRAM Dezwert nach R20...R23 = 32Bit Hex -- R20=L R23=H -- Dezwert=L Dezwert+10=H Vtb: cpi R20, 1 breq Vt1 cpi R20, 2 breq Vt2 cpi R20, 3 breq Vt3 cpi R20, 4 breq Vt4 cpi R20, 5 breq Vt5 ;ungültige Zahl ldiw Z, Textv6*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden lds AL, TCCR1B andi AL,0b00000111 mov R20, AL ldi AH, 48 add AL, AH ;Hex - Ascii rcall USART_Transmit ;USART_Transmit: nur AL senden ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rjmp Vtb ;--------------------------------------------------- Vt1: ;Kein Vorteiler ldiw Z, Textv1*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rjmp Vtw Vt2: ;/8 ldiw Z, Textv2*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rjmp Vtw Vt3: ;/64 ldiw Z, Textv3*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rjmp Vtw Vt4: ;/256 ldiw Z, Textv4*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rjmp Vtw Vt5: ;/1024 ldiw Z, Textv5*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden Vtw: lds AL, TCCR1B andi AL, 0b11111000 ;CS12..CS10 auf 0 andi R20, 0b00000111 or AL, R20 sts TCCR1B, AL rcall DaE ;laufe bis zum nächsten LF ret ;--------------------------------------------------- Zeit: ;Warte, bis Zeit abgelaufen ist - mit "x" abbrechen rcall Zeingabe ;Eingabe Zahlen über UART ;Ausgabe UART ldiw Z, Textz*2 ;Anfang Pufferspeicher - Zeit - rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall NDezwert ;lösche füllende nullen ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden call DEZ_ASC5 ;Dezimalwert spiegeln call ASC_DEZ ;ASCCII in Hex wandeln 10Byte SRAM Dezwert nach R20...R23 = 32Bit Hex -- R20=L R23=H -- Dezwert=L Dezwert+10=H ldi AL, 0b00100000 ;Marke für Timer setzen sts Status, AL ;speichern clr AL sts ZX, AL ;Lösche Flag "x" Zeit1: ;warte bis Status durch Timer auf 0 gesetzt wird oder ESC gesendet wird lds AL, ZX cpi AL, 120 ;"x" unterbrechung abfragen breq Zeitx lds AL, Status tst AL brne Zeit1 Zeit2: ldiw Z, Textzb*2 ;Anfang Pufferspeicher - Wartezeit beendet - rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall DaE ;laufe bis zum nächsten LF ret Zeitx: ldi R20, 1 clr R21 clr R22 clr R23 ldiw Z, Textzx*2 ;Anfang Pufferspeicher - Abbruch - rcall USART_Transmitf ;Text aus Programmspeicher --> senden rjmp Zeit2 ;----------------------- Betr: ;Ändere Betriebsart Motor rcall Zeingabe ;Eingabe Zahlen über UART ;Ausgabe UART ldiw Z, Textb*2 ;Anfang Pufferspeicher - Vorteiler - rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall NDezwert ;lösche füllende nullen ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden call DEZ_ASC5 ;Dezimalwert spiegeln call ASC_DEZ ;ASCCII in Hex wandeln 10Byte SRAM Dezwert nach R20...R23 = 32Bit Hex -- R20=L R23=H -- Dezwert=L Dezwert+10=H cpi R20, 0 breq Btri cpi R20, 1 breq Btr1 cpi R20, 2 breq Btr2 cpi R20, 3 breq Btr3 cpi R20, 4 breq Btr4 ldiw Z, Textmx*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall DaE ;laufe bis zum nächsten LF ret Btr1: ldiw Z, Textm1*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall BMot1 rjmp Btrx Btr2: ldiw Z, Textm2*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall BMot2 rjmp Btrx Btr3: ldiw Z, Textm3*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall BMot3 rjmp Btrx Btr4: ldiw Z, Textm4*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall BMot4 Btrx: ;verlassen ldi AL, 0b10000000 clr R8 ;soll ist auf 0 clr R9 clr R10 mov R11, AL clr R12 clr R13 clr R14 mov R15, AL Btr0: rcall DaE ;laufe bis zum nächsten LF ret Btri: ;Info lds AL, Bmot cpi AL,1 brne Btri2 ldiw Z, Textm1*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rjmp Btr0 Btri2: cpi AL,2 brne Btri3 ldiw Z, Textm2*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rjmp Btr0 Btri3: cpi AL,3 brne Btri4 ldiw Z, Textm3*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rjmp Btr0 Btri4: ldiw Z, Textm4*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rjmp Btr0 ;----------------------- Zeingabe: ;Eingabe Zahlen über UART ldi AH, 10 ldi R18, 48 ;=0 ldiw z, Dezwert Zein1: ;lösche Dezwert st z+, R18 dec AH brne Zein1 Zein2: ld AL, x+ ;nächstes Zeichen lesen sbrc R27, 6 ;Skip if Bit in Register Cleared ist 0x40 erreicht? ldi R27, 2 ;dann X= 0x200 sts SerZ+1, R26 ;Anfang Daten neu setzen sts SerZ, R27 lds R28, SerP+1 ;letztes Zeichen lds R29, SerP cp R26, R28 ;Ende Zeichenpuffer erreicht? cpc R27, R29 breq Zeinz cpi AL, 32 ;0x20 Leertaste breq Zein2 cpi AL, 58 ;>0x39 ist es eine Zahl > 9 ? brcc Zeinz ; cpi AL, 48 ;<0x30 brcs Zeinz rcall Posv ;;verschiebe Dezwert nach links und füge rechts AL ein rjmp Zein2 ;nächstes Zeichen Zeinz: ret ;----------------------- Zeingabek: ;Eingabe Zahlen über UART pushw z ;Anfang Daten retten - darf für Anweisund "D" nicht geändert werden ldi AH, 10 ldi R18, 48 ;=0 ldiw z, Dezwert Zeink1: ;lösche Dezwert st z+, R18 dec AH brne Zeink1 Zeink2: ld AL, x+ ;nächstes Zeichen lesen sbrc R27, 6 ;Skip if Bit in Register Cleared ist 0x40 erreicht? ldi R27, 2 ;dann X= 0x200 sts SerZ+1, R26 ;Anfang Daten neu setzen sts SerZ, R27 lds R28, SerP+1 ;letztes Zeichen lds R29, SerP cp R26, R28 ;Ende Zeichenpuffer erreicht? cpc R27, R29 breq Zeinkz cpi AL, 32 ;0x20 Leertaste breq Zeink2 cpi AL, 44 ;>0x2c ist es ein Komma ? breq Zeink ; cpi AL, 58 ;>0x39 ist es eine Zahl > 9 ? brcc Zeinkz ; cpi AL, 48 ;<0x30 brcs Zeinkz3 rcall Posv ;verschiebe Dezwert nach links und füge rechts AL ein rjmp Zeink2 ;nächstes Zeichen Zeinkz: popw z ret Zeink: rcall Posv ;verschiebe Dezwert nach links und füge rechts AL ein ld AL, x+ ;nächstes Zeichen lesen sbrc R27, 6 ;Skip if Bit in Register Cleared ist 0x40 erreicht? ldi R27, 2 ;dann X= 0x200 cpi AL, 58 ;>0x39 ist es eine Zahl > 9 ? brcc Zeinkz2 ; cpi AL, 48 ;<0x30 brcs Zeinkz2 rcall Posv popw z ret Zeinkz3: ;,0 einsetzen ldi AL, 44 ;0x2c erst Komma rcall Posv Zeinkz2: ldi AL, 48 ;<0x30 "0" rcall Posv popw z ret ;--------------------------------------------------- Frage: ldiw Z, Texta*2 ;Anfang Pufferspeicher "Position auf 0 gesetzt" rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall Posd rcall Winkel ret ;--------------------------------------------------- Anf0: ;Setze Position auf 0 clr R12 clr R13 clr R14 ldi AL, 0x80 ;+0 mov R15, AL ldiw Z, Textn*2 ;Anfang Pufferspeicher "Position auf 0 gesetzt" rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall PSa ;Pufferspeicher auf Anfang setzen rcall Text1 clr AL sts Uel, AL ;Merker für Überschreiben Datenanfang auf 0 sts LZ, AL ;Letztes LF löschen sts Lurchl, AL ;Anzahl der Durchläufe =0 sts Lurchl+1, AL sts Lurchl+2, AL sts Lurchl+3, AL ret ;--------------------------------------------------- ;rel Sprung zu weit entfernt Vt: ;Vorteiler Taktgrber jmp Vta Bet: ;Motor Betriebsart jmp Betr SWink: jmp SWinkel ;laufe auf Winkel SZeit: jmp Zeit SGeschw: jmp Geschw Position: jmp Posit DuL: jmp Durchlauf Anfa: jmp Anf0 Frag: jmp Frage EPS: jmp EEPROMS EPL: jmp EEPROML ;--------------------------------------------------- SerAbfrage: lds AL, LZ ;Ist ein Datensatz vorhanden? cpi AL, 10 breq SerAbfrage1 ret SerAbfrage1: rcall Speicher lds R26, SerZ+1 ;Anfang Daten lds R27, SerZ lds R28, SerP+1 ;letztes Zeichen lds R29, SerP sbiw Y, 1 SerAbfrage2: ld AL, x+ sbrc R27, 6 ;Skip if Bit in Register Cleared ist 0x40 erreicht? ldi R27, 2 ;dann X= 0x200 cpi AL, 63 ;Suche nach 0x3f "?" breq Frag ;Fragezeichen andi AL, 0b11011111 ;Umwandeln in Großbuchstaben cpi AL, 86 ;Suche nach 0x56 "V" breq Vt ;Vorteiler Taktgeber cpi AL, 80 ;Suche nach 0x50 "P" breq Position ;Position cpi AL, 83 ;Suche nach 0x53 "S" breq SWeite ;Schrittweite cpi AL, 65 ;Suche nach 0x41 "A" breq Anfa ;Anfang cpi AL, 66 ;Suche nach 0x42 "B" breq Bet ;Betrieb Motor cpi AL, 87 ;Suche nach 0x57 "W" breq SWink ;laufe auf Winkel cpi AL, 90 ;Suche nach 0x5A "Z" breq SZeit ;laufe auf Zeit cpi AL, 71 ;Suche nach 0x47 "G" breq SGeschw ;laufe auf Geschwindigkeit cpi AL, 68 ;Suche nach 0x44 "D" breq DuL ;laufe auf Durchlaufe cpi AL, 69 ;Suche nach 0x45 "E" breq EPS ;laufe auf EEPROM Schreiben cpi AL, 76 ;Suche nach 0x4C "L" breq EPL ;laufe auf EEPROM lesen rcall USART_Transmit ;AL ausgeben ldiw Z, Textnb*2 ;Anweisung nicht bekannt rcall USART_Transmitf ;Text aus Programmspeicher --> senden sts SerZ+1, R26 ;Anfang Daten neu setzen sts SerZ, R27 rcall DaE ;springe zum nächsten LF ret ;--------------------------------------------------- SWeite: rcall Zeingabe ;Zahleneingabe seriel Schrwx: ;Zahlenfolge abgeschlossen ;Ausgabe UART ldiw Z, Texts*2 ;Anfang Pufferspeicher - Schrittweite - rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall NDezwert ;Lösche füllende Nullen am Anfang Dezwert ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden call DEZ_ASC5 ;Dezimalwert spiegeln call ASC_DEZ ;ASCCII in Hex wandeln 10Byte SRAM Dezwert nach R20...R23 = 32Bit Hex -- R20=L R23=H -- Dezwert=L Dezwert+10=H or R22, R20 ;R21 bis R23 =0? or R22, R21 or R22, R23 breq Schrw1 subi R20, 1 ;-1 sbci R21, 0 tst R21 ;0? brne Schrw1 sts ZSchritt, R20 ;Schrittweite speichern rcall DaE ;laufe bis zum nächsten LF ret Schrw1: ldiw Z, Texts1*2 ;Anfang Pufferspeicher - Schrittweite - rcall USART_Transmitf ;Text aus Programmspeicher --> senden lds R20, ZSchritt ;lese aktuelle Schrittweite clr R21 clr R22 clr R23 ldi AL, 1 add R20, AL ;+1 adc R21, R23 ;+C call hex_dez ;32 Bit Hex zu dezimal R20...R23 = 32Bit Hex nach 10Byte SRAM Dezwert -- R20=L R23=H -- Dezwert=L Dezwert+10=H ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall DaE ;laufe bis zum nächsten LF ret ;-------------------------------------------------- Posit: ;Laufe auf Position ;in AL "P" clr AL sts PM, AL ldi AH, 10 ldi R18, 48 ;=0 ldiw y, Dezwert Positl: ;lösche Dezwert st y+, R18 dec AH brne Positl Positl1: ld AL, x+ ;prüfe "U", "D", "A" cpi AL, 43 ;2B "+" breq Posit1 cpi AL, 45 ;2D "-" breq Positm cpi AL, 32 ;20 "leerzeichen" SP breq Positl1 mov AH, AL ;prüfe, ob Ziffern subi AH, 48 brcs Positla cpi AH, 10 brcc Positla rjmp Positk Positla: andi AL, 0b11011111 ;Umwandeln in Großbuchstaben cpi AL, 68 ;0c44 =D breq Positv cpi AL, 85 ;0c55 =U breq Positv cpi AL, 65 ;0c41 =A breq Positv rjmp Positk Positv: ld AL, x+ ;x+1 sbrc R27, 6 ;Skip if Bit in Register Cleared ist 0x40 erreicht? ldi R27, 2 ;dann X= 0x200 Positk: cpi AL, 43 ;+ Zeichen breq Posit1 cpi AL, 45 ;- Zeichen breq Positm rjmp Posit2 ;kein Minuszeichen Positm: ldi AL, 1 ;Marke für minus sts PM, AL Posit1: ld AL, x+ ;nächstes Zeichen lesen sbrc R27, 6 ;Skip if Bit in Register Cleared ist 0x40 erreicht? ldi R27, 2 ;dann X= 0x200 Posit2: sts SerZ+1, R26 ;Anfang Daten neu setzen sts SerZ, R27 cp R26, R28 ;Ende Zeichenpuffer erreicht? cpc R27, R29 breq Positx cpi AL, 32 ;0x20 Leertaste breq Posit1 Posit1a: ;jetzt keine Leerzeichen mehr ignorieren cpi AL, 58 ;>0x39 ist es eine Zahl > 9 ? brcc Positx ; cpi AL, 48 ;<0x30 brcs Positx rcall Posv ;verschiebe Dezwert nach links und füge rechts AL ein ld AL, x+ ;nächstes Zeichen lesen sbrc R27, 6 ;Skip if Bit in Register Cleared ist 0x40 erreicht? ldi R27, 2 ;dann X= 0x200 sts SerZ+1, R26 ;Anfang Daten neu setzen sts SerZ, R27 cp R26, R28 ;Ende Zeichenpuffer erreicht? cpc R27, R29 breq Positx rjmp Posit1a ;nächstes Zeichen Positx: ;Zahlenfolge abgeschlossen ;Ausgabe UART ldiw Z, Textps*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldi AL, 43 ;"+" lds AH, PM sbrc AH, 0 ldi AL, 45 ;"-" rcall USART_Transmit ;USART_Transmit: nur AL senden rcall NDezwert ldiw z, Dezwert rcall USART_Transmits ;USART_Transmits: Text aus SRAM ausgeben - Z zeigt auf Anfang -Ausgabe bis "0x00" ldiw Z, Textcr*2 ;Anfang Pufferspeicher rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall DEZ_ASC5 ;Dezimalwert spiegeln rcall ASC_DEZ ;ASCCII in Hex wandeln 10Byte SRAM Dezwert nach R20...R23 = 32Bit Hex -- R20=L R23=H -- Dezwert=L Dezwert+10=H clr AL lds AH, PM sbrc AH, 0 rjmp PosR ;minusbereich clr AH ori R23, 0b10000000 ;pos. Wert sub R20, R12 ;errechne Dif. zu ist sbc R21, R13 sbc R22, R14 sbc R23, R15 Posm: rol AL ;C nach Bit0 or AH, R20 or AH, R21 or AH, R22 or AH, R23 breq Posd ;springe, wenn 0 cbi PORTC, 6 ;Richtung lds AH, PM cpse AL, AH ;AL = +-diff, R15 = +- sbi PORTC, 6 ;Richtung sbrc AL, 0 rcall PNt ;negiere Wert rcall Poss ;Errechne die INT Durchläufe ;Motor soll Schritte abarbeiten mov AL, R20 ;Teste, ob 0 or AL, R21 or AL, R22 or AL, R21 breq Posd ldi AL, 0b10000000 ;Motor an, bie R20...R23 =0 sts Status, AL Posw: ;warte, bis in der INT MotorTakt R20-R23 auf 0 gezählt sind lds AL, Status sbrc AL,7 rjmp Posw ;Lese neue Daten bis CR oder Ende Puffer Posd: rcall DaE ;laufe bis zum nächsten LF rcall Text1 ret Posc: ;noch ein LF gefunden sts SerZ+1, R26 ;Anfang Daten neu setzen sts SerZ, R27 clr AL sts LZ, AL ;Letztes LF löschen rcall Text1 ret ;---------------------------------- Text1: ldiw Z, Textp*2 ;aktuelle Position: rcall USART_Transmitf rcall IstPos_dez ;Wandle Ist-Position nach dezimal ldiw Z, Dezwert rcall USART_Transmits ;ausgabe Position ldiw Z, Textcr*2 ;aktuelle Position: rcall USART_Transmitf ret ;---------------------------------- DaE: ;laufe bis zum nächsten LF lds R26, SerZ+1 ;Anfang Daten neu laden lds R27, SerZ lds R28, SerP+1 ;Ende Daten lds R29, SerP DaE2: ld AL, x+ ;x+1 sbrc R27, 6 ;Skip if Bit in Register Cleared ist 0x40 erreicht? ldi R27, 2 ;dann X= 0x200 cp R26, R28 ;Ende erreicht? cpc R27, R29 breq DaE1 cpi AL, 10 ;0x0A LF breq DaE1 rjmp DaE2 DaE1: ;noch ein LF gefunden sts SerZ+1, R26 ;Anfang Daten neu setzen sts SerZ, R27 sub R28, R26 sbc R29, R27 breq DaE3 ret DaE3: clr AL sts LZ, AL ;Letztes LF löschen ret ;---------------------------------- PosR: ;- Aktuelle Position - auf Position clr R16 clr R17 clr R18 ldi R19, 0x80 sub R16, R20 sbc R17, R21 sbc R18, R22 sbc R19, R23 mov R20, R12 mov R21, R13 mov R22, R14 mov R23, R15 sub R20, R16 sbc R21, R17 sbc R22, R18 sbc R23, R19 rjmp Posm ;---------------------------------- Poss: ;errechne die Durchgänge von - INT MotorTakt: mov R16, R20 mov R17, R21 mov R18, R22 mov R19, R23 clr R21 clr R22 ldi R23, 1 lds R20, ZSchritt ;Schrittweite+1 add R20, R23 adc R21, R22 clr R23 rcall urdiv32 ;urdiv32: ;32 Bit / 32 Bit ; R19..R16 = R19..R16 / R23..R20 (Ganzzahldivision) R19(H)...R16(L) / R23(H)...R20(L) gerundet Ganzzahl mov R20, R16 mov R21, R17 mov R22, R18 mov R23, R19 ret ;---------------------------------- Poscr: ld AL, x+ ;nächstes Zeichen lesen cpi AL, 13 ;CR 0D Hex brne Poscr sts SerZ+1 ,R26 ;Anfang Daten sts SerZ ,R27 rjmp SerAbfrage1 PSchleife: rcall PV ;Positionsbvergleich lds AH, Status ;lese Status Byte sub R12, R8 PNt: ;pos. in neg. oder neg. in pos. wandeln clr R16 clr R17 clr R18 clr R19 sub R16, R20 sbc R17, R21 sbc R18, R22 sbc R19, R23 mov R20, R16 mov R21, R17 mov R22, R18 mov R23, R19 ret ;--------------------------------- Posv: ;verschiebe Dezwert nach links und füge rechts AL ein ldi AH, 9 ldiw Z, Dezwert+1 ldiw y, Dezwert Posv1: ld R18, z+ st y+, R18 dec AH brne Posv1 st y, AL ret ;--------------------------------------------------- Speicher: ;ist der pufferspeicher leer? cli ;für die Berechnung int sperren lds R26, SerZ+1 ;Anfang Daten lds R27, SerZ lds AL, SerP ;Ende Daten lds AH, SerP+1 sub AH, R26 sbc AL, R27 brcc Speicher1 lds R18, SerP lds R19, SerP+1 subi R18, 2 ldi AL, 0x40 ldi AH, 0 sub AH, R26 ;Platz bis Speicherende sbc AL, R27 add AH, R19 adc AL, R18 or R20, AH or R20, AL tst R20 brne Speicher1 ldi R20, 3 sts PL, R20 Speicher1: ;in AL, AH steht die Grösse der Belegung des Pufferspeichrs sts PG, AL ;speichere belegten Pufferspeicher sts PG+1, AH Speicher2: cpi AL, 0x1d ;0x1d 0x04 brcc Speicher3 ldi R18, 0x1d ;halber Speicher sts ZZ, R18 sbis PORTC, 7 ;Sprung, wenn 1 rjmp PC+2 cbi PORTC, 7 ;Neue Daten können kommen Speicher3: Speicher4: subi AH, 1 sbci AL,0 brcs Speicherx ;Speicherende erreicht ld R18, x+ sbrc R27, 6 ;Skip if Bit in Register Cleared ist 0x40 erreicht? ldi R27, 2 ;dann X= 0x200 cpi R18, 10 ;0x0a "LF" brne Speicher4 sts ZLF, R18 sts SerP2, R27 ;letztes "LF" sts SerP2+1, R26 lds R18, SerP ;Ende Daten lds R19, SerP+1 lds R20, PU andi R20, 2 ;Byte 0=0 Byte 1 nicht verändern wird in UARTlesen: zurückgesetzt sub R26, R19 ;ist letztes "LF" und Datenende gleich? sbc R27, R18 brne Speicher5 ldi R20, 3 Speicher5: sts Pu, R20 lds R26, SerZ+1 ;Anfang Daten lds R27, SerZ Speicherx: sei ;int freigeben ret ;--------------------------------------------------- DP: ;Setze SOLL-Wert Position +- mit Poti * DPw(Multiplikator) clr R22 ;für Übertrag lds AL, ADRD+2 ;24 Bit Zwischen Anfangswert lds AH, ADRD+1 lds R18, ADRD lds R19, ADw+2 ;24 Bit werte vom ADC holen lds R20, ADw+1 lds R21,ADw sub R19, AL ;Low Wert sbc R20, AH sbc R21, R18 ;High Wert sbci R22, 0 lds R8, RPOS ;Position beim Tastendruck lds R9, RPOS+1 lds R10, RPOS+2 lds R11, RPOS+3 add R8, R19 ;+- Änderung = soll adc R9, R20 adc R10, R21 adc R11, R22 ret ;--------------------------------------------------- GS: ;Schrittgeber Motorgeschwindigkeit mit dem Poti lds AL, ADw2+2 ;16 Bit werte vom ADC lds AH, ADw2+1 lds R18, ADRG+1 ;ADRG - ADC Wert bei Schalterbetätigung Geschwindigkeit lds R19, ADRG sub AL, R18 ;relativer Wert berechnen sbc AH, R19 brcs GS1 ;Drehrichtung setzen cbi PORTC,6 ;links herum rjmp GS2 GS1: ;prüfe, sbi PORTC,6 ;rechts herum com AL ;One’s Complement com AH ;hohe Spannung --> kleiner OCR- Wert also schneller GS2: ldi R19, 0 ;Prüfe, ob Wert sehr klein ldi R18, 128 cp AL, R18 ;wenn AL,AH kleiner R18, R19 --> C cpc AH, R19 brcc GS4 lds R18, Status ;lese Status Bit andi R18, 0b11111101;Bit zurücksetzen - Wert zu klein, Motor stoppen sts Status, R18 ;speichern ret GS4: lds R18, Status ;lese Status Bit ori R18, 0b00000010 ;Bit setzen Motor soll laufen sts Status, R18 ;speichern ori AL, 0b00111111 ;läuft ruhiger com AL ;One’s Complement com AH sts OCR1AH, AH ;Mode 4 - Zeitgeber sts OCR1AL, AL ret ;--------------------- GW1: ;AD-Werte für die rel. Werte sichern lds AL, ADw2+2 ;16 Bit werte vom ADC sts ADRG+1 ,AL ;ADRG - ADC Wert bei Schalterbetätigung Geschwindigkeit lds AL, ADw2+1 sts ADRG ,AL ret GW2: ;AD-Werte für die rel. Rerte sichern lds AL, ADw+2 ;24 Bit werte vom ADC sts ADRD+2 ,AL ;ADRG - ADC Wert bei Schalterbetätigung Distanz lds AL, ADw+1 sts ADRD+1 ,AL lds AL, ADw sts ADRD ,AL sts RPOS, R12 ;Sichere die derzeitige absolute Position sts RPOS+1, R13 sts RPOS+2, R14 sts RPOS+3, R15 ret ;--------------------- ;PORTA, 7 ;Schrittgeber Geschwindigkeit - 16 Bit Counter 1 Mode 4 einschalten sbic PINA, 7 ; offen = 1 rjmp An1 lds AL, ADw2+1 ;16 Bit werte vom ADC holen lds AH, ADw2 com AL ;One’s Complement com AH sts OCR1AH, AH ;Mode 4 - Zeitgeber sts OCR1AL, AL ldi AL, (0< senden sts SerP, R27 ;Zähler Datenende sts SerP+1, R26 ret EEDL2: ;Datenende erkannt sts SerP, R27 ;Zähler Datenende sts SerP+1, R26 st x+, AL ldiw Z, Texteg*2 ;Daten aus EPROM gelesen rcall USART_Transmitf ;Text aus Programmspeicher --> senden ldi AL, 2 sts SerZ, AL ;Zähler Datenanfang 0x0200 clr AL sts SerZ+1, AL ldi AL, 10 ;"LF" 0x0A Zeilenvorschub sts LZ, AL ;zum automatischen starten ret EEDL3: ldiw Z, Texte0*2 ;EPROM Bereich ist leer rcall USART_Transmitf ;Text aus Programmspeicher --> senden rcall DaE ;laufe bis zum nächsten LF ret ;---------------------------------------------------------------------------------------------------------- ; *** EEPROM lesen und schreiben *** ; reprom = Read EEPROM areg(R17,R18)=Adresse Rückgabe R16 <= Inhalt reprom: cli ;glob INT ausschalten sbic EECR, EEPE rjmp reprom out EEARH, r17 ; Adressregister <= Adresse out EEARL, r18 ; Adressregister <= Adresse sbi EECR, EERE ; Lesebit setzen in r16, EEDR ; R16 <= Inhalt sei ;glob INT einschalten ret ; weprom = Write EEPROM areg(R17,R18)=Adresse R16=Inhalt keine Rückgabe weprom: cli ;glob INT ausschalten weprom1: sbic EECR, EEPE ; warte bis EEWE=0 schreibbereit rjmp weprom1 out EEARH, r17 ; Adressregister <= Adresse out EEARL, r18 ; Adressregister <= Adresse out EEDR, r16 ; Datenregister <= Inhalt sbi EECR,EEMPE sbi EECR,EEPE weprom2: ; sbic EECR, EEPE ; warte bis EEWE=0 fertig ; rjmp weprom2 sei ;glob INT einschalten ret ;---------------------------------------------------------------------------------------------------------- ;-------- ; 2 Phasen Motor !!! ;Motoransteuerung: Z zeigt auf den aktuelle Schritt (MPa ... MPj) und in ZSchritt steht der Sprungwert (1...255) ;-------- ;Betriebsart ;Halbschritt Ansteuerung 4 Blöcke rechtsdrehend ; A A' B B' ;1 0 0 0 1 ;1 + - ;2 1 0 0 0 ;2 - + ;3 0 0 1 0 ;3 + - ;4 0 1 0 0 ;4 - + ;Halbschritt Ansteuerung 4 Blöcke linkssdrehend ; A A' B B' ;1 0 0 0 1 ;1 + - ;2 1 0 0 0 ;2 - + ;3 0 0 1 0 ;3 + - ;4 0 1 0 0 ;4 - + ; rechts links ;1) +A +A' PWM1 PWM2 ; -B' -B' PWM4 PWM4 ;2) -A -A PWM1 PWM1 ; +B +B' PWM3 PWM4 ;3) +A' +A PWM2 PWM1 ; -B -B PWM3 PWM3 ;4) -A' -A' PWM2 PWM2 ; +B' +B PWM4 PWM3 ;-------- ;Ende 2 Phasen Motor !!! ;PWMW = PWM-Mert M2P1: ;1) Lds AH, ZSchritt lds AL,PWMW ;PWM-Wert sbic PINC, 6 ;Richtung rjmp M2P12 M2P11: ;links rum adc AL, AH brcc M2P1x ;Kein Überlauf com AL ;Nach Überlauf sts PWMW, AL ;neuer PWM-Wert sichern ldi AH, 0 sts PWM4, AH rcall PK ;lin --> sin out PWM1, AH ;Übertrag com AL rcall PK ;lin --> sin sts PWM3, AH cbi PORTB, 0 ;PWM1 mit Port B0 sbi PORTC, 0 ;PWM2 mit Port C0 cbi PORTD, 4 ;PWM3 mit Port D4 sbi PORTD, 5 ;PWM4 mit Port D5 ldi AL, LOW(M2P2) sts PWMAdrl, AL ldi AL, HIGH(M2P2) sts PWMAdrh, AL ret M2P12: ;rechts rum sbc AL, AH brcc M2P1x ;Kein Überlauf com AL sts PWMW, AL ;neuer PWM-Wert sichern ldi AH, 0 out PWM1, AH rcall PK ;lin --> sin out PWM2, AH com AL rcall PK ;lin --> sin sts PWM4, AH sbi PORTB, 0 ;PWM1 mit Port B0 cbi PORTC, 0 ;PWM2 mit Port C0 sbi PORTD, 4 ;PWM3 mit Port D4 cbi PORTD, 5 ;PWM4 mit Port D5 ldi AL, LOW(M2P4) sts PWMAdrl, AL ldi AL, HIGH(M2P4) sts PWMAdrh, AL ret M2P1x: ;Kein Überlauf sts PWMW, AL ;neuer PWM-Wert sichern rcall PK ;lin --> sin out PWM1, AH com AL rcall PK ;lin --> sin sts PWM4, AH ret ;-------- M2P2: ;2) Lds AH, ZSchritt lds AL,PWMW ;PWM-Wert sbic PINC, 6 ;Richtung rjmp M2P22 M2P21: ;links rum sbc AL, AH brcc M2P2x ;Kein Überlauf com AL ;Nach Überlauf sts PWMW, AL ;neuer PWM-Wert sichern ldi AH, 0 out PWM1, AH ;Endwert rcall PK ;lin --> sin out PWM2, AH com AL rcall PK ;lin --> sin sts PWM3, AH sbi PORTB, 0 ;PWM1 mit Port B0 cbi PORTC, 0 ;PWM2 mit Port C0 cbi PORTD, 4 ;PWM3 mit Port D4 sbi PORTD, 5 ;PWM4 mit Port D5 ldi AL, LOW(M2P3) sts PWMAdrl, AL ldi AL, HIGH(M2P3) sts PWMAdrh, AL ret M2P22: ;links rum adc AL, AH brcc M2P2x ;Kein Überlauf com AL ;Nach Überlauf sts PWMW, AL ;neuer PWM-Wert sichern ldi AH, 0 sts PWM3, AH rcall PK ;lin --> sin out PWM1, AH ;Übertrag com AL rcall PK ;lin --> sin sts PWM4, AH cbi PORTB, 0 ;PWM1 mit Port B0 sbi PORTC, 0 ;PWM2 mit Port C0 sbi PORTD, 4 ;PWM3 mit Port D4 cbi PORTD, 5 ;PWM4 mit Port D5 ldi AL, LOW(M2P1) sts PWMAdrl, AL ldi AL, HIGH(M2P1) sts PWMAdrh, AL ret M2P2x: ;Kein Überlauf sts PWMW, AL ;neuer PWM-Wert sichern rcall PK ;lin --> sin out PWM1, AH com AL rcall PK ;lin --> sin sts PWM3, AH ret ;-------- M2P3: ;3) Lds AH, ZSchritt lds AL,PWMW ;PWM-Wert sbic PINC, 6 ;Richtung rjmp M2P32 M2P31: ;links rum adc AL, AH brcc M2P3x ;Kein Überlauf com AL ;Nach Überlauf sts PWMW, AL ;neuer PWM-Wert sichern ldi AH, 0 sts PWM3, AH rcall PK ;lin --> sin out PWM2, AH ;Übertrag com AL rcall PK ;lin --> sin sts PWM4, AH sbi PORTB, 0 ;PWM1 mit Port B0 cbi PORTC, 0 ;PWM2 mit Port C0 sbi PORTD, 4 ;PWM3 mit Port D4 cbi PORTD, 5 ;PWM4 mit Port D5 ldi AL, LOW(M2P4) sts PWMAdrl, AL ldi AL, HIGH(M2P4) sts PWMAdrh, AL ret M2P32: ;rechts rum sbc AL, AH brcc M2P3x ;Kein Überlauf com AL sts PWMW, AL ;neuer PWM-Wert sichern ldi AH, 0 out PWM2, AH rcall PK ;lin --> sin out PWM1, AH com AL rcall PK ;lin --> sin sts PWM3, AH cbi PORTB, 0 ;PWM1 mit Port B0 sbi PORTC, 0 ;PWM2 mit Port C0 sbi PORTD, 4 ;PWM3 mit Port D4 cbi PORTD, 5 ;PWM4 mit Port D5 ldi AL, LOW(M2P2) sts PWMAdrl, AL ldi AL, HIGH(M2P2) sts PWMAdrh, AL ret M2P3x: ;Kein Überlauf sts PWMW, AL ;neuer PWM-Wert sichern rcall PK ;lin --> sin out PWM2, AH com AL rcall PK ;lin --> sin sts PWM3, AH ret ;-------- M2P4: ;4) Lds AH, ZSchritt lds AL,PWMW ;PWM-Wert sbic PINC, 6 ;Richtung rjmp M2P42 M2P41: ;links rum sbc AL, AH brcc M2P4x ;Kein Überlauf com AL ;Nach Überlauf sts PWMW, AL ;neuer PWM-Wert sichern ldi AH, 0 out PWM2, AH ;Endwert rcall PK ;lin --> sin out PWM1, AH com AL rcall PK ;lin --> sin sts PWM4, AH cbi PORTB, 0 ;PWM1 mit Port B0 sbi PORTC, 0 ;PWM2 mit Port C0 sbi PORTD, 4 ;PWM3 mit Port D4 cbi PORTD, 5 ;PWM4 mit Port D5 ldi AL, LOW(M2P1) sts PWMAdrl, AL ldi AL, HIGH(M2P1) sts PWMAdrh, AL ret M2P42: ;links rum adc AL, AH brcc M2P4x ;Kein Überlauf com AL ;Nach Überlauf sts PWMW, AL ;neuer PWM-Wert sichern ldi AH, 0 sts PWM4, AH rcall PK ;lin --> sin out PWM2, AH ;Übertrag com AL rcall PK ;lin --> sin sts PWM3, AH sbi PORTB, 0 ;PWM1 mit Port B0 cbi PORTC, 0 ;PWM2 mit Port C0 cbi PORTD, 4 ;PWM3 mit Port D4 sbi PORTD, 5 ;PWM4 mit Port D5 ldi AL, LOW(M2P3) sts PWMAdrl, AL ldi AL, HIGH(M2P3) sts PWMAdrh, AL ret M2P4x: ;Kein Überlauf sts PWMW, AL ;neuer PWM-Wert sichern rcall PK ;lin --> sin out PWM2, AH com AL rcall PK ;lin --> sin sts PWM4, AH ret ;-------- ; rjmp Schleife ; ;-------- ;Motoransteuerung: Z zeigt auf den aktuelle Schritt (MPa ... MPj) und in ZSchritt steht der Sprungwert (1...255) ;-------- ;Betriebsart 2 ;Halbschritt Ansteuerung 5 Blöcke ; B ; A C ; ; E D ; links rechts eingeschaltet sind nach Überlauf ;1) +A -A PWM1 B+D 2 ; -B +B PWM2 5 ;2) +C -C PWM3 ; -D +D PWM4 ;3) +E -E PWM5 ; -A +A PWM1 ;4) +B -B PWM2 ; -C +C PWM3 ;5) +D -D PWM4 ; -E +E PWM5 ;-------- MP1: ;links: +PWM1 -PWM2 // rechts: -PWM1 Ü= 2PWM2 ;/* ; links rechts ;5) +E-D PWM5, PWM4 Übertrag ;1) +A,-B -A,+B PWM1, PWM2 ;2) +C,-D PWM3, PWM4 Übertrag Lds AH, ZSchritt in AL, PWM1 sbic PINC, 6 ;Richtung rjmp MP12 MP11: ;links rum adc AL, AH brcc MP1x ;Kein Überlauf ldi AH, 255 out PWM1, AH ;Endwert ldi AH, 0 out PWM2, AH sts PWM3, AL ;Übertrag com AL sts PWM4, AL ldi AL, LOW(MP2) sts PWMAdrl, AL ldi AL, HIGH(MP2) sts PWMAdrh, AL ret MP12: ;rechts rum sbc AL, AH brcc MP1x ;Kein Überlauf ldi AH, 0 out PWM1, AH ldi AH, 255 out PWM2, AH sts PWM4, AL ;Übertrag com AL sts PWM5, AL ldi AL, LOW(MP5) sts PWMAdrl, AL ldi AL, HIGH(MP5) sts PWMAdrh, AL ret MP1x: ;Kein Überlauf out PWM1, AL com AL out PWM2, AL ret ;-------- MP2: ;links: +PWM1 -PWM2 // rechts: -PWM1 Ü= 2PWM2 ;/* ; links rechts ;5) +E-D PWM5, PWM4 Übertrag ;1) +A,-B -A,+B PWM1, PWM2 ;2) +C,-D PWM3, PWM4 Übertrag Lds AH, ZSchritt lds AL, PWM3 sbic PINC, 6 ;Richtung rjmp MP22 MP21: ;links rum adc AL, AH brcc MP2x ;Kein Überlauf ldi AH, 255 sts PWM3, AH ;Endwert ldi AH, 0 sts PWM4, AH sts PWM5, AL ;Übertrag com AL out PWM1, AL ldi AL, LOW(MP3) sts PWMAdrl, AL ldi AL, HIGH(MP3) sts PWMAdrh, AL ret MP22: ;rechts rum sbc AL, AH brcc MP2x ;Kein Überlauf ldi AH, 0 sts PWM3, AH ldi AH, 255 sts PWM4, AH out PWM1, AL ;Übertrag com AL out PWM2, AL ldi AL, LOW(MP1) sts PWMAdrl, AL ldi AL, HIGH(MP1) sts PWMAdrh, AL ret MP2x: ;Kein Überlauf sts PWM3, AL com AL sts PWM4, AL ret ;-------- MP3: ;links: +PWM1 -PWM2 // rechts: -PWM1 Ü= 2PWM2 ;/* ; links rechts ;5) +E-D PWM5, PWM4 Übertrag ;1) +A,-B -A,+B PWM1, PWM2 ;2) +C,-D PWM3, PWM4 Übertrag Lds AH, ZSchritt lds AL, PWM5 sbic PINC, 6 ;Richtung rjmp MP32 MP31: ;links rum adc AL, AH brcc MP3x ;Kein Überlauf ldi AH, 255 sts PWM5, AH ;Endwert ldi AH, 0 out PWM1, AH out PWM2, AL ;Übertrag com AL sts PWM3, AL ldi AL, LOW(MP4) sts PWMAdrl, AL ldi AL, HIGH(MP4) sts PWMAdrh, AL ret MP32: ;rechts rum sbc AL, AH brcc MP3x ;Kein Überlauf ldi AH, 0 sts PWM5, AH ldi AH, 255 out PWM1, AH sts PWM3, AL ;Übertrag com AL sts PWM4, AL ldi AL, LOW(MP2) sts PWMAdrl, AL ldi AL, HIGH(MP2) sts PWMAdrh, AL ret MP3x: ;Kein Überlauf sts PWM5, AL com AL out PWM1, AL ret ;-------- MP4: ;links: +PWM1 -PWM2 // rechts: -PWM1 Ü= 2PWM2 ;/* ; links rechts ;5) +E-D PWM5, PWM4 Übertrag ;1) +A,-B -A,+B PWM1, PWM2 ;2) +C,-D PWM3, PWM4 Übertrag Lds AH, ZSchritt in AL, PWM2 sbic PINC, 6 ;Richtung rjmp MP42 MP41: ;links rum adc AL, AH brcc MP4x ;Kein Überlauf ldi AH, 255 out PWM2, AH ;Endwert ldi AH, 0 sts PWM3, AH sts PWM4, AL ;Übertrag com AL sts PWM5, AL ldi AL, LOW(MP5) sts PWMAdrl, AL ldi AL, HIGH(MP5) sts PWMAdrh, AL ret MP42: ;rechts rum sbc AL, AH brcc MP4x ;Kein Überlauf ldi AH, 0 out PWM2, AH ldi AH, 255 sts PWM3, AH sts PWM5, AL ;Übertrag com AL out PWM1, AL ldi AL, LOW(MP3) sts PWMAdrl, AL ldi AL, HIGH(MP3) sts PWMAdrh, AL ret MP4x: ;Kein Überlauf out PWM2, AL com AL sts PWM3, AL ret ;-------- MP5: ;links: +PWM1 -PWM2 // rechts: -PWM1 Ü= 2PWM2 ;/* ; links rechts ;5) +E-D PWM5, PWM4 Übertrag ;1) +A,-B -A,+B PWM1, PWM2 ;2) +C,-D PWM3, PWM4 Übertrag Lds AH, ZSchritt lds AL, PWM4 sbic PINC, 6 ;Richtung rjmp MP52 MP51: ;links rum; adc AL, AH brcc MP5x ;Kein Überlauf ldi AH, 255 sts PWM4, AH ;Endwert ldi AH, 0 sts PWM5, AH out PWM1, AL ;Übertrag com AL out PWM2, AL ldi AL, LOW(MP1) sts PWMAdrl, AL ldi AL, HIGH(MP1) sts PWMAdrh, AL ret MP52: ;rechts rum sbc AL, AH brcc MP5x ;Kein Überlauf ldi AH, 0 sts PWM4, AH ldi AH, 255 sts PWM5, AH out PWM2, AL ;Übertrag com AL sts PWM3, AL ldi AL, LOW(MP4) sts PWMAdrl, AL ldi AL, HIGH(MP4) sts PWMAdrh, AL ret MP5x: ;Kein Überlauf sts PWM4, AL com AL sts PWM5, AL ret ;---ende--- ;-------- ;Motoransteuerung: Z zeigt auf den aktuelle Schritt (MPa ... MPj) und in ZSchritt steht der Sprungwert (1...255) ;-------- ;Halbschritt Ansteuerung ; B ; A C ; ; E D ; links rechts - links von oben nach unten - rechts von unten nach oben ;1) B D -E +E PWM5 ;2) A B D +A -A PWM1 ;3) A D -B +B PWM2 ;4) A C D +C -C PWM3 ;5) A C -D +D PWM4 ;6) A C E +E -E PWM5 ;7) C E -A +A PWM1 ;8) B C E +B -B PWM2 ;9) B E -C +C PWM3 ;10)B D E +D -D PWM4 ; links rechts eingeschaltet sind ;a) +A -A PWM1 B+D ;b) -B +B PWM2 ;c) +C -C PWM3 ;d) -D +D PWM4 ;e) +E -E PWM5 ;f) -A +A PWM1 ;g) +B -B PWM2 ;h) -C +C PWM3 ;i) +D -D PWM4 ;j) -E +E PWM5 ;-------- MPa: ;links: +PWM1 Ü= -PWM2 // rechts: -PWM1 Ü= +PWM5 ;/* ; links rechts ;j) +E PWM5 ;a) +A -A PWM1 ;b) -B PWM2 Lds AH, ZSchritt in AL, PWM1 sbic PINC, 6 ;Richtung rjmp MPa2 MPa1: ;links rum adc AL, AH brcc MPaX ;Kein Überlauf ldi AH, 255 out PWM1, AH com AL out PWM2, AL ldi AL, LOW(MPb) sts PWMAdrl, AL ldi AL, HIGH(MPb) sts PWMAdrh, AL ret MPa2: ;rechts rum sbc AL, AH brcc MPaX ;Kein Überlauf ldi AH, 0 out PWM1, AH com AL sts PWM5, AL ldi AL, LOW(MPj) sts PWMAdrl, AL ldi AL, HIGH(MPj) sts PWMAdrh, AL ret MPaX: ;Kein Überlauf out PWM1, AL ret ;-------- MPb: ;links: -PWM2 Ü= +PWM3 // rechts: +PWM2 Ü= -PWM1 ; links rechts ;a) -A PWM1 ;b) -B +B PWM2 ;c) +C PWM3 Lds AH, ZSchritt in AL, PWM2 sbic PINC, 6 ;Richtung rjmp MPb2 MPb1: ;links rum sbc AL, AH brcc MPbX ;Kein Überlauf ldi AH, 0 out PWM2, AH com AL sts PWM3, AL ldi AL, LOW(MPc) sts PWMAdrl, AL ldi AL, HIGH(MPc) sts PWMAdrh, AL ret MPb2: ;rechts rum adc AL, AH brcc MPbX ;Kein Überlauf ldi AH, 255 out PWM2, AH com AL out PWM1, AL ldi AH, LOW(MPa) sts PWMAdrl, AH ldi AH, HIGH(MPa) sts PWMAdrh, AH ret MPbX: ;Kein Überlauf out PWM2, AL ret ;-------- MPc: ;links: +PWM3 Ü= -PWM4 // rechts: -PWM3 Ü= +PWM2 ; links rechts ;b) +B PWM2 ;c) +C -C PWM3 ;d) -D PWM4 Lds AH, ZSchritt lds AL, PWM3 sbic PINC, 6 ;Richtung rjmp MPc2 MPc1: ;links rum adc AL, AH brcc MPcX ;Kein Überlauf ldi AH, 255 sts PWM3, AH com AL sts PWM4, AL ldi AL, LOW(MPd) sts PWMAdrl, AL ldi AL, HIGH(MPd) sts PWMAdrh, AL ret MPc2: ;rechts rum sbc AL, AH brcc MPcX ;Kein Überlauf ldi AH, 0 sts PWM3, AH com AL out PWM2, AL ldi AL, LOW(MPb) sts PWMAdrl, AL ldi AL, HIGH(MPb) sts PWMAdrh, AL ret MPcX: ;Kein Überlauf sts PWM3, AL ret ;-------- MPd: ;links: -PWM4 Ü= +PWM5 // rechts: +PWM4 Ü= -PWM3 ; links rechts ;c) -C PWM3 ;d) -D +D PWM4 ;e) +E PWM5 Lds AH, ZSchritt lds AL, PWM4 sbic PINC, 6 ;Richtung rjmp MPd2 MPd1: ;links rum sbc AL, AH brcc MPdX ;Kein Überlauf ldi AH, 0 sts PWM4, AH com AL sts PWM5, AL ldi AL, LOW(MPe) sts PWMAdrl, AL ldi AL, HIGH(MPe) sts PWMAdrh, AL ret MPd2: ;rechts rum adc AL, AH brcc MPdX ;Kein Überlauf ldi AH, 255 sts PWM4, AH com AL sts PWM3, AL ldi AH, LOW(MPc) sts PWMAdrl, AH ldi AH, HIGH(MPc) sts PWMAdrh, AH ret MPdX: ;Kein Überlauf sts PWM4, AL ; sts PWM5, AL ret ;-------- MPe: ;links: +PWM5 Ü= -PWM1 // rechts: -PWM5 Ü= +PWM4 ; links rechts ;d) +D PWM4 ;e) +E -E PWM5 ;f) -A PWM1 Lds AH, ZSchritt lds AL, PWM5 sbic PINC, 6 ;Richtung rjmp MPe2 MPe1: ;links rum adc AL, AH brcc MPeX ;Kein Überlauf ldi AH, 255 sts PWM5, AH com AL out PWM1, AL ldi AL, LOW(MPf) sts PWMAdrl, AL ldi AL, HIGH(MPf) sts PWMAdrh, AL ret MPe2: ;rechts rum sbc AL, AH brcc MPeX ;Kein Überlauf ldi AH, 0 sts PWM5, AH com AL sts PWM4, AL ldi AL, LOW(MPd) sts PWMAdrl, AL ldi AL, HIGH(MPd) sts PWMAdrh, AL ret MPeX: ;Kein Überlauf sts PWM5, AL ret ;-------- MPf: ;links: -PWM1 Ü= -PWM2 // rechts: +PWM1 Ü= -PWM5 ; links rechts ;e) -E PWM5 ;f) -A +A PWM1 ;g) +B PWM2 Lds AH, ZSchritt in AL, PWM1 sbis PINC, 6 ;Richtung rjmp MPf2 MPf1: ;rechts rum adc AL, AH brcc MPfX ;Kein Überlauf ldi AH, 255 out PWM1, AH com AL sts PWM5, AL ldi AL, LOW(MPe) sts PWMAdrl, AL ldi AL, HIGH(MPe) sts PWMAdrh, AL ret MPf2: ;links rum sbc AL, AH brcc MPfX ;Kein Überlauf ldi AH, 0 out PWM1, AH com AL out PWM2, AL ldi AL, LOW(MPg) sts PWMAdrl, AL ldi AL, HIGH(MPg) sts PWMAdrh, AL ret MPfX: ;Kein Überlauf out PWM1, AL ret ;-------- MPg: ;links: +PWM2 Ü= -PWM3 // rechts: -PWM2 Ü= +PWM1 ; links rechts ;f) +A PWM1 ;g) +B -B PWM2 ;h) -C PWM3 Lds AH, ZSchritt in AL, PWM2 sbis PINC, 6 ;Richtung rjmp MPg2 MPg1: ;rechts rum sbc AL, AH brcc MPgX ;Kein Überlauf ldi AH, 0 out PWM2, AH com AL out PWM1, AL ldi AL, LOW(MPf) sts PWMAdrl, AL ldi AL, HIGH(MPf) sts PWMAdrh, AL ret MPg2: ;links rum adc AL, AH brcc MPgX ;Kein Überlauf ldi AH, 255 out PWM2, AH com AL sts PWM3, AL ldi AH, LOW(MPh) sts PWMAdrl, AH ldi AH, HIGH(MPh) sts PWMAdrh, AH ret MPgX: ;Kein Überlauf out PWM2, AL ret ;-------- MPh: ;links: -PWM3 Ü= +PWM4 // rechts: +PWM3 Ü= -PWM2 ; links rechts ;g) -B PWM2 ;h) -C +C PWM3 ;i) +D PWM4 Lds AH, ZSchritt lds AL, PWM3 sbis PINC, 6 ;Richtung rjmp MPh2 MPh1: ;rechts rum adc AL, AH brcc MPhX ;Kein Überlauf ldi AH, 255 sts PWM3, AH com AL out PWM2, AL ldi AL, LOW(MPg) sts PWMAdrl, AL ldi AL, HIGH(MPg) sts PWMAdrh, AL ret MPh2: ;links rum sbc AL, AH brcc MPhX ;Kein Überlauf ldi AH, 0 sts PWM3, AH com AL sts PWM4, AL ldi AL, LOW(MPi) sts PWMAdrl, AL ldi AL, HIGH(MPi) sts PWMAdrh, AL ret MPhX: ;Kein Überlauf sts PWM3, AL ret ;-------- MPi: ;links: +PWM4 Ü= -PWM5 // rechts: -PWM4 Ü= +PWM3 ; links rechts ;h) +C PWM3 ;i) +D -D PWM4 ;j) -E PWM5 Lds AH, ZSchritt lds AL, PWM4 sbis PINC, 6 ;Richtung rjmp MPi2 MPi1: ;links rum sbc AL, AH brcc MPiX ;Kein Überlauf ldi AH, 0 sts PWM4, AH com AL sts PWM3, AL ldi AL, LOW(MPh) sts PWMAdrl, AL ldi AL, HIGH(MPh) sts PWMAdrh, AL ret MPi2: ;rechts rum adc AL, AH brcc MPiX ;Kein Überlauf ldi AH, 255 sts PWM4, AH com AL sts PWM5, AL ldi AH, LOW(MPj) sts PWMAdrl, AH ldi AH, HIGH(MPj) sts PWMAdrh, AH ret MPiX: ;Kein Überlauf sts PWM4, AL ret ;-------- nop MPj: ;links: -PWM5 Ü= +PWM1 // rechts: +PWM5 Ü= -PWM4 ; links rechts ;i) -D PWM4 ;j) -E +E PWM5 ;a) +A PWM1 Lds AH, ZSchritt lds AL, PWM5 sbis PINC, 6 ;Richtung rjmp MPj2 MPj1: ;links rum adc AL, AH brcc MPjX ;Kein Überlauf ldi AH,255 sts PWM5, AH com AL sts PWM4, AL ldi AL, LOW(MPi) sts PWMAdrl, AL ldi AL, HIGH(MPi) sts PWMAdrh, AL ret MPj2: ;rechts rum sbc AL, AH brcc MPjX ;Kein Überlauf ldi AH, 0 sts PWM5, AH com AL out PWM1, AL ldi AL, LOW(MPa) sts PWMAdrl, AL ldi AL, HIGH(MPa) sts PWMAdrh, AL ret MPjX: ;Kein Überlauf sts PWM5, AL ret ;--------------------------------------- ;-------- ;Motoransteuerung: Z zeigt auf den aktuelle Schritt (MPa ... MPj) und in ZSchritt steht der Sprungwert (1...255) ;-------- ;Halbschritt Ansteuerung 5 Blöcke - 2 Spulen - ; B ; A C ; ; E D ; links rechts eingeschaltet ist A ;1) +A +E PWM1 ; -E -A PWM5 ;2) +E +D PWM4 ; -D -E PWM5 ;3) +D +C PWM3 ; -C -D PWM4 ;4) +C +B PWM2 ; -B -C PWM3 ;5) +B +A PWM1 ; -A -B PWM2 ;-------- MS1: ;/* ; links rechts ;5) +E-D PWM4 Übertrag ;1) +A,-E -A,+E PWM1, PWM5 ;2) +C,-D PWM2 Übertrag Lds AH, ZSchritt in AL, PWM1 sbis PINC, 6 ;Richtung rjmp MS12 MS11: ;links rum adc AL, AH brcc MS1x ;Kein Überlauf ldi AH, 0 out PWM2, AH sts PWM5, AL ;Übertrag com AL out PWM1, AL ldi AL, LOW(MS2) sts PWMAdrl, AL ldi AL, HIGH(MS2) sts PWMAdrh, AL ret MS12: ;rechts rum sbc AL, AH brcc MS1x ;Kein Überlauf ldi AH, 0 out PWM1, AH out PWM2, AL ;Übertrag com AL sts PWM3, AL ldi AL, LOW(MS5) sts PWMAdrl, AL ldi AL, HIGH(MS5) sts PWMAdrh, AL ret MS1x: ;Kein Überlauf out PWM1, AL com AL out PWM2, AL ret ;-------- MS2: ;/* ; links rechts ;5) +E-D PWM5, PWM4 Übertrag ;1) +A,-B -A,+B PWM1, PWM2 ;2) +C,-D PWM3, PWM4 Übertrag Lds AH, ZSchritt lds AL, PWM5 sbis PINC, 6 ;Richtung rjmp MS22 MS21: ;links rum adc AL, AH brcc MS2x ;Kein Überlauf ldi AH, 0 out PWM1, AH sts PWM4, AL ;Übertrag com AL sts PWM5, AL ldi AL, LOW(MS3) sts PWMAdrl, AL ldi AL, HIGH(MS3) sts PWMAdrh, AL ret MS22: ;rechts rum sbc AL, AH brcc MS2x ;Kein Überlauf ldi AH, 0 sts PWM5, AH out PWM1, AL ;Übertrag com AL out PWM2, AL ldi AL, LOW(MS1) sts PWMAdrl, AL ldi AL, HIGH(MS1) sts PWMAdrh, AL ret MS2x: ;Kein Überlauf sts PWM5, AL com AL out PWM1, AL ret ;-------- MS3: ;/* ; links rechts ;5) +E-D PWM5, PWM4 Übertrag ;1) +A,-B -A,+B PWM1, PWM2 ;2) +C,-D PWM3, PWM4 Übertrag Lds AH, ZSchritt lds AL, PWM4 sbis PINC, 6 ;Richtung rjmp MS32 MS31: ;links rum adc AL, AH brcc MS3x ;Kein Überlauf ldi AH, 0 sts PWM5, AH sts PWM3, AL ;Übertrag com AL sts PWM4, AL ldi AL, LOW(MS4) sts PWMAdrl, AL ldi AL, HIGH(MS4) sts PWMAdrh, AL ret MS32: ;rechts rum sbc AL, AH brcc MS3x ;Kein Überlauf ldi AH, 0 sts PWM4, AH sts PWM5, AL ;Übertrag com AL out PWM1, AL ldi AL, LOW(MS2) sts PWMAdrl, AL ldi AL, HIGH(MS2) sts PWMAdrh, AL ret MS3x: ;Kein Überlauf sts PWM4, AL com AL sts PWM5, AL ret ;-------- MS4: ;/* ; links rechts ;5) +E-D PWM5, PWM4 Übertrag ;1) +A,-B -A,+B PWM1, PWM2 ;2) +C,-D PWM3, PWM4 Übertrag Lds AH, ZSchritt lds AL, PWM3 sbis PINC, 6 ;Richtung rjmp MS42 MS41: ;links rum adc AL, AH brcc MS4x ;Kein Überlauf ldi AH, 0 sts PWM4, AH out PWM2, AL ;Übertrag com AL sts PWM3, AL ldi AL, LOW(MS5) sts PWMAdrl, AL ldi AL, HIGH(MS5) sts PWMAdrh, AL ret MS42: ;rechts rum sbc AL, AH brcc MS4x ;Kein Überlauf ldi AH, 0 sts PWM3, AH sts PWM4, AL ;Übertrag com AL sts PWM5, AL ldi AL, LOW(MS3) sts PWMAdrl, AL ldi AL, HIGH(MS3) sts PWMAdrh, AL ret MS4x: ;Kein Überlauf ; sts PWM5, AL sts PWM3, AL com AL ; out PWM2, AL sts PWM4, AL ret ;-------- MS5: ;/* ; links rechts ;5) +E-D PWM5, PWM4 Übertrag ;1) +A,-B -A,+B PWM1, PWM2 ;2) +C,-D PWM3, PWM4 Übertrag Lds AH, ZSchritt in AL, PWM2 sbis PINC, 6 ;Richtung rjmp MS52 MS51: ;links rum adc AL, AH brcc MS5x ;Kein Überlauf ldi AH, 0 sts PWM3, AH out PWM1, AL ;Übertrag com AL out PWM2, AL ldi AL, LOW(MS1) sts PWMAdrl, AL ldi AL, HIGH(MS1) sts PWMAdrh, AL ret MS52: ;rechts rum sbc AL, AH brcc MS5x ;Kein Überlauf ldi AH, 0 out PWM2, AH sts PWM3, AL ;Übertrag com AL sts PWM4, AL ldi AL, LOW(MS4) sts PWMAdrl, AL ldi AL, HIGH(MS4) sts PWMAdrh, AL ret MS5x: ;Kein Überlauf ; sts PWM5, AL out PWM2, AL com AL ; out PWM2, AL sts PWM3, AL ret ;-------------------------------------------------------------------------- ;https://www.mikrocontroller.net/articles/AVR_Arithmetik#32_Bit_.2F_32_Bit ;----------------------------------------------- umul32: ;32 Bit * 16 Bit cpi R19, 0 cpc R19, R18 breq _umu1 ;one operand must be below 65536 mov R24, R16 ; swap A <-> B mov R16, R20 mov R20, R24 mov R24, R17 mov R17, R21 mov R21, R24 mov R22, R18 mov R23, R19 clr R18 clr R19 ; a3,2,1,0 = a1,0 * b3,2,1,0 ; R19,R18,R17,R16 = R17,R16 * R23,R22,R21,R20 _umu1: ldi R28, 16 clr R24 clr R25 ror R17 ror R16 _umu2: brcc _umu3 add R18, R20 adc R19, R21 adc R24, R22 adc R25, R23 _umu3: ror R25 ror R24 ror R19 ror R18 ror R17 ror R16 dec R28 brne _umu2 ret ;----------------------------------------------- urdiv32: ;32 Bit / 32 Bit ; a3..0 = a3..0 / b3..0 (Ganzzahldivision) ; R19..R16 = R19..R16 / R23..R20 (Ganzzahldivision) ; b3..0 = a3..0 % b3..0 (Rest) ; R23..R20 = R19..R16 % R23..R20 (Rest) ; cycle: max 684 mov R24, R20 ;T = B mov R25, R21 mov R26, R22 mov R27, R23 lsr R27 ;B / 2 ror R26 ror R25 ror R24 add R16, R24 ;A = A + B / 2 adc R17, R25 adc R18, R26 adc R19, R27 udiv32: clr R24 clr R25 clr R26 clr R27 ldi R28, 32 udi1: lsl R16 rol R17 rol R18 rol R19 rol R24 rol R25 rol R26 rol R27 cp R24, R20 cpc R25, R21 cpc R26, R22 cpc R27, R23 brcs udi2 sub R24, R20 sbc R25, R21 sbc R26, R22 sbc R27, R23 inc R16 udi2: dec R28 brne udi1 mov R20, R24 mov R21, R25 mov R22, R26 mov R23, R27 ret ;----------------------------------------------- ;Mult: ;---------------------------------- ;Multiplikation r0..r1 = r16 * r17 ; R19*R20=R17..R18 ; R17= low, R18= high ;---------------------------------- mult: clr r17 ;Ergebnis = 0 ldi xl,8 ;8 mal schieben mul1: lsr r19 ;Bit (von 0..7 Niederwertige zuerst) ins Carry (Multiplikand) brcc mul2 ;Wenn 0, Addition überspringen add r18,r20 ;Ansonsten Multiplikator ins Highbyte addieren mul2: ror r18 ;Produkt mit evt. Übertrag nach rechts schieben ror r17 dec xl ;Das ganze 8 mal brne mul1 ret ;---------------------------------- ;Ende mul ;---------------------------------- ;-------------------------------------------------------------------------------- ; 16Bit Division durch 8Bit ; R17..R18/R20 = R17..R18 Rest R16 ; R17= low dividend ; R18= high dividend ;-------------------------------------------------------------------------------- div: ldi R19, 16 ;16* schieben clr R16 ;Rest =0 dv1: lsl R17 ;Ein Bit aus dem Dividend ... rol R18 ;ins Carry schieben rol R16 ;Carry in den Rest schieben ;brcs dv3 ;Bei Überlauf von Rest, Sprung cp R16, R20 brcs dv2 ;Wenn Rest <10, das 0-Bit in temp2 (LSL, oben) stehen lassen dv3: inc R17 ;Ansonsten Bit0 setzen und 10 vom Rest abziehen sub R16, R20 dv2: dec R19 ;Das ganze 16 mal brne dv1 ret ;------------------------------------------------- ; Ende Div Routine. ;------------------------------------------------- ;-------------------------------- ;Hex_dez: ;32 Bit Hex zu dezimal R20...R23 = 32Bit Hex nach 10Byte SRAM Dezwert -- R20=L R23=H -- Dezwert=L Dezwert+10=H ; ldiw x, Soll1 IstPos_dez: ;lade ist Position in R20..R23 sbrc R15, 7 ;teste, ob neg Werte rjmp IstPos_dez1 ldi AL, 45 ;Ausgabe "-" rcall USART_Transmit ;USART_Transmit: nur AL senden clr R20 ;neg. in pos. wandeln clr R21 clr R22 clr R23 sub R20, R12 sbc R21, R13 sbc R22, R14 sbc R23, R15 andi R23, 0b01111111 rjmp Hex_dez IstPos_dez1: ldi AL, 43 ;Ausgabe "+" rcall USART_Transmit ;USART_Transmit: nur AL senden mov R20, R12 mov R21, R13 mov R22, R14 mov R23, R15 andi R23, 0b01111111 Hex_dez: ldiw z, Tab_hex_dez*2 ldiw y, Dezwert clr AL clr R18 st y, AL std y+1, AL std y+2, AL std y+3, AL std y+4, AL std y+5, AL std y+6, AL std y+7, AL std y+8, AL std y+9, AL ldi R19, 10 ;Schleifenzähler auf 10 stellen ldi R24, 9 ;Schleifenzähler auf 8 Durchläufe rcall dezv mov R20, R21 rcall dezv mov R20, R22 rcall dezv mov R20, R23 rcall dezv rcall DEZ_ASC ret dezv: dec R24 ;Schleifenzähler 8x brne dez8 ldi R24, 9 ;Schleifenzähler auf neue 8 Durchläufe ret dez8: lsr R20 ;schiebe nach rechts brcc dezv1 rcall dezp rjmp dezv dezv1: ;Bit= 0 - nur Z+10 adiw z, 10 rjmp dezv dezp: rcall dezu dec R19 breq dezf rjmp dezp dezf: ldiw y, Dezwert ;auf Dezimalwert - Anfang ldi R19, 10 ;Schleifenzähler auf 10 stellen ret dezu: lpm AL, z+ ld AH, y add AL, R18 ;Übertrag add AL, AH ;Wert aus Ram + Wert aus Tabelle st y, AL subi AL, 10 ;>10? brcs dez1 st y+, AL ldi R18, 1 ;Übertrag ret dez1: clr R18 ;kein Übertrag ld AH, y+ ;nur y+1 ret ;Ende 32 Bit Hex zu dezimal ;-------------------------------- ;Dezwert SRAM umwandeln in ASCCII und rechts-links spiegeln für Ausgabe UART DEZ_ASC: ldiw y, Dezwert+10 ldi AH, 10 ldi R18, 32 ;erst Leerzeichen 32 - oder z.B. Punkt 46 DEZ_ASC1: subi AH, 1 breq DEZ_ASC4 ;letztes Zeichen kein leerzeichen brcc DEZ_ASC2 rcall DEZ_ASC5 ;Tausche rechts-links für Ausgabe UART ret ;fertig DEZ_ASC4: ldi R18, 48 ;Versatz 30Hex DEZ_ASC2: ld AL, -y tst AL brne DEZ_ASC3 add AL, R18 st y, AL rjmp DEZ_ASC1 DEZ_ASC3: ldi R18, 48 ;Versatz 30Hex add AL, R18 st y, AL rjmp DEZ_ASC1 DEZ_ASC5: ldi R18, 5 ;Spiegel für Ausgabe USART ldiw y, Dezwert+10 ldiw x, Dezwert DEZ_ASC6: ld AL,-y ld AH, x st x+, AL st y, AH dec R18 brne DEZ_ASC6 ret ;Ende Dezwert SRAM umwandeln in ASCCII Kommaweg: ldi R18, 9 ;Spiegel für Ausgabe USART ldiw y, Dezwert+9 ldiw x, Dezwert+8 Kommaweg1: ld AL, -x st -y, AL dec R18 brne Kommaweg1 ldi AL, 32 ;0x20 Leerzeichen st y, AL ret ;-------------------------------- ;ASCCII in Hex wandeln 10Byte SRAM Dezwert nach R20...R23 = 32Bit Hex -- R20=L R23=H -- Dezwert=L Dezwert+10=H ;ASC_DEZ_plus: ASCCII werte werden zu R20...R23 addiert ASC_DEZ: clr R20 clr R21 clr R22 clr R23 ASC_DEZ_plus: ; Einsprung - ASCCII werte werden zu R20...R23 addiert ldi R18, 10 ;Stellenzähler ldiw z, Tab_dez_hex*2 ldiw y, Dezwert ASC_DEZ1: subi r18, 1 ;-1 brcs ASC_DEZ4 ld AH, y+ subi AH, 0x30 ;erstmal dezimalzahlen brcc ASC_DEZ2 ;keine Steuerzeichen clr AH ASC_DEZ2: subi AH, 1 ;-1 brcs ASC_DEZ3 ;nächste Stelle lpm AL, z+ add R20, AL lpm AL, z+ adc R21, AL lpm AL, z+ adc R22, AL lpm AL, z+ adc R23, AL sbiw z, 4 ;4 Stellen zurück rjmp ASC_DEZ2 ASC_DEZ3: adiw z,4 rjmp ASC_DEZ1 ASC_DEZ4: ret ;fertig ;Ende ASCCII in Hex wandeln ;---------------------------------------------------------- .db "Anfang der Tabelle" Tab_hex_dez: .db 1,0,0,0,0,0,0,0,0,0 ;0,0,0,0,0,0,0,0,0,1 .db 2,0,0,0,0,0,0,0,0,0 ;0,0,0,0,0,0,0,0,0,2 .db 4,0,0,0,0,0,0,0,0,0 ;0,0,0,0,0,0,0,0,0,4 .db 8,0,0,0,0,0,0,0,0,0 ;0,0,0,0,0,0,0,0,0,8 .db 6,1,0,0,0,0,0,0,0,0 ;0,0,0,0,0,0,0,0,1,6 .db 2,3,0,0,0,0,0,0,0,0 ;0,0,0,0,0,0,0,0,3,2 .db 4,6,0,0,0,0,0,0,0,0 ;0,0,0,0,0,0,0,0,6,4 .db 8,2,1,0,0,0,0,0,0,0 ;0,0,0,0,0,0,0,1,2,8 .db 6,5,2,0,0,0,0,0,0,0 ;0,0,0,0,0,0,0,2,5,6 .db 2,1,5,0,0,0,0,0,0,0 ;0,0,0,0,0,0,0,5,1,2 .db 4,2,0,1,0,0,0,0,0,0 ;0,0,0,0,0,0,1,0,2,4 .db 8,4,0,2,0,0,0,0,0,0 ;0,0,0,0,0,0,2,0,4,8 .db 6,9,0,4,0,0,0,0,0,0 ;0,0,0,0,0,0,4,0,9,6 .db 2,9,1,8,0,0,0,0,0,0 ;0,0,0,0,0,0,8,1,9,2 .db 4,8,3,6,1,0,0,0,0,0 ;0,0,0,0,0,1,6,3,8,4 .db 8,6,7,2,3,0,0,0,0,0 ;0,0,0,0,0,3,2,7,6,8 .db 6,3,5,5,6,0,0,0,0,0 ;0,0,0,0,0,6,5,5,3,6 .db 2,7,0,1,3,1,0,0,0,0 ;0,0,0,0,1,3,1,0,7,2 .db 4,4,1,2,6,2,0,0,0,0 ;0,0,0,0,2,6,2,1,4,4 .db 8,8,2,4,2,5,0,0,0,0 ;0,0,0,0,5,2,4,2,8,8 .db 6,7,5,8,4,0,1,0,0,0 ;0,0,0,1,0,4,8,5,7,6 .db 2,5,1,7,9,0,2,0,0,0 ;0,0,0,2,0,9,7,1,5,2 .db 4,0,3,4,9,1,4,0,0,0 ;0,0,0,4,1,9,4,3,0,4 .db 8,0,6,8,8,3,8,0,0,0 ;0,0,0,8,3,8,8,6,0,8 .db 6,1,2,7,7,7,6,1,0,0 ;0,0,1,6,7,7,7,2,1,6 .db 2,3,4,4,5,5,3,3,0,0 ;0,0,3,3,5,5,4,4,3,2 .db 4,6,8,8,0,1,7,6,0,0 ;0,0,6,7,1,0,8,8,6,4 .db 8,2,7,7,1,2,4,3,1,0 ;0,1,3,4,2,1,7,7,2,8 .db 6,5,4,5,3,4,8,6,2,0 ;0,2,6,8,4,3,5,4,5,6 .db 2,1,9,0,7,8,6,3,5,0 ;0,5,3,6,8,7,0,9,1,2 .db 4,2,8,1,4,7,3,7,0,1 ;1,0,7,3,7,4,1,8,2,4 .db 8,4,6,3,8,4,7,4,1,2 ;2,1,4,7,4,8,3,6,4,8 .db 6,9,2,7,6,9,4,9,2,4 ;4,2,9,4,9,6,7,2,9,6 Tab_dez_hex: .db 0x01,0x00,0x00,0x00 ;0x00,0x00,0x00,0x01 .db 0x0A,0x00,0x00,0x00 ;0x00,0x00,0x00,0x0A .db 0x64,0x00,0x00,0x00 ;0x00,0x00,0x00,0x64 .db 0xE8,0x03,0x00,0x00 ;0x00,0x00,0x03,0xE8 .db 0x10,0x27,0x00,0x00 ;0x00,0x00,0x27,0x10 .db 0xA0,0x86,0x01,0x00 ;0x00,0x01,0x86,0xA0 .db 0x40,0x42,0x0F,0x00 ;0x00,0x0F,0x42,0x40 .db 0x80,0x96,0x98,0x00 ;0x00,0x98,0x96,0x80 .db 0x00,0xE1,0xF5,0x05 ;0x05,0xF5,0xE1,0x00 .db 0x00,0xCA,0x9A,0x3B ;0x3B,0x9A,0xCA,0x00 Texta: .db 10,13,"Bereit",10,13 .db "? - Info",10,13 .db "P - laufe auf Position",10,13 .db "S - Schrittweite 1-256",10,13 .db "V - Vorteiler Taktgeber 1..5",10,13 .db "A - Position auf 0 setzen und Pufferspeicher auf Anfang ",10,13 .db "W - Laufe auf Winkel x,x",10,13 .db "B - Betriebsart Motor 1..3 --> 5-Phasen-Motor oder 4 --> 2-Phasen-Motor ",10,13 .db "G - Geschwindigkeit Motor 1..65535",10,13 .db "Z - Zeit abwarten -Abbruch mit x-",10,13 .db "D - Durchlauf - Wiederholungen von Abfang Pufferspeicher -Abbruch mit x-",10,13 .db "E - Datensatz ins EEPROM schreiben (0 bis 6) oder 7= Bereich 0-6 loeschen ",10,13 .db "L - Datensatz aus EEPROM lesen (0 bis 6) oder 7= Datenspeicher anzeigen ",10,13 .db 10,13,0,0 ;LF CR - Ende Text Textcr: .db 10,13,0,0 ;CR Textnb: .db "... Anweisung nicht bekannt --> ? = Info ",10,13,0 Textp: .db "Aktuelle Position: ",0 Textu: .db "Umdrehungen: ",0,0 Textw: .db "Winkel: ",0,0 Textwa: .db " Grad",10,13,0 Textps: .db "Laufe auf Position:",0 Texts: .db "Schrittweite 1-256: ",0,0 Texts1: .db "Schrittweite: ",0,0 Textn: .db "Position auf 0 gesetzt und Pufferspeicher auf Anfang ",10,13,0 Textv: .db "Vorteiler Taktgeber 1...5",0 Textv1: .db "Vorteiler Taktgeber /1 ",10,13,10,13,0 Textv2: .db "Vorteiler Taktgeber /8 ",10,13,10,13,0 Textv3: .db "Vorteiler Taktgeber /64",10,13,10,13,0 Textv4: .db "Vorteiler Taktgeber /256 ",10,13,10,13,0 Textv5: .db "Vorteiler Taktgeber /1024",10,13,10,13,0 Textv6: .db "Vorteiler nicht geaendert: ",0 Textb: .db "Motor Betriebsart 1,2,3(5Phasen),4(2Phasen)",0 Textaw: .db "Laufe auf Winkel ",0,0 Textz: .db "Warte eine Zeit ab ",0,0 Textzb: .db "Wartezeit beendet",10,13,10,13,0 Textzx: .db "xxx Abbruch xxx",10,13,0 Textg: .db "Geschwindigkeit ",0,0 Textgi: .db "Geschwindigkeit ist:",0,0 Textgu: .db "Wert zu hoch",0,0 Textd: .db "Wiederholungen",0,0 Textd1: .db "keine weiteren Wiederholungen",0 Textd2: .db "noch",0,0 Textx: .db "xxx Abbruch xxx Wiederholungen",0,0 Textue: .db "Wiederholungen nicht moeglich - Datenanfang wurde ueberschrieben ",0 Texte: .db "Wiederholungen",0,0 Textep: .db "Daten in EEPROM Speicher Nr. ",0 Textex: .db "Daten im EEPROM geloescht",10,13,0 Texte0: .db "EEPROM Bereich ist leer",10,13,0 Texteg: .db "Daten aus EEPROM gelesen ",10,13,0 Textea: .db "Datenspeicher anzeigen ",10,13,10,13,0 Textee: .db "Datenende aus EEPROM- Bereich nicht erkannt",10,13,0 Texte2: .db "xxx Abbruch xxx nur Speicher Nr. 0..6 erlaubt",10,13,0 Texte3: .db "Daten ins EEPROM geschrieben ",10,13,0 Textel: .db "Daten aus EEPROM Speicher Nr. ",0,0 TextT: .db "Tastenanforderung Daten aus EEPROM Speicher Nr. ",0,0 Textm1: .db "Betriebsart 1:128000 Positionen/U, 4 Spulen werden gleichzeitig bestromt ",10,13,10,13,0 Textm2: .db "Betriebsart 2: 64000 Positionen/U, 4 Spulen werden gleichzeitig bestromt ",10,13,10,13,0 Textm3: .db "Betriebsart 3: 32000 Positionen/U, 2 Spulen werden gleichzeitig bestromt ",10,13,10,13,0 Textm4: .db "Betriebsart 4: 2-Phasen-Motor! ",10,13,10,13,0 Textmx: .db "Fehler: Nur Betriebsart 1,2,3 oder 4 moeglich",10,13,10,13,0 .EXIT