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

TM-1638 ovládací panel

osmimístný sedmisegmentový displej, osm led diod a osm tlačítek

Panel obsahuje osmimístný sedmisegmentový displej, osm led diod a osm tlačítek. Komunikace probíhá pomocí tří vodičů, DIO, CLK a STROBE. Ovládání displeje je velmi podobné TM1637. Navíc je zde rosvěcování a zhasínání led diod a čtení tlačítek. Stav tlačítek se ukládá do jednoho byte, kde jednotlivá tlačítka určují jednotlivé bity (tlačítko 1 až 8 => bity 7 - 0).
Pozice číslic a led diod je určena řídícím byte 0xC0 až 0xCF. Sudé čísla (0xC0, 0xC2, 0xC4...) určují pozici číslice a liché (0xC1, 0xC3, 0xC5...) pořadí ledky.

Níže uvedený kód obsahuje základní funkce pro TM1638:

Inicializace init TM1638 v setup části kódu, nastavení GPIO (clk, dio, stb)
procedura zapni, zapne displej a nastaví jas - 0x88 až 0x8F, 0x80 - displej vypne
procedura clear, zhasne displej a všechny ledky
procedura zobraz1, zobrazí znak v akumulátoru A na pozici registru YL
procedura zobraz, zobrazí znaky z adresy v registru X od pozice v registru YL, po ukončovací znak (0x8A), nebo osm znaků pokud na ukončovací znak nenarazí
procedura precti, přečte stav tlačítek do proměnné tlacitka
procedura ledky, rozsvítí, nebo zhasne ledku, podle jednotlivých bitů a akumulátoru A

V této ukázce je panel připojený k portu D, piny 2,3 a 4 (CLK, DIO, STROBE). Podle potřeby jdou samozřejmě připojit k jiným. Rychlost CPU je zde nastavená na 2 MHz. Pokud by byla požadována rychlost vyšší, až 16 MHz, možná bude třeba upravit zpožďovací proceduru zpozdeni. Na konci souboru je i definice segmentů pro číslice i další znaky abecedy v rámci možností sedmisegmentového displeje.
Ukázka zobrazí číslice 12345678 a pak v nekonečné smyčce čte tlačítka a podle stisknutého rozsvítí led. Další podrobnosti viz poznámky ve zdrojáku.

stm8/

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

              #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
PD_ODR         equ  $500F ; Port D
PD_IDR         equ  $5010 ;
PD_DDR         equ  $5011 ;
PD_CR1         equ  $5012 ;
PD_CR2         equ  $5013 ;
STB            equ  4
DIO            equ  3
CLK            equ  2


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

tlacitka       ds.b     1

               segment 'ram1'

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

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

main           sim
               mov   CLK_CKDIVR, #$18   ;cpu rychlost               
               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

               bset  PD_DDR, #STB  ;init TM1638
               bset  PD_DDR, #CLK
               bset  PD_DDR, #DIO
               bset  PD_CR1, #STB  ;nastaveni pool-up
               bset  PD_CR1, #CLK
               bset  PD_CR1, #DIO
               
               bset  PD_ODR, #STB
               bres  PD_ODR, #CLK
                                                            
               call  zapni
               ldw   Y, #$00C0
               ldw   X, #cislice_1
               call  zobraz

;-- hlavni smycka LOOP ----------------------------------------

infinite_loop.l
               callr  precti
               tnz    tlacitka
               jreq   infinite_loop
               ld     A, tlacitka
               call   ledky
               jra    infinite_loop
               
;--- TM 1638 --------------------------------------------------

zapni         ;zapne displej           
               ld     A, #$8C      ;Display ON, jas max 88-8F
               bres   PD_ODR, #STB ;strobe do nuly
               call   posli_byte   ;callr zpozdeni
               bset   PD_ODR, #STB
               bres   PD_ODR, #STB
               bres   PD_ODR, #CLK               
               bset   PD_ODR, #CLK
               bset   PD_ODR, #STB
               callr  clear
               ret
               
clear         ;vymaze a pozhasina vse
               push   #16           ;ulozi na zasobnik lokalni promennou
               clrw   Y
               ld     A, #$C0
               ld     YL, A
               clr    A
_sm03          callr  zobraz1
               incw   Y
               dec   (1,SP)
               jrne  _sm03
               addw   SP, #1        ;uvolni lokalni promennou
               ret
               
zobraz1       ;zobrazi znak v A na pozici YL
               push   A
               ld     A, #$44
               bres   PD_ODR, #STB ;strobe do nuly
               call   posli_byte   ;callr zpozdeni
               bset   PD_ODR, #STB
               bres   PD_ODR, #STB
               ld     A, YL
               callr  posli_byte
               pop    A
               callr  posli_byte
               bset   PD_ODR, #STB
               ret
               
