Great Cow BASIC documentation

About Inputs and Outputs

Most general purpose pins on a microcontroller can function in one of two modes: input mode, or output mode.

When acting as an input, the general purpose input/output pin will be placed in a high impedance state. The microcontroller will then sense the general purpose input/output pin, and the program can read the state of the general purpose input/output pin and make decisions based on it.

When in output mode, the microcontroller will connect the general purpose input/output pin to either Vcc (the positive supply), or Vss (ground, or the negative supply). The program can then set the state of the general purpose input/output pin to either high or low.

Great Cow BASIC will attempt to determine the direction of each general purpose input/output pin, and set it appropriately, when possible. Great Cow BASIC will try to set the direction of the general purpose input/output pin. However, if the general purpose input/output pin is read from and written to in your program, then the general purpose input/output pin must be configured to input or output mode by the program, using the appropriate Dir commands.

Example of dir commands.

Microchip specifics for read/write operations

For the specific ports and general purpose input/output pins available for a specific microcontroller please refer to the datasheet.

To read a general purpose input/output pin, you need to ensure the direction is correct DIR Portx IN is set (default is IN) or a specific set of port bits. Where uservar = PORTx.n can be used.

Examples:

To write to a general purpose input/output pin, you need to ensure the direction is correct DIR Portx OUT for port or a specific set of port bits. Where PORTx.n = uservar can be used.

Examples:

ATMEL specifics for read/write operations

Using a Mega328p as a general the following provides insights for the AVR devices. For the specific ports and general purpose input/output pins available for a specific microcontroller please refer to the datasheet.

To read a general purpose input/output pin, you need to ensure the direction is correct DIR Portx IN is set (default is IN) or a specific set of port bits. Where uservar = PINx.n can be used and therefore to read data port use uservar = PINx.

Examples:

To write to a general purpose input/output pin you need to ensure the direction is correct DIR Portx OUT for port or a specific set of port bits. Where PORTx.n = uservar can be used and therefore to write to a data port use PORTx = uservar.

Examples:

Setting Ports and Port.bit

You can set a port as shown above with a variable, or, you can set with a constant or any combination using the bitwise and logical operators.

The following is also valid - read a port.bit and then set port.bit with a variable or port value. As shown below.

The user code above may cause issues with glitches when the read and write operations occurs. Let us look at the generated assembler.

To resolve any glitches add #option Volatile to your user code.

This option provides the following assembler resolving the glitch issue.

See also Dir, #Option Volatile

About Configuration

(Note: This section does not apply to Atmel AVR microcontrollers. Atmel AVR microcontrollers do have a similar configuration settings, but they are controlled through "Configuration Fuses". Great Cow BASIC cannot set these - you MUST use the programmer software.)

Every Microchip PIC has a CONFIG word. This is an area of memory on the chip that stores settings which govern the operation of the chip.

The following asects of the chip are governed by the CONFIG word:

The exact configuration settings vary amongst chips. To find out a list of valid settings, please consult the datasheet for the microcontrollers that you wish to use.

This can all be rather confusing - hence, Great Cow BASIC will automatically set some config settings, unless told otherwise:

Note that these settings can easily be individually overridden whenever needed. For example, if the Watchdog Timer is needed, adding the line

This will enable the watchdog timer, without affecting any other configuration settings.

Using Configuration

Once the necessary CONFIG options have been determined, adding them to the program is easy. On a new line type "#config" and then list the desired options separated by commas, such as in this line:

Great Cow BASIC also supports this format on 10/12/16 series chips:

However, for upwards compatibility with 18F chips, you should use the = style config settings.

It is possible to have several #config lines in a program - for instance, one in the main program, and one in each of several #include files. However, care must then be taken to ensure that the settings in one file do not conflict with those in another.

For more help, see #config Directive

About Arrays

An array is a special type of variable - one which can store several values at once. It is essentially a list of byte numbers in which each one can be addressed individually through the use of an "index". The index is a value in brackets immediately after the name of the array.

