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

Radiopřijímač FM s RDS pomocí modulu Si4703

ukázka ovládání modulu radiopříjímače Si4703 přes sběrnici i2c a čtení dat z RDS

Jde o radiopřijímač VKV, s modulem s Si4703 podporující příjem dat z RDS. Modul se ovládá pomocí sběrnice i2c. Čtení i zápis řídících slov do registrů je velmi podobný předtím popsanému modulu s čipem TEA5767. Během zápisu i čtení se žádná čísla registrů nezadávají. Prostě odešlete/přečtete souvislou řadu byte. V datasheetu Si4703 sice registry číslovány jsou, ale asi jen pro orientaci. Registry jsou šestnactibitové a je jich celkem šestnáct (32 byte).
Zápis začíná vždy od registru 0x02 a odeslat by se mělo šest slov (12 byte). Tím se zapíší registry 0x02 až 0x07 včetně. Registr 0x02 je pro volbu režimu a zapnutí/vypnutí modulu. Regisitr 0x03 slouží k naladění stanice, registry 0x04, 0x05 a 0x06 jsou konfigurační. V registru 0x07 se zapíná oscilátor, bez toho modul nehraje. Následují ještě registry 0x08 a 0x09, ale ty jsou uvedeny jako testovací a činnost modulu nějspíše neovlivňují. V této ukázce se modul nastavuje na mono. Pro stereo je nutný silnější signál.
Čtení začíná registrem 0x0A. Můžete načíst všech šestnáct registrů v tomto pořadí: 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, pak teprve následují registry 0x00 až 0x09. Registry 0x0A a 0x0B jsou stavové a registry 0x0C, 0x0D, 0x0E a 0x0F jsou data RDS. Ještě zbývá dodat, že registr 0x00 je ID zařízení (device ID) a 0x01 je ID čipu (chip ID).

Propojení modulů je opět velmi jednoduché: napájení 3.3V, dva datové vodiče pro i2c (scl, sda), GPIO2 kvůli přerušení a RST (reset), nutný při zapnutí modulu. Toto schéma není úplné, je nutný ještě displej a nějaké ovládání. Ovládat se může buď pomocí tlačítek, nebo infra ovladačem. Na modulu je konektor 3,5mm jack, který slouží k připojení sluchátek. Kabel od sluchátek je zároveň anténa. Pokud by se měl připojit nf zesilovač, anténa se připojuje k pravému kanálu konektoru jack, tak jak je naznačeno ve schématu. Ladění frekvencí je oproti TEA5767 jednodušší. Zadává se přímo číslo kanálu, které lze snadno vypočítat.

        frekvence[khz] - okraj pásma
kanál = ---------------------------- 
             šířka kanálu[kHz]

Například pro 99.3MHz (Evropa2 z vysílače Praděd) vyjde číslo kanálu 118.

             99300 - 87500                      993 - 875
99.3 MHz =>  ------------- => pokrátit / 100 => --------- => 993 - 875 = 118
                  100                               1

Stačí tedy prostě vzít požadovanou frekvenci v MHz bez desetinné čárky, od ní odečíst 875 a máte číslo kanálu. Šířka kanálu je pro Evropu 100 kHz a nastavuje se v registru 0x05 položka "channel spacing" bity[5:4]. Pozor, defaultně je zde přednastaveno 200 kHz (USA). Celé nastavení konfigurace je patrné ze zdrojáku níže.

Čtení dat z RDS:
Aby příjem dat byl možný a spolehnivý, je potřebný poměrně silný signál. Načítání dat z RDS je zde přes přerušení. Jeví se mi to jako nejspolehlivější. Pro jednoduchost jsem se omezil pouze na přečtení názvu stanice, radiotextu a časové značky. Informací je však poskytováno daleko více. Data RDS jsou vysílány ve čtyřech blocích po šestnacti bitech (čtyři 16-ti bitová slova):

RDSA - reg.0x0C jedinečné ID stanice, asi ho přiděluje nějaká nadnárodní autorita
RDSB - reg.0x0D určuje, co obsahují data v RDSC a RDSD
RDSC - reg.0x0E data určená pomocí RDSB
RDSD - reg.0x0F data určená pomocí RDSB

