Elektronika, ukázky pro STM8S103F3, plus programování v assembleru.

Stolní digitální hodiny s DS3231

nastavované pomocí dálkového infra ovladače

Tento miniprojekt se snaží demonstrovat použití v assembleru nejen vlastního modulu reálného času, ale i displeje TM1637 a infrasnímače. Modul hodin je připojen ke sběrnici I2C, displej komunikuje sériově pomocí vlastního protokolu a infrasnímač (zde uváděný) jede podle standartu NEC.

Použité moduly:

Čas se nastavuje dálkovým ovladačem. Stiskkem hvězdičky se dostanete se módu nastavení. Displej zhasne a pak prostě namačkáte čas ve tvaru HHMM. Stiskem OK se čas uloží. Při uložení se vynulují vteřiny. Křížky (hash) fungují jako escape, mód nastavení se opustí bez uložení. Pomocí šipek nahoru/dolů se ovládá jas displeje.
schema

stáhnout toto schéma v PDF

V programu jsou aktivní dvě přerušení. Od timeru každou vteřinu a od infračerveného snímače při přijetí platného kódu. Další podrobnosti jsou v komentářích ve zdrojovém kódu níže.

stm8/

              .form 64
              .tab 10,8,18,60
               TITLE "RTC DS-3231"

              #include "mapping.inc"

ram0_start.b   equ  $ram0_segment_start
ram0_end.b     equ  $ram0_segment_end
ram1_start.w   equ  $ram1_segment_start
ram1_end.w     equ  $ram1_segment_end	
stack_start.w  equ  $stack_segment_start 
stack_end.w    equ  $stack_segment_end

;-------------------------------------------------------------

CLK_CKDIVR     equ  $50C6 ; Clock divider register

I2C_CR1        equ  $5210 ; adresy registru i2c
I2C_CR2        equ  $5211
I2C_FREQR      equ  $5212
I2C_OARL       equ  $5213
I2C_OARH       equ  $5214
I2C_DR         equ  $5216
I2C_SR1        equ  $5217
I2C_SR2        equ  $5218
I2C_SR3        equ  $5219
I2C_CCRL       equ  $521B
I2C_CCRH       equ  $521C
I2C_TRISER     equ  $521D
RTC_ADRESA     equ  $68   ; i2c adresa modulu

PD_ODR         equ  $500F
PD_IDR         equ  $5010
PD_DDR         equ  $5011
PD_CR1         equ  $5012
DIO_PIN        equ  3     ; PD3
CLK_PIN        equ  4     ; PD4

PA_ODR         equ  $5000 ; PA3 infra
PA_IDR         equ  $5001
PA_DDR         equ  $5002
PA_CR1         equ  $5003
PA_CR2         equ  $5004
PIN_INFRA      equ  3
EXTI_CR1       equ  $50A0
EXTI_CR2       equ  $50A1
HRANICE_0_1    equ  $02   ; co je mene je nula, vice, nebo rovno jednicka
INFRA_START    equ  $0B00 ; delka start impulzu infra

TIM_CR1        equ  $5300 ; timer 2
TIM_SR1        equ  $5304 
TIM_ARRH       equ  $530F 
TIM_ARRL       equ  $5310 
TIM_PSCR       equ  $530E 
TIM_IER        equ  $5303 

CASOVAC        equ  0
DVOJTEC        equ  1
INFRA          equ  3
NEC_VALID      equ  6
PRENOS         equ  7

;-- RAM promenne-----------------------------------------------

               segment 'ram0'
               
raw_infra      ds.b     32  ; raw data z infra
infra_long     ds.b     3   ; nactena hodnota z infra
infra_kod      ds.b     1
priznaky       ds.b     1   
ack            ds.b     1   ; TM1637
jas            ds.b     1   ; jas displeje 1 az 7
tmcounter      ds.b     1
dumph          ds.b     1  
dumpl          ds.b     1  
raw_cnt        ds.b     1
cislo          ds.b     1
poradiz        ds.b     1
set_h1         ds.b     1
set_h2         ds.b     1
set_m1         ds.b     1
set_m2         ds.b     1
i2c_reg        ds.b     1  ; pro i2c registr
i2c_val        ds.b     1  ; pro i2c hodnotu
minuty         ds.b     1
hodiny         ds.b     1
ticky          ds.b     1  ; pro kontrolu v timeru

               segment 'ram1'

