Hex-Editor           

von  Thomas Baum                      
Elektronik-Labor  Projekte   AVR   T13-Contest

 


Inspiriert von der "TPS" und der hńndigen Programmierung aus dem "Assembler-Kurs" habe ich die Tage mal meinen Hexdump-Code zu einem rudimentńren aber nutzbaren Hex-Editor aufgebohrt. Damit lńsst sich der kleine AVR in Verbindung mit einem SPI-Nokia-Display ohne sonstige Hardware programmieren. Nicht einfach aber dafŘr mit vollem Zugriff auf die Hardware.

Verwendete Hardware:
Attiny13a
Nokia 5510 Display

Bedienung:
Editormodus starten:    Port 0 beim Start auf Masse ziehen
Eingabe:        kurz-weiter; lang-bestńtigen
Organisation:        Seitenwahl->Zeilenwahl->Wortwahl->Worteingabe->Speichern
Abbruch:        Stromversorgung trennen


Aufbau und Funktion:
Der Programmcode des Editors befindet sich am Ende des Speichers. Das hat den Vorteil, dass man mit dem eigenen Programm auch die Interruptvektortabelle definieren kann. Der Befehlszńhler beginnt jedoch immer bei 0. Deshalb ist der erste Befehl ein Sprung in den Programmcode des Editors. Zur Vereinfachung zeigt dieser auf die letzte Adresse im Speicher, die man sich beim ▄berschreiben des Resetinterrupts besser merken kann, will man nochmal beim Neustart in den Editormodus. :)
Selbst geschriebene Programme k÷nnen nach dem ersten Wort angefŘgt werden, oder man kŘmmert sich selbst in seinem Code um den Aufruf des Editors. Die einzige Beschrńnkung gegenŘber einem blanken Attiny13 ist:
- nur noch 25% freier Programmspeicher verfŘgbar.

Wichtig: In den Fusebits muss die Selbstprogrammierung aktiviert werden. (Fuse 6AEF statt 6AFF)
Auf eine ─nderung des Reset Pins wurde bewusst verzichtet. Damit lńsst sich der Controller auch noch per ISP programmieren.



Youtube-Video: http://youtu.be/_kgd4lg4PgM

Download:  avr-hex-editor.zip

;Onboard AVR-Hex-Editor (attiny13) Thomas Baum (th.baum@online.de)
;Display Nokia 5510
;             ____
;            -|  |-VCC (3V)
;    LCD_SDIN-|  |-LCD_SCE
;    LCD_SCLK-|  |-LCD_DC
;    GND     -|__|-INPUT(Button nach Masse)
;
;kurz-weiter; lang-best├Ątigen
;Seitenwahl->Zeilenwahl->Wortwahl->Worteingabe->Speichern

.device ATtiny13A            ;Fuse 6AEF

.equ    INPUT        = 0        ;Pinbelegung
.equ    LCD_DC        = 1
.equ    LCD_SCE        = 2
.equ    LCD_SDIN    = 3
.equ    LCD_SCLK    = 4

.org 0x0000
flash_start:
        rjmp    flash_end        ;Sprung zum Editor

user_prog:                ;Userspace
;---------------------------------------
;---------------Userspace---------------
;---------------------------------------
;---
;---------------------------------------               
.org 0x0080                ;Startadresse Editorcode
    rjmp    user_prog        ;Lauf in Editor verhindern   
init:   
    ldi    r16, RAMEND        ;Stackinitalisierung
    out    spl, r16   
    sbi    PORTB, INPUT        ;Pullup definieren
    cbi    DDRB, INPUT        ;Definition der Ports
    sbi    DDRB, LCD_DC
    sbi    DDRB, LCD_SCE
    sbi    DDRB, LCD_SDIN
    sbi    DDRB, LCD_SCLK

start_prog:                ;Startmenu
    rcall    delay
    in    r16, PINB        ;Pin0 abfragen
    andi    r16, 0x01
    cpi    r16, 0x00        ;ist Pin0 0?
    brne    start_user_prog        ;wenn nicht starte Userprogramm
    rcall    button            ;Taster absteigende Flake abfangen
    rjmp    reset