Examples of array names are:

Defining an array

Use the DIM command to define an array.

The number of elements can be number or a constant - not a variable.

The value for the number elements in an array must be a number or constant. The compiler allocates RAM for arrays at compile time, and therefore you cannot use a variable because during compilation the value of a variable cannot be determined.

Setting an entire array at once

It is possible to set several elements of an array with a single line of code. This short example shows how:

When using the method above element 0 of the array TestVar will be set to the number of items in the list, which in this case is 9. Each element of the array will then be loaded with the corresponding value in the list - so in the example, TestVar(1) will be set to 1, TestVar(2) to 2, and so on. Element 0 will only be set to number of items in the array when using this method up to 48 data elements.

Array Length Element 0 should not be used to obtain the length of the array. Element 0 will only be a consistent with respect to the length of the array when the array is set as shown above.

The correct method is to use a constant to set the array size and use the constant within your code to obtain the array length.

Using Arrays

To use an array, its name is specified, then the index. Arrays can be used everywhere that a normal variable can be used.

The limit on array size varies dependent on the chip type.

Get the most from the available memory

Array RAM usage is determined by the architecture of the chip type. Getting most out of the available memory is determined by the allocation of the array within the available banks of memory.

An example is an array of 6 or 7 bytes when there is only 24 bytes of RAM and the 24 bytes is split across multiple memory banks. Assume in this example that 18 bytes have allocated to other variables and there is 29 bytes total available. An array of 6 bytes will fit into the free space in one bank, but the array of 7 will not.

Great Cow BASIC currently cannot split an array over banks, so if there are 6 bytes free in one bank and 5 in another, you cannot have an array of 7 bytes. This would be very hard to do efficiently on 12F/16F as there would be a series of special function registers in the middle of the array when using a 12F or 16F. This constraint is not the case on 16F1/18F as linear addressing makes it easy to span banks because the SFRs are not making the problem (as with 12F/16F).

Using Tables as an alternative.

If there are many items in the array, it may be better to use a Lookup Table to store the items, and then copy some of the data items into a smaller array as needed.

For more help, see Declaring arrays with DIM

About Comments

Adding comments to your Great Cow BASIC program is done with an apostrophe before the comment line. You can also comment out sections of code if you want just by placing an apostrophe, a semi-colon or use the statement REM at the beginning of each line. The SynGCB IDE has a feature to do this automatically.

Warning: Great Cow Graphical BASIC uses semi-colons to mark comments that it has inserted automatically. It does not read these comments when opening a file, so any comments in a Great Cow BASIC program starting with a semi-colon will be deleted if the program is opened using Great Cow Graphical BASIC.

Example:

About Conditions

In Great Cow BASIC (and most other programming languages) a condition is a statement that can be either true or false. Conditions are used when the program must make a decision. A condition is generally given as a value or variable, a relative operator (such as = or >), and another value or variable. Several conditions can be combined to form one condition through the use of logical operators such as AND and OR.

Great Cow BASIC supports these relative operators:

In addition, these logical operators can be used to combine several conditions into one:

NOT is slightly different to the other logical operators, in that it only needs one other condition. Other arithmetic operators may be combined in conditions, to change values before they are compared, for example.

Great Cow BASIC has two built in conditions - TRUE, which is always true, and FALSE, which is always false. These can be used to create Conditional tests and infinite loops.

The condition bit_variable = TRUE is treated as TRUE if the bit is on.  Any non-zero value will be treated as equal to a high bit. The condition bit_variable = other_type_of_variable generates a warning.  If the byte_variable is set to TRUE and then compared to the bit, it will always be FALSE because the high bit will be treated as a 1.  But the new warning will be generated, "Comparison will fail if %nonbit% is any value other than 0 or 1"

It is also possible to test individual bits in conditions. To do this, specify the bit to test, then 1 or 0 (or ON and OFF respectively). Presently there is no way to combine bit tests with other conditions - NOT, AND, OR and XOR will not work.