;-- PROGRAM ---------------------------------------------------
               segment 'rom'

;-- inicializace SETUP ----------------------------------------

main           sim
               mov   CLK_CKDIVR, #$18   ;cpu rychlost 2MHz         
               ldw   X, #stack_end
               ldw   SP, X
               ldw   X, #ram0_start
clear_ram0     clr   (X)
               incw  X
               cpw   X, #ram0_end	
               jrule clear_ram0
               ldw   X, #ram1_start
clear_ram1     clr  (X)
               incw  X
               cpw   X, #ram1_end	
               jrule clear_ram1	            
               ldw   X, #stack_start
clear_stack    clr  (X)
               incw  X
               cpw   X, #stack_end	
               jrule clear_stack
               
               bres  PA_DDR, #PIN_INFRA   ; ifra 
               bset  PA_CR1, #PIN_INFRA   ; pull-up
               bres  EXTI_CR1, #0         ; rising ne
               bset  EXTI_CR1, #1         ; falling ano
               bset  PA_CR2, #PIN_INFRA   ; interrupt povol
               bset  PD_DDR, #CLK_PIN     ; TM-1637 CLK a DIO
               bset  PD_DDR, #DIO_PIN     ; na output push-pull
               bset  PD_CR1, #CLK_PIN
               bset  PD_CR1, #DIO_PIN
               mov   TIM_ARRH, #$3c       ; 1sec pri fCPU 2MHz
               mov   TIM_ARRL, #$f8
               mov   TIM_PSCR, #$07
               bset  TIM_CR1, #0          ; povol timer
               bset  TIM_IER, #0
               mov   jas, #5              ; init jas
               mov   ticky, #3
               call  i2c_init          
               rim  ; povol preruseni
               
;-- hlavni smycka LOOP ----------------------------------------

infinite_loop.l
               btjt   priznaky, #INFRA, infra_stisk
               btjf   priznaky, #CASOVAC, infinite_loop ;ceka na signal z timeru
               bres   priznaky, #CASOVAC
               call   precti_cas
               call   zobraz_cas
               jra    infinite_loop               
infra_stisk    bres   priznaky, #INFRA
               ld     a, infra_kod       ; staci testovat posledni byte
               cp     a, infra_down
               jrne  _dal
               call   stmav
               jra   _vzc
_dal           cp     a, infra_up
               jrne  _dal2
               call   zjasni
               jra   _vzc
_dal2          cp     a, infra_hvez      ; hvezdicka nastaveni
               jrne  _vzc                ;call   pauza
               bres   TIM_CR1, #0        ; zastav timer
               bres   TIM_IER, #0
               bset   PA_CR2, #PIN_INFRA ; povol preruseni, cekej dalsi kod infra
               callr  infra_set
_vzc           bset   PA_CR2, #PIN_INFRA ; povol preruseni, cekej dalsi kod infra               
               bset   TIM_CR1, #0        ; povol timer
               bset   TIM_IER, #0
               jra    infinite_loop
               
infra_set     ;nastav cas infra ovladacem
               call   vymaz
               clr    poradiz
               clr    dumph
               clr    set_h1
               clr    set_h2
               clr    set_m1
               clr    set_m2
_ckod          bset   PA_CR2, #PIN_INFRA  ;povol preruseni, cekej kod infra
_rdz           btjf   priznaky, #INFRA, _rdz
               bres   priznaky, #INFRA  
               ld     a, infra_kod
               cp     a, infra_hash               
               jreq  _kz
               cp     a, infra_hash2
               jreq  _kz
               cp     a, infra_hvez
               jreq   infra_set        ; opakuj
               callr  cislice
               cp     a, #9
               jrugt _ckod             ; chybny znak
               ldw    x, #set_h1
               mov    dumpl, poradiz
               addw   x, dumph
               ld     a, cislo
               ld    (x), a
               pushw  x
               ld     xh, a
               ld     a, poradiz
               ld     xl, a
               call   zobraz1
               callr  pauza
               popw   x
               inc    poradiz
               bset   PA_CR2, #PIN_INFRA  ;povol preruseni, cekej dalsi kod infra
               ld     a, poradiz
               cp     a, #4
               jrne   _ckod
               bset   PA_CR2, #PIN_INFRA  ;povol preruseni, cekej potvrzeni