start_user_prog:
    rjmp    user_prog        ;Adressierung nur ├╝ber rjmp m├Âglich   
reset:                    ;Variablen zur├╝cksetzen
    clr    r31
    clr    r30
    clr    r10            ;Seitenvariable
    clr    r02            ;Zeilenvariable
    ldi    r16, 20            ;Offset Zeilennummerierung
    mov    r03, r16        ;word_pos
    clr    r04            ;word_add
    clr    r06            ;Eingabe
    clr    r07            ;Eingabe

main:
    rcall    init_display        ;Displayinitialisierung
    ldi    r16, 0x00        ;Ausgabeposition
    rcall    set_x_position        ;x auf 0
    ldi    r16, 0x00
    rcall    set_y_position        ;y auf 0
    rcall    draw_init
    rcall    out_page        ;Ganze Seite ausgeben
    rcall    draw_finish
    rcall    button            ;Eingabe abfragen
    cpi    r16, 0x02        ;langer Tastendruck?
    breq    line            ;gehe Zeile ausw├Ąhlen
    inc    r10           
    mov    r16, r10
    cpi    r16, 22            ;├œberlauf?
    brne    main            ;Nein, dann n├Ąchste Seite
    ldi    r31, 0x00        ;├œberlaufkorrektur
    ldi    r30, 0x00
    ldi    r16, 0x00
    mov    r10, r16
    rjmp    main

line:                    ;Zeile ausw├Ąhlen
    rcall    init_display
    ldi    r16, 0x00
    rcall    set_x_position
    mov    r16, r02
    rcall    set_y_position
    rcall    draw_init
    ldi    r16, 0xff        ;Zeilenmarkierung laden
    rcall    spi_out            ;Zeilenmarkierung zeichnen
    rcall    draw_finish
    rcall    button            ;Zeile ausw├Ąhlen?
    cpi    r16, 0x02        ;ja, dann Wort w├Ąhlen
    breq    word
    inc    r02
    rcall    init_display        ;alte Markierung l├Âschen
    ldi    r16, 0x00
    rcall    set_x_position
    mov    r16, r02
    dec    r16
    rcall    set_y_position
    rcall    draw_init
    ldi    r16, 0x00        ;leere Markierung
    rcall    spi_out            ;Zeilenmarkierung zeichnen
    mov    r16, r02
    cpi    r16, 6            ;Zeilen├╝berlauf
    brne    line           
    ldi    r16, 0x00        ;Werte korrigieren
    mov    r02, r16
    rjmp    line
   
word:                    ;Wort ausw├Ąhlen
    rcall    init_display
    mov    r16, r03   
    rcall    set_x_position
    mov    r16, r02
    rcall    set_y_position
    rcall    draw_init
    ldi    r16, 0xff        ;Wortmarkierung laden
    rcall    spi_out            ;ausgeben
    rcall    draw_finish
    rcall    button            ;Eingabe abfragen
    cpi    r16, 0x02
    breq    edit
    mov    r16, r03
    ldi    r17, 16
    add    r16, r17
    mov    r03, r16
    inc    r04
    rcall    init_display        ;Alte Markierung l├Âschen
    mov    r16, r03
    ldi    r17, 16
    sub    r16, r17
    rcall    set_x_position
    mov    r16, r02
    rcall    set_y_position
    rcall    draw_init
    ldi    r16, 0x00
    rcall    spi_out
    rcall    draw_finish
    mov    r16, r03
    cpi    r16, 84
    brne    word
    ldi    r16, 20            ;├œberlaufkorrektur
    mov    r03, r16
    ldi    r16, 0x00
    mov    r04, r16
    rjmp    word