Určující slovo RDSB vypadá asi nějak takto:

  15   14   13   12     11     10    9    8     7    6     5      4     3    2    1    0
  --- typ bloku ---     ver    --------- PTY ---------     TP     TA    - pozice textu -

název	bit	popis
typ bloku	15-12	určuje, o jaká data v RDSC a RDSD jde 0 (0000b)=název stanice 2 (0010b)=radiotext 4 (0100b)=časová značka atd. (typů je více, ale tato ukázka s nimi nepracuje)
verze (A nebo B)	11	pokud jde o název stanice, nebo radiotext (typ bloku 0000b, 0010b) u verze A RDSC i RDSD obsahují dva znaky, celkem čtyři znaky u verze B je v RDSC nějaké jiné info a RDSD obsahuje dva znaky
PTY, typ programu	10-6	5 bitů určujících žánr (v EU např. 1 = News, 10 = Pop Music...)
TP, dopravní zprávy	5	stanice vysílá dopravní zprávy
TA, dopravní relace	4	stanice vysílá dopravní relaci (jaký je v tom rozdíl nevím)
pozice textu	3-0	určuje pozici (index v pro textový řetězec) právě přijatého fragmentu názvu stanice, nebo radiotextu, je potřeba jej vynásobit čtyřmi, nebo dvěma podle verze určené bitem 11 v RSDB (A nebo B)

Ukázka zde pracuje s typem bloku 0A/0B - název stanice, 2A/2B - radiotext a 4A - časová značka. Pokud jde o text (název, radiotext), jsou znaky umístěny v RDSC pouze u verze A (viz bit 11 RDSB) a vždy v RDSD. U verze B jsou znaky pouze v RDSD, RDSC obsahuje nějakou jinou informaci. U verze A jsou to tedy čtyři znaky a u verze B dva. Kam fragment textu patří je určeno v RDSB v bitech 3-0. Délka vysílaného radiotextu může mít 64 znaků u verze A a 32 znaků u verze B.
U časové značky jsem se zatím zabýval pouze hodinou a minutou. Hodinu udává pět bitů, kde první je v nultém bitu v RDSC, pak následují další čtyři bity v RDSD (15-12). V dalších šesti bitech jsou minuty (11-6). Bit 5 určuje znaménko pro výpočet posunu UTC (bity 4-0). UTC je po půlhodinách, ale v kódu jsem řešil pouze celé hodiny se znaménkem plus, což odpovídá našemu časovému pásmu.

Obsah RDSC a RDSD u časové značky:

RDSC                                     RDSD
15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0    15 14 13 12   11 10  9  8  7  6    5    4 3 2 1 0
                                    -- hod 5 bitu --   - minuty 6 bitu -   +/-   -- UTC --

Si4703 by měl umět ošetřit případné chyby přenosu. Ve stavovém registru 0x0B jsou položky BLERB, BLERC, BLERD (BLERA je v registru 0x0A) vždy po dvou bitech, které udávají chybovost přenosu pro každý blok. Pokud je přenost bez chyby, obsahují nulovou hodnotu. Aby "BLERy" fungovaly musí být zapnut "RDS verbose", což je bit 11 v registru 0x02 (RSDM=1). V ukázce testuji bloky B, C a D, které uložím do paměti pouze v případě bezchybného přečtení.

název stanice a radiotext v paměti

Zdrojový kód:
Jde jen o jakýsi polotovar, který nastaví a zapne modul Si4703, naladí jednu stanici a čte data z RDS do paměti. Dále připravuje stavové informace, podle kterých by se mělo nějak reagovat (viz zdroják). Je potřeba dodělat zobrazování na nějaký displej. Pak hlavně nějaké ovládání jako ladění stanic, nastavení hlasitosti, přepínání mono/stereo, atd. Možná se do toho ještě pustím...

stm8/

              .form 64
              .tab 10,8,18,60
               TITLE "STM8"

              #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 ;CPU delicka pro rychlost
EXTI_CR1       equ  $50A0 ;nastaveni preruseni
EXTI_CR2       equ  $50A1 ;

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

