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

Velmi jednoduchý MP3 přehrávač

Serial MP3 Player

Tato ukázka snaží demonstrovat použití seriové linky UART, kdy se příjem (RX) ukládá přes přerušení. Dále použití infrasnímače pro dálkový ovladač a také základní způsob pro ukládání dat do eepromky čipu. Čip disponuje 640-ti bytes v EEPROM. Vše v assembleru. Co se mi na assembleru líbí nejvíce, je jeho úspornost. Tento "projekt" zabírá celých 866 byte z 8kb prostoru pro kód a určitě by šlo ještě něco ušetřit.
Nepředpokládám, že by tohle někdo postavil a trvale používal. Je to však dobré jako příklad. Zdroják jsem se snažil okomentovat, aby byl co nejčitelnější. Snad se mi to alespoň trochu podařilo.

Použité moduly:

Ovládání modulu přes infra je patrné z tabulky ve zdrojáku na konci. U jiného ovladače, než je zde, budou kódy tlačítek samozřejmě jiné. V tabulce je kod tlačítka, kod příkazu modulu mp3, zádost o potvrzení (0, nebo 1), parametr high a parametr low. Ostatní bajty odesílané pakety jsou napevno (0x7E, 0xFF, 0x06, příkaz, 0/1, param_hi, param_lo, 0xEF). Odesílání do modulu mp3 mi často vracelo chybu rámce, jakoby se nějaký ten bajtík ztratil. Dal jsem tedy mezi jednotlivé bajty krátkou prodlevu a přenosy byly rázem bez chyby. Modul mp3 asi po příjmu každého bajtu vykonává nějakou činnost a pak mu sem tam něco uteče. Proto nejspíš pomohla ta pauza.

Propojení modulů je velmi jednoduché, kromě napájení; infračidlo potřebuje jediný datový vodič a UART dva (rx, tx). K napájení použijte konektor mikro USB, který je na desce mikrokontroléru. Připojte jej k nějakému 5V (!) zdroji, například k USB nabíječce. V programu jsou aktivní tři přerušení. Od timeru4 podle potřeby, od UARTu při příjmu (RX) a od infrasnímače při stisku tlačítka. Použitý MP3 modul komunikuje binárně (ne v ascii) a má pevnou délku pakety s počáteční a koncovou značkou, což komunikaci usnadňuje.

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 rychlost 2MHz
FLASH_DUKR     equ  $5064  ;EEPEOM
FLASH_IAPSR    equ  $505F
TIM4_CR1       equ  $5340  ;TIMER4
TIM4_IER       equ  $5343
TIM4_SR        equ  $5344
TIM4_PSCR      equ  $5347
TIM4_ARR       equ  $5348
UART_SR        equ  $5230  ;UART1
UART_DR        equ  $5231
UART_BRR1      equ  $5232
UART_BRR2      equ  $5233
UART_CR1       equ  $5234
UART_CR2       equ  $5235
EXTI_CR1       equ  $50A0  ;IRQ pro PA
EXTI_CR2       equ  $50A1 
PA_ODR         equ  $5000  ;PA3
PA_IDR         equ  $5001
PA_DDR         equ  $5002
PA_CR1         equ  $5003
PA_CR2         equ  $5004
PA_PIN         equ  3
HRANICE_0_1    equ  $02  ;co je mene je nula, vice, nebo rovno jednicka
KOD_PRIJAT     equ  0
UART_RX        equ  1
TIMER_TIK      equ  2
PRVNI          equ  3
NEC_VALID      equ  7

;-- RAM promenne-----------------------------------------------
               segment 'ram0'

prijaty        ds.b     1
               ds.b     2   ;7E FF 
odeslat        ds.b     1   ;6
prikaz         ds.b     1   ;prikaz
feedback       ds.b     1
hi_param       ds.b     1
lo_param       ds.b     1
               ds.b     3   ;chs1, chs2, EF
raw_infra      ds.b     32  ;infra raw data

               segment 'ram1'

