01 Lua Functions

1. [, number class] indicates that the third parameter class is a numeric value, and it is optional. Specify the default class in class 1 in the parameter description.

62

1. **Any parameter in the [] is considered to be an optional parameter, and may not be transmitted when called. The default value will be given in the parameter description.**

63

**Call example**

|(((

//print(student("foo", 18)) //~-~- foo, 18 years old, assigned to class 1 by default

68

69

//print(student("bar", 19, 2))// ~-~-bar, 19 years old, assigned to class 2

70

71

//print(student("bar", 18)) //~-~-bar, 18 years old, assigned to class 1 by default

72

73

//local stat, err = student("bar", 18)// ~-~- Call again, use //err// to capture error messages

//print(stat, err)//

)))

**Output results**

|(((

//true//

//true//

//nil student bar registered//

86

87

//nil student bar registered//

)))

**Comment**

1. From the print result, the first line and the second line are successfully called and returns true; the third line fails the call, the error message is translated as: the bar student has been registered, and there is indeed an error in the code.

93

1. The fourth line of code uses two variables to receive the return value. The call failed, the first variable stat is nil, and the second variable err stores the error message. Then print it out using print, which is the output of the third line. This example shows how to capture and view the error message.

94

95

== **Modification of print function** ==

96

97

For the convenience of remote development, the print data is sent to the front end (web page) by means of network transmission, and the user can see the result of the debug output, because it consumes certain data and occupies the bandwidth of the server (or occupies server resources). So the following restrictions are made.

98

99

1. **Interval limit: **When debugging, transfer once every 2~~3 seconds;

100

1. **Data limit: **The transfer data cannot be larger than 1.5KB in a single transmission, otherwise the extra part will be ignored;

101

1. **Transmission limit: **The data transmission will be stopped automatically after the debugging windows is not closed normally. Only when it is in the debugging window and the switch is on, there is data transmission;

102

103

Users should pay attention to avoid printing a lot of useless information, should minimize the debug output

104

105

In addition, please refer to the front-end documentation for how to use view debugging.

106

107

(((

108

= **2 Address operation** =

)))

|12（Default）|0|1234（Default）|0|(((

12345678(Default)

)))|(((

0

)))

|21|6|(((

3412(High and low word conversion)

119

)))|2|(((

120

34127856 (High and low word conversion)

)))|2

| | |2143|3|(((

21436587

)))|3

| | |4321|6|(((

87654321

)))|6

| | | | |(((

78563412

)))|7

| | | | |(((

56781234

)))|8

| | | | |(((

65872143

)))|9

| | | | |(((

43218765

)))|10

Table 2-1

(% class="box infomessage" %)

144

(((

145

**✎Note: **If HLword enters any other value, it will be treated as invalid.

146

)))

147

148

== **addr_getshort(string addr[, number type, number hlword])** ==

149

150

**Function:** Read 16-bit signed decimal address

**Parameters:**

//addr//: address

//num//: value

[type = 0] not read through 1: read through

159

160

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: Single word signed decimal value

Failed: multi

(((

== **addr_setshort(string addr, number num[, number type, number hlword])** ==

170

)))

171

172

**Function:** Write 16-bit signed decimal address

**Parameters:**

//addr//: address

//num//: value

[type = 0]not read through 1: read through

181

182

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: true

Failed: multi

(((

== **addr_getword(string addr[, number type, number hlword])** ==

192

)))

193

194

**Function:** Read 16-bit unsigned decimal address

**Parameters:**

//addr//: address

[type = 0]not read through 1: read through

201

202

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: Single word unsigned decimal value

Failed: multi

(((

== **addr_setword(string addr, number num[, number type, number hlword])** ==

212

)))

213

214

**Function:**Write 16-bit unsigned decimal address

**Parameters:**

//addr//: address

//num//: value

[type = 0]not read through 1: read through

223

224

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: true

Failed: multi

(((

== **addr_getint(string addr[, number type, number hlword])** ==

234

)))

235

236

**Function:** Read 32-bit signed decimal address

**Parameters:**

//addr//: address

[type = 0]not read through 1: read through

243

244

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: Double word signed decimal value

Failed: multi

(((

== **addr_setint(string addr, number num[, number type, number hlword])** ==

254

)))

255

256

**Function:** Write 32-bit signed decimal address

**Parameters:**

//addr//: address

//num//: value

[type = 0]not read through 1: read through

265

266

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: true

Failed: multi

(((

== **addr_getdword(string addr[, number type, number hlword])** ==

276

)))

277

278

**Function:** Read 32-bit unsigned decimal address

**Parameters:**

//addr//: address

[type = 0]not read through 1: read through

285

286

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: Double word unsigned decimal value

Failed: multi

(((

== **addr_setdword(string addr, number num[, number type, number hlword])** ==

296

)))

297

298

**Function:** Write 32-bit unsigned decimal address