PD_ODR         equ  $500F
PD_IDR         equ  $5010
PD_DDR         equ  $5011
PD_CR1         equ  $5012
PD_CR2         equ  $5013

PB_ODR         equ  $5005 
PB_DDR         equ  $5007 

PIN_SDIO       equ  5
PIN_RESET      equ  4
PIN_GPIO2      equ  3
BIT_NAZEV      equ  7       ;priznak nacteni nazvu stanice
BIT_TEXT       equ  6       ;priznak nacteni radiotextu
BIT_CAS        equ  5       ;priznak nacteni casove znacky
BIT_STANICE    equ  1       ;priznak zmeny stanice
BIT_KOMPLET    equ  0       ;priznak, ze se neco nactetlo

;-- RAM promenne----------------------------------------------------------------
               segment 'ram0'
               
si470x_reg    ;registry si470x 
reg_a          ds.w    1
reg_b          ds.w    1
rds_a          ds.w    1     ;rds blok A
rds_b          ds.w    1     ;rds blok B
rds_c          ds.w    1     ;rds blok C
rds_d          ds.w    1     ;rds blok D
reg_0          ds.w    1
reg_1          ds.w    1
reg_2          ds.w    1
reg_3          ds.w    1
reg_4          ds.w    1
reg_5          ds.w    1
reg_6          ds.w    1
reg_7          ds.w    1
reg_8          ds.w    1
reg_9          ds.w    1
rds_id         ds.w    1     ;id stanice
priznaky       ds.b    1     ;priznaky ohledne cteni z RDS
hodiny         ds.b    1     ;cas z RDS
minuty         ds.b    1     
buffer_nazev   ds.b    8     ;buffery pro nazev a text
buffer_text    ds.b    64

               segment 'ram1'

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

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

main           sim
               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
               mov   CLK_CKDIVR, #0       ;$18     ;cpu rychlost
               
               bset  PD_DDR, #PIN_RESET   ;reset pin na output
               bset  PD_CR1, #PIN_RESET
               bres  PD_DDR, #PIN_GPIO2   ;gpio2 na input
               call  si470x_init
               bres  EXTI_CR1, #7         ;falling port D ne
               bset  EXTI_CR1, #6         ;rising port D ano
               rim                        ;povol preruseni
               
;-- hlavni smycka LOOP ---------------------------------------------------------

              ;testovaci frekvence
               ldw    y, #$0076  ; 99.3 MHz EVROPA2 z Praded Jesenik
              ;ldw    y, #$0091  ;102.0 MHz CRO2 z Kojal Brno
              ;ldw    y, #$006B  ; 98.2 MHz CRO3 z Praded Jesenik
              ;ldw    y, #$00AA  ;104.5 MHz F1 z Praded Jesenik
              ;ldw    y, #$0006  ; 88.1 MHz Orion z Praded Jesenik
               call   ladeni

infinite_loop.l
              ;v hlavni smycce by mel zobrazovat cas a texty podle priznaku
              ;po zpracovani dany priznak shodit a cekat dalsi              
              ;melo by tu byt i nejake ovladani, ladeni stanic atd...
               bset   PD_CR2, #PIN_GPIO2   ;povol interrupt od RDS
               btjt   priznaky, #BIT_STANICE, zmena_stan
               btjt   priznaky, #BIT_KOMPLET, zobraz
               jra    infinite_loop
               
zobraz         bres   PD_CR2, #PIN_GPIO2              ;zakaz interrupt od RDS
               bres   priznaky, #BIT_KOMPLET          ;shod priznnak
               btjf   priznaky, #BIT_NAZEV, _dale     ;a zjisti o co slo
               callr  zobraz_nazev
_dale          btjt   priznaky, #BIT_TEXT, _dale2
               callr  zobraz_text
_dale2         btjt   priznaky, #BIT_CAS, zobraz_cas
               jra    infinite_loop

zmena_stan     bres   priznaky, #BIT_STANICE          ;nejprve vzdy shod priznak
              ;reakce na zmenu stanice blok A RDS
              ;...
               jra    infinite_loop

zobraz_nazev   bres   priznaky, #BIT_NAZEV
              ;nazev stanice je kompletni
              ;...               
               ret

zobraz_text    bres   priznaky, #BIT_TEXT
              ;radiotext je kompletni
              ;...
               ret

zobraz_cas     bres   priznaky, #BIT_CAS
              ;cas precten
              ;...
               jra    infinite_loop

;-- i2c ------------------------------------------------------------------------

i2c_init      ;inicializace i2c
               bres   PB_DDR, #PIN_SDIO
               bres   I2C_CR1, #0         ;i2c 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
               ld     a, #4
               call   cekej_ms
               ret

posli_adrw    ;odesle zapisovaci adresu i2c
               bset   I2C_CR2, #0            ;start
_startw        btjf   I2C_SR1, #0, _startw   ;start spusten
               mov    I2C_DR, SI470X_ADR_W
_waitaddr      btjf   I2C_SR1, #1, _waitaddr ;cekat na ADDR                          
               mov    stack_start, I2C_SR3   ;nutne dummy cteni kvuli adrese
               ret
               
zapis8        ;odesle A podle X do i2c
               ld     a, (x)
               ld     I2C_DR, a
_wtx           btjf   I2C_SR1, #7, _wtx      ;cekat TXE
               incw   x
               ret
              
zapis_reg     ;zapise registry 2 az 7 
               callr  posli_adrw
               push   #6                    ;celkem 6 registru
               ldw    x, #reg_2
_sm05          callr  zapis8                ;MSB
               callr  zapis8                ;LSB
               dec   (1,SP)
               jrne  _sm05
               addw   SP, #1
               bset   I2C_CR2, #1           ;stop
               ret

posli_adrr    ;odesle cteci adresu na i2c
               bset   I2C_CR2, #0            ;start
_startr        btjf   I2C_SR1, #0, _startr
               mov    I2C_DR, SI470X_ADR_R   ;adresa pro cteni
_wtxr          btjf   I2C_SR1, #1, _wtxr
               mov    stack_start, I2C_SR3   ;dummy read kvuli clear ADDR    
               ret

precti8       ;precte jeden byte a ulozi podle X
_wrlsb         btjf   I2C_SR1, #6, _wrlsb
               ld     a, I2C_DR              ;precte byte
               ld    (x), a                  ;ulozi
               incw   x
               ret
               
precti_reg    ;precte registry na adresu si470x_reg z i2c pocet = A
               callr  posli_adrr 
               bset   I2C_CR2, #2            ;ACK
               dec    a                      ;posledni byte se cte zvlast
               push   a                      ;poctadlo word
               ldw    x, #si470x_reg         ;adresa registru
_sm04          callr  precti8                ;MSB
               callr  precti8                ;LSB
               dec   (1,SP)
               jrne  _sm04
               addw   SP, #1                 ;uvolni pocitadlo
               callr  precti8                ;precte posledni word
               bres   I2C_CR2, #2            ;bez ACK pro posledni byte
               bset   I2C_CR2, #1            ;stop
               callr  precti8               
               ret
    
precti_vse    ;precte vsechny registry modulu
               ld     a, #16                 ;bude se cist vsech 16 slow
               callr  precti_reg
               ret

precti_af     ;precte stavove a RDS registry modulu A az F
               ld     a, #6                  ;bude se cist 6 slow
               callr  precti_reg
               ld     a, reg_b               ;kontrola chyb bloku B,C,D
               bcp    a, #$fc                ;    musi byt zapnuty RDS verbose
               jrne  _chyba                  ;pri chybe prenosu nahodi carry
               ldw    y, rds_a               ;zjisti zmenu stanice
               cpw    y, rds_id
               jreq  _bezzm                  ;zmenila se stanice?
               bset   priznaky, #BIT_STANICE ; ano, nahodi priznakk zmeny
_bezzm         rcf                           ;bloky OK, shodi carry
               ret
_chyba         scf                           ;zde skoci pri chybe, nahodi carry
               ret

;-- si470x ---------------------------------------------------------------------

cekej_ms      ;zpozdovaci smycka podle A
               pushw  y
_sm01          clrw   y
_sm02          incw   y                      ;pricitat dokud Y nepretece
               jrnv  _sm02
               dec    a
               jrne  _sm01                   ;opakovat podle obsahu A                                                   
               popw   y 
               ret
               
si470x_init   ;reset modulu a prvotni nastaveni
               bset   PB_DDR, #PIN_SDIO    ;pri resetu modulu shodit SDIO
               bres   PB_ODR, #PIN_SDIO
               bres   PD_ODR, #PIN_RESET   ;shodit reset pin na cca 1ms            
               ld     a, #8
               callr  cekej_ms
               bset   PD_ODR, #PIN_RESET
               ld     a, #64
               callr  cekej_ms               
               call   i2c_init            ;nastavi i2c
               call   precti_vse
               ldw    y, #$8100           ;spust oscilator
               ldw    reg_7, y  
               call   zapis_reg
               ld     a, #64              ;nutna prodleva pro rozbeh oscilatoru
               callr  cekej_ms               
               call   precti_vse
               ldw    y, #$6801           ;zapnout a mono a RDS verbose
               ldw    reg_2, y
               ldw    y, #$9804           ;rds irq, dm=50us
               ldw    reg_4, y
               ldw    y, #$0018           ;krok po 100 kHz a polovicni hlasitost
               ldw    reg_5, y
               call   zapis_reg
               ld     a, #128              ;prodleva pro nabehnuti
               callr  cekej_ms               
               call   precti_vse
               ret

ladeni        ;naladi stanici v Y
               sim                        ;zakaze preruseni. at se neplete RDS
               clr    priznaky
               ldw    x, #buffer_nazev
               push   #72                 ;lokalni promenna
_sm16          clr   (x)                  ;vymaze buffery pro nazev a text 8+64
               incw   x
               dec   (1,SP)
               jrne  _sm16
               addw   SP, #1              ;uvolneni lokalni promenne
               call   precti_vse
               ld     a, yh
               or     a, #$80             ;nahodi TUNE bit
               ld     reg_3, a
               ld     a, yl
               ld    {reg_3+1}, a
               call   zapis_reg
_sm06          call   precti_vse
               btjf   reg_a, #6, _sm06    ;cekej bit STC = 1
               ld     a, reg_3
               and    a, #$7f             ;shodi  TUNE bit
               ld     reg_3, a
               call   zapis_reg
_sm08          call   precti_vse
               btjt   reg_a, #6, _sm08    ;cekej bit STC = 0
               rim                        ;povoli preruseni
               ret

;-- RDS -- volano z IRQ --------------------------------------------------------

precti_rds    ;precte registry A-F modulu
               call  precti_af
               jrc   _preskoc            ;pokud je carry, byla chyba RDS prenosu
               ld     a, rds_b
               and    a, #$f0                ;zjisti typ zpravy
               swap   a
               cp     a, #0
               jreq   rds_nazev
               cp     a, #2                  ;2A/2B
               jreq   rds_info
               cp     a, #4                  ;cas a datum
               jreq   rds_datum               
               ret
rds_nazev      ldw    x, #buffer_nazev       ;0A/0B nazev stanice
               jra    rds_infob               
               ret               
rds_info       btjt   rds_b, #3, rds_infob   ;2A/2B radiotext
               jra    rds_infoa
rds_datum      btjt   rds_b, #3, _preskoc    ;4B nebrat
               jp     rds_cas                ;4A cas a datum
_preskoc       ret
               
uloz_znak      ;otestuje a ulozi znak
               cp     a, #32                 ;vice, nebo rovno mezere?
               jrsge _platny                 ; ano, uloz platny znak
               tnz    a                      ;NULL?
               jreq  _eol
               cp     a, #13                 ;CR?               
               jreq  _eol
               cp     a, #10                 ;LF?
               jreq  _eol
               ld     a, #32                 ;jinak dej mezeru a pokracuj
               jra   _platny
_eol           clr    a                      ;konec textu 
               bset   priznaky, #BIT_KOMPLET
_platny        ld    (x), a
               incw   x
               ret