infra_long     ds.b     3   ;nactena hodnota
infra_byte     ds.b     1
priznak        ds.b     1   ;bit0 infra, bit8 NEC, 2=uart
raw_cnt        ds.b     1
index_hi       ds.b     1
index_lo       ds.b     1
tiknuti        ds.b     1
pocet_mp3      ds.w     1

;-- PROGRAM ---------------------------------------------------

               segment 'rom'

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

main           mov   CLK_CKDIVR, #$18	   ;cpu rychlost
               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    UART_BRR2, #$00  ;#$03  ;UART baud rate 9600 bd, BRR2 musi byt prvni
               mov    UART_BRR1, #$0d  ;#$68
               bset   UART_CR2,#3      ;povoli TX
               bset   UART_CR2,#2      ;povoli RX
               bres   PA_DDR, #PA_PIN  ;INFRA input
               bset   PA_CR1, #PA_PIN  ;pull-up
               bres   EXTI_CR1, #0     ;rising ne
               bset   EXTI_CR1, #1     ;falling ano               
               bset   UART_CR2,#5      ;povoli preruseni RX
               rim
               ld     a, #8          
               call   spust_timer
               ldw    x, #chip_reset
               call   odesli_prikaz
               ld     a, #250          ;potrebuje hodne casu
               call   spust_timer
               call   vypln_eeprom     ;skoci na posledni ulozene poradi mp3
               call   odesli_prikaz
               ld     a, #8                           
               call   spust_timer
               bset   PA_CR2, #PA_PIN  ;povoli interrupt infra
               
;-- hlavni smycka LOOP ----------------------------------------

infinite_loop
               btjt   priznak, #KOD_PRIJAT, ovladac
               btjt   priznak, #UART_RX, uart_rx
               jra    infinite_loop
                              
ovladac        bres   priznak, #KOD_PRIJAT ;hleda prikaz ovladace
               ldw    x, #prikazy
_hledej        ld     a, (x)
               cp     a, infra_byte
               jreq  _nasel
               cp     a, #$ff
               jreq  _nenasel
               addw   x, #5
               jra   _hledej        
_nasel         call   odesli_prikaz
_nenasel       ld     a, infra_byte
               cp     a, #$97           ;hvezdicka?
               jrne  _krizky 
               call   skok_minus10
               jra   _zadny
_krizky        cp     a, #$4F           ;krizky?
               jrne  _zadny
               call   skok_plus10               
_zadny         ld     a, #16            ;prodleva po infra
               call   spust_timer               
               bset   PA_CR2, #PA_PIN   ;povoli preruseni
               jra    infinite_loop
               
uart_rx       ;zpracuje prijaty prijem uartu
               bres   priznak, #UART_RX ;prijem z prehravace
               ld     a, #8
               call   spust_timer       ;prodleva pred zpracovanim               
               btjf   priznak, #PRVNI, _vlozeno
               ld     a, prikaz
               cp     a, #$41           ;feedback, pozadej o poradi mp3
               jreq   dej_poradi
               cp     a, #$4C           ;prislo poradi?
               jrne  _preskok 
               call   eeprom_poradi
               jra    infinite_loop
_preskok       cp     a, #$48           ;celkovy pocet?
               jrne  _preskok2
               ldw    x, hi_param
               ldw    pocet_mp3, x
_preskok2      cp     a, #$3A           ;byla vlozena karta?
               jreq  _vlozeno
               cp     a, #$3D           ;konec skladby, dej dalsi
               jreq  _dalsi_skladba
               jra    infinite_loop
_dalsi_skladba ldw    x, #prikaz_next
               callr  odesli_prikaz
               jra    infinite_loop
_vlozeno       bset   priznak, #PRVNI
               ldw    x, #prikaz_celkem ;pozadej o pocet mp3
               callr  odesli_prikaz
               jp     infinite_loop               
dej_poradi     ldw    x, #prikaz_poradi ;pozada o poradi prehravane mp3
               callr  odesli_prikaz
               jp     infinite_loop
                                                            
skok_plus10   ;posun vpred o 10
               ldw    x, pocet_mp3      ;pokud jeste neni znam pocet
               jrne  _preskok3          ;posli pro nej
               ldw    x, #prikaz_celkem
               callr  odesli_prikaz
               ret
_preskok3      callr  vypln_eeprom      ;jinak preskoci +10
               ldw    y, hi_param
               addw   y, #10
               cpw    y, pocet_mp3
               jrule _neni_pres
               ldw    y, pocet_mp3
_neni_pres     ldw    hi_param, y
               callr  odesli_prikaz
               call   eeprom_poradi               
               ret

skok_minus10  ;posun zpet o 10
               callr  vypln_eeprom      ;vyzvedne z EEPROM pozici
               ldw    y, hi_param
               subw   y, #10            ;snizi o deset
               jrpl   _pl
               clrw   y
_pl            ldw    hi_param, y
               callr  odesli_prikaz
               call   eeprom_poradi
               ret

vypln_eeprom  ;precte poradi z eeprom
               mov    prikaz, #$03 
               mov    hi_param, $4001
               mov    lo_param, $4002
               clr    feedback 
               ldw    x, #odeslat
               ret
               
;--------------------------------------------------------------

odesli_prikaz ;odesle prikaz do modulu MP3 z adresy X
_tx00          btjf   UART_SR, #7, _tx00  ;cekat na prazdny TX
               ld     a, #$7E
               callr  byte_tx             ;7E
               ld     a, #$FF
               callr  byte_tx             ;FF
               ld     a, #6
               callr  byte_tx             ;6
               ld     a, (1,x)            ;prikaz
               callr  byte_tx
               ld     a, (2,x)            ;feedback
               callr  byte_tx
               ld     a, (3,x)            ;hi param
               callr  byte_tx
               ld     a, (4,x)            ;lo param
               callr  byte_tx
               ld     a, #$EF
               callr  byte_tx
_tx08          btjf   UART_SR, #6, _tx08
               ret
               
byte_tx       ;odesle byte A, ceka na odeslani byte+mala prodleva
               ld     UART_DR, a          ;odesli byte
_txc           btjf   UART_SR, #7, _txc
               ld     a, #50              ;mala prodleva mezi bytes
_txp           dec    a                   ;bez teto prodlevy daval
               jrne   _txp                ;modul mp3 chybu, asi overrun
               ret

spust_timer   ;timer v A je pocet tiknuti
               ld     tiknuti, a          ;spusti timer
               bres   priznak, #TIMER_TIK ;shod priznak
               mov    TIM4_PSCR, #7    
               mov    TIM4_ARR, #250
               bres   TIM4_SR, #0         ;vymazat update flag
               bset   TIM4_IER, #0        ;povolit preruseni
               bset   TIM4_CR1, #0        ;spust timer
_cekejt        btjf   priznak, #TIMER_TIK, _cekejt ;ceka, az dojede
               ret

;--- infra -----------------------------------------------------
 
mereni_l      ;zmeri pocet taktu LOW 6 + (y * 6)
               clrw    y  
_r1            incw    y  
               jrv     _e1                 ; pokud pretece, ven
               btjf    PA_IDR, #PA_PIN, _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, #PA_PIN, _r2
_e2            ret
               
read_raw      ;meri delky impulzu
               ldw     x, #raw_infra
               mov     raw_cnt, #32
               callr   mereni_l   ; cekej na high
repe           callr   mereni_h   ; zmer delku high
               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
               ret

kod_infra     ;vypocte 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   priznak, #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   priznak, #NEC_VALID ;nec platny
_ne            ret
               
;-- EEPROM ----------------------------------------------------

eeprom_poradi ;zapise poradi na 0x4001               
               push   a
               ldw    x, #$4001
               ld     a, hi_param
               callr  eeprom_zapis8
               incw   x
               ld     a, lo_param
               callr  eeprom_zapis8
               pop    a
               ret
               
eeprom_zapis8 ;zapise A na adresu X
               mov    FLASH_DUKR, #$ae         ;1. byte pro odemceni  
               mov    FLASH_DUKR, #$56         ;2. byte pro odenceni