edit:                    ;Worteinagbe
    ldi    r16, 0x00
    mov    r07, r16        ;Ergebnis zur├╝cksetzen
    mov    r06, r16

    rcall    get_nibble        ;1. Zeichen einlesen
    andi    r20, 0x0f
    swap    r20
    mov    r07, r20   
    ldi    r16, 0x04
    add    r03, r16

    rcall    get_nibble        ;2. Zeichen einlesen
    andi    r20, 0x0f
    or    r07, r20
    ldi    r16, 0x04
    add    r03, r16

    rcall    get_nibble        ;3. Zeichen einlesen
    andi    r20, 0x0f
    swap    r20
    mov    r06, r20
    ldi    r16, 0x04
    add    r03, r16

    rcall    get_nibble        ;4. Zeichen einlesen
    andi    r20, 0x0f
    or    r06, r20
    ldi    r16, 0x04
    add    r03, r16

add_page:                ;Seitenadresse ermitteln
    clr    r24
    clr    r25
    mov    r16, r10
add_add_p:   
    cpi    r16, 0x00
    breq    add_line
    adiw    r25:r24, 48        ;48 Byte pro Seite
    dec    r16
    rjmp    add_add_p
       
add_line:                ;Zeilenadresse ermitteln
    mov    r16, r02
add_add:
    cpi    r16, 0x00
    breq    ok1
    adiw    r25:r24, 0x08        ;addiere pro Zeile 8
    dec    r16
    rjmp    add_add
ok1:
    mov    r16, r04   
add_add1:
    cpi    r16, 0x00
    breq    ok2
    adiw    r25:r24, 0x02        ;addiere pro Wort 2
    dec    r16
    rjmp    add_add1
ok2:
    mov    r31, r25        ;lade Pageadresse
    mov    r30, r24
    andi    r30, 0b11100000        ;Wortadresse auf 0

    ldi    r21, 0x00
    mov     r22, r24        ;ge├Ąnderte Wortadresse ermitteln
    andi    r22, 0x1f       
    lsr    r22            ;wort bit 1, 0 ist byteadresse
page_l:
    cpi    r21, 16            ;f├╝r alles 16 W├Ârter
    breq    delete

    cp    r21, r22
    brne    fill_old
    mov    r00, r07        ;ge├Ąnderte Werte laden
    mov    r01, r06
    adiw    r31:r30, 0x02        ;z manuell hochz├Ąhlen
    rjmp    fill_add
fill_old:                ;lade alte Werte   
    lpm    r00, Z+
    lpm    r01, Z+
fill_add:
    mov    r28, r30        ;rette Adresszeiger
    mov    r29, r31
    mov    r30, r21
    lsl    r30            ;Linksshift   
    ldi    r16, 0b00000001
    out    spmcsr,    r16
    spm                ;W├Ârter in Puffer laden
    mov    r30, r28
    mov    r31, r29
    inc    r21
    rjmp    page_l

delete:                    ;Page l├Âschen und neu schreiben
    mov    r31, r25        ;Pageadresse laden
    mov    r30, r24
    andi    r31, 0b00000011        ;Page maskieren
    andi    r30, 0b11100000
    ldi    r16, 0b00000011        ;L├Âschbefehl laden
    out    spmcsr,    r16
    spm                ;l├Âschen
    ldi    r16, 0b00000101        ;Schreibbefehl laden       
    out    spmcsr,    r16
    spm                ;schreiben
    rcall    button            ;User bereit f├╝r neue Anzeige?
    rjmp reset            ;Editor neu starten

get_nibble:                ;Zeichen einlesen
    clr    r20            ;Ausgabe 0 setzen
s_get_nibble:
    rcall    init_display
    mov    r16, r03   
    rcall    set_x_position
    mov    r16, r02
    rcall    set_y_position
    rcall    draw_init
    mov    r16, r20
    rcall    out_nibble        ;Zeichen ausgeben
    rcall    draw_finish
    rcall    button            ;Eingabe abfragen
    cpi    r16, 0x02        ;lange gedr├╝ckt?
    breq    f_get_nibble        ;Eingabe beenden
    inc    r20            ;Eingabez├Ąhler++
    ldi    r16, 0x0f
    and    r20, r16       
    rjmp    s_get_nibble
f_get_nibble:
    ret