**Parameters:**

//addr//: address

//num//: value

[type = 0]not read through 1: read through

307

308

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: true

Failed: multi

(((

== **addr_getbit(string addr[, number type])** ==

318

)))

319

320

**Function:** Read a bit of the register address

**Parameters:**

//addr//: address

[type = 0]not read through 1: read through

327

328

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: Bit address value

Failed: multi

(((

== **addr_setbit(string addr, number num[, number type])** ==

338

)))

339

340

**Function:** Write a bit of the register address

**Parameters:**

//addr//: address

//num//: value

[type = 0]not read through 1: read through

349

350

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: true

Failed: multi

(((

== **addr_getfloat(string addr[, number type, number hlword])** ==

360

)))

361

362

**Function:** Read 32-bit floating address

**Parameters:**

//addr//: address

[type = 0]not read through 1: read through

369

370

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: 32-bit floating point value

Failed: multi

(((

== **addr_setfloat(string addr, number num[, number type, number hlword])** ==

380

)))

381

382

**Function:** Write 32-bit floating address

**Parameters:**

//addr//: address

//num//: value

[type = 0]not read through 1: read through

391

392

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: true

Failed: multi

(((

== **addr_getdouble(string addr[, number type, number hlword])** ==

402

)))

403

404

**Function:** Read 64-bit floating address

**Parameters:**

//addr//: address

[type = 0]not read through 1: read through

411

412

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: 64-bit floating point value

Failed: multi

(((

== **addr_setdouble(string addr, number num[, number type, number hlword])** ==

422

)))

423

424

**Function:** Write 64-bit floating address

**Parameters:**

addr: address

num: value

[type = 0]not read through //1//: read through

433

434

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: true

Failed: multi

(((

== **addr_getstring(string addr, number length[, number type, number hlbyte])** ==

444

)))

445

446

**Function:** Read the specified length string from address

**Parameters:**

//addr//: address

//length//: length

[type = 0]not read through 1: read through

455

456

[hlbyte = 0] Don't convert，3:High and low byte conversion, 4:GBK, 5:GBK And the first byte is the length

**Return：**

Succeed: specified length string

Failed: multi

(((

== **addr_setstring(string addr, string str[, number type, number hlbyte])** ==

466

)))

467

468

**Function:** Write the specified length string to address

**Parameters:**

//addr//: address

//str//: string

[type = 0]not read through 1: read through

477

478

[hlbyte = 0] Don't convert，3:High and low byte conversion, 4:GBK, 5:GBK And the first byte is the length

**Return：**

Succeed: true

Failed: multi

(((

== **addr_bmov(string dst, string src, number length)** ==

488

)))

489

490

**Function:** Copy data from source address to destination address

**Parameters:**

//dst//: destination address

495

496

//src//: source address

//length//: length

**Return：**

Succeed: true

**Failed: multi**

(((

== **addr_fill(string addr, number num, number length)** ==

508

)))

509

510

**Function:** Write the same value to consecutive addresses

**Parameters:**

//addr//: address

//num//: value

//length//:continuous length

**Return：**

Succeed: true

Failed: multi

(((

== **addr_newnoaddr(string addr, number offset)** ==

528

)))

529

530

**Function:** Offset address value relative to //addr//

**Parameters:**

//addr//: address

//offset//: offset value

**Return：**

Succeed: New address after offset

Failed: multi

(((

== **addr_newstataddr(string addr, number offset)** ==

546

)))

547

548

**Function:** Offset station number relative to //addr //station number

**Parameters:**

//addr//: address

//offset//: offset value

**Return：**

Succeed: New station number after offset

Failed: multi

== **addr_gethex64(string addr[, number type, number hlword])** ==

563

564

**Function:** Read 64-bit hexadecimal numbers

**Parameters:**

//addr//: address

[type = 0]not read through 1: read through

571

572

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: 64-bit floating-point values

Failed: multi

== **addr_sethex64(string addr, number num[, number type, number hlword])** ==

581

582

**Function:** Write 64-bit hexadecimal addresses

**Parameters:**

//addr//: address

[type = 0]not write through 1: write through

589

590

[hlword = 0] Don't convert，See Form 2.1

**Return：**

Succeed: true

Failed: multi

(((

= **3 Serial port operation** =

600

)))

601

602

Operations on the serial port such as read, write, etc. must use ':' for full mode calls, ie operations on an open serial object.

603

604

**Serial port name and mode**

605

606

The serial port configured in the communication configuration window cannot be configured again using the script. RS232 and RS458 (or RS422) can be used simultaneously, but RS422 and RS485 are mutually exclusive.For example, when the communication port is configured with COM1-485, the script can only open COM1-232, but not COM1-485/422. Similarly, when the communication port is configured with COM2-485, the script can only open COM2-232, but not COM2-485.

607

608

Attempting to use a script to open a serial port in an unsupported mode will result in an error directly, as below.