_cekej_zap     btjt   FLASH_IAPSR, #0, _cekej_zap ;cekej, na povoleni zapisu
               ld    (x), a
_cekej_konec   btjt   FLASH_IAPSR, #0, _cekej_konec ;cekej dokonceni zapisu
               bres   FLASH_IAPSR, #3          ;nakonec zamkni eeprom
               ret
               
;---IRQ -------------------------------------------------------

               interrupt infra_ovl
infra_irq.l
               bres   PA_CR2, #PA_PIN       ;zakaz preruseni 
               btjt   PA_IDR, #PA_PIN, _nic ;pokud tu neni nula, tak ven
               call   mereni_l            
               cpw    y, #$0808        ;je start?
               jrult _nic              ;  ne, ven
               call   mereni_h         ;  ano
               call   read_raw         ;mereni delek impulzu  
               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
               bset   priznak, #KOD_PRIJAT  ;priznak kod precten, moznost volat kontrolu               
               call   nec_test
               jra   _iret             ;preruseni se povoli v hlavni smycce
_nic           bset   PA_CR2, #PA_PIN  ;povol preruseni
_iret          iret

              interrupt uart_rx   ;UART
uart_irq.l
               mov    prijaty, UART_DR
_precten       btjt   UART_SR, #5, _precten  ;cekej dokud nezmizi
               ld     a, prijaty
               cp     a, #$7E                ;pocatek pakety?
               jrne  _dbyte                  ; ne
               clr    index_hi               ; ano, vynuluj index
               clr    index_lo               
_dbyte         inc    index_lo               ;zvys index o 1
               ldw    x, index_hi
               ld    (x), a                  ;uloz byte
               cp     a, #$FE                ;konec pakety?
               jrne  _ret                    ; ne
               bset   priznak, #UART_RX      ; ano, nahod priznak
_ret           iret

               interrupt timer_4
timer4_irq.l
               bres   TIM4_SR, #0          ;vymazat update flag
               dec    tiknuti
               jrne  _nevypni
               bres   TIM4_IER, #0         ;zakaz dalsi preruseni
               bset   priznak, #TIMER_TIK  ;nahod priznak, ze dojel
_nevypni       iret

               interrupt NonHandledInterrupt
NonHandledInterrupt.l
               iret

;-- konstanty -------------------------------------------------
;                             cmd fb hi lo
prikazy        dc.b      $C7, $0d, 1, 0, 0  ;ok play
prikaz_next    dc.b      $A5, $01, 1, 0, 0  ;>  next
               dc.b      $EF, $02, 1, 0, 0  ;<  prev
               dc.b      $E7, $04, 0, 0, 0  ;up vol+
               dc.b      $B5, $05, 0, 0, 0  ;dn vol-
               dc.b      $5D, $07, 0, 0, 0  ;1  eq normal
               dc.b      $9D, $07, 0, 0, 1  ;2  eq pop
               dc.b      $1D, $07, 0, 0, 2  ;3  eq rock
               dc.b      $DD, $07, 0, 0, 3  ;4  eq jazz
               dc.b      $FD, $07, 0, 0, 4  ;5  eq klasika
               dc.b      $3D, $07, 0, 0, 5  ;6  eq bass               
               dc.b      $1F, $06, 0, 0, 0  ;7  mute
               dc.b      $57, $06, 0, 0, 18 ;8  hlas 18
               dc.b      $6F, $06, 0, 0, 28 ;9  hlas 28
               dc.b      $67, $0e, 0, 0, 0  ;0  pause               
               dc.l      $FFFFFFFF 
prikaz_celkem  dc.b      $00, $48, 0, 0, 0  ;celkem mp3
prikaz_poradi  dc.b      $00, $4C, 0, 0, 0  ;aktualni mp3
chip_reset     dc.b      $00, $09, 1, 0, 2  ;aktualni mp3
               dc.b     "Jednoduchy prehravac MP3 verze 1.0 release 7.10.2025 Ivan Sivak", 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_irq}           ; 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+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+uart_irq}            ; 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+timer4_irq}          ; 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