_potv          btjf   priznaky, #INFRA, _potv ;*=znovu, ok=uloz, jinak ven
               ld     a, infra_kod
               cp     a, infra_hvez ;jznovu
               jreq   infra_set
               cp     a, infra_ok
               jrne  _kz
               call   odesli_cas
_kz            call   precti_cas
               call   zobraz_cas
               ret
               
pauza         ;pauza po prijeti kodu cca 0.5 sec pro 2MHz CPU
               push   a
               pushw  y
               ld     a, #4
_cyklus        ldw    y, $ffff
_cyklus2       nop
               decw   y
               jrne  _cyklus2
               dec    a
               jrne  _cyklus
               popw   y
               pop    a
               ret
               
cislice       ;prevede kod infra v A na cislo, vrati ve znak
               ldw    x, #infra_0
               clr    cislo
_dz            ld     a, infra_kod
               cp     a, (x)
               jreq   _zr
               incw   x
               inc    cislo
               ld     a, cislo
               cp     a, #10
               jrne  _dz
_zr            ld     a, cislo    
               ret               
;--- i2c -------------------------------------------------------

i2c_init      ;nastavi i2c
               bres   I2C_CR1, #0     ; PE=0
               clr    I2C_CR1         ; init i2c
               mov    I2C_FREQR, #16
               mov    I2C_CCRL, #80   ; CCR = 80 - 100 kHz
               clr    I2C_CCRH
               mov    I2C_TRISER, #17 ; TRISE = 16+1
               bset   I2C_CR1, #0     ; PE=1
               ret

rtc_start     ;start transakce RTC
               bset   I2C_CR2, #0            ; start bit
_startw        btjf   I2C_SR1, #0, _startw   ; start spusten
               ld     a, #RTC_ADRESA
               sll    a                      ; adresa pro zapis
               ld     I2C_DR, a 
_waitaddr      btjf   I2C_SR1, #1, _waitaddr ; cekat na ADDR               
               ld     a, I2C_SR3             ; dummy read kvuli clear ADDR    
               ret
                              
i2c_writeb    ;zapise jeden byte v i2c_val do registru i2c_reg
               callr  rtc_start
               mov    I2C_DR, i2c_reg    ; posle registr
_wtx1          btjf   I2C_SR1, #7, _wtx1 ; cekat TXE
               mov    I2C_DR, i2c_val    ; posle data 
_wtx2          btjf   I2C_SR1, #7, _wtx2 ; cekat TXE
               bset   I2C_CR2, #1        ; stop
               ret

rtc_readb     ;precte jeden byte do i2c_val z registru i2c_reg
               callr  rtc_start
               mov    I2C_DR, i2c_reg    ; posle registr
_wtx3          btjf   I2C_SR1, #7, _wtx3 ; cekat TXE
               bset   I2C_CR2, #0        ; opakovany start
_starto        btjf   I2C_SR1, #0, _starto
               bres   I2C_CR2, #2        ; ACK=0
               ld     a, #RTC_ADRESA 
               sll    a                  ; adresa pro cteni
               or     a, #1
               ld     I2C_DR, a
_wtx4          btjf   I2C_SR1, #1, _wtx4
               ld     a, I2C_SR3         ; dummy read kvuli clear ADDR    
_wrx           btjf   I2C_SR1, #6, _wrx
               mov    i2c_val, I2C_DR    ; precte byte
               bset   I2C_CR2, #1        ; stop
               ret
               
;--- RTC DS3231 -----------------------------------------------

