Command VAR
 
Description Create a variable having a certain style and a default value.
A variable contains text or numbers which can be amended and be referred to as a single name in an equation or to show information on the display. Variable names must start with a letter or _.
Variables can be pointers to other variables and entities and use the '>' operator.
Non volatile parameter storage is also handled by VAR which initially loads the default value, then at subsequent power ON reloads the last stored value which was saved using LOAD(varname,newval);

A range of 'built in' styles exist like U8,U16,U32,S8,S16,S32,FLT1,FLT2,FLT3,FLT4,TXT as shown in VAR styles below.
These can be appended with E for storage in 'non volatile' EEPROM as described below. 
 
Syntax/Parameters VAR(Name,Value,Style)
+ pointer usage
+ non volatile parameter storage


Arrays are defined using an extension to the VAR() command.
Each required dimension is passed as an additional parameter to the command.
VAR(name,init,type,size0); One-dimensional (or single dimension) array
VAR(name,init,type,size0,size1); Two-dimensional array
VAR(name,init,type,size0,size1,size2); Three-dimensional array
VAR(name,init,type,size0,size1,size2,size3); Four-dimensional array
 
Style VAR Data Styles
 Specify your own style for integer, float, pointer or text or use a built in style name
   
STYLE(stVar, Data)
  { 
   type = U8;     // U8, U16, U32 - unsigned 8, 16 and 32 bit integer
                      // S8, S16, S32 - signed 8, 16, 32 bit integer
                      // TEXT for text strings
                      // FLOAT for higher resolution calculation up to 17 decimal places
                      // POINTER for use with images
  length=64;    // For text, specify the length from 1 to 8192, default =32
  decimal=3;    // Specify the number of decimal places when type is float. Range 0 to 17, default=2
  format="dd mm YY";      //Specify RTC format. see RTC page for format character types
  location=SDRAM;            //Specify the data location as SDRAM (default) or EEPROM
  }
  
Built In Styles
The following pre defined 'built in' style names are available. Add E for EEPROM types Example FLT4E.
  U8/U8E      - type = U8,   U16/U16E - type = U16,  U32/U32E    - type = U32
  S8/S8E      - type = S8,   S16/S16E  - type = S16,  S32/S32E     - type = S32
  PTR/PTRE    - type = pointer,  TXT/TXTE - type = TEXT, length=32
  FLT1/FLT1E  - type = float, decimal = 1,  FLT2/FLT2E  - type = float, decimal = 2
  FLT3/FLT3E  - type = float, decimal = 3,  FLT4/FLT4E  - type = float, decimal = 4
 
Options Example Numbers
VAR(lowval,32.4,FLT1); define lowval as a single decimal float and default value 32.4
 VAR(lowval,22.4,FLT1E); define lowval as a single decimal float and default value 22.7
                                      or load EEPROM value if already exists.
                                  Use RESET(EEPROM); to clear and reload only current values.
 
Example Pointers
Create a pointer which is defaulted to null using the '>' symbol.
VAR(EntPtr1>"",PTR);
  
To set/change which entity the entity pointer is pointing to you use '>' instead of ','.
  LOAD( EntPtr1>"Var1"); // Set EntPtr1 to point to Var1
  
To put data into the entity pointed to by the entity pointer, enclose data / source entity in quotes.
  LOAD( EntPtr1, "ABC" );    // Load the Entity pointed to by EntPtr1 with ABC
  
The following commands now support entity pointers where  ( | means 'or this')
  > LOAD(name | ptr | "ptr", | > num | "txt" | var | ptr,...);
  > CALC(var | ptr, var | ptr, num | var | ptr,"op");
  > TEXT(name | ptr, "txt" | var | ptr,...);
  > IF(var | ptr op num | "txt" | var | ptr ? func | func_ptr : func | func_ptr);
  > KEY(name, func | func_ptr,...);
  > INT(name, buf, func | func_ptr,...);
  > SHOW(name | ptr,...);
  > HIDE(name | ptr,...);
  > RUN(name | func_ptr,...);
  > IMG(name | img_ptr, lib | img_ptr,...);
  
 Floats - v47.12
Increased maximum decimal places to 17 (was 7).