Example conditions:

Constraints when using Conditional Test

As Great Cow BASIC is very flexible with the use of variables type this can cause issues when testing constants and/or functions.

A few simple rules. Always put the function or constant first, or, always call the function with the addition of the braces.

The example code below shows the correct method and an example that does compile but will not work as expected.

This fails as the function will not be called

About Constants

A constant tells the compiler to find a given word, and replace it with another word or number. Define directives create constants.

Constants are useful for situations where a routine needs to be easily altered. For example, a define could be used to specify the amount of time to run an alarm for once triggered.

It is also possible to use defines to specify ports - thus defines can be used to aid in the creation of code that can easily be adapted to run on a different microcontroller with different ports.

Great Cow BASIC makes considerable use of defines internally. For instance, the LCD code uses defines to set the ports that it must use to communicate with the LCD.

About Defines

To create a define is a matter of using the #define directive. Here are some examples of defines:

Line is a simple constant - Great Cow BASIC will find Line in the program, and replace it with the number 34. This could be used in a line following program, to make it easier to calibrate the program for different lighting conditions.

Light is a port - it represents a particular pin on the microcontroller. This would be of use if the program had many lines of code that controlled the light, and there was a possibility that the port the light was attached to would need to change in the future.

LightOn is a define used to make the program more readable. Rather than typing Set PORTB.0 on over and over, it would then be made possible to type LightOn, and have the compiler do the hard work.

Great Cow BASIC Defined constants

Great Cow BASIC special constant

Forever is a special constant. For Great Cow Graphical BASIC users think of this as 'false'. For those not using Great Cow Graphical BASIC think of this as a non numeric value that has no value. You can use Forever in a DO-LOOP but not in a REPEAT-END REPEAT loop, as the in the later case the REPEAT will have no value and you will create an error condition.

Precedence of Constants within Great Cow BASIC.

The #define command creates constants, and, a script can creates constants.

The precedence is as follows:

#define in the main program are read first,

then, the #define in the include files. Constants defined in the include files will be ignored if they conflict or are different to another constant in the main program,

then, the scripts are processed. Scripts that create constants always override any constant value previously defined.

Scripts are highest priority, then constants in the main program, then constants in include files from the main program, then constants in the standard libraries.

See #define

About Functions

Functions are a special type of subroutine that can return a value. This means that when the name of the function is used in the place of a variable, Great Cow BASIC will call the function, get a value from it, and then put the value into the line of code in the place of the variable.

Functions may also have parameters - these are treated in exactly the same way as parameters for subroutines. The only exception is that brackets are required around any parameters when calling a function.

Using Functions

This program uses a function called AverageAD to take two analog readings, and then make a decision based on the average:

See Also Subroutines, Exit

About Labels

Labels are used as markers throughout the program. Labels are used to mark a position in the program to ‘jump to’ from another position using a goto, gosub or other command.

Labels can be any word (that is not already a reserved keyword) and may contain digits and the underscore character. Labels must start with a letter or underscore (not digit), and are followed directly by a colon (:) at the marker position. The colon is not required within the actual commands.

The compiler is not case sensitive. Lower and/or upper case may be used at any time.

Example:

For more help, see Goto, Gosub

About Lookup Tables

A lookup table is a list of values that are stored in the program memory of the chip, which can be accessed using the ReadTable command.

The advantage of lookup tables is that they are memory efficient, compared to an equivalent set of IF statements.

Data tables are defined as

Defining Tables

A single value on each line

Multiple elements on a single line separated by commas:

Constants and calculations within the single line:

Data tables can now be loaded directly from a file. The source file will be read as a hexidecimal raw file.

Using Lookup Tables

First, the table must be created. The code to create a lookup table is simple - a line that has Table and then the name of the table, a list of numbers (up to 10,000 elements), and then End Table.