odesli_cas    ;ulozi cas v set_h1, h2 m1, m2
               ld     a, set_h1
               swap   a
               or     a, set_h2
               ld     i2c_val, a  ;hodiny
               mov    i2c_reg, #2 ;;registr pro hodiny
               callr  i2c_writeb  ;zapis hodiny
               ld     a, set_m1
               swap   a
               or     a, set_m2
               ld     yl, a       ;minuty
               ld     a, #1
               ld     yh, a       ;registr pro minuty
               callr  i2c_writeb  ;zapis minuty
               clrw   y           ;nakonec vynuluj sekundy reg=0 sec=0
               callr  i2c_writeb
               ret
               
precti_cas    ; precte hodiny a minuty
               bset   priznaky, #PRENOS  ; priznak prenosu
               mov    i2c_reg, #1 ;registr 1 minuty
               callr  rtc_readb
               mov    minuty, i2c_val
               mov    i2c_reg, #2 ;registr 2 hodiny
               callr  rtc_readb
               mov    hodiny, i2c_val
               bres   priznaky, #PRENOS  ; priznak konec prenosu
               ret

;--- TM 1637 --------------------------------------------------

zobraz_cas    ;zabrazi cas z minuty hodiny
               ld     a, hodiny
               and    a, #$f0
               swap   a
               clrw   x          ;pozice 0
               ld     xh, a
               callr  zobraz1
               ld     a, hodiny
               and    a, #$0f
               ldw    x, #1      ;pozice 1
               ld     xh, a
               callr  zobraz1
               ld     a, minuty
               and    a, #$f0
               swap   a
               ldw    x, #2      ;pozice 2
               ld     xh, a
               callr  zobraz1
               ld     a, minuty
               and    a, #$0f
               ldw    x, #3      ;pozice 3
               ld     xh, a
               callr  zobraz1
               ret
               
zobraz1       ;zobrazi cislici v XH, na pozici XL
               ld      a, xh
               clr     dumph
               ld      dumpl, a
               ld      a, xl
               call    start_fix
               ldw     x, #tabulka_znaku
               addw    x, dumph
               ld      a, (x)
               btjf    priznaky, #DVOJTEC, _normal
               or      a, dvojtecka
_normal        call    tm_byte
               callr   konecp
               ret
               
vymaz         ;vymaze displej
               mov     raw_cnt, #4
_dalc          ld      a, raw_cnt
               dec     a
               call    start_fix
               clr     a
               callr   tm_byte
               callr   konecp
               dec     raw_cnt
               jrne   _dalc
               ret

stmav         ;snizi jas displeje
               ld     a, jas
               cp     a, #1
               jreq  _exs     ; doraz
               dec    jas
               call   zobraz_cas
_exs           ret
               
zjasni        ;zvysi jas displeje
               ld     a, jas
               cp     a, #7
               jreq  _exz     ; doraz
               inc    jas
               call   zobraz_cas
_exz           ret

start_fix     ;pocatek prenosu pro pevnou pozici v A je pozice
               push    A
               call    tm_start
               ld      A, #$44
               callr   tm_byte
               callr   tm_stop
               callr   tm_start
               pop     A
               or      A, #$c0
               callr   tm_byte
               ret

konecp        ;konec prenosu       
               callr   tm_stop
               callr   tm_start
               ld      A, #$88
               add     A, jas
               call    tm_byte
               callr   tm_stop               
               ret
                              
tm_start      ;start sekvence
               bset  PD_ODR, #DIO_PIN  ;dio high
               bset  PD_ODR, #CLK_PIN  ;clk high
               callr cekej_us
               bres  PD_ODR, #DIO_PIN  ;dio low
               callr cekej_us
               ret

tm_stop       ;stop sekvence
               bres  PD_ODR, #CLK_PIN  ;clk_low
               bres  PD_ODR, #DIO_PIN  ;dio_low
               callr cekej_us
               bset  PD_ODR, #CLK_PIN  ;clk_high
               callr cekej_us
               bset  PD_ODR, #DIO_PIN  ;dio_high
               callr cekej_us
               ret

tm_byte       ;zapise byte
               mov   tmcounter, #8
_loop          bres  PD_ODR, #CLK_PIN  ;clk_low
               callr cekej_us
               srl   A
               jrnc  _zero
               bset  PD_ODR, #DIO_PIN  ;dio high
               jra   _next
_zero          bres  PD_ODR, #DIO_PIN  ;dio low
_next          callr cekej_us
               bset  PD_ODR, #CLK_PIN  ;clk_high
               call  cekej_us
               dec   tmcounter
               jrne  _loop
               callr  tm_ack
               ret
               
tm_ack        ;faze ack, konec byte a odezva stavu
               bres  PD_ODR, #CLK_PIN  ;clk_low
               bset  PD_ODR, #DIO_PIN  ;dio high
               callr cekej_us
               bset  PD_ODR, #CLK_PIN  ;clk_high
               callr cekej_us
               bres  PD_ODR, #CLK_PIN  ;clk_low
               callr cekej_us
               bres  PD_DDR, #DIO_PIN  ;DIO na input
               callr cekej_us
               clr   ack
               btjf  PD_IDR, #DIO_PIN, _dale ;precti ack, mel by byt 1
               mov   ack, #1
_dale          bset  PD_DDR, #DIO_PIN  ;DIO na output               
               ret

cekej_us      ;cca 25 us pri CPU 2MHz
               push  A
               ld    A, #10
_smycka        nop
               dec   A
               jrne  _smycka
               pop   A
               ret

;--- infra -----------------------------------------------------
 
mereni_l      ;zmeri pocet taktu LOW 6 + (y * 6)
               clrw    y  
_r1            incw    y  
               jrv     _e1                 ; pokud pretece, ven
               btjf    PA_IDR, #PIN_INFRA, _r1
_e1            ret

mereni_h      ;zmeri pocet taktu HIGH 6 + (y * 6)
               clrw    y
_r2            incw    y
               jrv     _e2                ; pokud pretece, ven
               btjt    PA_IDR, #PIN_INFRA, _r2
_e2            ret
               
read_raw      ;meri delky impulzu
               ldw     x, #raw_infra
               mov     raw_cnt, #32
               callr   mereni_l   ; cekej na high
               jrv    _e3         ; pokud pretekl, tak ven 
repe           callr   mereni_h   ; zmer delku high
               jrv    _e3         ; pokud pretekl, tak ven 
               ld      a, yh      ; postaci ulozit pouze vyssi byte
               ld     (x), a
               incw    x
               callr   mereni_l   ; cekej na dalsi high
               dec     raw_cnt
               jrne    repe
_e3            ret

kod_infra     ;bypocte byte z raw dat X=cil, Y=raw
               clr   (x)
               ld     a, (y)          ;1. bit
               cp     a, #HRANICE_0_1 
               jrult  nula
               ld     a, #1
               ld    (x), a
nula           incw   y
               mov    raw_cnt, #7     ;dalsich 7 bitu
dalsi_bit      sll   (x)
               ld     a, (y)          ;1. bit
               cp     a, #HRANICE_0_1 
               jrult  nula2
               ld     a, (x)
               or     a, #1
               ld    (x), a               
nula2          incw   y
               dec    raw_cnt
               jrne   dalsi_bit
               ret
               
nec_test      ;otestovat platnost prijateho kodu podle NEC
               bres   priznaky, #NEC_VALID ;init na neplatny
               ldw    x, #infra_long
               ld     a, (x)
               xor    a, (1,x)
               cp     a, #$ff
               jrne  _ne
               ld     a, (2,x)
               xor    a, (3,x)
               cp     a, #$ff
               jrne  _ne               
               bset   priznaky, #NEC_VALID ;nec platny
_ne            ret

;---IRQ -------------------------------------------------------

               interrupt infra_interrupt
