/* * 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 Phasen = 5 ;4= 2-Phasenmotor oder 5= 5-Phasenmotor .equ Schrittweite = 63 ;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 .equ PWM5l = OCR3AL ;PB6 test .equ PWM5h = OCR3AH ;PB6 test ;nur eine Auswahl .equ Mot1 = 0 ;4 Wicklungen gleichzeitig - (1000 mal n Schritte) .equ Mot2 = 1 ;4 Wicklungen gleichzeitig - (500 mal n Schritte) .equ Mot3 = 0 ;2 Wicklungen gleichzeitig - (500 mal n Schritte) .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 ;ISP PORTB 5,6,7 ;JTAG PORTC 2,3,4,5 ;PORTA, 0 ;Poti ;PORTA, 1 ; ;PORTA, 2 ; ;PORTA, 3 ; ;PORTA, 4 ; ;PORTA, 5 ; ;PORTA, 6 ;Position ;PORTA, 7 ;Schrittgeber Geschwindigkeit ;PORTB, 0 ;Drehgeber A ;PORTB, 1 ; ;PORTB, 2 ; ;PORTB, 3 ;PWM1 ;PORTB, 4 ;PWM2 ;PORTB, 5 ;ISP,MOT4 ;PORTB, 6 ;PWM5,ISP ;PORTB, 7 ;ISP,MOT5 ;PORTC, 0 ;Drehgeber B ;PORTC, 1 ; ;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 ;Res. für 2. 2-Phasen Motor Takt ;PORTD, 4 ;Eingang Richtung Motor ;PORTD, 5 ;Res. für 2. 2-Phasen Motor Richtung ;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 AZ: .byte 4 ;für laufe auf Position - Anzahl der Schritte MPinB: .byte 1 ;Merker für Pin B Drehgeber 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 +- 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 reti .ORG PCI0addr; = 0x0008 ; Pin Change Interrupt Request 0 reti .ORG PCI1addr; = 0x000a ; Pin Change Interrupt Request 1 rjmp DrehA .ORG PCI2addr; = 0x000c ; Pin Change Interrupt Request 2 rjmp DrehB .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 ;.db 0,1,2,3,4,5,6,7,8,9,10,11 ;.db "Ende der Korrekturtabelle " ; Adresse 0x200 ;Test ;call PK ;Positionskorrektur ;rjmp Posit -Test- 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, 4 ;Richtung Eingang sbi PORTC, 6 ;Richtung Ausgang =1 rcall Schritt pop AH pop AL out SREG,AL pop AL reti DrehA: push AL in AL,SREG push AL ldi AL, 0b00000100 ;PCIE2 - nur B vom Drehgeber auswerten sts PCICR, AL ;– – – – PCIE3 PCIE2 PCIE1 PCIE0 = PCICR in AL, PINC ;lese Drehgeber B sts MPinB, AL ;sichern pop AL out SREG,AL pop AL reti DrehB: push AL in AL,SREG push AL push AH ldi AL, 0b00000010 ;PCIE1 - nur A vom Drehgeber auswerten sts PCICR, AL ;– – – – PCIE3 PCIE2 PCIE1 PCIE0 = PCICR in AL, PINB in AH, PINC sbrs AL, 0 ;Überspringe, wenn A vom Drehgeber = 1 rcall DrehB1 ;nur, wenn A vom Drehgeber = 0 pop AH pop AL out SREG,AL pop AL reti DrehB1: lds AL, MPinB cbi PORTC, 6 ;Setze Richtung auf 0 sbrc AL, 0 ;Richtung vom Drehgeber sbi PORTC, 6 ;Setze Richtung pushw z rcall Schritt popw z ret 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 rcall 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 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 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: ;rcall USART_Transmit ;test ;UL4: 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 ;---------------------------------------------- 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 ;---------------------------------------------- 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, 0b11111110 ; 1= Ausgang out DDRB, AL ldi AL, 0x01 ;Bit 0 Pull up out PORTB, AL ldi AL, 0b11111110 ; 1= Ausgang out DDRC, AL ldi AL, 0x01 ;Bit 0 Pull up out PORTC, AL ldi AL, 0b11000010 ; 1= Ausgang Motor1: D2=Takt Eingang D4=Richtung Eingang out DDRD, AL ldi AL, 0b00111100 ;1= Pull up out PORTD, AL ldi AL, Schrittweite sts ZSchritt, AL 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 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 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 ;---------------------------------------------------------------------------------------------------------------------------------------------------- Reset: rcall Init sei Anfang: ;Hauptprogramm lds AH, Status ;lese Status Byte rcall ADCAuswertung rcall Tastenabfrage rcall SerAbfrage 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 ;--------------------------------------------------- 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 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 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: ldiw Z, Textm3*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 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: 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 ret Zeinkz3: ;,0 einsetzen ldi AL, 44 ;0x2c erst Komma rcall Posv Zeinkz2: ldi AL, 48 ;<0x30 "0" rcall Posv 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 rjmp Posd ;--------------------------------------------------- ;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 ;--------------------------------------------------- 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 Frage ;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 Anf0 ;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 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 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 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 ;--------------------------------------------------- Anf: 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. Rerte 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< 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 ",10,13 .db "W - Laufe auf Winkel x,x",10,13 .db "B - Betriebsart Motor 1..3",10,13 .db "G - Geschwindigkeit Motor 1..65535",10,13 .db "Z - Zeit abwarten -Abbruch mit x-",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 ",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",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 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 Textmx: .db "Fehler: Nur Betriebsart 1,2 oder 3 moeglich",10,13,10,13,0 .EXIT