button:                    ;Taster abfragen
    in    r16, PINB        ;PortB einlesen
    andi    r16, 0x01        ;Port0 separieren
    cpi    r16, 0x00        ;wurde auf Masse gezogen?
    brne    button            ;nein dann weiter abfragen
    rcall    delay            ;ja dann kurz warten
    in    r16, PINB        ;erneut abfragen
    andi    r16, 0x01
    cpi    r16, 0x00        ;noch auf Masse?
    breq    ok            ;ja dann langes Event           
    ldi    r16, 0x01        ;R├╝ckgabewert f├╝r "kurz"
    ret
ok:                    ;langes dr├╝cken erkannt
    rcall    delay            ;delay
    in    r16, PINB        ;PortB einlesen
    andi    r16, 0x01
    cpi    r16, 0x00        ;noch auf Masse?
    breq    ok            ;ja dann warte
    ldi    r16, 0x02        ;R├╝ckgabewert f├╝r "lang"
    ret

out_page:                ;Seite ausgeben (6 Zeilen)
    cpi    r16, 0x00        ;erste Seite?
    breq    load_p
load_add:
    adiw    r31:r30, 48        ;pro Seite 48 Byte weiter
    dec    r16
    brne    load_add
load_p:
    ldi    r19, 0x06
    mov    r26, r30        ;Anfangsadresse laden
    mov    r27, r31   
p_loop:
    rcall    out_line
    adiw    r27:r26, 8        ;Adresse f├╝r die n├Ąchsten 8 Byte
    dec    r19
    brne    p_loop   
    ret

delay:                    ;Delay mit 2 Schleifen
    ldi    r16, 0x00
    ldi    r17, 0x00
d_wait:
    inc    r16
    cpi    r16, 0x00
    brne    d_wait
    inc    r17   
    cpi    r17, 0xa0
    brne    d_wait
    ret

out_line:                  ;Zeile ausgeben
    mov    r16, r27        ;Adresse laden (H)
    rcall    out_byte      ;Adresse ausgeben
    mov    r16, r26        ;Adresse laden (L)
    rcall    out_byte      ;Adresse ausgeben
    ldi    r16, 0x00       ;":" bauen und ausgeben
    rcall spi_out
    ldi    r16, 0x00
    rcall spi_out
    ldi    r16, 0x24
    rcall spi_out
    ldi    r16, 0x00
    rcall spi_out
    ldi    r18, 0x08        ;Z├Ąhler f├╝r 8 Byte   
l_loop:
    lpm    r16, Z+            ;Byte laden
    rcall    out_byte        ;Byte ausgeben
    dec    r18
    brne    l_loop   
    ret

out_byte:                ;Byte ausgeben
    mov    r00, r16        ;Zeichen retten
    swap    r16            ;oberstes Nibble
    andi    r16, 15            ;Maskierung
    mov    r28, r30        ;rette Z-Register
    mov    r29, r31        ;rette Z-Register
    rcall    out_nibble        ;Ausgabe
    mov    r16, r00        ;unterstes Nibble   
    andi    r16, 15            ;Maskierung
    rcall    out_nibble        ;Ausgabe
    mov    r30, r28        ;rette Z-Register
    mov    r31, r29        ;rette Z-Register
    ret

draw_init:                ;Daten├╝bertragung vorbereiten
    sbi    PORTB, LCD_DC        ;LCD Kommandomodus setzen
    cbi    PORTB, LCD_SCE        ;LCD aktivieren
    ret

draw_finish:                ;LCD Schreibvorgang abschlie├Ÿen
    sbi    PORTB, LCD_SCE        ;LCD deaktivieren   
    ret

init_display:
    ldi    r16, 0x21        ;Displayinitialisierung
    rcall    lcd_write_cmd
    ldi    r16, 0xD0
    rcall    lcd_write_cmd
    ldi    r16, 0x04
    rcall    lcd_write_cmd
    ldi    r16, 0x13
    rcall    lcd_write_cmd
    ldi    r16, 0x20
    rcall    lcd_write_cmd
    ldi    r16, 0x0C
    rcall    lcd_write_cmd

    ldi    r16, 0x21        ;Kontrasteinstellung
    rcall    lcd_write_cmd
    ldi    r16, 0x80 | 0x3C    ;Kontrastwert laden
    rcall    lcd_write_cmd
    ldi    r16, 0x20
    rcall    lcd_write_cmd

    ret