infra_interrupt.l
               bres   PA_CR2, #PIN_INFRA       ;zakaz preruseni 
               btjt   PA_IDR, #PIN_INFRA, _nic ;pokud tu neni nula, tak ven
               call   mereni_l            
               jrv   _nic              ;pokud pretekl, tak ven 
               cpw    y, #INFRA_START  ;je start?
               jrult _nic              ;  ne, ven
               call   mereni_h         ;  ano
               jrv   _nic              ;pokud pretekl, tak ven 
               call   read_raw         ;mereni delek impulzu  
               jrv    _nic             ;pokud pretekl, tak ven 
               ldw    y, #raw_infra    ;preved delky impuzu na bity
               ldw    x, #infra_long
               call   kod_infra        ;1.byte
               incw   x
               call   kod_infra        ;2.byte
               incw   x
               call   kod_infra        ;3.byte
               incw   x
               call   kod_infra        ;4.byte
               call   nec_test
               btjf   priznaky, #NEC_VALID, _nic  ;nec test nevysel
               bset   priznaky, #INFRA  ;priznak kod precten pro hlavni smycku
               jra   _iret             ;preruseni se povoli v hlavni smycce
_nic           bset   PA_CR2, #PIN_INFRA     ;povol preruseni
_iret          iret

               interrupt timer_interrupt
timer_interrupt.l
               bres    TIM_SR1, #0  ;update interrupt flag
               bset    TIM_IER, #0
               btjf    priznaky, #PRENOS, _i2cok ; pokud by prenos z i2c jeste neskoncil
               dec     ticky                     ; sniz pocitadlo, pokud dojde do nuly, tak 
               jrne   _skip                      ; i2c, nekde zustal viset, udelej reset
               bset    $50D1, #7                 ; SWCR.SWRESET = 1 = okamzity reset    
_i2cok         mov     ticky, #3
_skip          bset    priznaky, #CASOVAC          ;oznameni pro hlavni smycku
               btjt    priznaky, #DVOJTEC, _nedvoj ;pro blikani dvojtecky
               bset    priznaky, #DVOJTEC
               jra    _dvoj
_nedvoj        bres    priznaky, #DVOJTEC
_dvoj          iret

               interrupt NonHandledInterrupt
NonHandledInterrupt.l
               iret

;-- konstanty -------------------------------------------------

tabulka_znaku ;cisla + abeceda (v ramci moznosti sedmi segmentu)
cislice_0      dc.b      $3f
cislice_1      dc.b      $06
cislice_2      dc.b      $5b
cislice_3      dc.b      $4f
cislice_4      dc.b      $66
cislice_5      dc.b      $6d
cislice_6      dc.b      $7d
cislice_7      dc.b      $07
cislice_8      dc.b      $7f
cislice_9      dc.b      $6f
dvojtecka      dc.b      $80  ; dat jako OR s jinym znakem (!)pouze u druhe pozice
konec_tabulky  dc.l      $ffffffff
infra_0        dc.b      $67 ; kody ovladace
infra_1        dc.b      $5d  
infra_2        dc.b      $9d
infra_3        dc.b      $1d
infra_4        dc.b      $dd
infra_5        dc.b      $fd
infra_6        dc.b      $3d
infra_7        dc.b      $1f
infra_8        dc.b      $57
infra_9        dc.b      $6f
infra_hvez     dc.b      $97
infra_hash     dc.b      $4f
infra_hash2    dc.b      $79 ; ?
infra_up       dc.b      $e7
infra_down     dc.b      $b5
infra_left     dc.b      $ef
infra_right    dc.b      $a5
infra_ok       dc.b      $c7
verze          dc.b      "RTC-3231, TM-1637 ver. 1.0 release 002"
nuly           dc.l      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0