|(((

local setup = {

name = "COM2",

mode = 422, -- COM2 does not support RS422

...

}

serial.open(setup)

)))

**Data bit:**

1. When the data bit is 7, the maximum value of data transmission is 127 (0x7F), and non-ASCII characters will be truncated, resulting in data errors and garbled characters.

629

1. When the data bit is 8, the maximum value of data transmission is 255 (0xFF), which supports the transmission of any character.

630

631

(((

632

== **serial.open(table setup)** ==

633

)))

634

635

**Function:** Enable one serial port

**Parameters:**

//Setup// is a Lua table; it needs to contain the following fields

640

641

//String setup.name//,// //serial port name, such as: COM1/COM2 (requires uppercase)

642

643

//number setup.mode//, mode: RS232/RS485/RS422

644

645

//number setup.baud_rate//, such as 115200

646

647

//number setup.stop_bit//, stop bit: 1 or 2

648

649

//number setup.data_len//, data bit: 7 or 8

650

651

//string setup.check_bit//, check bit: NONE/ODD/EVEN/SPACE

652

653

//number [setup.wait_timeout=300]//, waiting timeout

654

655

//number [setup.recv_timeout=50]//, receive wait timeout

656

657

//number [setup.flow_control=0]//, Flow control method, 0:XON/XOFF, 2:DSR/ER

Supported baud rate

1200/2400/4800/9600/14400/19200/38400/43000/57600/76800/115200/128000/230400/256000/460800/961000

**Return：**

Succeed: serial object

Failed: multi

(((

== **serial.close(serial obj)** ==

671

)))

672

673

**Function:** Disable the serial port

674

675

**Parameters: **//Obj //is the object returned by serial.open

**Return：**

Succeed: true

Failed: multi

(((

== **serial:read(number bytes[, number timeout])** ==

685

)))

686

687

**Function:** Read the specified byte length serial port data

**Parameters:**

//bytes//: number of bytes

692

693

//[timeout=50]//: timeout for reading, in milliseconds

**Return：**

Succeed: true

Failed: multi

(((

== **serial:write(string data)** ==

703

)))

704

705

**Function:** Write the specified byte length to serial port data

**Parameters: **

//data//: serial port data

**Return：**

Succeed: true

Failed: multi

(((

== **serial:flush([number flag])** ==

719

)))

720

721

**Function:** Clear the serial port buffer

**Parameters:**

//[flag=2]// clear option: 0: read, 1: write, 2: read-write

**Return：**

Succeed: true

Failed: multi

(((

== **serial:close()** ==

735

)))

736

737

**Function:** Close the serial port object

**Parameters:** None

**Return：**

Succeed: true

Failed: multi

(((

= **4 MQTT operation** =

749

)))

750

751

Operations on MQTT such as connect, subscribe, etc. must use ':' for full mode calls, that is, operate on a created MQTT object.

752

753

Both MQTT subscriptions and publications are asynchronous implementations that require the user to implement a callback function.

**QoS value:**

* 0: Only push messages once, messages may be lost or duplicated. It can be used for environmental sensor data, it doesn't matter if lose a record, because there will be a second push message soon. This method is mainly used for normal APP push, but if the user smart device is not connected when the message is pushed, the message will be discarded, and the smart device will not be received when it is networked again.

758

* 1: The message is delivered at least once, but the message may be delivered repeatedly.

759

* 2: The message was delivered exactly once. This level can be used in a billing system. In a billing system, repeated or missing messages can lead to incorrect results. This highest quality message push service can also be used for instant messaging APP pushes, ensuring that users only receive messages once.

**Retain flag:**

0: not reserved;

1: reserved

(((

== **mqtt.create(string serverurl, string clientid[, int useDomain])** ==

769

)))

770

771

**Function:** Create an MQTT object

**Parameters:**

//serverurl //Server url

776

777

Format: "//protocol:~/~/host:port//"

778

779

//protocol//: tcp/ssl

780

781

//host//: Host name/IP

782

783

//port//: such as 1883

784

785

//clientid//: Client ID

786

787

//int useDomain: //0: convert to IP for connection, 1: use domain name for connection.

**Return：**

Succeed: MQTT object

Failed: multi

(((

== **mqtt.close(mqtt obj)** ==

797

)))

798

799

**Function:** Close the specified MQTT object (if the connected server will be disconnected automatically)

800

801

**Parameters: **//Obj //is the objeced returned by mqtt.create

**Return：**

Succeed: true

Failed: multi

(((

== **mqtt:connect(table conn[, table lwt, table cart])** ==

811

)))

812

813

**Function:**Establish a connection to the server

**Parameters:**

//conn //is a Lua table and needs to contain the following fields

818

819

* //string conn.username//, user name

820

* //string conn.password//, password

821

* //number [conn.netway=0]//, networking method, if set error number will use Ethernet method

** 0: Ethernet