For tables with more than 255 elements it is mandated to used a WORD variable to read the size of the table. See below.

Once the table is created, the ReadTable command is used to read data from it. The ReadTable command requires the name of the table it is to read, the location of the item to retrieve, and a variable to store the retrieved number in.

Lookup tables can store byte, word, longs and integer values. Great Cow BASIC will automatically detect the type of the table depending on the values in it. Great Cow BASIC can be explicitly instructed to cast the table to a variable type, as follows:

Item 0 of a lookup table stores the size of the table. If the ReadTable command attempts to read beyond the end of the table, the value 0 will be returned.

For tables with more than 255 elements it is mandatory to use a WORD variable to read the size of the table. See below.

For tables that are defined using an external file the table data will be read into the TestDataSource table from the external file.

An example file is shown below:

The following program will import the external data file.

And the program will out the following:

Advanced use of Lookup Tables

You can use the Table statement to store the data table in EEPROM. If the compiler is told to store a data table in "Data" memory, it will store it in the EEPROM.

NOTE The limitation of of using EPPROM tables is that you can only store BYTEs. You cannot store WORD values in the EEPROM tables.

Here is some example code:

For more help, see ReadTable

About Miscellaneous things…​.

It is possible to combine multiple instructions on a single line, by separating them with a colon. For example, this code:

could also be written as:

In most cases, it will make no difference if commands share a line or not. However, special care should be taken with If commands, as this code:

Will be equivalent to this:

Also, the commands used to start and end subroutines, data tables and functions must be alone on a line. For example, this is WRONG:

About ReadTable

The ReadTable command is used to read information from lookup tables. TableName is the name of the table that is to be read, Item is the line of the table to read, and Output is the variable to write the retrieved value in to.

Syntax:

Command Availability:

Available on all microcontrollers.

Explanation:

Item is 1 for the first line of the table, 2 for the second, and so on. If the Table is more than 256 elements then Item must be WORD variable. Care must be taken to ensure that the program is not instructed to read beyond the end of the table as Zero will be returned.

The type of Output should match the type of data stored in the table. For example, if the table contains Word values then Output should be a Word variable. If the type does not match, Great Cow BASIC will attempt to convert the value.

Example:

For more help, see Lookup Tables

About Scripts

A script is a small section of code that Great Cow BASIC runs when it starts to compile a program. Uses include performing calculations that are required to adjust the program for different chip frequencies.

Scripts are not compiled or downloaded to the microcontroller - Great Cow BASIC reads them, executes them, then removes them from the program and then the results calculated can be used as constants in the user program.

Inside a script, constants are treated like variables. Scripts can read the values of constants, and set them to contain new values.

Using Scripts

Scripts start with #script and end with #endscript. Inside, they can consist of the following commands:

If is similar to the If command in normal Great Cow BASIC code, except that it does not have an Else clause. It is used to compare the values of the script constants.

The = sign is identical to that in Great Cow BASIC programs. The constant that is to be set goes on the left side of the = and the new value goes to the right of the =.

Error is used to display an error message. Anything after the Error command is displayed at the end of compilation, and is saved in the error log for the program.

Warning is used to display a warning message. Anything after the Warning command is displayed at the end of compilation but warning does not halt compilation.

Int() will calculate the integer value of a calculation. Using Int() is critical to set the constant to the integer component of the calculation.

Notes:

Use Warning to display constant values when creating and debugging scripts.

Scripts have a limited syntax and limited error checking when compiling. The compiler may halt if you get something wrong.

Scripts that are incorrectly formatted may also halt the compiler or return unrelated error.

Scripts used for calculations should use the Int( expression ) where you may have a floating point numbers returned.
Scripts do use floating point for all calculations and a failure to use Int() may set the script constant and the resulting constant to 0.

Scripts may require that complex math expressions may require definition in multiple steps/line to simplify the calculation.
The returned value could be incorrect if simplification is not implemented.

Scripts can only access existing constants both user and system defined.