Pointers - v48.24
Support added for pointers to pointers.
   VAR( vU16Ent, 1234, U16 );

   VAR( vPtrEnt1 > "vU16Ent", PTR );
   VAR( vPtrEnt2 > "vPtrEnt1", PTR );
   VAR( vPtrEnt3 > "vPtrEnt2", PTR );

   TEXT( txtEnt, vPtrEnt3 ); effectively puts 1234 in text box 'txtEnt'
   LOAD( vPtrEnt3, 5678 ); effectively loads vU16Ent with 5678

VARs - v49.02
VARs can now be initialised with other VARs, as well as immediate values.

Touch - v49.14
Added built-in variables TOUCH0, TOUCH1, TOUCH2, TOUCH3, TOUCHP to aid with touchscreen diagnotics.
 
ADC - v49.16
Added system variables ADC1VAL, ADC2VAL (U16) to allow direct use of conversion results.

Pointer Copy - v49.18
Pointers can be copied using CALC(dst,src,''PCOPY'');
   VAR( v1 > "v3", PTR );
   VAR( v2 > "v4", PTR );
   VAR( v3, "alpha", TXT );
   VAR( v4, "beta", TXT );
   gives: v1>v3; v2>v4; v1=alpha; v2=beta; v3=alpha; v4=beta
   CALC( v1, v2, "PCOPY" );
   gives: v1>v4; v2>v4; v1=beta; v2=beta; v3=alpha; v4=beta

Text VAR Source - v49.32
Added ability to use same source text variable as the destination text variable:
LOAD( txtVarA, txtVarB, txtVarA );

 Read-Only VARs (Constants) - v49.32
Variables can be designated read-only (constants) by specifying readonly=y; in the data style:
> STYLE(U8C,data){type=u8;readonly=y;}
A system error will occur if modification to a read-only variable is requested.
Checking is performed in LOAD(), VAR() and CALC() commands only.

Built-in "Constant" styles - v49.32
U8C, U16C, U32C, S8C, S16C, S32C, PTRC, FLT1C, FLT2C, FLT3C, FLT4C, TXT4C, TXT16C, TXTC, TXT64C, TXT128C.

 Arrays Definitions
Array: A data structure consisting of a collection of elements (values), each identified by at least one index.
Index: A non-negative integer used to index a value in an array. Indices can also be called subscripts.
Element: A location in the array data structure which is used to store a value.
Dimension: The dimension of an array is the number of indices needed to select an element.

Indexing Arrays
Arrays use zero-based indexing, i.e. the first element of the array is indexed by 0.
For example, we define a 20 element array as:
VAR( A, 0, U8, 20 );
Then the elements of the array are indexed A.0 through to A.19.
Array elements are accessed by separating the indices with a dot.
Single dimension with A.0  through to 4 dimensions with name.idx0.idx1.idx2.idx3
 
Example VAR(lowval,32.4,FLT1); //define lowval as a single decimal float and default value 32.4
 VAR(lowval,22.4,FLT1E); //define lowval as a single decimal float and default value 22.7
                                     // or load EEPROM value if already exists.
                                  //Use RESET(EEPROM); to clear and reload only current values.

VAR(Txt1,"Hello World",TXT);

Arrays
VAR(A,0,U8,3); //One-dimensional (or single dimension) array
VAR(B,1,U8,2,20); //Two-dimensional array
VAR(C,2,U8,2,5,20); //Three-dimensional array
VAR(D,3,U8,2,5,4,15); //Four-dimensional array
 
Update Information

 Version

 Title

Date  

 Details

49.51

 Extra Built-In Data Styles TXT and FLT

10 Feb 14 

Show

* Added TXTn, TXTnE and TXTnC data styles of type text where n is the maxLen value allocated for the data between 1 and 8192. If the name ends in an 'E' then it stored in EEPROM. If the name ends in 'C' then it is a constant (ie read-only). Examples TXT42, TXT27E, TXT32C.
* Added FLTn, FLTnE and FLTnC data styles of type float where n is the number of displayed decimal places between 0 and 17. If the name ends in an 'E' then it stored in EEPROM. If the name ends in 'C' then it is a constant (ie read-only). Examples FLT5, FLT7E, FLT4C.