rds_infoa      ;zpracuje text, verze A 4 znaky               
               ldw    x, #buffer_text
               ld     a, {rds_b+1}
               and    a, #$0f                 ;zjisti cislo bloku 4 znaku
               cp     a, #$0f
               push   CC                      ;zapamatuj zero flag
               sll    a                       ;vynasob ctyrmi
               sll    a                       
               push   a                       ;vytvor lokalni promennou
               push   #0                      ; pro scitani
               addw   x, (1,SP)
               addw   SP, #2                  ;uvolni lokalni pronennu word
               ld     a, rds_c
               callr  uloz_znak               ;uloz prvni znak z RDSC
               ld     a, {rds_c+1}
               callr  uloz_znak               ;uloz druhy znak z RDSC
               ld     a, rds_d               
               callr  uloz_znak               ;uloz prvni znak z RDSD
               ld     a, {rds_d+1}
               callr  uloz_znak               ;uloz druhy znak z RDSD
               pop    CC
               jreq  _kompla
               btjt   priznaky, #BIT_KOMPLET, _kompla2
               ret
_kompla        bset   priznaky, #BIT_KOMPLET
_kompla2       bset   priznaky, #BIT_TEXT     ; ano               
               ret

rds_infob      ;zpracuje text, verze B 2 znaky
               ldw    x, #buffer_text
               ld     a, {rds_b+1}
               and    a, #$03                 ;zjisti pozici dvou znaku
               cp     a, #$03
               push   CC                      ;zapamatuj zero flag
               sll    a                       ;vynasob dvema
               push   a                       ;vytvor lokaltni promennou
               push   #0                      ; pro scitani
               addw   x, (1,SP)               ;pripocti pozici k adrese bufferu
               addw   SP, #2                  ;uvolni lokalni pronennu word
               ld     a, rds_d                ;uloz prvni znak z RDSD
               call   uloz_znak               
               ld     a, {rds_d+1}            ;uloz druhy znak z RDSD
               call   uloz_znak
               pop    CC                      ;obnov flagy
               jreq  _komplb                  ;zero flag blok je posledni 8-my
               btjt   priznaky, #BIT_KOMPLET, _komplb2
               ret               
_komplb        bset   priznaky, #BIT_KOMPLET               
_komplb2       bset   priznaky, #BIT_NAZEV    ; ano               
               ret

rds_cas       ;cas hodiny a minuty
               push   #6                     ;RDSD budeme posouvat o 6 doprava
               ldw    x, rds_d              
_sm15          srlw   x
               dec   (1,SP)
               jrne  _sm15
               addw   SP, #1                 ;uvolni lokalni promennou
               ld     a, xl
               and    a, #$3f                ;6 bitu zprava jsou minuty
               ld     minuty, a               
               srlw   x
               srlw   x                      ;jeste dva doprava
               ld     a, xl                  ;a v xl je ted MSB byte z RDSD
               swap   a                      ;zajimaji mne prvi 4 bity
               and    a, #$0f
               btjf   {rds_c+1}, #0, _b5nula ;a zohledni nulty bit v bloku C
               or     a, #$10                ;pokudje v 1, pripocti +16
_b5nula        ld     hodiny, a              
               ld     a, {rds_d+1}           ;jeste zohlednit UTC              
               and    a, #$0f                ;je po pulhodinach
               srl    a                      ; takze podelit dvema
               add    a, hodiny              ;pricist UTC
               ld     hodiny, a
               bset   priznaky, #BIT_CAS     ;nahodi priznak cas precten
               ret
               
;---IRQ ------------------------------------------------------------------------

               interrupt rds_irq
               bres   PD_CR2, #PIN_GPIO2  ;zakazat irq pro jistotu
rds_irq.l      call   precti_rds          ; v hlavni smycce se zase povoli   
               iret

               interrupt NonHandledInterrupt
NonHandledInterrupt.l
               iret

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

SI470X_ADR_W   dc.b    $20   ;i2c adresa modulu 0x20 pro zapis
SI470X_ADR_R   dc.b    $21   ;i2c adresa modulu 0x21 pro cteni

;-------------------------------------------------------------------------------
	             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+NonHandledInterrupt} ; EXTI Port A
               dc.l {$82000000+NonHandledInterrupt} ; EXTI Port B
               dc.l {$82000000+NonHandledInterrupt} ; EXTI Port C
               dc.l {$82000000+rds_irq}             ; 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+NonHandledInterrupt} ; 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š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