User defines variables are not accessible within the scope of a script.

Scripts has precendence over #define. A #define constant statements are read first, then scripts run. So, a script will always overwrite a constant that was set with #define.

Use Warning to display constants values when creating and debugging scripts.

Example Script

This script is used in the pwm.h file. It takes the values of the user defined constants PWM_Freq, PWM_Duty and system constant ChipMHz and calculates the results using the equations. These calculation are based on information from a Microchip PIC datasheet to calculate the correct values to setup Pulse Width Modulation (PWM).

During the execution of the script the calculations and assignment uses the constants in the script.

After this script has completed the constants PR2Temp, DutyCycleH and DutyCycleL are set using the constants and/or the calculations.

The constants assigned in this script, PR2Temp, DutyCycleH and DutyCycleL, are made available as constants in the user program.

About Subroutines

A subroutine is a small program inside of the main program. Subroutines are typically used when a task needs to be repeated several times in different parts of the main program.

There are two main uses for subroutines:

When the microcontroller comes to a subroutine it saves its location in the current program before jumping to the start of, or calling, the subroutine. Once it reaches the end of the subroutine it returns to the main program, and continues to run the code where it left off previously.

Normally, it is possible for subroutines to call other subroutines. There are limits to the number of times that a subroutine can call another sub, which vary from chip to chip:

These limits are due to the amount of memory on the microcontroller which saves its location before it jumps to a new subroutine. Some Great Cow BASIC commands are subroutines, so you should always allow for 2 or 3 subroutine calls more than your program has.

On 16F chips, the program memory is divided into pages. Each page holds 2048 instructions.    If the program jumps from code on one page to code on another, the compiler has to select the new page.   Having to do this makes the program bigger, so try to avoid this. To keep jumps between pages down, Great Cow BASIC imposes a rule that each subroutine must be entirely within one page, so that only jumps to other subroutines require the page selection.    As an example, say you have two pages of memory, each 2048 instructions (words) long.
If you have a main sub that is 1500 words, and four other subroutines each 600 words long, your total program size would be 3900 words and you might expect it to fit into the 4096 words available.     The problem though is that once the main routine takes 1500 words from page 1, nothing else will fit after it. Three of the 600 word subroutines would fit onto page 2, but that leaves one 600 word subroutine that will not fit into the 500 left on page 1 or the 200 left on page 2.    If you want to reduce the chance of this happening, the best option is to keep your subroutines smaller - move anything out of the main routine and into another one - this will resolve memory page constraints.   

Atmel AVR microcontrollers have no fixed limit on how many subroutines can be called at a time, but if too many are called then some variables on the chip may be corrupted. To check if there are too many subroutines, work out the most that will be called at once, then multiply that number by 2 and create an array of that size. If an out of memory error message comes up, there are too many calls.

Another feature of subroutines is that they are able to accept parameters. These are values that are passed from the main program to the subroutine when it is called, and then passed back when the subroutine ends.

Using Subroutines

To call a subroutine is very simple - all that is needed is the name of the sub, and then a list of parameters. This code will call a subroutine named "Buzz" that has no parameters:

If the sub has parameters, then they should be listed after the name of the subroutine. This would be the command to call a subroutine named "MoveArm" that has three parameters:

Or, you may choose to put brackets around the parameters, like so:

All that this does is change the appearance of the code - it doesn’t make any difference to what the code does. Decide which one meets your own personal preference, and then stick with it.

Creating subroutines

To create a subroutine is almost as simple as using one. There must be a line at the start which has sub, and then the name of the subroutine. Also, there needs to be a line at the end of the subroutine which reads end sub. To create a subroutine called Buzz, this is the required code:

If the subroutine has parameters, then they need to be listed after the name. For example, to define the MoveArm sub used above, use this code:

In the above sub, ArmX, ArmY and ArmZ are all variables. If the call from above is used, the variables will have these values at the start of the subroutine:

When the subroutine has finished running, Great Cow BASIC will copy the values back where possible. NewX will be assigned to ArmX, and NewY will be assigned to ArmY. Great Cow BASIC will not attempt to set the number 10 to ArmZ.

Controlling the direction data moves in

It is possible to instruct Great Cow BASIC not to copy the value back after the subroutine is called. If a subroutine is defined like this:

Then Great Cow BASIC will copy the values to the subroutine, but will not copy them back.

Great Cow BASIC can also be prevented from copying the values back, by adding Out before the parameter name. This is used in the EEPROM reading routines - there is no point copying a data value into the read subroutine, so Out has been used to avoid wasting time and memory. The EPRead routine is defined as Sub EPRead(In Address, Out Data).

Many older sections of code use #NR at the end of the line where the parameters are specified. The #NR means "No Return", and when used has the same effect as adding In before every parameter. Use of #NR is not recommended, as it does not give the same level of control.

Using different data types for parameters

It is possible to use any type of variable a as parameter for a subroutine. Just add As and then the data type to the end of the parameter name. For example, to make all of the parameters for the MoveArm subroutine word variables, use this code:

Optional parameters

Sometimes, the same value may be used over and over again for a parameter, except in a particular case. If this occurs, a default value may be specified for the parameter, and then a value for that parameter only needs to be given in a call if it is different to the default.

For example, suppose a subroutine to create an error beep is required. Normally it emits ! 440 Hz tone, but sometimes a different tone is required. To create the sub, this code would be use:

Note the Optional before the parameter, and the = 440 after it. This tells Great Cow BASIC that if no parameter is supplied, then set the OutTone parameter to 440.

If called using this line:

then a 440 Hz beep will be emitted. If called using this line:

then the sub will produce a 1000 Hz tone.

When using several parameters, it is possible to make any number of them optional. If the optional parameter/s are at the end of the call, then no value needs to be specified. If they are at the start or in the middle, then you must insert commas to allow Great Cow BASIC to tell where the optional parameters are.

Overloading

It is possible to have 2 subroutines with the same name, but different parameters. This is known as overloading, and Great Cow BASIC will automatically select the most appropriate subroutine for each call.

An example of this is the Print routine in the LCD routines. There are actually several Print subroutines; for example, one has a byte parameter, one a word parameter, and one a string parameter. If this command is used:

Then the Print (byte) subroutine will be called. However, if this command is used:

Then the Print (word) subroutine will be called. If there is no exact match for a particular call, Great Cow BASIC will use the option that requires the least conversion of variable types. For example, if this command is used:

The byte print will be used. This is because byte is the closest type to the single bit parameter.

See Also Functions, Exit

About Variables

A variable is an area of memory on the microcontroller that can be used to store a number or a series of letters. This is useful for many purposes, such as taking a sensor reading and acting on it, or counting the number of times the microcontroller has performed a particular task.

Each variable must be given a name, such as "MyVariable" or "PieCounter". Choosing a name for a variable is easy - just don’t include spaces or any symbols (other than _), and make sure that the name is at least 2 characters (letters and/or numbers) long.

Variable Types

There are several different types of variable, and each type can store a different sort of information. These are the variable types that Great Cow BASIC can currently use:

Using Variables

Byte variables do not need any special commands to set them up - just put the name of the variable in to the command where the variable is needed.

Other types of variable can be used in a very similar way, except that they must be "dimensioned" first. This involves using the DIM command, to tell Great Cow BASIC that it is dealing with something other than a byte variable.

A key feature of variables is that it is possible the have the microcontroller check a variable, and only run a section of code if it is a given value. This can be done with the IF command.

String Variables

Strings are defined as follows:

String variables default to the following rules and the RAM constraints of a specific chip.

You cannot store a string 20 characters long in a chip with 16 bytes of RAM.

To change the default string size handled internally by the Great Cow BASIC compiler you add increase/decrease the default string size