Examples of styles created:

VAR(v1,"",TXT1);
STYLE(TXT1,DATA){type=text;maxLen=1;}

VAR(v2,"",TXT99);
STYLE(TXT99,DATA){type=text;maxLen=99;}

VAR(v2,"",TXT8192);
STYLE(TXT8192,DATA){type=text;maxLen=8192;}

VAR(v3,"",TXT2048);
STYLE(TXT2048,DATA){type=text;maxLen=2048;}

VAR(v4,"",TXT128C);
STYLE(TXT128C,DATA){type=text;maxLen=128;readonly=y;}

VAR(v5,"",TXT48E);
STYLE(TXT48E,DATA){type=text;maxLen=48;locate=eeprom;}


VAR(v6,3.141,FLT7);
STYLE(FLT7,DATA){type=float;decimal=7;}

VAR(v7,1.23,FLT8C);
STYLE(FLT8C,DATA){type=float;decimal=8;readonly=y;}

VAR(v8,2.34,FLT12E);
STYLE(FLT12E,DATA){type=float;decimal=12;locate=eeprom;}

49.46

 Text Arrays - Functionality available by using U8 and U16 arrays

24 Oct 13 

Show

* Text arrays can consist of either ASCII (8-bit) or Unicode (16-bit) characters.

* Creating an array of ASCII (8-bit) characters. Use the U8 data type.

VAR( varA, 0, U8, 6, 10 );

Number of text strings = 6
Maximum text string length = 10

Loading the array, use text formatting '%t%'

LOAD( varA.0, %t% "Zero" );
LOAD( varA.1, %t% "One" );
LOAD( varA.2, %t% "Two" );
LOAD( varA.3, %t% "Three" );
LOAD( varA.4, %t% "Four" );
LOAD( varA.5, %t% "This is too long" ); // truncates to "This is to"

Reading from the array, again using the text formatting '%t%'

LOAD( RS2, %t% varA.0, ", ", %t% varA.4 ); // Outputs "Zero, Four"
LOAD( RS2, %t% varA.5 ); // Outputs "This is to"
TEXT( txt1, varA.3 );; // Displays "Three"


* Creating an array of Unicode (16-bit) characters. Use the U16 data type

VAR( varB, 0, U16, 4, 8 );

Number of text strings = 4
Maximum text string length = 8

Loading the array, using text formatting '%t%'

LOAD( varB.0, %t% "\\w1234Zero" ); // varB.0.0 = \\1234
LOAD( varB.1, %t% "One" );
LOAD( varB.2, %t% "Two" );
LOAD( varB.3, %t% "Three" );

Reading from the Array, using the text formatting '%t%'

LOAD( RS2, %t% varB.0, ", ", %t% varB.3 ); // Outputs "\\w1234Zero, Three"


* Accessing individual characters using standard array accesses.

LOAD( RS2, %h% varB.0.0 ); // Outputs 1234
LOAD( varB.2.1, 42 ); // '*'
LOAD( RS2, varB.2 ); // Outputs "T*o"

* Displaying the raw data using the %r% formatting outputs the whole string including the terminating nulls.

LOAD( RS2, %r% varB.3 ); // Outputs "Three\\00\\00\\00"

49.42

 Structures - STRUCT(){}

06 Sep 13 

Show

* Structures are now supported in the firmware.
* To define a structure type (does not create actual structure yet):

STRUCT( strName )
{
var1, type1;
var2, type2;
....
}

where
strName is the name for the structure
var1, var2 ... are the names for the variables in the structure
type1, type2 ... are the data types for the variables in the structure

Example:

STRUCT( strPerson )
{
name, TXT;
age, U8;
height, U16;
weight, FLT4;
}

* To create a structure variable

VAR( name, 0, strName );

where
name is the name for your structure variable
0 is the intial value (not used)
strName is the name of the structure definition

Example:

VAR( Per, 0, strPerson ); // Create a structure for one person
LOAD( Per.name, "Itron" );
LOAD( Per.age, 100 );
LOAD( RS2, Per.name ); // will output "Itron"

* To create an array of structures