;--------------------------------------------------------------
	             segment 'vectit'

               dc.l {$82000000+main                 ; reset
               dc.l {$82000000+NonHandledInterrupt} ; trap
               dc.l {$82000000+NonHandledInterrupt} ; TLI_IRQHandler; External Top Level interrupt
               dc.l {$82000000+NonHandledInterrupt} ; Auto Wake Up from Halt
               dc.l {$82000000+NonHandledInterrupt} ; Clock Controller
               dc.l {$82000000+infra_interrupt}     ; EXTI Port A
               dc.l {$82000000+NonHandledInterrupt} ; EXTI Port B
               dc.l {$82000000+NonHandledInterrupt} ; EXTI Port C
               dc.l {$82000000+NonHandledInterrupt} ; EXTI Port D
               dc.l {$82000000+NonHandledInterrupt} ; EXTI Port E
               dc.l {$82000000+NonHandledInterrupt} ; CAN Rx (STM8AF only, N/A on STM8S103)
               dc.l {$82000000+NonHandledInterrupt} ; CAN Tx (STM8AF only, N/A on STM8S103)
               dc.l {$82000000+NonHandledInterrupt} ; SPI
               dc.l {$82000000+NonHandledInterrupt} ; TIM1 Update/Overflow
               dc.l {$82000000+NonHandledInterrupt} ; TIM1 Capture/Compare
               dc.l {$82000000+timer_interrupt}     ; TIM2 Update/Overflow
               dc.l {$82000000+NonHandledInterrupt} ; TIM2 Capture/Compare
               dc.l {$82000000+NonHandledInterrupt} ; TIM3 Update/Overflow
               dc.l {$82000000+NonHandledInterrupt} ; TIM3 Capture/Compare
               dc.l {$82000000+NonHandledInterrupt} ; UART1 Tx complete
               dc.l {$82000000+NonHandledInterrupt} ; UART1 Rx full
               dc.l {$82000000+NonHandledInterrupt} ; I2C
               dc.l {$82000000+NonHandledInterrupt} ; UART2 (not present on STM8S103)
               dc.l {$82000000+NonHandledInterrupt} ; UART2 (not present on STM8S103)
               dc.l {$82000000+NonHandledInterrupt} ; ADC1 end of conversion
               dc.l {$82000000+NonHandledInterrupt} ; TIM4 Update/Overflow
               dc.l {$82000000+NonHandledInterrupt} ; EEPROM EEC
               dc.l {$82000000+NonHandledInterrupt} ; irq25
               dc.l {$82000000+NonHandledInterrupt} ; irq26
               dc.l {$82000000+NonHandledInterrupt} ; irq27
               dc.l {$82000000+NonHandledInterrupt} ; irq28
               dc.l {$82000000+NonHandledInterrupt} ; irq29

               end

V programu se neřeší správnost zadávaného času a nijak zvlášť ho neřeší ani modul DS3231. Zadat se dá i nesmyslný čas. Je možné, že v programu zadané kódy ovladače nebudou odpovídat, tomu Vašemu. Bude třeba je zjistit a upravit v programu.

všeobecné informace

U modulů, které jsem v rámci svých možností odladil a otestoval, jsem vytvořil prográmek, který lze formou copy-paste vytáhnout (buď celý, nebo pouze potřebné kusy kódu) a použít jej v nějaké Vaší aplikaci. Zkopírovat se musí potřebný kód, proměnné v paměti a deklarace konstant (equ).

Na stránkách výrobce ST Microelectronics je ke stažení vývojové prostředí ST Visual develop a dále jsou zde velmí podrobné manuály v PDF (v angličtině) odledně popisu mikrokontroléru a jeho instrukčního souboru.

Každý zde uváděný zdroják má stejnou strukturu. Na začátku jsou deklarace adres použitých systémových registrů (UART, I2C, GPIO...), což je klíčové. Tyto adresy jsou popsány jednak v datasheetu STM8, a také jsou k dispozici ve zdrojovém kódu, který je nainstalován spolu s prostředím ST Visual develop ve složce [Program Files]\ STMicroelectronics\ st_toolset\ asm\ include\ STM8S103F.asm). Asi je možné ji deklarovat jako include, ale zde jsou ve zdrojáku definovány pouze ty, které jsou použity.
Dále je inicializační část, kde je vynulována paměť ram, nastaví se rychost CPU a proběhne základní nastavení použitého hardware, například rychlost UARTu, GPIO input/output, atd. Pak už následují rutiny pro konkrétní modul.V nekonečné smyčce infinite_loop je ukázka činnosti. Samotné rutiny lze podle potřeby vykopírovat do jiného projektu. Úplně na konci je tabulka vektorů přerušení v segmentu vectit s popisy, které zařízení může přerušení vyvolat.