Defining a length for the string is the best way to limit memory usage. It is good practice if you need a string of a certain size to set the length of a strings, since the default length for a string variable changes depending on the amount of memory in the microcontroller (see above).

To set the length of a string, see the example below:

To place quotation marks (" ") in a string of text. For example:

Use the following method to show the string with the insertion of two quotation marks in a row as an embedded quotation mark. These two examples apply to all output methods like HerPrint, Print etc.

Variable Aliases

Some variables are aliases, which are used to refer to memory locations used by other variables. These are useful for joining predefined byte variable together to form word variables.

Alias are not like pointers in many languages - they must always refer to the same variable or variables and cannot be changed.

Casting

Casting changes the type of a variable or value. Placing the type that the value should be converted to in square brackets will tell the compiler to convert it. For example, this will cause two byte variables to be treated as word variables by the addition code:

Why do this? If there are no casts, then Great Cow BASIC will add the two values using the byte addition code, and then convert the result to a word to store in MyWord. Suppose that ByteVar is 150, and AnotherByteVar is 231. When added, this will come to 381 - which will overflow, leaving 125 in the result. However, when the cast is added, Great Cow BASIC will treat ByteVar as if it were a word, and so will use the word addition code. This will cause the correct result to be calculated.

Often, a cast will be used when calculating an average:

It’s also possible to cast the second value:

The result will be exactly the same.

Doing things to individual bits of variables see, Set, Rotate

Checking variables and doing different things based on their value, see If, Do, For, Conditions

For more help, see: Declaring variables with DIM, Setting Variables

About Converters

Converters allow Great Cow BASIC to read files that have been created by other programs. A converter can convert these files into Great Cow BASIC libraries or any Great Cow BASIC instruction or a Great Cow BASIC dataset.

A typical use case is when you have a data source file from another computer system and you want to consume the data within your Great Cow BASIC program. The data source file could be database, graphic, reference data or music file. The converter will read these source files and convert them into a format that can be processed by Great Cow BASIC. The conversion process is completed by external application which can be written by the developer or you can use one of the converters provided with the Great Cow BASIC release.

The Great Cow BASIC release includes the converter for BMP files and standard Text files.

With an appropriate Converter installed, and an associated #include to these non-Great Cow BASIC files, Great Cow BASIC will detect that the file extension and hand the processing to the external converting program. When the external converting program had complete, Great Cow BASIC will then continue with the converted source file as a Great Cow BASIC source file.

An example of a converter is to read an existing picture file, convert the picture file to a GCB table and then refer to the picture file table to display the picture file on a GLCD.

Conversion is achieved by including a command within the source program to transform external data. The command used is the instruction #include followed by the data source. An example:

The inclusion of the #include line within a Great Cow BASIC program will enable the commencement of the following process:

For example programs see here.

More about Converters

Example 3 : Converter Program

Example 4 : Dynamic Import

Example 5 : Add build numbers and time/date details to your programs

This converter is used to expose two string variables as follows:

The user code is simple. Using the #include statement specify any filename with an extension must be cnt. As follows:

Complete code would like this - this not optimised - this shows the use of the exposed strings.

This outputs the following - where #20 is the current build and the date/time is correct for build time.

This works as the support INI file instructs the compiler to call a utility that automatically creates a build number tracker file and the supportting string functions. The utility creates a tracker file and the methods files in the same folder as your source program - so, each tracker is specific to each project. The converter requires the following files - these are included within your Installation.

This is the Analog/Digital conversion section of the Help file. Please refer the sub-sections for details using the contents/folder view.

This is the Bitwise section of the Help file. Please refer the sub-sections for details using the contents/folder view.

This is the Memory section of the Help file. Please refer the sub-sections for details using the contents/folder view.

This is the Flow control section of the Help file. Please refer the sub-sections for details using the contents/folder view.

This is the Fixed Voltage Reference section of the Help file. Please refer the sub-sections for details using the contents/folder view.