Jako że w tym dziale się relatywnie mało dzieje, a ja właśnie jestem na etapie nauki assemblera dla avrów, to trochę ożywię forum i pochwalę się nowym programikiem napisanym w asm.
Program multipleksuje czteropozycyjny siedmiosegmentowy wyświetlacz, przesuwając na nim datę i godzinę pobieraną przez sprzętowy moduł I2C. Zestaw: ATB 1.04, procek: atmega32, kwarc: 11059200, kalendarium: PCF8583.
Wykorzystane są trzy przerwania:
INT0 z PCF-a, w którym atmega pobiera datę, "obrabia" dane (przekształca je na graficzne reprezentacje cyfr) i umieszcza w wyświetlanym buforze,
OC1A, które przesuwa wyświetlany bufor,
OC2, które multipleksuje wyświetlacz.
PCF-a już wcześniej zaprogramowałem na daną datę i godzinę. Póki co mój programik tylko odczytuje dane z tego scalaka i jeszcze nic nie zapisuje, ale dzięki temu, że w całości odbywa się w przerwaniach, a główna pętla programu jest pusta, można ją swobodnie zaprzęgnąć do np. ustawiania daty i godziny 
Jest to mój pierwszy bardziej sensowny program w asm, więc proszę o sugestie i uwagi bardziej zaawansowanych (bo nie znam się jeszcze m.in. na dobrej organizacji kodu asemblerowego, domyślam się też, że pewnie powinienem ujednolicić własne definicje 
). A do tych, którzy są w tym temacie krok za mną - jak macie jakieś pytania, to postaram się odpowiedzieć w miarę możliwości 
Poniżej kod i filmik, jak to śmiga.
[syntax=asm]/*
* mydefs.inc
*
* Created: 2014-08-19 19:18:15
* Author: HCOOH
*/
; Moje definicje
; Definicje portow
.equ POZ_PORT= PORTB
.equ POZ_DDR= DDRB
.equ CYF_PORT= PORTA
.equ CYF_DDR= DDRA
; Czy uzywana optymalna funkcja przetwarzania znaku na jego graficzna interpretacje
; Bajt pobierany z I2C jest bezposrednio konwertowany w rejestrze
; z pominieciem przechowania jego wartosci w komorce SRAM
.equ USE_FORM_CHAR_FROM_I2C = 1
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Wartosci PORTB
.equ poz1 = 0x0E; wartosci dla PORTB (sterujacy pozycjami)
.equ poz2 = 0x0D; aby wlaczal kolejne pozycje
.equ poz3 = 0x0B
.equ poz4 = 0x07
; Wartosci PORTA
.equ c0= 0b11000000; wartosci dla PORTA (sterujacy segmentami)
.equ c1= 0b11111001; aby wlaczal symbole kolejnych cyfr
.equ c2= 0b10100100
.equ c3= 0b10110000
.equ c4= 0b10011001
.equ c5= 0b10010010
.equ c6= 0b10000010
.equ c7= 0b11111000
.equ c8= 0b10000000
.equ c9= 0b10010000
.equ dot= 0b01111111
.equ s= 0b11111111
.equ dash= 0b10111111
; Rejestry
.def rmp= r16; multipurpose regs
.def rmp2= r17; 1 & 2
.def ri2c = r18; rejestry do operacji z I2C
.def rack = r19; 1 & 2
.def rcell = r13; rejestr przechowujacy komorke dostepu w PCF8583
.def rsreg = r15; rejestr do zapamietywania wartosci SREG
.def buf1= r20; cztery rejestry do przechowywania zawartosci wyswietlacza
.def buf2= r21; 1 & 2
.def buf3= r22; & 3
.def buf4= r23; & 4
.def cnt1= r25; MSB
.def cnt2= r24; LSB
; Dlugosc wyswietlanego paska daty i godziny
.equ str_len = 22
.equ PCF_ADR = 0xA2
; Makra ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Ustawienie domyslnych wartosci wyswietlanemu paskowi
; Niektore z komorek (takie jak te zawierajace wartosc "dash")
; oplaca sie inicjowac w ten sposob.
; Inne mozna pominac, aby zmniejszyc objetosc kodu
; ale chcialem miec efekt daty i godziny od poczatku pisania programu
; (zanim pobiore jakiekolwiek dane z I2C)
.macro SetDisplay
ldi XH, HIGH(DisplTab)
ldi XL, LOW(DisplTab)
ldi rmp, s
st X+, rmp
ldi rmp, s
st X+, rmp
ldi rmp, s
st X+, rmp
ldi rmp, s; 4
st X+, rmp
ldi rmp, c2
st X+, rmp
ldi rmp, c0
st X+, rmp
ldi rmp, c1
st X+, rmp
ldi rmp, c4
st X+, rmp; 8
ldi rmp, dash
st X+, rmp; 9
ldi rmp, c0
st X+, rmp
ldi rmp, c8
st X+, rmp; 11
ldi rmp, dash
st X+, rmp; 12
ldi rmp, c1
st X+, rmp
ldi rmp, c9
st X+, rmp; 14
ldi rmp, s
st X+, rmp
ldi rmp, s
st X+, rmp; 16
ldi rmp, c1
st X+, rmp
ldi rmp, c7 & dot
st X+, rmp
ldi rmp, c5
st X+, rmp
ldi rmp, c6
st X+, rmp; 20
ldi rmp, s
st X+, rmp
ldi rmp, s
st X+, rmp
ldi rmp, s
st X+, rmp
ldi rmp, s
st X+, rmp
.endmacro
.macro I2C_init
ldi ri2c, (1<<TWPS0)|(1<<TWPS1); inicjalizacja I2C
out TWSR, ri2c
ldi ri2c, 1
out TWBR, ri2c
.endmacro[/syntax]
[syntax=asm]/*
* i2c.asm
*
* Created: 2014-08-19 21:25:18
* Author: HCOOH
*/
I2C_start:
ldi ri2c, (1<<TWINT)|(1<<TWEN)|(1<<TWSTA)
out TWCR, ri2c
_istrwhile:
in ri2c, TWCR
sbrs ri2c, TWINT
rjmp _istrwhile
ret
; ; ;
I2C_stop:
ldi rack, (1<<TWINT)|(1<<TWEN)|(1<<TWSTO)
out TWCR, rack
_istowhile:
in rack, TWCR
sbrc rack, TWSTO
rjmp _istowhile
ret
; ; ;
I2C_write_byte:
out TWDR, ri2c
ldi ri2c, (1<<TWINT)|(1<<TWEN)
out TWCR, ri2c
_istr2while:
in ri2c, TWCR
sbrs ri2c, TWINT
rjmp _istr2while
ret
; ; ;
I2C_read_byte:
cpi rack, 1
breq _isetack
ldi ri2c, (1<<TWINT)|(1<<TWEN)|(0<<TWEA)
out TWCR, ri2c
rjmp _irgoon
_isetack:
ldi ri2c, (1<<TWINT)|(1<<TWEN)|(1<<TWEA)
out TWCR, ri2c
_irgoon:
in ri2c, TWCR
sbrs ri2c, TWINT
rjmp _irgoon
in ri2c, TWDR
ret
; ; ;
; Procedura pobierajaca jeden bajt z ukladu PCF8583
; i zwracajaca go w rejestrze ri2c
; tuz przed jej uruchomieniem trzeba nadac rejestrowi rmp wartosc
; okreslajaca numer komorki w pamieci RAM ukladu PCF8583
; z ktorej ma byc pobrany bajt
; Np. ldi rmp, 2; (komorka przechowujaca sekundy)
; rcall PCF_get_byte; wywolanie procedury
; out PORTB, ri2c; wyswietlenie na porcie B wartosci binarnej aktualnej ilosci sekund (format BCD)
PCF_get_byte:
mov rcell, rmp
rcall I2C_start
ldi ri2c, PCF_ADR
rcall I2C_write_byte
mov ri2c, rcell
rcall I2C_write_byte
rcall I2C_start
ldi ri2c, PCF_ADR + 1
rcall I2C_write_byte
ldi rack, 0
rcall I2C_read_byte
rcall I2C_stop
nop nop nop
ret
; innym pomyslem (pewnie lepszym) byloby zrobienie procedury
; PCF_get_date, ktora za jednym zamachem zczytywalaby kilka bajtow
; przyspieszyloby to program[/syntax]
[syntax=asm]/*
* main.asm
*
* Program pobierajacy date i godzine z ukladu PCF8583
* i wyswietlajacy je na wyswietlaczu LED 7-segmentowym
* w formie przesuwanego paska.
*
* Created: 2014-08-19 21:39:35
* Author: HCOOH
*/
.nolist
.include "m32def.inc"
.include "mydefs.inc"
.list
; Przestrzen FLASH ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
.cseg
.org 0
; Wektory poczatkowe (zerowanie + przerwania)
rjmp Main; poczatek progrmau
nop
rjmp INT_0; INT0
nop; pobranie danych przez I2C
reti; INT1
nop
reti; INT2
nop
rjmp OC2; OC2
nop; multipleksowanie wyswietlacza led
reti; OVF2
nop
reti; ICP1
nop
rjmp OC1A; OC1A
; delay przesuwania napisu
; Poczatek programu glownego ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Main:
SetDisplay; makro ustawiajace wyswietlacz
ldi rmp, HIGH(RAMEND); stworzenie stosu
out SPH, rmp
ldi rmp, LOW(RAMEND)
out SPL, rmp
I2C_init; inicjalizacja modulu TWI
ldi rmp, 0xFF; ustawienie rejestrow in/out
out CYF_DDR, rmp; PORTB - pozycje wyswietlacza
out POZ_DDR, rmp; PORTA - symbole cyfr
out CYF_PORT, rmp
out POZ_PORT, rmp
out PORTD, rmp
ldi rmp, (1<<WGM21)|(1<<CS22)|(1<<CS21)|(1<<CS20); Timer2 w tryb CTC, prescaler 1024
out TCCR2, rmp; f = 10800Hz
ldi rmp, 0x0B; OCR2 = 11 - f = 10800Hz / 11 = ~982Hz
out OCR2, rmp; czestotliwosc odswiezania (dla 4 cyfr) = 982Hz / 4 = 245.5Hz
ldi rmp, (1<<WGM12)|(1<<CS10)|(1<<CS12); Timer1 w tryb CTC, prescaler 1024
out TCCR1B, rmp; f = 10
ldi rmp, 0x07; OCR1AH = 0x07
out OCR1AH, rmp
ldi rmp, 0x38; OCR1AL = 0x38
out OCR1AL, rmp; sumarycznie OCR1A = 1848
; czestotliwosc przesuwu paska = 10800Hz / 1848 = ~5.84Hz
ldi rmp, (1<<OCIE1A)|(1<<OCIE2)
out TIMSK, rmp; zezwolenie na przerwanie OC2 i OC1A
ldi cnt1, HIGH(DisplTab); zaladowanie adresu wyswietlanego bufora
ldi cnt2, LOW(DisplTab); do pomocniczego rejestru
ldi rmp, (1<<ISC01)
out MCUCR, rmp; zbocze opadajace na INT0
ldi rmp, (1<<INT0); przerwanie od INT0 ON
out GICR, rmp
sei; przerwania ON
; Petla glowna programu ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
MainLoop:
; petla glowna pusta :)
; czyli mozliwosci rozbudowy programu
; dopiero sie zaczynaja
; np tutaj mozna utworzyc procedury nastawiania zegara
; zwroc uwage, ze rejestry rmp i rmp2 sa w przerwaniach uzywane
; z odkladaniem i pobieraniem ich ze stosu
; wiec w glownym watku mozna z nich korzystac do woli
rjmp MainLoop
; Koniec petli glownej programu
; Koniec programu glownego
; ; ;
; Procedury obslugi przerwan ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; INT0
INT_0:
push rmp
ldi rmp, 3
rcall PCF_get_byte
mov rmp, ri2c
andi ri2c, 0x0F; obrobka bajtu BCD
rcall FormCharFromI2C
sts dMin1, ri2c
mov ri2c, rmp
rcall lsr_ri2c_4x; obrobka bajtu BCD
andi ri2c, 0x07; cd.
rcall FormCharFromI2C
sts dMin, ri2c
;
ldi rmp, 4
rcall PCF_get_byte
mov rmp, ri2c
andi ri2c, 0x0F; obrobka bajtu BCD
rcall FormCharFromI2C
andi ri2c, dot
sts dGodz1, ri2c
mov ri2c, rmp
rcall lsr_ri2c_4x; obrobka bajtu BCD
andi ri2c, 0x03; cd.
rcall FormCharFromI2C
sts dGodz, ri2c
;
ldi rmp, 5
rcall PCF_get_byte
mov rmp, ri2c
andi ri2c, 0x0F; obrobka bajtu BCD
rcall FormCharFromI2C
sts dDzien1, ri2c
mov ri2c, rmp
rcall lsr_ri2c_4x; obrobka bajtu BCD
andi ri2c, 0x03; cd.
rcall FormCharFromI2C
sts dDzien, ri2c
;
ldi rmp, 6
rcall PCF_get_byte
mov rmp, ri2c
andi ri2c, 0x0F; obrobka bajtu BCD
rcall FormCharFromI2C
sts dMies1, ri2c
mov ri2c, rmp
rcall lsr_ri2c_4x; obrobka bajtu BCD
andi ri2c, 0x01; cd.
rcall FormCharFromI2C
sts dMies, ri2c
pop rmp
reti
; pomocniczna (optymalizujaca flash) procedura do przesuniecia bitowego ri2c >> 4
lsr_ri2c_4x:
lsr ri2c
lsr ri2c
lsr ri2c
lsr ri2c
ret
; INT0 - koniec
; Output Compare Match 2
OC2:
push rmp2
push rmp
lds rmp2, Pos
_oc2_beg:
inc rmp2; rotujacy licznik 0 - 4
cpi rmp2, 0x05
breq _oc2_zero
cpi rmp2, 0x01
breq _oc2_1
cpi rmp2, 0x02
breq _oc2_2
cpi rmp2, 0x03
breq _oc2_3
cpi rmp2, 0x04
breq _oc2_4
;;
_oc2_1:
ldi rmp, poz4
out POZ_PORT, rmp; uruchomienie pozycji 4
out CYF_PORT, buf1
rjmp _oc2_end
_oc2_2:
ldi rmp, poz3
out POZ_PORT, rmp; uruchomienie pozycji 3
out CYF_PORT, buf2
rjmp _oc2_end
_oc2_3:
ldi rmp, poz2
out POZ_PORT, rmp; uruchomienie pozycji 2
out CYF_PORT, buf3
rjmp _oc2_end
_oc2_4:
ldi rmp, poz1
out POZ_PORT, rmp; uruchomienie pozycji 1
out CYF_PORT, buf4
rjmp _oc2_end
;;
_oc2_zero:
clr rmp2
rjmp _oc2_beg
_oc2_end:
sts Pos, rmp2
pop rmp
pop rmp2
reti
; Output Compare Match 2 - koniec
; Output Compare Match 1A
OC1A:
push rmp
push rmp2
lds rmp, Slide
ldi rmp2, 0x00
_oc1a_beg:
mov XH, cnt1
mov XL, cnt2
ld buf1, X+
ld buf2, X+
ld buf3, X+
ld buf4, X+
inc cnt2
adc cnt1, rmp2
inc rmp
cpi rmp, str_len
breq _oc1a_again
sts Slide, rmp
pop rmp2
pop rmp
reti
_oc1a_again:
ldi rmp, 0x00
ldi cnt1, HIGH(DisplTab)
ldi cnt2, LOW(DisplTab)
rjmp _oc1a_beg
reti
; Output Compare Match 1A - koniec
; Procedury - inne ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
.if USE_FORM_CHAR_FROM_I2C == 0
; wersja procedury bez uzycia z I2C
; czyli uformowanie znaku z jakiegokolwiek zrodla
; troche wolniejsza i pozerajaca dodatkowy bajt SRAM
; ale za to bardziej uniwersalna pod wzgledem
; korzystania z rejestrow, a wiec bardziej elastyczna
FormChar:
push rmp2
lds rmp2, Recreate
cpi rmp2, 0
breq _form_0
cpi rmp2, 1
breq _form_1
cpi rmp2, 2
breq _form_2
cpi rmp2, 3
breq _form_3
cpi rmp2, 4
breq _form_4
cpi rmp2, 5
breq _form_5
cpi rmp2, 6
breq _form_6
cpi rmp2, 7
breq _form_7
cpi rmp2, 8
breq _form_8
cpi rmp2, 9
breq _form_9
ldi rmp2, dot
sts Recreate, rmp2
rjmp _form_end
_form_0:
ldi rmp2, c0
sts Recreate, rmp2
rjmp _form_end
_form_1:
ldi rmp2, c1
sts Recreate, rmp2
rjmp _form_end
_form_2:
ldi rmp2, c2
sts Recreate, rmp2
rjmp _form_end
_form_3:
ldi rmp2, c3
sts Recreate, rmp2
rjmp _form_end
_form_4:
ldi rmp2, c4
sts Recreate, rmp2
rjmp _form_end
_form_5:
ldi rmp2, c5
sts Recreate, rmp2
rjmp _form_end
_form_6:
ldi rmp2, c6
sts Recreate, rmp2
rjmp _form_end
_form_7:
ldi rmp2, c7
sts Recreate, rmp2
rjmp _form_end
_form_8:
ldi rmp2, c8
sts Recreate, rmp2
rjmp _form_end
_form_9:
ldi rmp2, c9
sts Recreate, rmp2
rjmp _form_end
_form_end:
pop rmp2
ret
.endif
; druga wersja:
; Procedura otrzymujaca w rejestrze bajt z wartoscia 0x00 - 0x09
; i przerabiajaca go na graficzna interpretacje cyfry
; wartosci > 0x09 zostana zmienione na znaczek "." (dot)
;
; wartosc otrzymywana jest z I2C w rejestrze ri2c
; i tamze zmieniana (bez angazowania pamieci RAM)
.if USE_FORM_CHAR_FROM_I2C
FormCharFromI2C:
cpi ri2c, 0
breq _form_0
cpi ri2c, 1
breq _form_1
cpi ri2c, 2
breq _form_2
cpi ri2c, 3
breq _form_3
cpi ri2c, 4
breq _form_4
cpi ri2c, 5
breq _form_5
cpi ri2c, 6
breq _form_6
cpi ri2c, 7
breq _form_7
cpi ri2c, 8
breq _form_8
cpi ri2c, 9
breq _form_9
ldi ri2c, dot
rjmp _form_end
_form_0:
ldi ri2c, c0
rjmp _form_end
_form_1:
ldi ri2c, c1
rjmp _form_end
_form_2:
ldi ri2c, c2
rjmp _form_end
_form_3:
ldi ri2c, c3
rjmp _form_end
_form_4:
ldi ri2c, c4
rjmp _form_end
_form_5:
ldi ri2c, c5
rjmp _form_end
_form_6:
ldi ri2c, c6
rjmp _form_end
_form_7:
ldi ri2c, c7
rjmp _form_end
_form_8:
ldi ri2c, c8
rjmp _form_end
_form_9:
ldi ri2c, c9
rjmp _form_end
_form_end:
ret
.endif
; ; ;
.include "i2c.asm"; doklejenie procedur obslugi I2C
; ; ;
; Przestrzen SRAM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
.dseg
.org 0x0060
Pos:; numer wyswietlanej pozycji
.byte 1
Slide:; wartosc przesuniecia napisu
.byte 1
.if USE_FORM_CHAR_FROM_I2C == 0
Recreate:; komorka przetwarzajaca wartosc binarna cyfry na graficzna interpretacje
.byte 1; (przy pomocy procedury FormChar)
.endif
DisplTab:; bufor przesuwanego napisu
.byte str_len
; Pozycje wyswietlacza
; aliasy do latwiejszego poruszania sie po
; fragmentach wyswietlanego bufora (napisu)
.equ dRok1 = DisplTab + 7
.equ dMies = DisplTab + 9
.equ dMies1 = DisplTab + 10
.equ dDzien = DisplTab + 12
.equ dDzien1 = DisplTab + 13
.equ dGodz = DisplTab + 16
.equ dGodz1 = DisplTab + 17
.equ dMin = DisplTab + 18
.equ dMin1 = DisplTab + 19[/syntax]
------------------------ [ Dodano po: 1 minucie ]
Filmik będzie za chwil kilka
------------------------ [ Dodano po: 33 minutach ]
Oto i on:
https://www.youtube.com/watch?v=B32EgeLAvaYStatystyki: Napisane przez HCOOH — 26 sie 2014, o 21:42
]]>
Podziwiam ludzi którzy piszą w tym języku, mi nigdy nie wystarczyło samozaparcia, aby nawet liznąć ten język.