VAR( name, 0, strName, n, n, n );

where n is the number of subscripts

Example:

VAR( Co, 0, strPerson, 2, 5 ); // Create a structure for a company
LOAD( Co.0.0.name, "Mike" ); // First index used for department
LOAD( Co.0.0.age, 102 );
LOAD( Co.0.0.height, 100 );
LOAD( Co.0.0.weight, 8.4 );
LOAD( Co.0.1.name, "Andy" );
...
LOAD( Co.0.2.name, "Dave" );
...
LOAD( Co.1.0.name, "Bob" ); // Next department
LOAD( Co.1.0.age, 23 );
LOAD( Co.1.0.height, 180 );
LOAD( Co.1.0.weight, 12.4 );
LOAD( Co.1.1.name, "Mark" );
...

LOAD( RS2, Co.1.0.name, " aged ", Co.1.0.age, " is ", Co.1.0.height, "cm tall" ); // will output "Bob aged 23 is 180cm tall"
CALC( Co.0.2.age, Co.1.0.age, Co.0.0.age, "+" ); // will give Dave an age of 125


* How it works - multiple entities are created.

STRUCT( myStruc )
{
aa,U8;
bb,U16;
cc,TXT;
}

will effectively create 3 variables when STRUCT is defined:
VAR( aa, 0, U32C );
VAR( bb, 1, U32C );
VAR( cc, 2, U32C );


VAR( xx, 0, myStruc );

will effectively create (3+1) = 4 variables and set up the pointers:
VAR( xx > "", PTR, 3 );
VAR( xx_aa, 0, U8 ); LOAD( xx.0 > "xx_aa" );
VAR( xx_bb, 0, U16 ); LOAD( xx.1 > "xx_bb" );
VAR( xx_cc, "", TXT ); LOAD( xx.2 > "xx_cc" );


VAR( st, 0, myStruc, 3, 2 );

will effectively create (3*2*3+1) = 19 variables and set up the pointers:
VAR( st > "", PTR, 3, 2, 3 );
VAR( st_0_0_aa, 0, U8 ); LOAD( st.0.0.0 > "st_0_0_aa" );
VAR( st_0_0_bb, 0, U16 ); LOAD( st.0.0.1 > "st_0_0_bb" );
VAR( st_0_0_cc, "", TXT ); LOAD( st.0.0.2 > "st_0_0_cc" );
VAR( st_0_1_aa, 0, U8 ); LOAD( st.0.1.0 > "st_0_1_aa" );
VAR( st_0_1_bb, 0, U16 ); LOAD( st.0.1.1 > "st_0_1_bb" );
VAR( st_0_1_cc, "", TXT ); LOAD( st.0.1.2 > "st_0_1_cc" );
VAR( st_1_0_aa, 0, U8 ); LOAD( st.1.0.0 > "st_1_0_aa" );
VAR( st_1_0_bb, 0, U16 ); LOAD( st.1.0.1 > "st_1_0_bb" );
VAR( st_1_0_cc, "", TXT ); LOAD( st.1.0.2 > "st_1_0_cc" );
VAR( st_1_1_aa, 0, U8 ); LOAD( st.1.1.0 > "st_1_1_aa" );
VAR( st_1_1_bb, 0, U16 ); LOAD( st.1.1.1 > "st_1_1_bb" );
VAR( st_1_1_cc, "", TXT ); LOAD( st.1.1.2 > "st_1_1_cc" );
VAR( st_2_0_aa, 0, U8 ); LOAD( st.2.0.0 > "st_2_0_aa" );
VAR( st_2_0_bb, 0, U16 ); LOAD( st.2.0.1 > "st_2_0_bb" );
VAR( st_2_0_cc, "", TXT ); LOAD( st.2.0.2 > "st_2_0_cc" );
VAR( st_2_1_aa, 0, U8 ); LOAD( st.2.1.0 > "st_2_1_aa" );
VAR( st_2_1_bb, 0, U16 ); LOAD( st.2.1.1 > "st_2_1_bb" );
VAR( st_2_1_cc, "", TXT ); LOAD( st.2.1.2 > "st_2_1_cc" );