** 1: WIFI

** 2: 4G

** 3: 2G

* //number [conn.keepalive=60]//, keep connected heartbeat interval, in seconds

827

* //number [conn.cleansession=1]//, empty the session as described below:

828

829

This function is used to control the behavior when connecting and disconnecting, and the client and server will retain the session information. This information is used to guarantee "at least once" and "accurately once" delivery, as well as the subject of the client subscription, the user can choose to keep or ignore the session message, set as follows:

830

831

* 1 (Empty): If a session exists and is 1, the previous session messages on the client and server are emptied.

832

* 0 (reserved): Conversely, both the client and the server use the previous session. If the previous session does not exist, start a new session.

833

834

//lwt// (Last Will and Testament) is a Lua table and needs to contain the following fields

835

836

* //string lwt.topic//, topic

837

* //string lwt.message//, message

838

* //number [lwt.qos=0]//, qos value

839

* //number [lwt.retain=0]//, retain flag

**Return：**

Succeed: true

Failed: multi

(((

== **mqtt:disconnect([number timeout])** ==

849

)))

850

851

**Function:** Disconnect from the MQTT server

852

853

**Parameters: **//[timeout=10000] //Disconnect waiting timeout, in milliseconds

**Return：**

Succeed: true

Failed: multi

(((

== **mqtt:isconnected()** ==

863

)))

864

865

**Function:** Test whether or not a client is currently connected to the MQTT server

**Parameters:** None

**Return：**

Succeed: true ~-~-Connected

872

873

Failed: false ~-~- Unconnected and other unknowns

874

875

(((

876

== **mqtt:subscribe(string topic, number qos)** ==

877

)))

878

879

**Function: **Subscribe to the topic (before the subscription, the user must first call the connect method to connect to the server)

**Parameters:**

//topic//, topic name

884

885

//qos//, quality of service

**Return：**

Succeed: true

Failed: multi

(((

== **mqtt:unsubscribe(string topic)** ==

895

)))

896

897

**Function:** Unsubscribe topic

**Parameters:**

//topic//, topic name

**Return：**

Succeed: true

Failed: multi

(((

== **mqtt:publish(string topic, string message, number qos, number retain[, number timeout])** ==

911

)))

912

913

**Function:** Publish message

**Parameters:**

//topic//, topic name

//message//, message

//qos//, quality of service

922

923

//retain//, retain flag

924

925

//[timeout=1000]//, waiting for response timeout, in milliseconds (only valid when qos is greater than 0)

**Return：**

Succeed: true

Failed: multi

(((

== **mqtt:close()** ==

935

)))

936

937

**Function:** Close the mqtt object (the connection to the server will be automatically disconnected)

**Parameters:** None

**Return：**

Succeed: true

Failed: multi

(((

== **mqtt:on(string method, function callback)** ==

949

)))

950

951

**Function:** Register event callback function

**Parameters:**

//method//, It can be message/arrived/offline, these 3 types of events

956

957

//callback//, It is a callback function that needs to pass in a function

958

959

**1.**"message" will call this function after receiving the message

960

961

//Callback// prototype~:// function (string topic, string message)//

Parameter:

* //Topic//, topic name

966

* //Message//, content

967

968

**2."arrived" is published by publish, this function will be called after the publication arrives**

969

970

//Callback// prototype~:// function ()//

Parameter: None

**3.This function will be called after the "offline" connection is lost**

975

976

//Callback// prototype~:// function (string cause)//

Parameter:

//cause//, reason for loss of connection

**Return：**

Succeed: true

Failed: multi

(((

== **mqtt:setup_cfg()** ==

990

)))

991

992

**Function:** Cloud mode interface, to obtain MQTT information configured by the cloud platform

**Parameters:** None

**Return:**

//serverurl, clientid, conn, lwt, cart //(5 returns, respectively, server address, client ID, connection table, last word table, certificate table)

999

1000

//conn// is the first parameter of the mqtt:connect method, which is fixed to table. If not configured, the information in the table is an empty string

1001

1002

//LWT// Last Words configuration is not yet open for setting, //lw//t is fixed to nil

1003

1004

If ssl is not enabled, //cart// is nil, otherwise //cart// is table

1005

1006

(((

1007

= **5 JSON operation** =

1008

)))

1009

1010

Lua only has a table data structure, so all arrays and key-value objects of json will be returned as a table.

1011

1012

(((

1013

== **json.encode( lua_object )** ==

1014

)))

1015

1016

**Function: **Convert lua data type to json string

1017

1018

**Parameters: **Lua data type (including boolean, number, string, table)

1019

1020

**Return：** Json format string

1021

1022

(((

1023

== **json.decode(string json_string)** ==

1024

)))

1025

1026

**Function:** Convert json string to lua data type

1027

1028

**Parameters: **//json_string//, string of json data structure

1029

1030

**Return: **Lua data type

(((

== **json.null** ==

)))

**Function:**

This method is used when assembling json data, which is equivalent to null in json. If the user directly uses json.null() to return the address of the function, it must be valid with the use of encode.

**Parameters:** None

**Return: **None

= **6 Cloud mode** =

The cloud interface is only used in cloud mode, and V-NET mode is not available.

1047

1048

(((

1049

== **bns_get_alldata()** ==

1050

)))

1051

1052

**Function:** Obtain all monitoring points (point table) data configured by the end user

1053

1054

**✎Note: **Assuming there are timing scripts A and B with a period of 1 second, if this function is called in script A, the data will not be obtained if called in script B

**Parameters:** None

**Return:**

Succeed: table two-dimensional array, the structure is as follows

1061

1062

Each item is a monitoring point, which contains 5 attributes:

1063

1064

(1 ID, 2 status, 3 tag name, 4 value, 5 custom)

1065

1066

The status contains 3 enumerated values (0: offline, 1: online, 2: timeout)

1067

1068

If there is no custom configuration, return an empty table, otherwise, return with "field name/field content"

**For example:**

{

[1]= {[1]=1234, [2]=1, [3]='temp', [4]='23.5', [5]={"fruit"="apple"}},

1076

1077

[2]= {[1]=1235, [2]=1, [3]='humi', [4]='67', [5]={"fruit"="pear"}},

...

[n]= {[1]=xxxx, [2]=x, [3]='xxxx', [4]='xx.x', [5]={}},

}

Failed: table empty table

(((

== **bns_get_config(string from)** ==

1090

)))

1091

1092

**Function:** Obtain custom configuration parameters with the specified from type

**parameter:**

from type, there are the following two categories, the string must be all lowercase

1097

1098

'user': terminal parameters, that is, custom parameters configured by the user

1099

1100

'bind': binding parameters, which are custom parameters that need to be input

1101

1102

when the user binds V-BOX

**Return:**

Succeed: table field name/field content table in organization form

1107

1108

Failed~:// table// empty table

1109

1110

(((

1111

== **bns_get_data(string name, string data)** ==

1112

)))

1113

1114

**Function:**write data to the name of the monitoring point

**parameter:**

//name //The name of the monitoring point

1119

1120

//data// the data to be written

**Return:**

Succede: //string // value before the monitoring point is written

Failed: nil

(((

== **bns_get_data(string name)** ==

)))

**Function:**

Read the data of the monitoring point name

**parameter:**

//name // The name of the monitoring point

**Return:**

Succeed: string, table 2 results: the value of the monitoring point, custom content

Failed: nil

(((

== **bns_get_datadesc()** ==

1148

)))

1149

1150

**Function: **Obtain all configured communication ports and monitoring point information

**Parameters:** None

**Return:**

Succeed: table three-dimensional array, the structure is as follows

1157

1158

Each item is a communication port, which contains 3 attributes (1 monitoring point array, 2 ID, 3 name)

1159

1160

The monitoring point array contains 4 attributes (1 ID, 2 name, 3 read and write attributes, 4 types)

1161

1162

Read and write attributes (1: read only, 2: write only, 3: read and write)

1163

1164

Type (1: switch, 2: number, 3: string)

**For example:**

{

[1]={--The first communication port

1172

1173

[1]={--monitoring point array of the first communication port

1174

1175

[1]={[1]=11,[2]='data1',[3]=3,[4]=2},

1176

1177

[2]={[1]=12,[2]='data2',[3]=3,[4]=2},

...

[n]={[1]=xx,[2]='datan',[3]=x,[4]=x},--n monitoring points

},

[2]=14, --ID

[3]='Modbus TCP' --n monitoring points

},

[2]={--The second communication port

1192

1193

[1]={},--The monitoring point of the second communication port is not configured and is empty

[2]=15, --ID

[3]='WECON' --communication protocol name

},

...n communication ports and so on

}

Failed~:// table// empty table

1207

1208

(((

1209

== **bns_get_machineinfo()** ==

1210

)))

1211

1212

**Function:** get machine information

**Parameters:** None

**Return:**

Succeed: 3 string type results (model, machine code, software version)

Failed: nil

(((

== **bns_get_groupdata(string name)** ==

1224

)))

1225

1226

**Function:** Get all monitoring point data under the specified group name

**parameter:**

//Name // group name

**Return:**

Succeed: //table// two-dimensional array, the structure is consistent with section 6.1

1235

1236

Failed: //table// empty table

1237

1238

(((

1239

== **bns_get_groupdesc()** ==

1240

)))

1241

1242

**Function:** Get all group information

**Parameters:** None

**Return:**

Succeed: //table// two-dimensional array, the structure is as follows

1249

1250

Each item represents a group, which contains 3 attributes (1 collection type, 2 name, 3 cycles)

1251

1252

Acquisition type (0: change acquisition, 1: word trigger, 2: no trigger, 3: trigger by time and conditions, 4: reset after trigger, 5: not reset after trigger)

1253

1254

Some collection types do not have a period, the period is -1

1255

1256

Failed: //table // empty table

1257

1258

(((

1259

== **bns_get_onecache(string msg)** ==

1260

)))

1261

1262

**Function:** Save a message to the cache file, which can be stored after power failure. Store up to 2000 items, delete the old and save the new in a rolling manner when it is full.

1263

1264

**Parameters: **//msg// String

**Return:**

Succeed: true

Failed: nil

(((

== **bns_get_allcache()** ==

1274

)))

1275

1276

**Function:** Get all the cached content (once the internal cache file will be emptied)

**Parameters:** None

**Return:**

Succeed: //table// one-dimensional array

**For example:**

{

[1]="This is the oldest message", - the first is the oldest message

1290

1291

[2]="This is a test",

...

[n]="This is the latest message", - the last is the latest message

}

Failede: nil

(((

= **7 HTTP operation** =

1304

)))

1305

1306

Network communication includes Http request interface, this document does not provide interface description, please refer to the online document for how to use it.

1307

1308

(((

1309

== **http request** ==

1310

)))

1311

1312

[[http:~~/~~/w3.impa.br/~~~~diego/software/luasocket/http.html#request>>url:http://w3.impa.br/~~diego/software/luasocket/http.html#request]]

1313

1314

== **https request** ==

**For example:**

local json = require("json")

1320

1321

local https = require("https")

1322

1323

functions https_demo.main()

1324

1325

local url = "https://XXXXXXXXXXXXXXXXXXXXXXXXXX"

local body = {}

body["XXXXXX"] = "XXXXX"

1330

1331

body["XXXXXXX"] = "XXXXXXXXXXX"

1332

1333

local bodyJson = json.encode(body)

local header = {}

header["content-type"] = "application/json"

1338

1339

local result_table, code, headers, status = https.request(url,

bodyJson)

if code == 200 then

print("https suc")

return true

else

print("https fail")

return nil

end

end

(((

)))

(((

= **8 General Functions** =

)))

(((

== **send_sms_ira(string number, string message)** ==

1370

)))

1371

1372

**Function:** Use IRA character set to send English text messages

**Parameters:**

//number: //number (up to 32 characters, the excess will be discarded)

1377

1378

//message~:// SMS content (up to 160 English characters, including special symbols, the part exceeding 160 characters will be discarded, and no characters in other languages should appear in the content)

**Return：**

Succeed: SMS corresponding id, used to get whether the SMS was sent successfully

Failed: multi

(((

== **send_sms_ucs2(string number, string message)** ==

)))

**Function:**

Use UCS2 character set to send SMS in Chinese and other languages, such as Korean, Japanese, etc.

**Parameters:**

//number: //number (up to 32 characters, the excess will be discarded)

1397

1398

//message~:// SMS content (Only 70 Chinese characters at most, the part exceeding the length will be discarded)

**Return：**

Succeed: SMS corresponding id, used to get whether the SMS was sent successfully

Failed: multi

(((

== **sms_get_state(number id)** ==

1408

)))

1409

1410

**Function:** Get the status of the SMS

**parameter:**

//id~:// SMS corresponding id

**Return:**

Succeed: SMS status (1: not sent, 2: sent successfully, 3: failed to send)

Failed: multi

(((

== **jwt_encode(table head, table payload, string aud, number iat, number exp, string key, int jwttype)** ==

1424

)))

1425

1426

**Function:** Convert data to JWT format

**parameter:**

//aud: //project name

1431

1432

//iat: //The valid period start timestamp of the JWT data format

1433

1434

//exp~:// the expiration time stamp of the JWT data format

1435

1436

//head~:// head information table

1437

1438

key: key in JSON format

1439

1440

value: value in JSON format

1441

1442

type:value type, 0:string,1:integer,2:number,3:boolean

{

{key="test1",value="test1",type="0"}

}

payload: payload information table

1451

1452

The format is consistent with the header information table

{

{key="test",value="test",type="0"}

}

//jwttype: //encryption type

1461

1462

0:RS256 1:RS384 2:RS512

1463

1464

3: PS256 4: PS384 5: PS512

1465

1466

6:HS256 7:HS384 8:HS512

1467

1468

9:ES256 10:ES384 11:ES512

1469

1470

//key~:// the private key required for encryption

**For example:**

function jwt.main()

local PRIVATE_KEY = [[-- Please enter the secret key--]]

local JWTType=0

local payload = {{key="test1",value="test1",type="0"},

1482

1483

{key="test",value="123122131",type="1"}}

1484

1485

local head = {{ key="name",value="data",type="0"},

1486

1487

{key="test2",value="test2",type="0"}}

1488

1489

local aud = "project"

1490

1491

local iat = 123122131

1492

1493

local exp1 = 123122331

1494

1495

local en = jwt_encode(head,payload,aud,iat,exp1,PRIVATE_KEY,JWTType);

print(en)

End

(((

== **convertohex(number type, number value)** ==

1504

)))

1505

1506

**Function:** Convert data into hexadecimal data

**parameter:**

//type~:// incoming data type 0:word 1:dword 2:float

1511

1512

//value~:// the data to be converted

**Return:**

Succeed: the converted hexadecimal data

Failed: multi

== **crc.init(table prarm)** ==

1521

1522

**Function:** Initialize the CRC

**Parameters:**

prarm is a Lua table and needs to contain the following fields.

1527

1528

* string prarm name, see table 9-1 for details of the parameter model name When this parameter is passed in, the default table parameters are used and the poly,init,xorout,refin,and refout passed in are invalid.

1529

* number prarm.width: the width, i.e. the number of CRC bits.

1530

* number [prarm.poly]: short for the generated item in hexadecimal. For example, CRC-32 is 0x04C11DB7, ignoring the highest bit "1", i.e., the complete generation item is 0x104C11DB7.

1531

* number [prarm.init]: the initialization preset value of the register (crc) at the beginning of the algorithm in hexadecimal.

1532

* number [prarm.xorout]: the final CRC value obtained after heterodyning the calculation result with this parameter.

1533

* number [prarm.refin]: whether each byte of the data to be measured is inverted by bit, true or false.

1534

* number [prarm.refout]: after the calculation or before the heterodyning output, whether the whole data is inverted by bit, true or false.

**Return:**

Success: crc object

Failure: multi, error code

(((

|crc8|0x07|0x00|0x00|false|false

1545

|crc8_cdma2000|0x9B|0xFF|0x00|false|false

1546

|crc8_darc|0x39|0x00|0x00|true|true

1547

|crc8_dvb_s2|0xD5|0x00|0x00|false|false

1548

|crc8_ebu|0x1D|0xFF|0x00|true|true

1549

|crc8_i_code|0x1D|0xFD|0x00|false|false

1550

|crc8_itu|0x07|0x00|0x55|false|false

1551

|crc8_maxim|0x31|0x00|0x00|true|true

1552

|crc8_rohc|0x07|0xFF|0x00|true|true

1553

|crc8_wcdma|0x9B|0x00|0x00|true|true

1554

|crc8_sae_j1850|0x1D|0xFF|0xFF|false|false

1555

|crc8_opensafety|0x2F|0x00|0x00|false|false

1556

|crc16_tms37157|0x1021|0x3791|0x0000|true|true

1557

|crc16_a|0x1021|0x6363|0x0000|true|true

1558

|crc16_riello|0x1021|0x554D|0x0000|true|true

1559

1560

|crc16_arc|0x8005|0x0000|0x0000|true|true

1561

|crc16_arc_ccitt|0x1021|0x1D0F|0x0000|false|false

1562

|crc16_buypass|0x8005|0x0000|0x0000|false|false

1563

1564

|crc16_dds110|0x8005|0x800D|0x0000|false|false

1565

|crc16_dect_r|0x0589|0x0000|0x0001|false|false

1566

|crc16_dect_x|0x0589|0x0000|0x0000|false|false

|crc16_t10_dif|0x8BB7|0x0000|0x0000|false|false

1573

|crc16_teledisk|0xA097|0x0000|0x0000|false|false

1574

1575

|crc16_kermit|0x1021|0x0000|0x0000|true|true

1576

1577

(% class="wikigeneratedid" %)

1578

Table 9-1

1579

1580

== **crc:calc(string crcValue)** ==

1581

1582

**Function:** Calculate CRC result

**Parameter:**

crcValue: the value to be calculated

**Return:**

Succeed: calculated result

1591

1592

Failed: multi, error code

)))

**For example:**

function crcTest.main()

local param = {

name = '',

width = 64,

poly = 0x42F0E1EBA9EA3693,

1607

1608

init = 0xFFFFFFFFFFFFFFFF,

1609

1610

xorout = 0xFFFFFFFFFFFFFFFF,

refin = 1,

refout = 1

}

crc64,err = crc.init(param)

if not crc64 then

print("Crc init failed:", err)

1623

else

1624

1625

crcvalue = crc64:calc("123456789")

1626

1627

print(string.format("crc64 calc :0X%16X", crcvalue))

end

end

= **9 Special function for V-NET** =

1635

1636

== **normal_get_alldata()** ==

1637

1638

**Function: **Obtain the data of all the monitoring points

**Parameter: None**

**Return:**

Succeed: table two-dimensional arrays, as follows:

1645

1646

* Each item is a monitoring point and contains 4 attributes:

** 1: ID

** 2: status

** 3: tag name

** 4: value

* Status contains 3 enumerated values

** 0: offline

** 1: online

** 2: timeout

* Customization returns an empty table if there is no configuration, otherwise returns "field name/field content"

**For example:**

{

[1]= {[1]=1234, [2]=1, [3]='temp', [4]='23.5'},

1663

1664

[2]= {[1]=1235, [2]=1, [3]='humi', [4]='67'},

...

[n]= {[1]=xxxx, [2]=x, [3]='xxxx', [4]='xx.x'},

}

Failed: table, empty table

1673

1674

1675

== **normal_setdata_byname(string name, string data)** ==

1676

1677

**Function:** Write data to the monitoring point name

**Parameter:**

data: the data to be written

**Return:**

Succeed: string: The value of the monitor point before it is written

Failed: nil

== **normal_getdata_byname(string name)** ==

1692

1693

**Function:** Read the data of the monitoring point name

**Parameter:**

**Return:**

Succeed: string

Failed: nil

= **10 Message summary algorithm** =

1706

1707

== **hmac(string hash_func, string key, string message)** ==

1708

1709

**Function:** HMAC calculate

**Function name**

hash_func:

* [md5, sha1, sha224, sha256, sha384, sha512]

1716

* [sha512_224, sha512_256, sha3_224, sha3_256]

1717

* [sha3_384, sha3_512]

**Parameter:**

key: the key

message: message content

**Return:**

Succeed: string, calculation result

Failed: nil

**For example:**

local sha = require"sha2"

1735

1736

function hmac_test.main()

1737

1738

local hmac = sha.hmac

print(hmac(sha.sha1,

"your key", "your message"))

end

== **sha(string message)** ==

1748

1749

**Function:** SHA calculate

**Function name:**

sha:

* sha1, sha224, sha256, sha384, sha512]

1756

* [sha512_224, sha512_256, sha3_224, sha3_256]

1757

* [sha3_384, sha3_512]

**Parameter:**

key: the key

message: message content

**Return:**

Succeed: string, calculation result

Failed: nil

For example:

local sha = require"sha2"

1775

1776

function sha_test.main()

1777

1778

local sha256 = sha.sha256

1779

1780

print(sha256("your message"))

end

= **11 MySQL database operation** =

1786

1787

1788

Note: E series V-box with E02 firmware doesn't support

1789

1790

1791

== **luaMySql.init(string sourcename, string username, string password, string host, number port, string character)** ==

1792

1793

**Function:** Configure database connection parameters

**Parameters:**

sourcename: Database name

1798

1799

username: Connection username

1800

1801

password: Connection password

1802

1803

host: Connection host name

1804

1805

port: Connection host port

1806

1807

character: Character set used for the connection

**Returns:**

Success: true

Failure: multi

== **luaMySql.exec(string statement)** ==

1816

1817

**Function:** Execute the given SQL statement (no result set required, e.g., insert, delete, update)

**Parameters:**

statement: The given SQL statement

**Returns:**

Success: status (Returns the number of rows affected by the SQL statement execution)

1826

1827

Failure: nil, errorString

1828

1829

== **luaMySql.execWithResult(string statement)** ==

1830

1831

**Function:** Execute the given SQL statement (result set required, e.g., query)

**Parameters:**

statement: The given SQL statement

**Returns:**

Success: table (Returns the result set)

1840

1841

Failure: nil, errorString

**Example:**

**{{code language="lua"}}mysql = require "mysqlclient"

1847

1848

function DataInitRight()

1849

local dbName = "db_lua1"

1850

local user = "root"

1851

local pwd = "123456"

1852

local host = "192.168.56.186"

1853

local port = 3306

1854

local character = "UTF8"

1855

mysql.init(dbName, user, pwd, host, port, character)

end

function ExecFunc()

status, errorString = mysql.exec("delete from tb_lua1 where mykey = 10;")

1860

if nil == status then

1861

print("ExecFunc() error:", errorString)

1862

return -1

1863

else

1864

print("the number of rows affected by the command:", status)

end

return 0

end

function ExecWithResultFunc()

1870

status, errorString = mysql.execWithResult("select * from tb_lua1;")

1871

if nil == status then

1872

print("ExecWithResultFunc() error:", errorString)

1873

return -1

1874

else

1875

print("ExecWithResultFunc() success: status type =", type(status))

1876

print("ExecWithResultFunc() success: status len =", #status)

local num = #status

local i = 1

if num > 0 then

for i = 1, num, 1 do

local var = string.format("select result[%d] :mykey = %d, value = %s",

1883

i, status[i].mykey, status[i].value)

print(var)

end

end

print("---------------")

end

return 0

end

function luaMysql_apiTest.main()

1893

print("script running ...")

DataInitRight()

-- use exec demo

if ExecFunc() < 0 then

return

end

-- use execWithResult demo

1902

if ExecWithResultFunc() < 0 then

return

end

print("script running success")

1907

end{{/code}}**

Wiki source code of 01 Lua Functions

Navigation

Table of Contents