zobraz        ;zobrazi znaky z adresy X, od pozice YL, po ukoncovak
               push   #8              ;max pocet 8
_sm06          ld     A, (X)
               cp     A, ukoncovak
               jreq  _konec
               callr  zobraz1
               dec   (1,SP)
               jreq  _konec
               incw   X
               incw   Y
               incw   Y
               jra   _sm06
_konec         addw   SP, #1
               ret

precti        ;precte do tlacitka nahodi bity 0-7
               ldw    X, #_posun      ;pro shifty o nulu az o tri
               ld     A, #$42         ;cteni tlacitek
               bres   PD_ODR, #STB
               callr  posli_byte
               clr    tlacitka    
               push   #4              ;lokalni pocitadlo
_sm04          call   precti_byte     ;postupne nacte 4 byte               
               jp    (X)              ;postupne skace na ..sll.. kvuli serazeni bitu
               sll    A               
               sll    A
               sll    A
_posun         or     A, tlacitka
               ld     tlacitka, A
               decw   X
               dec   (1,SP)           ;bude o jeden shisft vice
               jrne  _sm04
               bset   PD_ODR, #STB
               addw   SP, #1          ;uvolni lokalni promennou
               ret
               
ledky         ;rozsviti / zhasne LED podle A
               push   A
               push   #8
               ldw    Y, #$00C1
_sm07          clr    A
               srl   (2,SP)
               jrnc  _jenula
               inc    A
_jenula        callr  zobraz1
               dec   (1,SP)
               jreq  _konec2
               incw   Y
               incw   Y
               jra   _sm07
_konec2        addw   SP, #2          ;uvolni lokalni promennou
               ret

posli_byte    ;posila bit po bitu zprava, LSB prvni
               push  A
               push  #8
_sm01          bres  PD_ODR, #CLK
               srl   A              ;pokud je carry jednicka
               jrnc _nula
               bset  PD_ODR, #DIO
               jra  _preskok
_nula          bres  PD_ODR, #DIO
_preskok       callr zpozdeni
               bset  PD_ODR, #CLK
               dec  (1,SP)
               jrne _sm01
               addw  SP, #1        ;uvolni lokalni promennou
               pop   A
               ret
               
precti_byte   ;cteni tlacitek 
               clr    A
               push   #8
               bres   PD_DDR, #DIO    ;dio na input
               bset   PD_ODR, #DIO
_sm05          bres   PD_ODR, #CLK
               nop 
               btjt   PD_IDR, #DIO, _bit1
_bit0          srl    A
               jra   _bit
_bit1:         srl    A
               or     A, #$80
_bit           bset   PD_ODR, #CLK
               nop 
               dec   (1,SP)
               jrne  _sm05
               bset   PD_DDR, #DIO    ;dio zpet na output
               bres   PD_ODR, #DIO
               addw   SP, #1        ;uvolni lokalni promennou
               ret
               
zpozdeni      ;nutno upravit podle nastavene rychlosti CPU
               push   #8
_sm02          dec   (1,SP)
               nop
               jrne  _sm02
               addw   SP, #1        ;uvolni lokalni promennou
               ret
               
;---IRQ -------------------------------------------------------

               interrupt NonHandledInterrupt
NonHandledInterrupt.l
               iret

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

;  -- a --       bit  7 6 5 7  3 2 1 0
; |       |   segment : g f e  d c b a
; f       b
; |       |
;  -- g --
; |       |
; e       c
; |       |
;  -- d --   + DP (bit 7)
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
pismeno_A      dc.b      $77
pismeno_b      dc.b      $7c
pismeno_c      dc.b      $58
pismeno_d      dc.b      $5e
pismeno_E      dc.b      $79
pismeno_F      dc.b      $71
pismeno_g      dc.b      $67
pismeno_h      dc.b      $74
pismeno_I      dc.b      $30
pismeno_J      dc.b      $1e
pismeno_K      dc.b      $76
pismeno_L      dc.b      $38
pismeno_M      dc.b      $37
pismeno_n      dc.b      $54
pismeno_o      dc.b      $5c
pismeno_P      dc.b      $73
pismeno_Q      dc.b      $3f
pismeno_r      dc.b      $50
pismeno_S      dc.b      $6d
pismeno_t      dc.b      $31
pismeno_u      dc.b      $1c
pismeno_V      dc.b      $3e
pismeno_w      dc.b      $3e
pismeno_x      dc.b      $76
pismeno_y      dc.b      $66
pismeno_z      dc.b      $09
mezera         dc.b      $00   
pomlcka        dc.b      $40
rovnitko       dc.b      $48
tecka          dc.b      $80  ; dat jako OR s jinym znakem
ukoncovak      dc.b      $8a

;--------------------------------------------------------------
	             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+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+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