* Limitations:
The concatenation of structure var name with underscores and indices must fit within an entity name length. Therefore structure var names should be kept short.
The user must be careful not to create entities with the same name as the vars in the STRUCT - an error message will occur.

49.37

 Large Buffer Variables (> 8192)

10 Jun 13 

Show

* Special case for buffers required > 8192 bytes, use bufLen rather than maxLen/length.

49.32

 LOAD() - Added ability to use same source text variable as the destination text variable.

14 Feb 13 

Show

* Added ability to use same source text variable as the destination text variable:
LOAD( txtVarA, txtVarB, txtVarA );
* Corrected copying of text to allow value of 0 to be ignored and not treated as terminating NUL.
* Changed default precision from 0 to 2 for writing immediate floats into a text variable to match default of float variable.
* Text entities now supported in LOAD() commands: LOAD( txtVar, txtEnt, ... ); and LOAD( txtEnt, txtVar, ... ); and LOAD( RS2, txtEnt );

49.32

 Read-Only VARs - Variables can be designated read-only (constants).

14 Feb 13 

Show

* Variables can be designated read-only (constants) by specifying readonly=y; in the data style:
STYLE(U8C,data){type=u8;readonly=y;}
* A system error will occur if modification to a read-only variable is requested.
* Checking is performed in LOAD(), VAR() and CALC() commands only.
* Built-in "Constant" styles created:
U8C, U16C, U32C, S8C, S16C, S32C, PTRC, FLT1C, FLT2C, FLT3C, FLT4C, TXT4C, TXT16C, TXTC, TXT64C, TXT128C

49.18

 Pointer Copy - Pointers can now be copied using CALC(dst,src,''PCOPY'');.

22 Sep 12 

Show

Pointers can now be copied using CALC(dst,src,"PCOPY");
* Example:
VAR( v1 > "v3", PTR );
VAR( v2 > "v4", PTR );
VAR( v3, "alpha", TXT );
VAR( v4, "beta", TXT );
gives: v1>v3; v2>v4; v1=alpha; v2=beta; v3=alpha; v4=beta
CALC( v1, v2, "PCOPY" );
gives: v1>v4; v2>v4; v1=beta; v2=beta; v3=alpha; v4=beta

49.18

 FILE(''WRITE''|''APPEND''|''WRITEALL'') - Support for numbers, U8, FLT, immediate etc added

22 Sep 12 

Show

* Support for numbers, U8, FLT, immediate etc added

49.16

 Built-in System Entities - Added TXT4, TXT4E, TXT16 and TXT16E.

14 Sep 12 

Show

* Added TXT4, TXT4E, TXT16 and TXT16E.

49.16

 ADC - Added system variables ADC1VAL, ADC2VAL (U16) to allow direct use of conversion results.

14 Sep 12 

Show

* Added system variables ADC1VAL, ADC2VAL (U16) to allow direct use of conversion results.

49.14

 Touch - Added built-in variables TOUCH0, TOUCH1, TOUCH2, TOUCH3, TOUCHP to aid with touchscreen diagnotics.

27 Jul 12 

Show

* Added built-in variables TOUCH0, TOUCH1, TOUCH2, TOUCH3, TOUCHP to aid with touchscreen diagnotics

49.08

 Random Number Generation - CALC( varD, varX, ''RND'' );

11 Jul 12 

Show

CALC( varD, varX, "RND" );
* Gives varD equal to a Random number (0 to 0.999999) mutiplied by varX

49.03

 Float Formatting - Increased decimal places range from %f0% to %f9%.

01 Jun 12 

Show

Increased decimal places range from %f0% to %f9% (was %f1% to %f8%).

49.02

 RUN( cmd ) - Added support for running commands from a text variable.

15 May 12 

Show

Added support for running commands from a text variable.
This is useful when sending a SMART command over a serial link embedded in a user protocol.
It is then possible to dynamically create new entities and pages remotely from a host in a user protocol.
LOAD( cmd, "LOAD(RS2,1);LOAD(RS2,\\22Hello\\22);" ); // cmd is a text variable.Use \\22 to insert double quotes
RUN( cmd ); //Sends 1Hello via RS232 port
* Inline functions also supported: RUN( [LOAD( RS2, "Hello" );] );

49.02

 VARs - VARs can now be initialised with other VARs, as well as immediate values.

15 May 12 

Show

VARs can now be initialised with other VARs, as well as immediate values.

49.00

 Exponents - Parser now supports numbers in exponent format.

22 Mar 12 

Show

Parser now supports numbers in exponent format, eg 1.2e-7 or 3.142E5. For example, LOAD(fltVar,45.67e-5);

49.00

 CALC float to/from U32 - Added function to convert a U32 containing a IEEE 754 binary 32 formatted float into a float.

22 Mar 12 

Show

Added function to convert a U32 containing a IEEE 754 binary 32 formatted float into a float and vice versa.
Action depends on source and destination types.
> CALC( flt, u32, "CFLT" ); // Converts a float to IEEE 754 binary 32 formatted float
> CALC( u32, flt, "CFLT" ); // Converts an IEEE 754 binary 32 formatted float to a float
Example 1
var(f,0,FLT4);
var(u,0,U32);
load(f,68.123);
calc(u,f,"cflt");
load(rs2,"f=",f,"; u=",%H08%u,"\\0d\\0a");

> f=68.1230; u=42883EFA
Example 2
load(u,\\41460000);
calc(f,u,"cflt");
load(rs2,"f=",f,"; u=",%H08%u,"\\0d\\0a");

> f=12.3750; u=41460000

48.24

 Pointers - Support added for pointers to pointers.

10 Mar 12 

Show

Support added for pointers to pointers, eg

VAR( vU16Ent, 1234, U16 );

VAR( vPtrEnt1 > "vU16Ent", PTR );
VAR( vPtrEnt2 > "vPtrEnt1", PTR );
VAR( vPtrEnt3 > "vPtrEnt2", PTR );

TEXT( txtEnt, vPtrEnt3 ); effectively puts 1234 in text box 'txtEnt'
LOAD( vPtrEnt3, 5678 ); effectively loads vU16Ent with 5678

48.24

 Formatting for U16's to Text

10 Mar 12 

Show

Conversion from U16 for full unicode range now supported (Was previously taking U8 value).

47.12

 Floats - Increased maximum decimal places to 17 (was 7).

09 Sep 11 

Show

Increased maximum decimal places to 17 (was 7).
* In IF() commands, bottom nibble is now masked off fractional part of float to handle small differences in value representation.

39.00

 Text/Strings/Parameters - Increased maximum text var length to 8192 characters throughout code.

21 Jan 11 

Show

Increased maximum text var length to 8192 characters throughout code

39.00

 LIB - LIB command now accepts text variable (or pointer to text variable) for file name.

21 Jan 11 

Show

LIB command now accepts text variable (or pointer to text variable) for file name.

39.00

 String Length Comparisons - Added ~>= and ~<= operators.

21 Jan 11 

Show

Added ~>= and ~<= operators
Strings lengths can now be compared with integer lengths or another string

36.00

 Wait - WAIT() can now be used with INTs, VARs or PTR.

23 Nov 10 

Show

WAIT() can now be used with INTs, VARs or PTR.

36.00

 Calc - Error in storage of U16's (ie they were not being updated).

23 Nov 10 

Show

Error in storage of U16's (ie they were not being updated).

35.00

 Backlight Control - Backlight can now be set using a variable as well as a number.

12 Nov 10 

Show

Backlight can now be set using a variable as well as a number
Example
VAR(level,50,U8);
LOAD(BLED,level);

35.00

 RTC - RTC can now be set by a text strings and VARs using concatenation.

12 Nov 10 

Show

RTC can now be set by a text strings and VARs using concatenation. Examples:
LOAD(RTC,"2010:12:11:10:19:26");
or
VAR(years,2010,U16);
VAR(months,11,U8);
VAR(days,2,U8);
VAR(time,"00:00",TXT);
LOAD(RTC,years,":",months,":",days,":",hours,":",time,":00");
(This will give "2010:11:02:00:00:00")
You must supply the complete string…ie you cannot just load years.

34.00

 EEPROM Storage - The user software can store values (text and numbers) in EEPROM.

19 Oct 10 

Show

The user software can store values (text and numbers) in EEPROM
About 1500 bytes are available. This would hold about 50 variable names and their values.
Example command VAR(MyEENum, 123, U8E); stores 123 in MyEENum the first time as a default. When you use LOAD(MyEENum, 244); the value is updated in RAM and in EEPROM. When power is removed and reapplied, VAR(MyEENum, 123, U8E); will not load 123 but the previously saved value.
To clean up the EEPROM during development, use RESET(EEPROM); which cleans the EEPROM and loads back only the currently defined variables.

STYLE( EEstyle, data) { type=U8; location=eeprom; } if location is specified as eeprom, data is stored otherwise just RAM is used and data lost at power off.

Built in data types have been created to simplify EEPROM storage: U8E, S8E, U16E, S16E, U32E, S32E, PTRE, FLT1E, FLT2E, FLT3E, FLT4E, TXTE

The ‘aircon.mnu’ now uses two U8E variables for the minimum and maximum temperatures. Error messages will be generated if a variable stored in EEPROM is redefined in SDRAM or a different VAR type is specified.

34.00

 Text Unsigned U32 - U32 numbers now being correctly displayed as unsigned.

19 Oct 10 

Show

U32 numbers now being correctly displayed as unsigned.

34.00

 UNICODE - Outputting of RTC and VAR’s has been fixed for Unicode.

19 Oct 10 

Show

Outputting of RTC and VAR’s has been fixed for Unicode

32.00

 VAR - VAR(Name,Style); changes to VAR(Name, default Value, Style);.

14 Oct 10 

Show

Due to customer request, including the default value reduces the lines of code and matches other command types like TEXT, IMG, DRAW.
VAR(Name,Style); changes to VAR(Name, default Value, Style);
Example1: VAR( MyVarU8, 0, U8 );
Example2: VAR( MyVarTxt, "Hello", TXT );
Example3: VAR( MyVarPtr > "ImgABC", PTR );
A new built in style TXT can be used for text variables with default 32 characters length

27.00

 CALC - Added '%' (modulus) operator to CALC.

10 Sep 10 

Show

Added '%' (modulus) operator to CALC for U8, U16. U32, S8, S16, S32 types.

27.00

 Entity Pointers - Entity pointers have been added.

10 Sep 10 

Show

Entity pointers have been added.
STYLE( PtrData, DATA ) { type = pointer; }
VAR( EntPtr1, PtrData );

To set/change which entity the entity pointer is pointing to you enclose its name in quotes.
LOAD( "EntPtr1", "Var1" ); // Set EntPtr1 to point to "Var1"

To access the entity pointed to by the entity pointer, do not enclose is quotes.
LOAD( EntPtr1, "ABC" ); // Load the Entity pointed to
by EntPtr1 with "ABC"

The following commands now support entity pointers:
> LOAD(name|ptr|"ptr",num|"txt"|var|ptr,...);
> CALC(var|ptr,var|ptr,num|var|ptr,"op");
> TEXT(name|ptr,"txt"|var|ptr,...);
> IF(var|ptr op num|"txt"|var|ptr ? func|func_ptr : func|func_ptr);
> KEY(name,func|func_ptr,...);
> INT(name,buf,func|func_ptr,...);
> SHOW(name|ptr,...);
> HIDE(name|ptr,...);
> RUN(name|func_ptr,...);
> IMG(name|img_ptr,lib|img_ptr,...);

See the tu480.mnu file for an example of using pointers to update images representing CNTSECS.

24.00

 TEXT U32 - Fixed the displaying of a U32 variable in TEXT string.

25 Aug 10 

Show

Fixed the displaying of a U32 variable in TEXT string (was using U16).

24.00

 VAR - Fixed a problem with using single character entity names.

25 Aug 10 

Show

Fixed a problem with using single character entity names, e.g. VAR( x, style ); now possible.

21.00

 FLT - Support floating point data type and handling across all functions.

30 Jul 10 

Show

Support floating point data type and handling across all functions. Specify number of decimal points to show on the page

20.00

 FLT - Command parser now reads floating point numbers.

22 Jul 10 

Show

Command parser now reads floating point numbers