set_x_position:                ;LCD x-Position setzen
    ori    r16, 0x80        ;Wertnormalisierung
    rcall    lcd_write_cmd        ;Daten schreiben
    ret

set_y_position:                ;LCD y-Position setzen
    ori    r16, 0x40        ;Wertnormalisierung
    rcall    lcd_write_cmd        ;Daten schreiben
    ret

spi_out:                ;Software SPI
    cbi    PORTB, LCD_SCLK        ;Clock auf 0 setzen
    ldi    r17, 0x08        ;Schleifenz├Ąhler f├╝r 8 Bit
spi_out_byte:                ;Byte ausgeben
    sbrc    r16, 0x07        ;Pr├╝fe ob Bit 7 nicht gesetzt
    sbi    PORTB, LCD_SDIN        ;Datenleitung auf 1 setzen
    sbrs    r16, 0x07        ;Pr├╝fe ob Bit 7 gesetzt
    cbi    PORTB, LCD_SDIN        ;Datenleitung auf 0 setzen
    sbi    PORTB, LCD_SCLK        ;Clock auf 1 setzen
    cbi    PORTB, LCD_SCLK        ;Clock auf 0 setzen
    lsl    r16            ;Shift f├╝r n├Ąchstes Bit   
    dec    r17            ;Schleifenz├Ąhler--
    brne    spi_out_byte        ;F├╝r alle ├╝brigen Bits
    ret

lcd_write_cmd:                ;LCD Kommando schreiben
    cbi    PORTB, LCD_DC        ;LCD Kommandomodus setzen
    rcall    lcd_out            ;Daten schreiben
    ret

lcd_write_data:                 ;LCD Daten schreiben
    sbi    PORTB, LCD_DC        ;LCD Datenmodus setzen
    rcall    lcd_out            ;Daten schreiben
    ret

lcd_out:
    cbi    PORTB, LCD_SCE        ;LCD aktivieren
    rcall    spi_out             ;Daten ausgeben
    sbi    PORTB, LCD_SCE        ;LCD deaktivieren
    ret

out_nibble:                ;Nibble ausgeben   
    add    r16, r16
    add    r16, r16        ;Zeichenadressierung
    ldi    r30, LOW(data*2)    ;Offset laden
    ldi    r31, HIGH(data*2)   
    add    r30, r16        ;Zeichenposition addieren
    ldi    r16, 0x00
    adc    r31, r16
    lpm    r16, Z+         ;Zeichen laden
    rcall spi_out          ;Zeichen ausgeben
    lpm    r16, Z+         ;...
    rcall spi_out
    lpm    r16, Z+
    rcall spi_out
    lpm    r16, Z+
    rcall spi_out   
    ret

data:                    ;Zeichensatz
    .db    0x00, 0x3E, 0x41, 0x3E    ;0
    .db    0x00, 0x04, 0x02, 0x7F    ;1
    .db    0x00, 0x46, 0x71, 0x4E    ;2
    .db    0x00, 0x49, 0x49, 0x36    ;3
    .db    0x00, 0x0C, 0x0A, 0x7F    ;4
    .db    0x00, 0x4F, 0x49, 0x31    ;5
    .db    0x00, 0x3E, 0x49, 0x31    ;6
    .db    0x00, 0x01, 0x79, 0x0F    ;7
    .db    0x00, 0x36, 0x49, 0x36    ;8
    .db    0x00, 0x46, 0x49, 0x3E    ;9
    .db    0x00, 0x7F, 0x09, 0x7F    ;A
    .db    0x00, 0x7F, 0x49, 0x36    ;B
    .db    0x00, 0x3E, 0x41, 0x41    ;C
    .db    0x00, 0x7F, 0x41, 0x3E    ;D
    .db    0x00, 0x7F, 0x49, 0x49    ;E
    .db    0x00, 0x7F, 0x09, 0x09    ;F

flash_end:
    rjmp    init            ;jmp to editor



Elektronik-Labor  Projekte   AVR   T13-Contest