Rychlý návod jak vytvořit nový projekt v prostředí ST Visual Dvelop:

V Hlavním menu vybrat File a New workspace.
Zvolit položku Create workspace and project
Objeví se dialog pro zadání skupiny projektů.
Vyplňte pole workspace filename (název skupiny projektů)
Vyyplňte pole workspace location (složka pro umístění)
Naskočí další okno pro projekt.
Vyplňte pole project filename (název projektu)
Vyplňte pole project location (složka pro umístěni projektu, zde doporučuji vybrat podsložku skupiny projektů).
Do pole toolchain vyberte ST Assembler Linker.
Pole toolchain root ponechte nezměněno.
Naběhne výběr pro konkrétní CPU.
Vyberte v něm STM8S103F3P.

Tím se vytvoří projekt. Na levé straně se objeví strom Workspace, kde ve větvi source files otevřete main.asm, které je hlavní zdroják projektu. Je předvyplněn o počáteční definici segmentů a tabulku přerušení. Můžete jej vyčistit a pak do něj přes copy-paste (CTRL+A - CTRL+C -> CTRL+V) vložit některé s zde uváděných mých (nebo Vašich) zdrojáků. Soubory mapping.asm a mapping.inc systém vytvořil automaticky a není doporučeno do nich zasahovat, protože systém je interně přepisuje. Do téhož workspace můžete vkládat více projektů, každý však musí mít svou složku.
Do existujícího workspace pak lze přidávat libovolný počet projektů, pomocí pravého tlačítka myši na kořenové (nejvyšší) větvi stromu "workspace". Podmínkou je, aby každý projekt byl v samostatné složce (adresáři). Do podvětví source files, nebo include files, každého projektu se mohou přidávat další moduly. Další podrobnosti ohledně práce v prostředí ST Visual develop je v tomto manuálu (anglicky).

Nahrání (vypálení) programu do modulu:

RTC Především připojte k modulu vývojové desky STM8S103F3 programátor ST-Link. K tomu jsou určeny čtyři piny na desce vpravo: 3V3, SWIM, GND a NRST (viz obrázek vlevo).
Program lze vypálit přímo z prostředí "ST Visual Dvelopu" takto: v hlavním menu vyberte Build - Build (F7). Pokud překlad a sestavení proběhhne bez chyb, spusťte Debug - Start debugging. Tím se projekt nahraje (vypálí), naskočí okno debuggeru a případně můžete projekt spustit (F5), nebo krokovat (F10).
Vypálit program do STM8 se dá i jednodušeji pomocí ST Visual Programmer, pokud máte k dispozici již "visual developem" přeložený soubor (F7-build, viz výše) *.s19. Tento vznikne v podsložce projektu DEBUG, nebo RELEASE. Otevřete jej přes hlavní menu-File-Open a přes hlavní menu-Program-Current tab program vypálíte. Případně ještě můžete správnost vypálení ověřit pomocí hlavní menu-Verify-Current tab. Další podobnosti odhledně používání ST Visual Programmeru jsou v jeho nápovědě: hlavní menu-Help-Index.

Dúležité upozornění: Zde presentovaný modul mikrokontroléru má výstupy 5V, 3V3 a GND. Na výstupu 5V ve skutečnosti není 5 voltů, ale vstupní napětí, kterým celý tento modul napájíte, buď přes piny +/-, nebo přes konektor mikroUSB, což může být 4.5 - 15V. Buďte opatrní, co k tomu pinu (5V) připojíte, připojovaný modul můžete tímto zničit. Doporučuji modul napájet výhradně z 5V zdroje.

Elektronika, ukázky pro Arduino a STM8, plus programování v Delphi (Lazarusu).

Všechna zapojení modulů v ukázkách (viz elektrická schémata) pracují s velmi malým napětím 3.3V až 12V a neobsahují návod na napájecí zdroj. Pokud se rozhodnete některé z těchto zařízení postavit, důrazně doporučuji používat zdroje s výstupním napětím maximálně 12V, podle schválených norem platných v ČR. Autor návodů za případné škody nepřebírá žádnou odpovědnost.

nahoru