Smart LCD - User contributions [en]

MediaWiki:Sidebar

2025-10-22T05:34:22Z

Usr255:

Show Extended Code on String Element

2025-10-21T09:16:50Z

Usr255:

=== background ===
For some of the countries, they commonly use specific kind of character form external code page. Smart LCD can provide various Countries Code and External Code Pages with String Element

=== how to ===

* Font Setting --> Font Config <2> --> built font

[[File:SAN-21-0625-01-build font.png]]

* select Externed codepage

[[File:SAN-21-0625-02-build font.png|600x600px]]

note. Some of the font face may not provide all the extended char, check before select it.

* Config the codepage to be used in project setting

[[File:SAN-21-0625-04-cp.png|600x600px]]

* Code page can also be config by sys_reg (System Registers[0xFFFF30] := 4 for 860 OEM Portuguese)
* Code page can also be config by command Set_codepage (0xE7)
* Select the corresponding font for String Element with VP_STR[0x000100]
* In case of displaying Portuguese, the relationship can see in the build font panel

[[File:SAN-21-0625-03-font relation.png|560x560px]]

* Use Command Tools to send command to the Smart LCD
* AA E7 01 04 CC 33 C3 3C (for Country Code=USA , Extended Code Page=PC860
* AA 42 00 00 01 00 50 6F 72 74 75 67 75 65 73 65 00 CC 33 C3 3C (send some basic ASCII char ("Portuguese")
* AA 42 00 00 01 00 80 81 82 83 A0 A1 A2 A3 00 CC 33 C3 3C (send some extended code page char to be shown)

[[File:SAN-21-0625-05-example.png|600x600px]]

=== downloads ===
nil

Show Extended Code on String Element

2025-10-21T09:13:51Z

Usr255: Created page with "=== background === For some of the countries, they commonly use specific kind of character form external code page. Smart LCD can provide various Countries Code and External Code Pages with String Element === how to === * built font, select Font Setting --> Font Config <2> File:SAN-21-0625-01-build font.png * select Externed codepage 600x600px note. Some of the font face may not provide all the extended char, check before..."

=== background ===
For some of the countries, they commonly use specific kind of character form external code page. Smart LCD can provide various Countries Code and External Code Pages with String Element

=== how to ===

* built font, select Font Setting --> Font Config <2>

[[File:SAN-21-0625-01-build font.png]]

* select Externed codepage

[[File:SAN-21-0625-02-build font.png|600x600px]]

note. Some of the font face may not provide all the extended char, check before select it.

* Config the codepage in project setting codepage

[[File:SAN-21-0625-04-cp.png|600x600px]]

* Code page can be config by sys_reg (System Registers[0xFFFF30] := 4 for 860 OEM Portuguese)
* Code page can be config by command Set_codepage (0xE7)
* Select the corresponding font for String Element with VP_STR[0x000100]
* In case of displaying Portuguese, the relationship can see in the build font panel

[[File:SAN-21-0625-03-font relation.png|560x560px]]

* Use Command Tools to send command
* AA E7 01 04 CC 33 C3 3C (for Country Code=USA , Extended Code Page=PC860
* AA 42 00 00 01 00 50 6F 72 74 75 67 75 65 73 65 00 CC 33 C3 3C (send some basic ASCII char ("Portuguese")
* AA 42 00 00 01 00 80 81 82 83 A0 A1 A2 A3 00 CC 33 C3 3C (send some extended code page char to be shown)

[[File:SAN-21-0625-05-example.png|600x600px]]

=== downloads ===
nil

File:SAN-21-0625-05-example.png

2025-10-21T09:12:59Z

Usr255:

SAN-21-0625-05-example

File:SAN-21-0625-03-font relation.png

2025-10-21T09:05:40Z

Usr255:

SAN-21-0625-03-font relation

File:SAN-21-0625-04-cp.png

2025-10-21T08:58:12Z

Usr255:

SAN-21-0625-04-cp

File:SAN-21-0625-02-build font.png

2025-10-21T08:50:00Z

Usr255:

SAN-21-0625-02-build font

File:SAN-21-0625-01-build font.png

2025-10-21T08:49:08Z

Usr255:

SAN-21-0625-01-build font

Tech-Memos-01

2025-10-21T08:29:15Z

Usr255:

* [[Floating point value input]]
* [[Floating point value display]]
* [[Ardunio (soft_serial) connect to Smart LCD]]
* [[hmt.gettick() function usage]]
* [[Touch_Key lock on touch]]
* [[Show Extended Code on Static String]]
* [[Assign VP value in page (init VP values)]]
* [[Copy a page during editing]]
* [[Assign Page ID manually in display project]]
* [[Show Extended Code on String Element]]

Assign Page ID manually in display project

2025-10-20T06:57:22Z

Usr255: /* how to */

=== background ===
When developing Smart LCD project, it may need to group pages or re-arrange page sequence.

It is possible to assign Page ID to do so.

=== how to ===

* right click on a page in the Project Resources window
[[File:Set page id 01.png]]

* click continue (note. all the page references with this page will be update accordingly)

[[File:Set page id 02.png]]

* enter new id

[[File:Set page id 03.png]]

* this example the PG0001 updated as PG0301

[[File:Set page id 04.png]]

=== download ===
nil

File:Set page id 04.png

2025-10-20T06:56:40Z

Usr255:

Set page id 04

File:Set page id 03.png

2025-10-20T06:55:24Z

Usr255:

Set page id 03

File:Set page id 02.png

2025-10-20T06:54:27Z

Usr255:

Set page id 02

File:Set page id 01.png

2025-10-20T06:51:53Z

Usr255:

Set page id 01

Assign Page ID manually in display project

2025-10-20T06:51:19Z

Usr255: Created page with "=== background === When developing Smart LCD project, it may need to group pages or re-arrange page sequence. It is possible to assign Page ID to do so. === how to === # right click on a page in the Project Resources window"

=== background ===
When developing Smart LCD project, it may need to group pages or re-arrange page sequence.

It is possible to assign Page ID to do so.

=== how to ===

# right click on a page in the Project Resources window

Tech-Memos-01

2025-10-20T05:49:40Z

Usr255:

FAQ-01

2025-10-20T05:44:10Z

Usr255: /* Abnormal USB drive found */

== General ==

=== What is SGTools? ===

* SGTools is an UI development software dedicated for TOPWAY Smart LCD.
* SGTools is an upgraded version over the previous RGTools.
* It supports all the Smart LCD with resistive touch or capacitive touch.

=== How many background image can be store in to Smart LCD? ===

* Most of the Smart LCD is having 256Mbyte Flash (vary by model) in the Smart LCD
* The no. of background image can be preload is depends on the display resolutions (vary by model)
* The Smart LCD is showing the interface by PAGE and pages can share the same background image
* The maximum no. of PAGE is up to 1000
* It should be good enough for most of the UI design

{| class="wikitable"
|+
!Smart LCD resolutions
!No. of background picture
|-
|800x600
|~270
|-
|800X480
|~330
|-
|480X272
|~1000
|}

=== What kind of image can be use in the SGTools? ===
Background Image

* Recommend 24bit BMP
* Recommend matched resolution image
* SGTools will resize the un-matched resolution to fit the screen

Icons

* Recommend 24bit BMP
* Limit to 1/4 of the Smart LCD display resolutions

Animations

* Recommend 24bit BMP, Animated GIF supported
* Limit to 1/4 of the Smart LCD display resolutions

== USB issue during display project download ==

=== Power off Smart LCD ===

* Ensure the Smart LCD is totally power off
* Disconnect the power supply cable of the Smart LCD

=== Cable issue ===

* Use a good quality USB cable
* Ensure USB power supply(500mA/5V USB supply)
* A dual USB-A to micro-USB cable, may help in some case

=== PC USB terminal ===

* Try another the USB terminal
* Connect to the PC motherboard directly (back side of the is better than the front)

== Smart LCD cannot be recognized by PC… ==

=== Smart LCD USB access locked ===

* In case no USB device found on the PC (Smart LCD connected), it is possible than the Smart LCD USB access locked
* Connect the RS-232 terminal to the PCB
* In TOPWAY Command Tools, use the “Unlock USB drive” command with the correct password to unlock the USB access

[[File:Unlock usb drive.png]]

=== Smart LCD USB access locked (forgot password) ===

* In case no USB device found on the PC (Smart LCD connected), it is possible the Smart LCD USB access locked
* Connect the RS-232 terminal to the PCB
* In TOPWAY Command Tools, use the “Format USB drive” command to format the USB drive and the USB access will be unlock at the same time

[[File:Format usb drive.png]]

=== Abnormal USB drive found ===

* In case no USB device found on the PC (Smart LCD connected), it is possible the Smart LCD USB drive was corrupted during previous download
* Use PC format tools to format the drive with FAT32 filesystem

== Display Project Configuration ==

=== How to config the screen saver? ===

* To Set the Screen Saver Mode...

* The Screen Saver Mode can be config in the SGTools Menu ⇒ Tools ⇒ Project Setting

[[File:Screen saver mode.png]]

Note. Dim down backlight can further extend the backlight LEDs life.

=== How to wake up form screen saver? ===

* To Wake-up form Screen Saver...
* Anywhere on screen being touched
* A page jump command received
* A data on screen was updated

=== How to shorten the power up “Starting RTC” time? ===
Install RTC battery

* Operate with RTC battery installed can shorten the power up time

RTC Mode Setting

* The RTC mode can be config in the SGTools Menu ⇒ Tools ⇒ Project Setting

[[File:RTC mode.png]]

* RTC Mode as follow

{| class="wikitable"
|+
!RTC Mode
!Operating with RTC battery
!Operating without RTC battery
!Descriptions
|-
|Enable
|1st power up takes 6s;
next power up takes 1s
|every power up takes 6s
|RTC run with correct init
|-
|Disable
|every power up takes 1s
|every power up takes 1s
|RTC stop
|-
|Engineering Mode
|every power up takes 1s
|every power up takes 1s
|RTC run without init
RTC might not run correctly
NOT suggest for production setting
|}

== UI Elements and Functions ==

=== How to calibrate the resistive touch panel? ===
Power-on Calibration

* Touch and hold the top-right corner of the RTP
* Power on the Smart LCD
* The display will enter the calibrate mode
* Touch the cross on screen to do the calibration

Command Calibration

* Power on the Smart LCD
* Use a E4 command to enter the calibration mode (AA E4 55 AA 5A A5 CC 33 C3 3C)
* The display will enter the calibrate mode
* Touch the cross on screen to do the calibration

=== How to show Value with decimal point? ===
Integer Value (VP_N16, VP_N32, VP_N64)

* Data Type can be Signed or Un-signed
* Config the Integer Digits and Decimal Digits in the Number elements
* It will show integers with decimal point.
{| class="wikitable"
|+
!VP's value(10's)
!Interger Digits
!Decimal Digits
!Display Result
|-
|15
|Auto
|3
|0.015
|-
|23762
|Auto
|3
|23.782
|-
|5629
|5
|1
|00562.9
|-
| -87913
|3
|2
| -879.13
|-
| -13277
|2
|2
| -99.99
|-
|1758
|3
|0
|999
|}
Note. Over range value will show its max value

Floating Value (VP_N32)

* Data Type should be Floating Value
* Float type value is suggested to select: Integer Digits=Auto, Decimal Digits=1~9. to prevent over maximum value presentation error

Note. Float type value might rounded or truncated due to hex-dec conversion

=== How to hide an element in page? ===
Real Time Properties Control

* Enable VP is can be use to hide an element in page
* Enable VP is none by default (element operate normally)
* It can assign a VP address (VP_N16, VP_N32, VP_N64) to it as its Enable control register
* The VP value set to 1 as enable at power-on.
* It can be disabled (hidden) by a zero value

=== How to display Chinese Char? ===

* Smart LCD support GB2312, GBK, BIG5
* GB2312 support the most command 6763 simplified Chinese
* Select a Chinese Font Char set in the String ElementConfig a VP_STR with it
* Send a GB code string to the VP_STR to display it on screen

Note. It can generate custom font in SGTools (Menu ⇒ Tools ⇒ Font Setting ⇒ Font Config <2>)

== Communications ==

=== How to config the terminal buadrate? ===
By Project setting

* The terminal baudrate can be config in the SGTools (Menu ⇒ Tools ⇒ Project Setting)

[[File:SGT Project Baud Rate.png|223x223px]]

* default is115200 baud per second

By Command

* It is also possible to change the baudrate by using command.
* Use a E0 command to set sys config (AA E0 55 AA 5A A5 07 83 00 CC 33 C3 3C)
* Baud rate will back to project setting after next power on

=== How to resolve communication issue? ===
Physical Connections

* Check the terminal connections cable
* Ensure the GND is connection
* Confirm the cross wiring (Tx to Rx )

{|
|Smart LCD TX ⇒ PC Rx
|-
|Smart LCD Rx ⇐ PC Tx
|-
|Smart LCD RTS ⇒ PC CTS
|}
Signal Levels

* Check the terminal signal of the Smart LCD
* There are three kind of Smart LCD terminal (depends on model) UART (3.3V) / RS-232C (±12V) / RS-485 (3.3V)
* The host and the Smart LCD must be have the same signal levels
* Only Smart LCD with RS-232C can interface to PC RS-232C signal(±12V)

Byte Packet Config

* Check the baud rate (115200 by default)
* Check the no. of bit, parity and stop bit (8N1 by default)
* All the command are in hex/binary (NOT ASCII)

=== What is the function of terminal RTS signal? ===
RTS signal

* RTS is an output signal of the Smart LCD, working like a busy signal
* It will be set, while the Smart LCD input buffer full When RTS set, host should stop sending data/command to prevent data/command lost
* As Smart LCD is having 32kbyte (various by model) input buffer
* In most of the case, it may not necessary to use RTS signal

MediaWiki:Sidebar

2025-10-20T05:16:31Z

Usr255:

MediaWiki:Sidebar

2025-10-20T05:10:12Z

Usr255:

Memory & Ranges

2025-10-20T05:04:44Z

Usr255: Created page with "== Memory area == * TOPWAY Smart LCD provide RAM area for variables VP_N16, VP_N32, VP_N64, VP_STR, … * Be aware that data in RAM dissipates when Smart LCD power is cut. * There are multiple storage areas within Smart LCD. * Table below explains those areas and ways to access them. {| class="wikitable" |+ !Int RAM |'''HW RAM area''' * VP_N16/32/64 * VP_STR * VP_G16 | | |- !Int Flash |'''HW Flash area''' * cmd 0x94 W/R * cmd 0x90 W * cmd 0x91 R |'''Partition0''' * Di..."

== Memory area ==

* TOPWAY Smart LCD provide RAM area for variables VP_N16, VP_N32, VP_N64, VP_STR, …
* Be aware that data in RAM dissipates when Smart LCD power is cut.
* There are multiple storage areas within Smart LCD.
* Table below explains those areas and ways to access them.

{| class="wikitable"
|+
!Int RAM
|'''HW RAM area'''
* VP_N16/32/64
* VP_STR
* VP_G16
|
|
|-
!Int Flash
|'''HW Flash area'''
* cmd 0x94 W/R
* cmd 0x90 W
* cmd 0x91 R
|'''Partition0'''
* Display Project
* cmd 0x95 R usr.bin
* Lua R/(W)
|style=vertical-align:top|'''Partition2'''
* Lua R/W
|-
!Ext U-Drv
|
|style=vertical-align:top|'''Partition1'''
* Lua R/W
|
|-
|
!Hardware
! colspan="2" |File System
|}

=== HW RAM area (on-board internal RAM) ===

* It is for VP variables (VP_N16, VP_N32, VP_N64, VP_STR, VP_G16,…)
* VP variables' default values are either 0s or “blank” at startup
* TRAM is volatile memory
* VP variables can be accessed by Project Elements, Lua Commands, Serial commands

=== HW Flash area (on-board internal flash) ===

* It can be directly accessed by serial command
* Serial command 0x94: provides backup or restore function
* Serial command 0x90: write a data to Hardware Flash area
* Serial command 0x91: read a from Hardware Flash area
* Lua access via “hmt.runcmd” that by execute the above commands

Partition 0 (on-board internal flash)

* Display Project files are stored in this partition
* Constant data is stored in usr.bin file at design-time. User can use serial command 0x95 to retrieve that.
* Lua io.open, io.read commands can be used to access the partition (named as “disk0”). For data safety, DON’T use Lua io.write command in Partition 0.

=== Partition1 (External U-Drv) ===

* External USB storage is defined as partition 1.
* This partition (named as “disk1”) can be accessed by Lua io.open, io.read commands
* In most of the case, it is for backing up the internal stored data (with Lua script)

=== Partition2 (on-board internal flash) ===
* This partition can be config in SGTools (project config)
* This partition (named as “disk2”) can be access by Lua io.open, io.read command[[File:Project Setting 2nd Partition Size.png|640x640px]]
'''Note'''

We can assign a default value at run-time, by using "Page Function". The function will run before the host page is loaded.

[[File:Page Function Call.png]]

= PAGEs, Image-Resources and VP-Variables Ranges =
{| class="wikitable"
!'''icon'''
!'''Mnemonic'''
!'''Name'''
!'''Linked VP.'''
!'''Linked IMG'''
!'''Editor Limit'''
!'''Memory Limit'''
!'''Address range'''
|-
|[[File:PAGE.png|64x64px]]
|PAGE
|Page
|<nowiki>--</nowiki>
|IMG_BKG
|≤1000/project
|256M byte (*4)
|PG0000 ~ PG0999
|-
|[[File:BKG IMG.png|64x64px]]
|IMG_BKG
|Background Image
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|≤10000/project

(*1)
|
|DP0000 ~ DP9999
|-
|[[File:ICO IMG.png|64x64px]]
|IMG_ICO
|Icon
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|≤10000/project

(*2)
|
|DI0000 ~ DI9999
|-
|[[File:ANI IMG.png|64x64px]]
|IMG_ANI
|Animation
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|≤1000/project

(*2)(*3)
|
|ANI000 ~ ANI999
|-
|[[File:VP STR.png|64x64px]]
|VP_STR
|String Variable
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|≤1024 / project
|1024(MAX) x (127+1)byte
|0x000000 ~ 0x01FF80
|-
|[[File:VP N16.png|64x64px]]
|VP_N16
|16bit Variable
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|≤32512 / project
|32512(MAX) x (2)byte
|0x080000 ~ 0x08FDFE
|-
|[[File:VP N32.png|64x64px]]
|VP_N32
|32bit Variable
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|≤16128 / project
|16128(MAX) x (4)byte
|0x020000 ~ 0x02FBFC
|-
|[[File:VP N64.png|64x64px]]
|VP_N64
|64bit Variable
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|≤7936 / project
|7936(MAX) x (8)byte
|0x030000 ~ 0x03F7F8
|-
|[[File:VP G16.png|64x64px]]
|VP_G16
|16bit Graph Variable
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|≤16384 / project
|16384(MAX) x (8)byte

(dynamic array allocation)
|0x060000 ~ 0x07FFF8
|-
|[[File:VP BP1.png|64x64px]]
|VP_BP1
|Bitmap Variable
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|≤2048 / project
|2048(MAX) x (64)byte

(dynamic array allocation)
|0x060000 ~ 0x05FFBF
|-
|[[File:VP REG.png|64x64px]]
|VP_REG
|Register Variable
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|0xFFFF00 ~ 0xFFFFFF
|-
|[[File:VP TMR.png|64x64px]]
|VP_TMR
|Timer Variable
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|≤8 / project
|<nowiki>--</nowiki>
|0x02FFE0 ~ 0x02FFFC
|}
Note:

<nowiki>*</nowiki>1. IMG_BKG must >1/2 of Full-Screen (SGTools auto resize to fit screen)

<nowiki>*</nowiki>2. IMG_ICON and IMG_ANI Size Limit
{| class="wikitable"
!Project resolution
!Size Limit
|-
|320x240
|320x240 max. (Full-Screen)
|-
|480x272
|480x272 max. (Full-Screen)
|-
|640x480
|131072pixels (42% of Full Screen)
|-
|800x480
|131072pixels (34% of Full Screen)
|-
|800x600
|131072pixels (27% of Full Screen)
|-
|1366X480
|131072pixels (20% of Full Screen)
|}
<nowiki>*</nowiki>3. 1~128frame max.

<nowiki>*</nowiki>4. Memory Size may vary by model.

= Elements in PAGE Limitation =
{| class="wikitable"
|'''icon'''
|'''Mnemonic'''
|'''Name'''
|'''Linked VP.'''
|'''Linked IMG'''
|'''Editor Limit'''
|'''Memory Limit'''
|'''ID range'''
|-
|[[File:TPK.png|64x64px]]
|'''TPK'''
|Touch Key
|<nowiki>--</nowiki>
|1x IMG_ICO or

1x IMG_BKG (*1)
|≤256 / PAGE
|<nowiki>--</nowiki>
|0 ~ 255 (each page)
|-
|[[File:VPK.png|64x64px]]
|'''VPK'''
|Virtual Key
|VP_N16 (*2)

VP_N32 (*2)
|<nowiki>--</nowiki>
|≤64 / PAGE
|<nowiki>--</nowiki>
|0 ~ 63 (each page)
|-
|[[File:STS.png|64x64px]]
|'''STS'''
|Static String
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|≤128 / PAGE
|<nowiki>--</nowiki>
|0 ~ 127 (each page)
|-
|[[File:STR.png|64x64px]]
|'''STR'''
|String Element
|VP_STR
|<nowiki>--</nowiki>
|≤128 / PAGE
|<nowiki>--</nowiki>
|0 ~ 127 (each page)
|-
|[[File:Num.png|64x64px]]
|'''N16'''

'''N32'''

'''N64'''
|Number Element
|VP_N16

VP_N32

VP_V64
|<nowiki>--</nowiki>
|≤120 / PAGE
|<nowiki>--</nowiki>

--

--
|0 ~ 119 (each page)
|-
|[[File:TMR.png|64x64px]]
|'''TMR'''
|Timer Display
|VP_N32

(timer only)
|<nowiki>--</nowiki>
|≤8 / PAGE
|<nowiki>--</nowiki>
|0 ~ 7 (each page)
|-
|[[File:RTC.png|64x64px]]
|'''RTC'''
|Real Time Clock
|<nowiki>--</nowiki>
|<nowiki>--</nowiki>
|≤8 / PAGE
|<nowiki>--</nowiki>
|0 ~ 7 (each page)
|-
|[[File:ICO.png|64x64px]]
|'''ICO'''
|Static Icon
|<nowiki>--</nowiki>
|1x IMG_ICO
|≤128 / PAGE
|<nowiki>--</nowiki>
|0 ~ 127 (each page)
|-
|[[File:ANI.png|64x64px]]
|'''ANI'''
|Animation Element
|<nowiki>--</nowiki>
|1x IMG_ANI
|≤8 / PAGE
|<nowiki>--</nowiki>
|0 ~ 7 (each page)
|-
|[[File:IDX BIT.png|64x64px]]
|'''IDX_BIT'''
|Bit Icon
|VP_N16

VP_N32
|2(MAX) x IMG_ICON
|≤64 / PAGE
|<nowiki>--</nowiki>
|0 ~ 63 (each page)
|-
|[[File:IDX.png|64x64px]]
|'''IDX'''
|Indexed Icon
|VP_N16
|10000(MAX) x IMG_ICON
| rowspan="2" |≤64 / PAGE
|<nowiki>--</nowiki>
| rowspan="2" |0 ~ 63 (each page)
|-
|[[File:TCM.png|64x64px]]
|'''TCM'''
|Tachometer
|VP_N16
|181(MAX) x IMG_ICON
|<nowiki>--</nowiki>
|-
|[[File:IDX DEC.png|64x64px]]
|'''I16'''

'''I32'''
|Decimal Icon
|VP_N16

VP_N32
|12x IMG_ICON

(0~9,”.”,”-“)
|≤32 / PAGE
|<nowiki>--</nowiki>
|0 ~ 31 (each page)
|-
|[[File:B16.png|64x64px]]
|'''B16'''
|Progress Bar
|VP_N16
|1x IMG_ICON
|≤32 / PAGE
|<nowiki>--</nowiki>
|0 ~ 31 (each page)
|-
|[[File:G16.png|64x64px]]
|'''G16'''
|Graph Element
|VP_G16
|<nowiki>--</nowiki>
|≤8 / PAGE
|<nowiki>--</nowiki>
|0 ~ 7 (each page)
|-
|[[File:BP1.png|64x64px]]
|'''BP1'''
|Bitmap Element
|VP_BP1
|<nowiki>--</nowiki>
|≤32 / PAGE
|<nowiki>--</nowiki>
|0 ~ 31 (each page)
|-
|[[File:QRC.png|64x64px]]
|'''QRC'''
|QR Code Element
|VP_STR

VP_N16 (in seq.)
|<nowiki>--</nowiki>
|≤4 / PAGE
|<nowiki>--</nowiki>
|0 ~ 3 (each page)
|-
|[[File:DPD.png|64x64px]]
|'''DPD'''
|Draw Pad
|VP_N16 (in seq.)
|<nowiki>--</nowiki>
|≤4 / PAGE
|<nowiki>--</nowiki>
|0 ~ 3 (each page)
|}
Note:

<nowiki>*</nowiki>1. IMG_ICO for key-down display, IMG_BKG will be cropped to key size for key-down display

<nowiki>*</nowiki>2. Monitoring values

<nowiki>*</nowiki>3. Element display Size: 8x8 (MIN), except Bitmap Element

<nowiki>*</nowiki>4. The above limitation is to ensure the display performance, though it can be override by the “config.ini” in the SGTools installation folder. (Remember to backup the file before edit!)

= System Registers =
{| class="wikitable"
|'''Address'''
|'''System Register'''
|'''Descriptions'''
|'''Note'''
|-
|0xFFFF00

<nowiki>:</nowiki>

0xFFFF07
|Timer_Ctrl0

<nowiki>:</nowiki>

Timer_Ctrl7
|D[0]=0 : stop the timer

D[0]=1 : start the timer

D[1]=0 : count down, time down to 0x00000000

D[1]=1 : count up, time up to 0x7fffffff

D[7:2]=000000 : reserved
|(*1)
|-
|0xFFFF10
|RTC_Year
|Value=0~99
| rowspan="7" |0xffff10~0xffff16

should be written at the same time
|-
|0xFFFF11
|RTC_Month
|Value=1~12
|-
|0xFFFF12
|RTC_Day
|Value=1~31
|-
|0xFFFF13
|RTC_Hour
|Value=0~23
|-
|0xFFFF14
|RTC_Minute
|Value=0~59
|-
|0xFFFF15
|RTC_Second
|Value=0~59
|-
|0xFFFF16
|RTC_Set
|Value=1 : sync the time
|-
|0xFFFF20
|Buzzer
|Value=0~63; buzzer beeping duration (*1)
| rowspan="2" |See Project Setting for details
|-
|0xFFFF21
|Backlight
|Value=0~63; Real time backlight brightness setting (*1)
|-
|0xFFFF22
|ScreenSaverBacklight
|Value=0~63; Screen Saver Backlight Brightness (*1)
| rowspan="7" |see Screen Saver section for details
|-
|0xFFFF23
|ScreenSaverPage_H
| rowspan="2" |Value=0~999; Screen Saver display Page (*2)
|-
|0xFFFF24
|ScreenSaverPage_L
|-
|0xFFFF25
|ScreenSaver Timer1_H
| rowspan="2" |Value=0~65535; Screen saver delay time 1 (*2)
|-
|0xFFFF26
|ScreenSaver Timer1_L
|-
|0xFFFF27
|ScreenSaver Timer2_H
| rowspan="2" |Value=0~65535; Screen saver delay time 2 (*2)
|-
|0xFFFF28
|ScreenSaver Timer2_L
|-
|0xFFFF30
|Font_CodePage
|Font Code Page index value (*1) (*3)
|
|-
|0xFFFF31
|Font_Country
|Font Country index value (*1) (*4)
|
|}
Note:

<nowiki>*</nowiki>1. Value can be update by command System_register_write (0xb3) to access the register

<nowiki>*</nowiki>2. Value should be written at the same time by command Sucesstive_write (0x82)

<nowiki>*</nowiki>3. Code Page index value
{|
|'''index'''
|'''Code Page'''
|..........
|'''index'''
|'''Code Page'''
|-
|1
|437(OEM United States)
|
|12
|1252(ANSI Latin I)
|-
|2
|737(OEM Greek437G)
|
|13
|1253(ANSI Greek)
|-
|3
|852(OEM Latin II)
|
|14
|1254(ANSI Turkish)
|-
|4
|860(OEM Portuguese)
|
|15
|1255(ANSI Hebrew)
|-
|5
|863(OEM Canadian French)
|
|16
|1256(ANSI Arabic)
|-
|6
|865(OEM Nordic)
|
|17
|1257(ANSI Baltic)
|-
|7
|866(OEM Russian)
|
|18
|1258(ANSI/OEM Viet Nam)
|-
|8
|874(ANSI/OEM Thai)
|
|19
|GB2312 (Simplified Chinese)
|-
|9
|932(ANSI/OEM Japanese Shift JIS)
|
|20
|GBK (Simplified Chinese)
|-
|10
|1250(ANSI Central Europe)
|
|21
|ECU-KR ( Korea )
|-
|11
|1251(ANSI Cyrillic)
|
|22
|BIG5 (Traditional Chinese)
|-
|0
|uni-code (with font config <3> TTF)
|
|
|
|}
<nowiki>*</nowiki>4. Country index value
{|
|'''index'''
|'''Code Page'''
|..........
|'''index'''
|'''Code Page'''
|-
|1
|USA
|
|7
|DenmarkⅡ
|-
|2
|France
|
|8
|Sweden
|-
|3
|Germany
|
|9
|Italy
|-
|4
|UK
|
|10
|Spain
|-
|5
|DenmarkⅠ
|
|11
|Japan
|-
|6
|DenmarkⅡ
|
|
|
|}

MediaWiki:Sidebar

2025-10-20T05:02:32Z

Usr255:

MediaWiki:Sidebar

2025-10-20T05:02:09Z

Usr255:

SGTools

2025-10-14T07:17:38Z

Usr255: /* Project Setting (Menu - Tools - Project Setting) */

== TOPWAY SGTools ==
SGTools is a UI design tools for Smart LCD. SGTools enables UI design with zero coding. It dramatically simplifies and speeds up the whole product design process

== SGTools Layout ==
[[File:SGT-Interface.png|800x800px]]
{|
|A.
|menu and config
|file tools for project open, save, project options
|-
|B.
|alignment tools
|alignment and display filter tools; with compile and download tools
|-
|C.
|elements for UI
|display elements tools
|-
|D.
|resource (VP, icons, etc)
|Resource windows (right click on the resources); built new page; import pictures (IMG_BKG, IMG_ICO, IMG_ANI); allocated VP variable (VP_N16, VP_N32, VP_N64); user file, etc... (*1)
|-
|E.
|UI editing area
|The working area for composing the display page. User could build element onto the page.
|-
|F.
|Elements or page properties
|Display the selected element properties or Page properties
|-
|G.
|prompt output area
|Prompt output window show the compiling information, warning and error information
|}

== SGTools Menu - File ==

=== Start (Menu - File - Welcome) ===
At the start up of SGTools, a pop-up Welcome interface for user to select which project to work on.

[[File:SGT welcome.png]]

=== New Project (Menu - File - New Project) ===
[[File:File-new(128x128).png|64x64px]] For New Project, user can type in the project name and select the folder for that project. It is important to select the correct screen size that matches the target Smart LCD. (0°/180° for landscape projects), (90°/270° for portrait projects). After click the OK button, SGTools will create a folder in to the Project Folder.

[[File:SGT New Project.png]]

=== Open Project (Menu - File - Open Project) ===
[[File:File-open(128x128).png|64x64px]] Open Project look for the project folder with .tpj or .tp9 file inside
=== Save (Menu - File - Save) ===
[[File:File-save(128x128).png|64x64px]]Save the current project.

=== Save As (Menu - File - Save As) ===
Save the current project another (folder) name.

=== Close Project (Menu - File - Close) ===
[[File:File-close(128x128).png|64x64px]]Close the current project.

== SGTools Menu - Tools ==

=== Editor Setting (Menu - Tools - Option) ===
[[File:SGT Editor Setting.png|480x480px]]

'''In Editor Setting'''

* Fine adjust all the image color tone during compile by setting Image Gamma
* Select Compile Options
* Output Project Image File (see “Download the display project” section for details)
* Open Output folder after compile
* Compile Project before download
* Save the project before compile
* Compile Orphan Background Images

=== Project Setting (Menu - Tools - Project Setting) ===
[[File:Tools icon(128x128).png|64x64px]] Project Setting

[[File:SGT Project Setting.png|480x480px]]

* Page: Starting page to show at power on
* power on "Backlight Brightness" level
* select one of the "Screen Saver Mode", user can select one of the following with related parameter [[File:Screen saver mode.png]]
* Delay Time1 = 0 can disable the Screen Saver Function
* set "Buzzer" beeping length (0=no sound)
* set RTC (real time clock) operation mode [[File:RTC mode.png|407x407px]]

{| class="wikitable"
|+
!'''RTC Mode'''
!'''Operating with RTC battery'''
!'''Operating without RTC battery'''
!'''Descriptions'''
|-
|Enable
|1st power up takes 6s;
next power up takes 1s
|every power up takes 6s
|RTC runs with correct init
|-
|Disable
|every power up takes 1s
|every power up takes 1s
|RTC stops
|-
|Engineering Mode
|every power up takes 1s
|every power up takes 1s
|RTC runs without init, it might not run correctly. It is NOT suggested for production setting
|}

* set RS232 communication baud rate
* set “Command Format”, three kinds of command Format are available.(normal command, normal command + instruction length, normal command + instruction length + CRC) [[File:SGT Project Setting CommandFormat.png|297x297px]]
* set “Command Timeout” (0=no timeout)
* set power on "Country Code" for ASCII display
* set power on "Code Page" for ext. char & decoding
* set “Enable ACK” to provide command responses; “:>” : ready for new command; “!>” : command error
* set "Touch-Key lock on touch" to lock the touch down key and action on release
* set "Upside-down" to flip screen at run-time
* Partition2 can be create for data storage

* LAN settings only available for SmartLCD equipped with Ethernet interface [[File:SGT LAN Setting a.png|480x480px]]
* IP is the static assigned IP address for a SmartLCD
* IP, TCP Port, Mask and GW(Gateway) are standard Ethernet config parameters
* TFTP Port is for remote TFTP file access

=== Font Setting (Menu - Tools - Font Setting) ===
[[File:Font config icon(128x128).png|64x64px]]There are 3 sections of Fonts.

Font Config <1>, the Font Width and Height are fixed and mainly for ASCII Char. (with some default font, vary by model)

[[File:SGT FontConfig1.png|480x480px]] [[File:SGT FontConfig1 build.png|480x480px]]

Font Config <2>, provide more free option about Size and Decoding selection. (without font by default)

[[File:SGT FontConfig2.png|480x480px]] [[File:SGT FontConfig2 build.png|480x480px]]

Font Config <3>, support True Type Font (TTF) for some models. (without font by default)

[[File:SGT FontConfig3.png|480x480px]]

Right click on the font table, select "build" could build the font with several options. It is suggested to delete un-used Font area to free up memory.

=== Compile (Menu - Tools - Compile) ===
[[File:Compile(128x128).png|64x64px]] Compile [F7]

After finish the layout, "Built Project Files" will compile all the resource and font etc in to a set of files. It could download or copy to the Smart LCD at any time. It will pop-up the output folder inside the Project Folder

=== Download to Module (Menu - Tools - Download to Module) ===
[[File:Quick-download(128x128).png|64x64px]] Download to Module [F9]

After connect the Smart LCD USB to user PC, the Smart LCD will appear as a removable drive. Using "Download to Module" will copy the compiled project files into the Smart LCD.

[[File:SGT DownloadToModule-successful.png|480x480px]]

Note. it will refuse to download without Smart LCD

Lua Script

2025-09-28T04:17:59Z

Usr255: /* tpkhook */

== Smart LCD Lua Script Support ==
Lua script is supported in some of the TOPWAY Smart LCD to enhance the flexibility. Engineer may refine the Smart LCD functionality with script. The provided Lua functionality support most of the features of Lua 5.3 except OS operation. (please refer to lua.net for Lua 5.3 details)It also extended with hmt library for Smart LCD variables access, function control and value return etc.

== Lua Script Structure ==

==== Basic structure ====
-- define variable(s)
Script_Variable01 = 0x00

-- main loop
luamain = function(void)

return 0
end
Note: main loop run continually intensive loop in the main loop may affect the Smart LCD UI operations

==== Advance structure with hooks ====
-- define variable(s)
Script_Variable01 = 0x00

-- main loop
luamain = function(void)

return 0
end

-- touch key hook
tpkhook = function(page, id, state)
return 0
end

-- page hook
pagechangehook = function(pageid)

return 0
end
Note:

* main loop run continually
* intensive loop in the main loop may affect the Smart LCD UI operations
* hooks share the MCU time with the main loop.
* looping or long delay will affect the main loop
* “wait loop” is not allowed in the hooks.

== Smart LCD VP variables ==
{| class="wikitable"
|+
!Mnemonic
!Name
!Memory Limit
!Address Range
|-
|VP_STR
|String Variable
|1024(MAX)*(127+1)byte
|0x000000~0x01FF80
|-
|VP_N16
|16Bit Integer Variable
|32512(MAX)*(2)byte
|0x080000~0x08FDFE
|-
|VP_N32
|32Bit Integer Variable
|16128(MAX)*(4)byte
|0x020000~0x02FEFC
|-
|VP_N64
|64Bit Integer Variable
|7936(MAX)*(8)byte
|0x030000~0x03F7F8
|-
|VP_SYS
|System Register Variable
|256(MAX)*(1)byte
|0xFFFF00~0xFFFFFF
|}
Note. Please also refer to Smart LCD handbook for VP variables details

== hmt Lua Functions Summary ==
{| class="wikitable"
|+
| '''Category'''
| '''Function Name'''
| '''Descriptions'''
|-
! rowspan="12" |VP
read/write
| hmt.readvpstr(addr)
| Read VP_STR value
|-
| hmt.writevpstr(addr, string)
| Write VP_STR value
|-
| hmt.readvp16(addr)
| Read VP_16 value
|-
| hmt.writevp16(addr, value)
| Write VP_16 value
|-
| hmt.readvp32(addr)
| Read VP_32 value
|-
| hmt.readvp32f(addr)
| Read VP_32 value (floating point value)
|-
| hmt.writevp32(addr, value)
| Write VP_32 value
|-
| hmt.readvp64(addr)
| Read VP_64 value
|-
| hmt.readvp64f(addr)
| Read VP_64 value (floating point value)
|-
| hmt.writevp64(addr, value)
| Write VP_64 value
|-
| hmt.readvpreg(addr)
| Read VP_SYS value
|-
| hmt.writevpreg(addr, value)
| Write VP_SYS value
|-
! rowspan="9" | System
| hmt.changepage(pageid)
| Display a pre-stored PAGE
|-
| hmt.readpage()
| Read Page ID
|-
| hmt.gettick()
| Read system time
|-
| hmt.delayms(time)
| Delay in ms(*1)
|-
| hmt.runcmd(table, num)
| Execute terminal command (without packet header and taill)
|-
| hmt.bypass(is)
| Disable Smart LCD terminal command execution (I/O); is=1 for disable; is=0 for enable(normal)
|-
| hmt.crc16calc(table, num)
| Generate a CRC value
|-
| hmt.formatdisk2()
| Format module flash second partition (*4)
|-
| hmt.inituart(baudrate,parity)
| Set baud rate and parity parameters of A and B (*4)
|-
! rowspan="5" | Thread
| hmt.createthread(function())
| Create a thread and return a thread object (*4)
|-
| suspend()
| Suspend thread (*4)
|-
| resume()
| Resume thread (*4)
|-
| terminate()
| Terminate thread (*4)
|-
| getid()
| Get thread ID and handle (*4)
|-
! rowspan="7" | UART0
| hmt.uartisempty()
| Check for UART0 buffer; 1 for empty; 0 for not empty
|-
| hmt.uartclearbuf()
| Clear UART0 buffer
|-
| hmt.getchar()
| Read a byte form UART0 buffer
|-
| hmt.putchar(char)
| Send a byte to UART0
|-
| hmt.uartsendbytes(table, num)
| Send a num of byte to UART0
|-
| hmt.uartlock()
| Lock UART0 before Lua sending data to UART0 (*2, *3)
|-
| hmt.uartunlock()
| Unlock UART0 after Lua sending data to UART0 (*2, *3)
|-
! rowspan="7" | UART1
| hmt.uart1isempty()
| Check for UART1 buffer; 1 for empty; 0 for not empty
|-
| hmt.uart1clearbuf()
| Clear UART1 buffer
|-
| hmt.uart1getchar()
| Read a byte form UART1 buffer
|-
| hmt.uart1putchar(char)
| Send a byte to UART1
|-
| hmt.uart1sendbytes(table, num)
| Send a num of byte to UART1
|-
| hmt.uart1lock()
| Lock UART1 before sending data to UART1 (*2, *3)
|-
| hmt.uart1unlock()
| Unlock UART1 after sending data to UART1 (*2, *3)
|}

Note. *1. long delay may affect the Smart LCD normal operation. *2. It is necessary to lock the UART for Lua access, if hmt.bypass is not enabled. *3. Generally hmt.uartlock() and hmt.uartunlock() should be used in pair. *4. Selected model only

== VP read/write Functions ==

=== hmt.readvpstr ===
{|
|'''Function'''
|hmt.readvpstr(addr)
|-
|'''Description'''
|Read VP_STR value
|-
|'''Parameter'''
|addr is the VP_STR address (*1)
|-
|'''Return Value'''
|String
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local strvalue = ““ strvalue = hmt.readvpstr(0x000080) print(“strvalue=”, strvalue)
|
* Put “TOPWAY” into VP_STR 0x000080 via SmartLCD UI
* define a local variable strvalue and put ““ inside
* copy value in VP_STR at 0x000080 to strvalue
* print to UART0
* it should find the following at the UART0
* '''strvalue=TOPWAY'''
|}

=== hmt.writevpstr ===
{|
|'''Function'''
|hmt.writevpstr(addr, string)
|-
|'''Description'''
|Write a value to VP_STR
|-
|'''Parameter'''
|addr is the VP_STR address (*1), string is the value to be written
|-
|'''Return Value'''
|nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local strvalue = “ShenZhen” hmt.writevpstr(0x000080, strvalue) print(“0x000080:”, hmt.readvpstr(0x000080))
|
* define a local variable strvalue and put “ShenZhen” inside
* copy the strvalue to VP_STR at 0x000080
* print to UART0
* it should find the following at the UART0
* '''0x000080:ShenZhen'''
|}

=== hmt.readvp16 ===
{|
|'''Function'''
|hmt.readvp16(addr)
|-
|'''Description'''
|Read VP_N16 value
|-
|'''Parameter'''
|addr is the VP_N16 address (*1)
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local N16value = 0 N16value = hmt.readvp16(0x080002) print(“N16value:”, N16value)
|
* Put 24 into VP_N16 0x080002 via SmartLCD UI
* define a local variable N16value and put 0 inside
* copy value in VP_N16 at 0x080002 to N16value
* print to UART0
* it should find the following at the UART0
* '''N16value:24'''
|}

=== hmt.writevp16 ===
{|
|'''Function'''
|hmt.writevp16(addr, value)
|-
|'''Description'''
|Write a value to VP_N16
|-
|'''Parameter'''
|addr is the VP_N16 address(*1), value is the value to be written
|-
|'''Return Value'''
|nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local N16value = 123 hmt.writevp16(0x080002, N16value) print(“0x080002:”, hmt.readvp16(0x080002))
|
* define a local variable N16value and put 123 inside
* copy the N16value to VP_N16 at 0x080002
* print to UART0
* it should find the following at the UART0
* '''0x080002:123'''
|}

=== hmt.readvp32 ===
{|
|'''Function'''
|hmt.readvp32(addr)
|-
|'''Description'''
|Read VP_N32 value
|-
|'''Parameter'''
|addr is the VP_N32 address (*1)
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local N32value = 0 N32value = hmt.readvp32(0x020004) print(“N32value:”, N32value)
|
* Put 1108410368 into VP_N32 0x020004 via SmartLCD UI
* define a local variable N32value and put 0 inside
* copy value in VP_N32 at 0x020004 to N32value
* print to UART0
* it should find the following at the UART0
* '''N32value:1108410368'''
|}

=== hmt.readvp32f ===
{|
|'''Function'''
|hmt.readvp32f(addr)
|-
|'''Description'''
|Read VP_N32 value with floating value inside
|-
|'''Parameter'''
|addr is the VP_N32 address (*1)
|-
|'''Return Value'''
|Floating point
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local N32value = 0.0 N32value = hmt.readvp32f(0x020004) print(“N32value:”, N32value)
|
* Put a floating point value 36.25 into VP_N32 0x020004 via SmartLCD UI
* define a local variable N32value and put 0.0 inside
* copy floating point value in VP_N32 at 0x020004 to N32value
* print to UART0
* it should find the following at the UART0
* '''N32value:36.25'''
|}

=== hmt.writevp32 ===
{|
|'''Function'''
|hmt.writevp32(addr, value)
|-
|'''Description'''
|Write a value to VP_N32
|-
|'''Parameter'''
|addr is the VP_N32 address(*1), value is the value to be written
|-
|'''Return Value'''
|nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local N32value = 54321 hmt.writevp32(0x080004, N32value) print(“0x080004:”, hmt.readvp32(0x080004))
|
* define a local variable N32value and put 54321 inside
* copy the N32value to VP_N32 at 0x080004
* print to UART0
* it should find the following at the UART0
* '''0x080004:54321'''
|}

=== hmt.readvp64 ===
{|
|'''Function'''
|hmt.readvp64(addr)
|-
|'''Description'''
|Read VP_N64 value
|-
|'''Parameter'''
|addr is the VP_N64 address (*1)
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local N64value = 0 N32value = hmt.readvp64(0x030000) print(“N64value:”, N64value)
|
* Put 4638029965185179976 into VP_N64 0x030000 via SmartLCD UI\
* define a local variable N64value and put 0 inside
* copy value in VP_N64 at 0x030000 to N64value
* print to UART0
* it should find the following at the UART0
* '''N64value: 4638029965185179976'''
|}

=== hmt.readvp64f ===
{|
|'''Function'''
|hmt.readvp64f(addr)
|-
|'''Description'''
|Read VP_N64 value with floating value inside
|-
|'''Parameter'''
|addr is the VP_N64 address (*1)
|-
|'''Return Value'''
|Floating point
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local N64value = 0.0 N64value = hmt.readvp64f(0x030000) print(“N64value:”, N64value)
|
* Put a floating point value 118.37 into VP_N64 0x030000 via SmartLCD UI
* define a local variable N64value and put 0.0 inside
* copy floating point value in VP_N64 at 0x030000 to N64value
* print to UART0
* it should find the following at the UART0
* '''N64value:118.37'''
|}

=== hmt.writevp64 ===
{|
|'''Function'''
|hmt.writevp64(addr, value)
|-
|'''Description'''
|Write a value to VP_N64
|-
|'''Parameter'''
|addr is the VP_N64 address(*1), value is the value to be written
|-
|'''Return Value'''
|nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local N64value = 123456789 hmt.writevp64(0x030000, N64value) print(“0x030000:”, hmt.readvp64(0x030000))
|
* define a local variable N64value and put 123456789 inside
* copy the N64value to VP_N64 at 0x030000
* print to UART0
* it should find the following at the UART0
* '''0x030000:123456789'''
|}

=== hmt.readvpreg ===
{|
|'''Function'''
|hmt.readvpreg(addr)
|-
|'''Description'''
|Read Smart LCD system register value (VP_SYS) value
|-
|'''Parameter'''
|ddr is the VP_SYS address (*1)
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local Regvalue = 0 Regvalue = hmt.readvpreg(0xFFFF20) print(“Regvalue:”, Regvalue)
|
* define a local variable Regvalue and put 0 inside
* copy value in VP_SYS at 0xFFFF20 to Regvalue
* print to UART0
* it should find the following at the UART0
* '''Regvalue:8'''
|}

=== hmt.writevpreg ===
{|
|'''Function'''
|hmt.writevpreg(addr, value)
|-
|'''Description'''
|Write a value to Smart LCD system register value (VP_SYS) value
|-
|'''Parameter'''
|addr is the VP_SYS address(*1), value is the value to be written
|-
|'''Return Value'''
|nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local Regvalue = 18 hmt.writevpreg(0xFFFF20, Regvalue) print(“0xFFFF20:”, hmt.readvpreg(0xFFFF20))
|
* define a local variable Regvalue and put 18 inside
* copy the Regvalue to VP_SYS at 0xFFFF20
* print to UART0
* it should find the following at the UART0
* '''0xFFFF20:18'''
|}
Note: *1. Please refer to Smart LCD VP variables section.

== System Functions ==

=== hmt.changepage ===
{|
|'''Function'''
|hmt.changepage(pageid)
|-
|'''Description'''
|Change the Smart LCD UI display PAGE
|-
|'''Parameter'''
|pageid is the target display PAGE to be shown
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.changepage(0x02)
|
* UI show up the PAGE 2
|}

=== hmt.readpage ===
{|
|'''Function'''
|hmt.readpage()
|-
|'''Description'''
|Read the current display page id
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local pageid = 0 pageid = hmt.readpage() print(“pageid:”, pageid)
|
* SmartLCD UI is showing PAGE 3
* define a local variable pageid and put 0 inside
* copy the current display page id to pageid
* print to UART0
* it should find the following at the UART0
* '''pageid:3'''
|}

=== hmt.gettick ===
{|
|'''Function'''
|hmt.gettick()
|-
|'''Description'''
|Read the system running time in ms
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local worktime = 0 worktime = hmt.gettick() print(“worktime:”, worktime)
|
* define a local variable worktime and put 0 inside
* copy the current system running time to worktime
* print to UART0
* it should find the following at the UART0
* worktime:334520 (The system ran for about 334520ms)
|}
Note. Return Value will loop back to 0(dec) after 4294966(dec)

=== hmt.readpage ===
{|
|'''Function'''
|hmt.readpage()
|-
|'''Description'''
|Read the current display page id
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local pageid = 0 pageid = hmt.readpage() print(“pageid:”, pageid)
|
* SmartLCD UI is showing PAGE 3
* define a local variable pageid and put 0 inside
* copy the current display page id to pageid
* print to UART0
* it should find the following at the UART0
* '''pageid:3'''
|}

=== hmt.delayms ===
{|
|'''Function'''
|hmt.delayms(time)
|-
|'''Description'''
|delay routine
|-
|'''Parameter'''
|time is the delay in ms
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.delaymy(200)
|
* system will do nothing for 200ms and jump and go on
|}
Note. long delay may affect the Smart LCD normal operation.

=== hmt.runcmd ===
{|
|'''Function'''
|hmt.runcmd(table, num)
|-
|'''Description'''
|Send a command directly as sending command to the Smart LCD terminal (no command head and command tail)
|-
|'''Parameter'''
|table is the command byte array to be send, num is the number of byte to be send
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local cmdtab = {0x5F, 0x04} hmt.runcmd(cmdtab, 2)
|
* define a local variable array and put 0x5F, 0x04 inside
* use hmt.runcmd to send 2 byte of local variable array to Smart LCD
* it will adjust the backlight of the display to dim down
|}
Note. 0x5F is backlight control command; please also refer to Smart LCD handbook for command details

=== hmt.bypass ===
{|
|'''Function'''
|hmt.bypass(is)
|-
|'''Description'''
|Disable Smart LCD terminal command execution (I/O), And prevent data stream corruption while Lua accessing the UART0
|-
|'''Parameter'''
|is=1 for disable; is=0 for enable(normal)
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.bypass(1)
hmt.bypass(0)
|
* Disable Smart LCD terminal command execution
* Send AA 5F 03 CC 33 C3 3C to Smart LCD terminal to dim down the backlight
* No response
* Enable Smart LCD terminal command execution
* Send AA 5F 03 CC 33 C3 3C to Smart LCD terminal to dim down the backlight
* Display dim down accordingly
|}
Note. 0x5F is backlight control command; please also refer to Smart LCD handbook for command details

=== hmt.crc16calc ===
{|
|'''Function'''
|hmt.crc16calc(table, num)
|-
|'''Description'''
|Generate a CRC value form given num of bytes
|-
|'''Parameter'''
|table is the byte array to be input, num is the number of byte to be taken form the table (see appendix for reference)
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local padcmd = {0x82, 0x00, 0x08, 0x05} local crcreturn = 0 crcreturn = hmt.crc16calc(padcmd, 4) print(“crcreturn:”, crcreturn)
|
* define a local variable array and put 0x82, 0x00, 0x08, 0x05 inside
* define a local variable and put 0 inside
* calculate a CRC value of the 4 bytes form the array
* print to UART0
* it should find the following at the UART0
* '''crcreturn:6134316'''
|}

=== hmt.formatdisk2 ===
{|
|'''Function'''
|hmt.formatdisk2()
|-
|'''Description'''
|Format Smart LCD 2nd FLASH partition ("disk2" is the 2nd partition for Lua File I/O)
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.formatdisk2()
|
* Format Smart LCD 2nd FLASH partition.
* All the files in this partition will be eased.
|}

=== hmt.inituart ===
{|
|'''Function'''
|hmt.inituart(baudrate,parity)
|-
|'''Description'''
|Initialize baud rate and parity parameters of UART0 and UART1
|-
|'''Parameter'''
|Baudrate: 0=1200bps, 1=2400bps, 2=4800bps, 3=9600bps, 4=19200bps, 5=38400bps, 6=57600bps, 7=115200bps; Parity: 0=none, 1=odd, 2=even
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.inituart(7,0)
|
* Set the baud rate of UART0 and UART1 to 115200, 8N1
|}

== Thread functions ==
Other than Lua main loop, maximum two threads can be executed at the same time for multi-tasking purpose in TOPWAY Smart LCD Lua script environment. Threads can be control easily with suspend, resume and terminate command. It is recommended to add a delay inside the thread to avoid allocating the CPU continuously, which may affect the display performance.

=== hmt.createthread ===
{|
|'''Function'''
|hmt.createthread(function())
|-
|'''Description'''
|Create a thread and return a thread object
|-
|'''Parameter'''
|a callback function
|-
|'''Return Value'''
|If successful, return a thread object; If failed, return nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|FUN_PRINT_THREAD = function(arg) while(1) do print(arg) hmt.delayms(3000) end end Thread_object = hmt.createthread(FUN_PRINT_THREAD, “TOPWAY”)
|
* Define a function named FUN_PRINT_THREAD,
* This function prints the parameters of the input function every 3 seconds.
* Create a thread and pass the defined callback function as a parameter.
* “Thread_object ” is the object of the function's return value.
* The thread will be executed immediately after created successfully.
|}
Note. Maximum two threads can be executed in lua_main

=== thread_object:suspend ===
{|
|'''Function'''
|thread_object:suspend()
|-
|'''Description'''
|Suspend thread(pause thread execution); this function can only be called after a thread was created
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|FUN_PRINT_THREAD = function() while(1) do print(“THREAD IS RUNNING”) hmt.delayms(3000) end end Thread_object = hmt.createthread(FUN_PRINT_THREAD) Thread_object:suspend()
|
* Define a function named FUN_PRINT_THREAD,
* This function prints the parameters of the input function every 3 seconds.
* Thread_object is an object returned by the hmt.creatthread
* pause the thread execution
|}

=== thread_object:resume ===
{|
|'''Function'''
|thread_object:resume()
|-
|'''Description'''
|Restart thread ; this function can only be called after a thread was created
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|FUN_PRINT_THREAD = function() while(1) do Thread_object:suspend() print(“THREAD IS RUNNING”) hmt.delayms(3000) end end Thread_object = hmt.createthread(FUN_PRINT_THREAD) Thread_object:resume()
|
* Define a function named FUN_PRINT_THREAD,
* This function prints the parameters of the input function every 3 seconds.
* Thread_object is an object returned by the hmt.creatthread
* resume the thread execution
|}

=== thread_object:terminate ===
{|
|'''Function'''
|thread_object:terminate()
|-
|'''Description'''
|Terminate thread, terminate thread execution (this function can only be called after creating a thread)
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|FUN_PRINT_THREAD = function() while(1) do print(“THREAD IS RUNNING”) hmt.delayms(3000) end end Thread_object = hmt.createthread(FUN_PRINT_THREAD) local value = instance_thread:terminate() Thread_object = nil
|
* Define a function named FUN_PRINT_THREAD
* This function prints the parameters of the input function every 3 seconds.
* Thread_object is an object returned by the hmt.creatthread
* terminate the thread execution
* clear the object
|}

=== thread_object:getid ===
{|
|'''Function'''
|thread_object:getid()
|-
|'''Description'''
|Get thread ID and handle (this function can only be called after creating a thread)
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Return callback function id and callback handle value. If the handle value is 0, the thread execution is completed
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|FUN_PRINT_THREAD = function() while(1) do print(“THREAD IS RUNNING”) hmt.delayms(3000) end end Thread_object = hmt.createthread(FUN_PRINT_THREAD) local id, handle = Thread_object:getid() print(“id=”,id) print(“handle=”,handle)
|
* Define a function named FUN_PRINT_THREAD,
* This function prints the parameters of the input function every 3 seconds.
* Thread_object is an object returned by the hmt.creatthread
* get its id and handle value
|}

== UART0 functions ==
UART0 is the default command terminal of the Smart LCD. It may be RS-232C or UART(3.3V) depends on model. Lua print function also using UART0 for default output. Some of the Smart LCD equipped with a second terminal UART1. It may be RS-232C or UART(3.3V) depends on model.

=== hmt.uartisempty ===
{|
|'''Function'''
|hmt.uartisempty()
|-
|'''Description'''
|Check the UART0 buffer status
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Integer; Return 1 for buffer empty; 0 for data in buffer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local Uart0state = 0 Uart0state = hmt.uartisempty() print(“Uart0state:”, Uart0state)
|
* define a local variable Uart0state and put 0 inside
* copy the current UART is empty result to Uart0state
* print to UART0
* it should find the following at the UART0 '''Uart0state:1''' (as there is no data received form UART0)
|}

=== hmt.uartclearbuf ===
{|
|'''Function'''
|hmt.uartclearbuf()
|-
|'''Description'''
|Clear the UART0 buffer
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.uartclearbuf() print(“Uart0state:”, hmt.uartisempty())
|
* use command to clear the UART0 buffer
* print to UART0
* it should find the following at the UART0 '''Uart0state:1''' (as there is no data send to the UART0)
|}

=== hmt.getchar ===
{|
|'''Function'''
|hmt.getchar()
|-
|'''Description'''
|Receive one byte of data form UART0 buffer
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local getdata = 0 getdata = hmt.getchar() print(“getdata:”, getdata)
|
* Send one byte of data 0x99 to the Smart LCD terminal
* define a local variable getdata and put 0 inside
* get one byte of data form the UART0 buffer and put it into getdata
* print to UART0
* it should find the following at the UART0 '''getdata:153''' (0x99 is 153(d))
|}

=== hmt.putchar ===
{|
|'''Function'''
|hmt.putchar(char)
|-
|'''Description'''
|Send one byte of data to UART0
|-
|'''Parameter'''
|char is the byte of data to be sent (it should be a byte value, not string char)
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.putchar(0x41) hmt.putchar(66)
|
* it should find the following at the UART0 '''0x41 0x42''' (in hex) or '''AB''' (in ASCII)
|}

=== hmt.uartsendbytes ===
{|
|'''Function'''
|hmt.uartsendbytes(table, num)
|-
|'''Description'''
|Send bytes of data to UART0
|-
|'''Parameter'''
|table is the data byte array to be send, num is the number of byte to be send
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local sendbuff = {0xab, 0xcd, 0xef} hmt.uartsendbytes(sendbuff, 3)
|
* define a local variable array and put 0xab, 0xcd, 0xef inside
* use hmt.uartsendbytes to send 3 byte of local variable array to UART0
* it should find the following at the UART0 '''0xab 0xcd 0xef''' (in hex)
|}

=== hmt.uartlock ===
{|
|'''Function'''
|hmt.uartlock()
|-
|'''Description'''
|Lock the UART0 before Lua send data to UART0
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.uartlock() hmt.putchar(0xaa) hmt.putchar(0x02) hmt.putchar(0x31) hmt.uartunlock()
|
* Lock the UART0 for Lua use
* Send 0xaa to UART0
* Send 0x02 to UART0
* Send 0x31 to UART0
* it should find the following at the UART0 '''0xaa 0x02 0x31''' (in hex)
* Release the UART0 for Smart LCD normal operation
|}
Note. It is necessary to lock the UART for Lua access, if hmt.bypass is not enabled. Generally hmt.uartlock() and hmt.uartunlock() should be used in pair.

=== hmt.uartunlock ===
{|
|'''Function'''
|hmt.uartunlock()
|-
|'''Description'''
|unlock the UART0 after Lua send data to UART0
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.uartlock() hmt.putchar(0xaa) hmt.putchar(0x02) hmt.putchar(0x31) hmt.uartunlock()
|
*Lock the UART0 for Lua use
*Send 0xaa to UART0
* Send 0x02 to UART0
* Send 0x31 to UART0
* it should find the following at the UART0 '''0xaa 0x02 0x31''' (in hex)
* Release the UART0 for Smart LCD normal operation
|}
Note. It is necessary to lock the UART for Lua access, if hmt.bypass is not enabled. Generally hmt.uartlock() and hmt.uartunlock() should be used in pair.

== UART1 functions ==
UART1 is the extend terminal of some of the Smart LCD. It may be RS-232C or UART(3.3V) depends on model.

=== hmt.uart1isempty ===
{|
|'''Function'''
|hmt.uart1isempty()
|-
|'''Description'''
|Check the UART1 buffer status
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Integer; Return 1 for buffer empty; 0 for data in buffer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local Uart1state = 0 Uart1state = hmt.uart1isempty() print(“Uart1state:”, Uart1state)
|
* define a local variable Uart1state and put 0 inside
* copy the current UART is empty result to Uart1state
* print to UART0
* it should find the following at the UART0 '''Uart1state:1''' (as there is no data received form UART1)
|}

=== hmt.uart1clearbuf ===
{|
|'''Function'''
|hmt.uart1clearbuf()
|-
|'''Description'''
|Clear the UART1 buffer
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.uart1clearbuf() print(“Uart1state:”, hmt.uart1isempty())
|
* use command to clear the UART1 buffer
* print to UART0
* it should find the following at the UART0 '''Uart1state:1''' (as there is no data send to the UART1)
|}

=== hmt.uart1getchar ===
{|
|'''Function'''
|hmt.uart1getchar()
|-
|'''Description'''
|Receive one byte of data form UART1 buffer
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local getdata = 0 getdata = hmt.uart1getchar() print(“getdata:”, getdata)
|
* Send one byte of data 0xaa to the Smart LCD terminal
* define a local variable getdata and put 0 inside
* get one byte of data form the UART1 buffer and put it into getdata
* print to UART0
* it should find the following at the UART0 '''getdata:170''' (0xaa is 170(d))
|}

=== hmt.uart1putchar ===
{|
|'''Function'''
|hmt.uart1putchar(char)
|-
|'''Description'''
|Send one byte of data to UART1
|-
|'''Parameter'''
|char is the byte of data to be sent (it should be a byte value, not string char)
|-
|'''Return Value'''
|Integer
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.uart1putchar(0x61) hmt.uart1putchar(97)
|
* it should find the following at the UART1 '''0x61 0x62''' (in hex) or '''ab''' (in ASCII)
|}

=== hmt.uart1sendbytes ===
{|
|'''Function'''
|hmt.uart1sendbytes(table, num)
|-
|'''Description'''
|Send bytes of data to UART1
|-
|'''Parameter'''
|table is the data byte array to be send, num is the number of byte to be send
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|local sendbuff = {0xab, 0xcd, 0xef} hmt.uart1sendbytes(sendbuff, 3)
|
* define a local variable array and put 0xab, 0xcd, 0xef inside
* use hmt.uart1sendbytes to send 3 byte of local variable array to UART1
* it should find the following at the UART1 '''0xab 0xcd 0xef''' (in hex)
|}

=== hmt.uart1lock ===
{|
|'''Function'''
|hmt.uart1lock()
|-
|'''Description'''
|Lock the UART1 before Lua send data to UART1
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.uart1lock() hmt.uart1putchar(0xaa) hmt.uart1putchar(0x02) hmt.uart1putchar(0x31) hmt.uart1unlock()
|
* Lock the UART1 for Lua use
* Send 0xaa to UART1
* Send 0x02 to UART1
* Send 0x31 to UART1
* it should find the following at the UART1 '''0xaa 0x02 0x31''' (in hex)
* Release the UART1 for Smart LCD normal operation
|}
Note. It is necessary to lock the UART for Lua access, if hmt.bypass is not enabled. Generally hmt.uart1lock() and hmt.uart1unlock() should be used in pair.

=== hmt.uart1unlock ===
{|
|'''Function'''
|hmt.uart1unlock()
|-
|'''Description'''
|unlock the UART1 after Lua send data to UART1
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|Nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|hmt.uart1lock() hmt.uart1putchar(0xaa) hmt.uart1putchar(0x02) hmt.uart1putchar(0x31) hmt.uart1unlock()
|
*Lock the UART1 for Lua use
*Send 0xaa to UART1
* Send 0x02 to UART1
* Send 0x31 to UART1
* it should find the following at the UART1 '''0xaa 0x02 0x31''' (in hex)
* Release the UART1 for Smart LCD normal operation
|}
Note. It is necessary to lock the UART for Lua access, if hmt.bypass is not enabled. Generally hmt.uart1lock() and hmt.uart1unlock() should be used in pair.

== Main Loop and Hooks ==

=== luamain ===
{|
|'''Function'''
|luamain = function(void)
|-
|'''Description'''
|A loop routine run continuously. Looping cycle 10ms(MIN)
|-
|'''Parameter'''
|Nil
|-
|'''Return Value'''
|nil
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|luamain = function(void) print(“TOPWAY”) return 0 end
|
* Beginning of the luamain
* print to UART0, it should find the following at the UART0, '''TOPWAY'''
* no return value
* end of the luamain
* it will loop back to the beginning of the luamain continuously
|}

=== tpkhook ===
{|
|'''Function'''
|tpkhook = function(page, id, state)
|-
|'''Description'''
|A hook routine that will be trigged while any of the touch key status that defined in the Smart LCD UI is being changed
|-
|'''Parameter'''
|page is the touched touch key’s PAGE; id is the touch key’s ID; state is the statues of the touch key (0 for released; 1 for touched; 2 for moved out)
|-
|'''Return Value'''
|return 0 tell Smart LCD UI continue to execute the touch key predefined operations; return 1 tell Smart LCD UI not to execute the touch key predefined operations
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|tpkhook = function(page, id, state) print(“PageID=”, page,“ TPKID=”, id,“ state=”, state) return 0 end
|
* On page 0 touch the touch key (ID=2)
* Beginning of the tpkhopok
* print to UART0, it should find the following at the UART0,,'''PageID=0 TPKID=2 state=1'''
* return 0 for UI normal continue run
* end of the tpkhook
|}

=== pagechangehook ===
{|
|'''Function'''
|pagechangehook = function(pageid)
|-
|'''Description'''
|A hook routine that will be trigged when page changed (before showing the page)
|-
|'''Parameter'''
|pageid is the target PAGE ID
|-
|'''Return Value'''
|return 0 tell Smart LCD UI continue to showing up the target page; return 1 tell Smart LCD UI staying at the previous page
|-
|'''Example'''
|
|}
{| class="wikitable"
|+
!Lua Script
!Descriptions
|-
|pagechangehook = function(pageid) print(“PageID=”, pageid) return 0 end
|
* On page 0 touch the touch key to jump to page 1
* Beginning of the pagechangehook
* print to UART0, it should find the following at the UART0 '''PageID=1'''
* return 0 for UI normal continue run
* end of the pagechangehook
|}

== Example ==

=== Built an alarm clock function with Lua ===
set up a default alarm (alarmhour, alarmminute, alarmsecond) and alarm duration (alarmend) continue checking the Smart LCD compare the RTC with the alarm; if match then sound the buzzer on the Smart LCD. set up a touch key monitor, when it is touched, assign the alarm with value store in the smart LCD (those values, can be assign with the user interface)

-- define variable(s)
Alarmhour = 0x7
alarmminute = 0x14
alarmsecond = 0x0
alarmend = 0

-- main loop
luamain = function(void)
if((hmt.readvpreg(0xffff13) == alarmhour) and (hmt.readvpreg(0xffff14) == alarmminute) and (hmt.readvpreg(0xffff15) == alarmsecond))
then
alarmend = hmt.gettick() + 60000
end
if(alarmend > hmt.gettick())then
local buzzercmd = {0x7a, 0x01, 0x01, 0x01, 0x05, 0x08}
hmt.runcmd(buzzercmd,6)
hmt.delayms(200)
end
return 0
end

-- touch key hook
tpkhook = function(page, id, state)
if((page == 1)and(id == 2)and(state == 1))then
alarmhour = hmt.readvp16(0x080002)
alarmminute = hmt.readvp16(0x080004)
alarmsecond = hmt.readvp16(0x080006)
end
if((page == 1)and(id == 4)and(state == 1))then
alarmend = hmt.gettick()
end
return 0
end

-- page hook
pagechangehook = function(pageid)
return 0
end
Note: “wait loop” is not allowed in the script!

== Reference ==

=== hmt.crc16calc(table, num) ===
uint16_t const CRC16[256]={
/* 16: 8005 reflected */
0x0000,0xc0c1,0xc181,0x0140,0xc301,0x03c0,0x0280,0xc241,0xc601,0x06c0,0x0780,0xc741,0x0500,0xc5c1,0xc481,0x0440,
0xcc01,0x0cc0,0x0d80,0xcd41,0x0f00,0xcfc1,0xce81,0x0e40,0x0a00,0xcac1,0xcb81,0x0b40,0xc901,0x09c0,0x0880,0xc841,
0xd801,0x18c0,0x1980,0xd941,0x1b00,0xdbc1,0xda81,0x1a40,0x1e00,0xdec1,0xdf81,0x1f40,0xdd01,0x1dc0,0x1c80,0xdc41,
0x1400,0xd4c1,0xd581,0x1540,0xd701,0x17c0,0x1680,0xd641,0xd201,0x12c0,0x1380,0xd341,0x1100,0xd1c1,0xd081,0x1040,
0xf001,0x30c0,0x3180,0xf141,0x3300,0xf3c1,0xf281,0x3240,0x3600,0xf6c1,0xf781,0x3740,0xf501,0x35c0,0x3480,0xf441,
0x3c00,0xfcc1,0xfd81,0x3d40,0xff01,0x3fc0,0x3e80,0xfe41,0xfa01,0x3ac0,0x3b80,0xfb41,0x3900,0xf9c1,0xf881,0x3840,
0x2800,0xe8c1,0xe981,0x2940,0xeb01,0x2bc0,0x2a80,0xea41,0xee01,0x2ec0,0x2f80,0xef41,0x2d00,0xedc1,0xec81,0x2c40,
0xe401,0x24c0,0x2580,0xe541,0x2700,0xe7c1,0xe681,0x2640,0x2200,0xe2c1,0xe381,0x2340,0xe101,0x21c0,0x2080,0xe041,
0xa001,0x60c0,0x6180,0xa141,0x6300,0xa3c1,0xa281,0x6240,0x6600,0xa6c1,0xa781,0x6740,0xa501,0x65c0,0x6480,0xa441,
0x6c00,0xacc1,0xad81,0x6d40,0xaf01,0x6fc0,0x6e80,0xae41,0xaa01,0x6ac0,0x6b80,0xab41,0x6900,0xa9c1,0xa881,0x6840,
0x7800,0xb8c1,0xb981,0x7940,0xbb01,0x7bc0,0x7a80,0xba41,0xbe01,0x7ec0,0x7f80,0xbf41,0x7d00,0xbdc1,0xbc81,0x7c40,
0xb401,0x74c0,0x7580,0xb541,0x7700,0xb7c1,0xb681,0x7640,0x7200,0xb2c1,0xb381,0x7340,0xb101,0x71c0,0x7080,0xb041,
0x5000,0x90c1,0x9181,0x5140,0x9301,0x53c0,0x5280,0x9241,0x9601,0x56c0,0x5780,0x9741,0x5500,0x95c1,0x9481,0x5440,
0x9c01,0x5cc0,0x5d80,0x9d41,0x5f00,0x9fc1,0x9e81,0x5e40,0x5a00,0x9ac1,0x9b81,0x5b40,0x9901,0x59c0,0x5880,0x9841,
0x8801,0x48c0,0x4980,0x8941,0x4b00,0x8bc1,0x8a81,0x4a40,0x4e00,0x8ec1,0x8f81,0x4f40,0x8d01,0x4dc0,0x4c80,0x8c41,
0x4400,0x84c1,0x8581,0x4540,0x8701,0x47c0,0x4680,0x8641,0x8201,0x42c0,0x4380,0x8341,0x4100,0x81c1,0x8081,0x4040,
};

static __inline uint16_t rshiftu16(uint16_t value, int nb)
{
return (uint16_t)((value >> nb) & ~((( uint16_t) 0x8000) >> (nb-1)));
}

uint16_t crc16_calc(unsigned char *q, int len)
{
uint16_t crc = 0xffff;
while (len-- > 0)
crc=(rshiftu16(crc,8) ^ CRC16[(crc ^ *q++) & 0xff]);
return crc;
}

Copy a page during editing

2025-09-17T11:55:18Z

Usr255: Created page with "=== background === When developing Smart LCD project, it may need to built several similar pages to give a structuralized pages. Using page copy can help and speed up the project development. === how to === * right click on a page in the Project Resources and select Copy File:SAN--0615 page copy01.png * right click on the Page group and select Paste Page File:SAN--0615 page copy02.png === e.g. === * in this case the source page is PG0001 * it will be past..."

=== background ===
When developing Smart LCD project, it may need to built several similar pages to give a structuralized pages.

Using page copy can help and speed up the project development.

=== how to ===

* right click on a page in the Project Resources and select Copy

[[File:SAN--0615 page copy01.png]]

* right click on the Page group and select Paste Page

[[File:SAN--0615 page copy02.png]]

=== e.g. ===

* in this case the source page is PG0001
* it will be paste as a new page named as @PG0001 (source page ID, with "@")
* it can be renamed later

[[File:SAN--0615 page copy03.png]]

=== download ===
nil

File:SAN--0615 page copy03.png

2025-09-17T11:54:11Z

Usr255:

SAN--0615 page copy03

File:SAN--0615 page copy02.png

2025-09-17T11:50:39Z

Usr255:

SAN--0615 page copy02

File:SAN--0615 page copy01.png

2025-09-17T11:48:30Z

Usr255:

SAN--0615 page copy01

Tech-Memos-01

2025-09-17T11:43:19Z

Usr255:

Assign VP value in page (init VP values)

2025-09-17T11:39:34Z

Usr255: /* note */

=== background ===
When start up, all the VP will be clear to "0".

In some cases, it need to init some VP values at power on start up. it can be realize by defining page function in the start up page. Moreover, page function can call an operation just before a page to be display.

=== how to ===

* right click on the start up page or right click to the page that need to init a VP
* select Page Functions
* click "Add" to add a function
* select an operation to be "call"

[[File:SAN-21-0422 Page Func Add Call.png|800x800px]]

* multiple page function can be added to a page
* all the function will be execute just before a page to be shown on screen
* all the pages can use page function
* all the pages have their own page function

=== e.g. ===
Every time, jump from page_A to page_B or jump form page_C to page_B. page_B's page function will be executed accordingly.

=== download ===
nil

Assign VP value in page (init VP values)

2025-09-17T11:39:07Z

Usr255: /* note */

=== background ===
When start up, all the VP will be clear to "0".

In some cases, it need to init some VP values at power on start up. it can be realize by defining page function in the start up page. Moreover, page function can call an operation just before a page to be display.

=== how to ===

* right click on the start up page or right click to the page that need to init a VP
* select Page Functions
* click "Add" to add a function
* select an operation to be "call"

[[File:SAN-21-0422 Page Func Add Call.png|800x800px]]

=== note ===

* multiple page function can be added to a page
* all the function will be execute just before a page to be shown on screen
* all the pages can use page function
* all the pages have their own page function

=== e.g. ===
Every time, jump from page_A to page_B or jump form page_C to page_B. page_B's page function will be executed accordingly.

=== download ===
nil

Assign VP value in page (init VP values)

2025-09-17T11:38:00Z

Usr255: Created page with "=== background === When start up, all the VP will be clear to "0". In some cases, it need to init some VP values at power on start up. it can be realize by defining page function in the start up page. Moreover, page function can call an operation just before a page to be display. === how to === * right click on the start up page or right click to the page that need to init a VP * select Page Functions * click "Add" to add a function * select an operation to be "call"..."

=== background ===
When start up, all the VP will be clear to "0".

In some cases, it need to init some VP values at power on start up. it can be realize by defining page function in the start up page. Moreover, page function can call an operation just before a page to be display.

=== how to ===

* right click on the start up page or right click to the page that need to init a VP
* select Page Functions
* click "Add" to add a function
* select an operation to be "call"

[[File:SAN-21-0422 Page Func Add Call.png|800x800px]]

=== note ===

* multiple page function can be added to a page
* all the function will be execute just before a page to be shown on screen
* all the pages can use page function
* all the page have their own page function

=== e.g. ===
every time, jump from page_A to page_B or jump form page_C to page_B. page_B's page function will be executed accordingly.

=== download ===
nil

File:SAN-21-0422 Page Func Add Call.png

2025-09-17T11:25:25Z

Usr255:

SAN-21-0422 Page Func Add Call

Tech-Memos-01

2025-09-17T11:14:00Z

Usr255:

Tech-Memos-01

2025-09-17T09:51:44Z

Usr255:

Floating point value display

2025-09-17T09:49:59Z

Usr255: /* e.g. */

=== background ===
Smart LCD provide VP_N32 can holding a 32bit number value and show as integer or floating point value. Here give an example about how to show it in NUM element.

=== how to ===
[[File:SAN-21-0623 VP N32 Float setting.png|right]]

* VP_N32 is a variable in RAM area, it can hold a 32bit value, which can be an integer or a floating point value.
* For showing floating point value that hold in the VP, Data Type have to selected as "Float"
* See also [[Character Elements#Number Element (NUM)|Number Element (NUM)]] for details

=== e.g. ===

* send a value in to the VP_N32 by command

AA 44 00 02 00 00 444988F6 CC 33 C3 3C
* VP_N32 (Add 0x20000)
* 0x020000 := 0x444988f6 (806.4(d))

=== downloads ===
nil.

Floating point value display

2025-09-17T08:59:58Z

Usr255:

=== background ===
Smart LCD provide VP_N32 can holding a 32bit number value and show as integer or floating point value. Here give an example about how to show it in NUM element.

=== how to ===
[[File:SAN-21-0623 VP N32 Float setting.png|right]]

* VP_N32 is a variable in RAM area, it can hold a 32bit value, which can be an integer or a floating point value.
* For showing floating point value that hold in the VP, Data Type have to selected as "Float"
* See also [[Character Elements#Number Element (NUM)|Number Element (NUM)]] for details

=== e.g. ===

* use command AA 44 00 02 00 00 444988F6 CC 33 C3 3C to send the value in to the VP_N32
* VP_N32 (Add 0x20000)
* 0x020000 := 0x444988f6 (806.4(d))

Floating point value display

2025-09-17T08:55:50Z

Usr255: /* how to */

=== background ===
Smart LCD provide VP_N32 can holding a 32bit number value and show as integer or floating point value. Here give an example about how to show it in NUM element.

=== how to ===
[[File:SAN-21-0623 VP N32 Float setting.png|right]]

* VP_N32 is a variable in RAM area, it can hold a 32bit value, which can be an integer or a floating point value.
* For showing floating point value that hold in the VP, Data Type have to selected as "Float"
[[Character Elements#Number Element (NUM)|Number Element (NUM)]]

Floating point value display

2025-09-17T08:52:04Z

Usr255:

=== background ===
Smart LCD provide VP_N32 can holding a 32bit number value and show as integer or floating point value. Here give an example about how to show it in NUM element.

=== how to ===
[[File:SAN-21-0623 VP N32 Float setting.png|right]]

* VP_N32 is a variable in RAM area, it can hold a 32bit value, which can be an integer or a floating point value.
* For showing floating point value that hold in the VP, Data Type have to selected as "Float"
[[Character Elements:Number Element (NUM)|Number Element (NUM)]]

Floating point value display

2025-09-17T08:50:46Z

Usr255:

=== background ===
Smart LCD provide VP_N32 can holding a 32bit number value and show as integer or floating point value. Here give an example about how to show it in NUM element.

=== how to ===
[[File:SAN-21-0623 VP N32 Float setting.png|right]]

* VP_N32 is a variable in RAM area, it can hold a 32bit value, which can be an integer or a floating point value.
* For showing floating point value that hold in the VP, Data Type have to selected as "Float"
[[Character Element:Number Element (NUM)|Number Element (NUM)]]

Floating point value display

2025-09-17T08:37:47Z

Usr255:

Floating point value display

2025-09-17T08:33:22Z

Usr255: Created page with "=== background === Smart LCD provide VP_N32 can holding a 32bit number value and show as integer or floating point value. Here give an example about how to show it in NUM element. === how to === right * VP_N32 is a variable in RAM area, it can hold a 32bit value, which can be an integer or a floating point value. * For showing floating point value that hold in the VP, Data Type have to selected as "Float""

File:SAN-21-0623 VP N32 Float setting.png

2025-09-17T08:22:55Z

Usr255:

SAN-21-0623 VP N32 Float setting

Tech-Memos-01

2025-09-17T07:49:43Z

Usr255:

MediaWiki:Sidebar

2025-09-03T13:15:22Z

Usr255:

Show Extended Code on Static String

2025-09-02T12:33:26Z

Usr255: /* download */

=== background ===
UI designer normally put the static text onto the background picture to provide fine visual result. Smart LCD also provide various text font option with character elements.

To show ASCII text on screen with Static String (STS), it is quite straight forward. While it is also possible to show Extended Code on Static String.

=== how to ===
1. Generate font library in Font Config <2>, select "Extended [0x80-0xFF] codepage" to include into the font library.

[[File:SDM-21-0011 build font.png|480x480px]]

2. Select a corresponding extended codepage in Project Setting

[[File:SDM-21-0011 project cp.png|480x480px]]

3. Built a project with a Static String (STS) element

4. Put the desire extended char as hex in the element properties (CP250 CHAR(128(d)) = Euro sign, enter #80)

[[File:SDM-21-0011 editing.png|800x800px]]
[[File:SDM-21-0011 display.jpg|800x800px]]

=== note ===

* Some of the font face may not provide all the extended char
* code page setting can also be assigned via serial command, Set_codepage (0xE7 command)

=== download ===

* example model: HMT070DTA-D
* demo project: [[Media:SDM-21-0011(Ext code page char in static string).zip|SDM-21-0011(Ext_code_page_char_in_static_string).zip]]

Show Extended Code on Static String

2025-09-02T12:31:16Z

Usr255: /* download */

=== background ===
UI designer normally put the text onto the background picture to provide fine visual result. Smart LCD also provide various text font option with character elements.

To show ASCII text on screen with Static String (STS), it is quite straight forward. While it is also possible to show Extended Code on Static String.

=== how to ===
1. Generate font library in Font Config <2>, select "Extended [0x80-0xFF] codepage" to include into the font library.

[[File:SDM-21-0011 build font.png|480x480px]]

2. Select a corresponding extended codepage in Project Setting

[[File:SDM-21-0011 project cp.png|480x480px]]

3. Built a project with a Static String (STS) element

4. Put the desire extended char as hex in the element properties (CP250 CHAR(128(d)) = Euro sign, enter #80)

[[File:SDM-21-0011 editing.png|800x800px]]
[[File:SDM-21-0011 display.jpg|800x800px]]

=== note ===

* Some of the font face may not provide all the extended char
* code page setting can also be assigned via serial command, Set_codepage (0xE7 command)

=== download ===

* example model: HMT070DTA-D
* demo project: [[Media:SDM-21-0011(Ext code page char in static string).zip|SDM-21-0011(Ext_code_page_char_in_static_string).zip]]

File:SDM-21-0011(Ext code page char in static string).zip

2025-09-02T12:30:42Z

Usr255:

Show Extended Code on Static String

2025-09-02T12:29:49Z

Usr255: /* note */

=== background ===
UI designer normally put the text onto the background picture to provide fine visual result. Smart LCD also provide various text font option with character elements.

To show ASCII text on screen with Static String (STS), it is quite straight forward. While it is also possible to show Extended Code on Static String.

=== how to ===
1. Generate font library in Font Config <2>, select "Extended [0x80-0xFF] codepage" to include into the font library.

[[File:SDM-21-0011 build font.png|480x480px]]

2. Select a corresponding extended codepage in Project Setting

[[File:SDM-21-0011 project cp.png|480x480px]]

3. Built a project with a Static String (STS) element

4. Put the desire extended char as hex in the element properties (CP250 CHAR(128(d)) = Euro sign, enter #80)

[[File:SDM-21-0011 editing.png|800x800px]]
[[File:SDM-21-0011 display.jpg|800x800px]]

=== note ===

* Some of the font face may not provide all the extended char
* code page setting can also be assigned via serial command, Set_codepage (0xE7 command)

=== download ===

* example model: HMT070DTA-D
* demo project: SDM-21-0011(Ext_code_page_char_in_static_string).zip

Show Extended Code on Static String

2025-09-02T12:25:38Z

Usr255: