Micromite Manual

Micromite
User Manual
MMBasic Ver 5.05.05
For updates to this manual and more details on MMBasic go to

http://geoffg.net/micromite.html
and http://mmbasic.com
Copyright
The Micromite firmware including MMBasic and this manual are Copyright 2011-2021 by Geoff Graham.
I2C Support is Copyright 2011 Gerard Sexton.

1-Wire Support is Copyright 1999-2006 Dallas Semiconductor Corporation and 2012 Gerard Sexton.
On the Micromite Plus:

M-Stack USB/CDC driver is Copyright 2013 Alan Ott and Signal 11 Software
FatFs (SD Card) driver is Copyright (C) 2014, ChaN.
The USB VID and PIDs are sublicensed by Microchip Technology Incorporated for this project.
The compiled object code (the .hex file) for the Micromite is free software: you can use or redistribute it as you
please. The source code is available via subscription (free of charge) to individuals for personal use or under a
negotiated license for commercial use. In both cases go to http://mmbasic.com for details.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
This manual is distributed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Australia

license (CC BY-NC-SA 3.0)
Contributions
Acknowledgement and thanks to Phil Boyce (WhiteWizard) for supporting the Micromite's development with
much needed hardware, Peter Carnegie (G8JCF) for his help in developing the CFunction functionality and
Gerard Sexton who developed the I2C and 1-Wire support for the original Maximite.
A very big thanks to Peter Mather (matherp) for his ongoing support including introducing low cost LCD
panels, writing the ILI9341 and ST7735S drivers, doing the original port to the MX470 and MZ chips, porting
the M-Stack USB/CDC and FatFs drivers, pushing the implementation of CFunctions to new heights and the
uncountable number of bugs that he has found and documented. Thank you very much Peter.
Also thanks to the members of the Back Shed forum who have beta tested the Micromite firmware over the past
few years and reported many, many bugs. Thanks guys.
Micromite User Manual Page 2

Contents
Introduction............................................................................................................................. 4
Suitable Microcontrollers ........................................................................................................ 5
28-pin Micromite Connections ................................................................................................ 6
44-pin Micromite Connections ................................................................................................ 7
Programming the Firmware .................................................................................................... 8
Console Connection ............................................................................................................... 9
Quick Start Tutorial ............................................................................................................... 11
Using MMBasic..................................................................................................................... 13
Micromite Special Features .................................................................................................. 14
LCD Displays ........................................................................................................................ 18
Touch Support ...................................................................................................................... 20
Using an LCD Panel ............................................................................................................. 21
Micromite LCD Backpack ..................................................................................................... 24
Special Device Support ........................................................................................................ 26
Full Screen Editor ................................................................................................................. 32
Defining and Using Variables ............................................................................................... 34
Using the I/O pins ................................................................................................................. 38
Timing................................................................................................................................... 41
Defined Subroutines and Functions...................................................................................... 42
Special Functions and the Library ........................................................................................ 47
Electrical Characteristics ...................................................................................................... 51
MMBasic Characteristics ...................................................................................................... 52
Predefined Read Only Variables .......................................................................................... 54
Commands ........................................................................................................................... 55
Functions .............................................................................................................................. 78
Obsolete Commands and Functions .................................................................................... 84
Appendix A – Serial Communications .................................................................................. 85
Appendix B – I2C Communications ...................................................................................... 89
Appendix C – 1-Wire Communications ................................................................................. 92
Appendix D – SPI Communications...................................................................................... 93

Introduction
The Micromite is a low cost Microchip PIC32 microcontroller programmed
with the MMBasic firmware.
MMBasic is a Microsoft BASIC compatible implementation of the BASIC
language with floating point, integer and string variables, arrays, long variable
names, a built in program editor and many other features.
Using MMBasic you can use communications protocols such as I2C or SPI to
get data from a variety of sensors. You can display data on low cost colour
LCD displays, measure voltages, detect digital inputs and drive output pins to
turn on lights, relays, etc. All from inside this cheap microcontroller.
Everything is internal to the Micromite and it will run from a couple of AA batteries. The only extra
component required is a 47 µF capacitor. The 28-pin dual in line version is particularly easy to use as it can be
easily soldered or plugged into an IC socket. Even better, it costs just $4.
In summary the features of the Micromite are:
 A fast 32 bit CPU with 256 KB of flash and 64 KB RAM running a powerful BASIC interpreter. 59 KB
of non volatile flash memory is reserved for the program, 52 KB of RAM is available for BASIC
variables, arrays, buffers, etc. This is sufficient for quite large BASIC programs up to 2500 lines or more.
 The BASIC interpreter is full featured with floating point, 64-bit integers and string variables, long
variable names, arrays of floats, integers or strings with multiple dimensions, extensive string handling
and user defined subroutines and functions. Typically it will execute a program at 30,000 lines per
second. MMBasic allows the embedding of compiled C programs for high performance functions and
the running program can be protected from being listed or modified by a PIN number.
 Nineteen input/output pins are available on the 28-pin chip and 33 on the 44-pin chip. These can be
independently configured as digital input or output, analog input, frequency or period measurement and
counting. Within MMBasic the I/O pins can be dynamically configured as inputs or outputs with or
without pullups or pulldowns. MMBasic commands will generate pulses and can be used to transfer data
in parallel. Interrupts can be used to notify when an input pin has changed state. Up to five PWM or
SERVO outputs can be used to create various sounds, control servos or generate computer controlled
voltages for driving equipment that uses an analogue input (eg, motor controllers).
 TFT LCD display panels using the ILI9341 and other controllers are supported allowing the BASIC
program to display text and draw lines, circles, boxes, etc in 65,535 colours. Resistive touch controllers
on these panels are also supported allowing them to be used as sophisticated input devices. These LCD
panels typically cost US$7 and provide a low cost, high tech graphical user interface.
 Programming and control is done via a serial console (TTL voltage levels) at 38400 baud
(configurable). Once the program has been written and debugged the Micromite can be instructed to
automatically run the program on power up with no user intervention. Special software is not needed to
develop programs.
 A full screen editor is built into the Micromite. This only requires a VT100 terminal emulator and can
edit the whole program in one session. It includes advanced features such as colour coded syntax, search
and copy, cut and paste to and from a clipboard.
 Programs can be easily transferred from another computer (Windows, Mac or Linux) using the
XModem protocol or by streaming the program over the serial console input.
 A comprehensive range of communications protocols are implemented including I2C, asynchronous
serial, RS232, IEEE 485, SPI and 1-Wire. These can be used to communicate with many sensors
(temperature, humidity, acceleration, etc) as well as for sending data to test equipment.
 The Micromite has built in commands to directly interface with infrared remote controls, the DS18B20
temperature sensor, LCD display modules, battery backed clock, numeric keypads and more.
 Special embedded controller features in MMBasic allow the CPU to be put to sleep or the clock speed
to be varied to balance power consumption and speed. A watchdog feature will monitor the running
program and can be used to restart the processor if the program fails with an error or is stuck in a loop.
 Power requirements are 2.3 to 3.6 volts at 6 to 31 mA.

Suitable Microcontrollers
The standard Micromite firmware will run on the following PIC32 microcontroller manufactured by Microchip.
These are available from Microchip (http://www.microchipdirect.com) or their distributors – use Octopart
(http://octopart.com) to search for suppliers.
See http://microchip.com for the data sheets.
28-pin Chips
The best chip to use is the PIC32MX170F256B-50I/SP which is guaranteed to run up to 48MHz (the maximum
Micromite speed) and is in a 28-pin DIL package. It costs about $4 direct from Microchip. There is a 40 MHz
variant (the PIC32MX170F256B-I/SP) which is a little cheaper. All of the 40 MHz chips tested have run fine at
48 MHz so this chip is also a good option.
The following is a summary of the recommended chips for the Micromite in a 28-pin package:
PIC32MX170F256B-50I/SP Guaranteed to run at 48 MHz. 28-pin DIL package.
PIC32MX170F256B-50I/SO As above but is in a surface mount SOIC package
PIC32MX170F256B-I/SP Should run at 48 MHz despite its 40 MHz spec. 28-pin DIL package.
PIC32MX170F256B-I/SO As above but is in a surface mount SOIC package
The firmware will also run on the PIC32MX270F256 series of chips. These have built in USB (which is not
supported in the Micromite) and therefore you lose access to two I/O pins (pins 15 and 23) which are used in
the chip for dedicated USB functions. In addition pins 21 and 22 are not 5V tolerant.
44-pin Chips
The best chip to use is the PIC32MX170F256D-50I/PT which is guaranteed to run up to 48 MHz and costs a
little over $4 when purchased from Microchip. Similar to the 28-pin package there are versions rated at 40
MHz and versions with USB - with the latter MMBasic does not support USB and you lose access to two I/O
pins which are reserved for USB functions (pins 10 and 42).
The following is a summary of the recommended chips for the Micromite in a 44-pin package:
PIC32MX170F256D-50I/PT Guaranteed to run at 48 MHz.
PIC32MX170F256DI/PT Should run at 48 MHz despite its 40 MHz rating.
These chips are in a TQFP surface mount package with a lead pitch of 0.8mm. This is reasonably easy to
solder and the chip can be mounted on a carrier board (for example futurlec.com part code 44PINTQFP) which
brings the pins out on an easy to use 0.1 inch grid.
The Micromite firmware file will work with either the 28 or 44-pin chips. The only difference is that the 44-
pin chip has an extra fourteen I/O pins that are accessible from within MMBasic.
PICMX150 Series Chips

The first versions of the Micromite firmware ran on the PIC32MX150F128 series of chips. The firmware
described in this manual will only run on the newer PIC32 chips listed above however the firmware for the
original Micromite running on the MX150 series of chips is still available. It can be found in the download
section of http://geoffg.net/micromite.html and is supplied with its own manual.

28-pin Micromite Connections
The following diagram shows the possible functions of each I/O pin on the Micromite.
Note that the physical pins on the chip and the pin numbers used in MMBasic are the same. This means that
nine pins are not available in MMBasic as they are dedicated to functions such as power and ground. These
pins are shaded in grey in the diagram.

RESET Wired to +V directly or via a 10K resistor 1 28 ANALOG POWER (+2.3 to +3.6V)
DIGITAL | ANALOG 2 27 ANALOG GROUND
SPI OUT | DIGITAL | ANALOG 3 26 ANALOG | DIGITAL | PWM 2A
PWM 1A | DIGITAL | ANALOG 4 25 ANALOG | DIGITAL | SPI CLOCK
PWM 1B | DIGITAL | ANALOG 5 24 ANALOG | DIGITAL | PWM 2B
PWM 1C | DIGITAL | ANALOG 6 23 ANALOG | DIGITAL
COM1: ENABLE | DIGITAL | ANALOG 7 22 DIGITAL | 5V | COM1: RECEIVE
GROUND 8 21 DIGITAL | 5V | COM1: TRANSMIT
COM2: TRANSMIT | DIGITAL 9 20 47µF 16V TANT CAPACITOR (+)
COM2: RECEIVE | DIGITAL 10 19 GROUND
CONSOLE Tx (DATA OUT) 11 18 DIGITAL | 5V | COUNT | I2C DATA
CONSOLE Rx (DATA IN) 12 17 DIGITAL | 5V | COUNT | I2C CLOCK
POWER (+2.3 to +3.6V) 13 16 DIGITAL | 5V | COUNT | WAKEUP | IR
SPI IN | 5V | DIGITAL 14 15 DIGITAL | 5V | COUNT
The notation is as follows (the mnemonic in brackets is the mode used in the SETPIN command):
ANALOG These pins can be used to measure voltage (AIN).
DIGITAL Can be used for digital I/O including digital input (DIN) and digital output (DOUT).
COUNT Can be used to measure frequency (FIN), period (PIN) or counting (CIN).
5V These pins can be connected to 5V circuits. All other I/O pins are strictly 3.3V maximum.
COM xxx Can be used for serial communications (see Appendix A).
2
I C xxx Can be used for I2C communications (see Appendix B).
SPI xxx Can be used for SPI I/O (see Appendix D).
PWM xxx Can be used for PWM or SERVO output (see the PWM and SERVO commands).
IR This can be used to receive signals from an infrared remote control (see the IR command).
WAKEUP This pin can be used to wake the CPU from a sleep (see the CPU SLEEP command).
Pins 27 and 28 are the ground and power for analog measurements. Normally they are connected to the general
ground and power (pins 8 and 13) but if you require noise free and accurate analog readings you should make
sure that the power on pin 28 is regulated to precisely 3.3V and well filtered. Also your analog inputs should
be referenced to pin 27 (the analog ground).
Within MMBasic the SETPIN command is used to set the function of an I/O pin for general I/O. The PIN
command or function is then used to interact with the pin. For example, this will print out the voltage on pin 7:
SETPIN 7, AIN
PRINT "The voltage is" PIN(7) "V"
This voltage reading is referenced to pin 28 and assumes that the supply voltage on this pin is exactly 3.3V.
You will need to scale the readings in your BASIC program if you use a supply voltage other than this.

44-pin Micromite Connections
The following diagram shows the possible functions of each I/O pin on the 44-pin Micromite.
Note that the physical pins on the chip and the pin numbers used in MMBasic are the same. This means that
eleven pins are not available in MMBasic (these pins are shaded in grey).
Pin 23
Pin 34
Pin 12
Pin 1
Pin Pin
ANALOG | DIGITAL | PWM 1C 23 22 PWM 1B | DIGITAL | ANALOG
ANALOG | DIGITAL | COM1: ENABLE 24 21 PWM 1A | DIGITAL | ANALOG
ANALOG | DIGITAL 25 20 SPI OUT (MOSI) | DIGITAL | ANALOG
ANALOG | DIGITAL 26 19 DIGITAL | ANALOG
ANALOG | DIGITAL 27 18 RESET Wired to +V directly or via 10K resist
POWER (+2.3 to +3.6V) 28 17 ANALOG POWER (+2.3 to +3.6V)
GROUND 29 16 ANALOG GROUND
DIGITAL | COM2: TRANSMIT 30 15 PWM 2A | DIGITAL | ANALOG
DIGITAL | COM2: RECEIVE 31 14 SPI CLOCK | DIGITAL | ANALOG
DIGITAL | 5V 32 13 5V | DIGITAL
CONSOLE Tx (DATA OUT) 33 12 5V | DIGITAL
CONSOLE Rx (DATA IN) 34 11 PWM 2B | DIGITAL | ANALOG

DIGITAL | 5V 35 10 DIGITAL | ANALOG
DIGITAL 36 9 COM1: RECEIVE | 5V | DIGITAL
DIGITAL | 5V 37 8 COM1: TRANSMIT | 5V | DIGITAL
DIGITAL | 5V 38 7 47µF 16V TANT CAPACITOR (+)
GROUND 39 6 GROUND
POWER (+2.3 to +3.6V) 40 5 5V | DIGITAL
DIGITAL | 5V | SPI IN (MISO) 41 4 5V | DIGITAL
DIGITAL | 5V | COUNT 42 3 5V | DIGITAL
DIGITAL | 5V | COUNT | WAKEUP | IR 43 2 5V | DIGITAL
2 2
DIGITAL | 5V | COUNT | I C CLOCK 44 1 I C DATA | COUNT | 5V | DIGITAL
The notation is the same as described for the 28-pin version.

Programming the Firmware
28-pin Chips
To program the Micromite firmware into the microcontroller you need a suitable programmer. Probably the
best is the Microchip PICkit 3 which is reasonably cheap at US$45 and clones can be purchased on the Internet
for less than $20. If you install Microchip's MPLAB X (free from Microchip) it will also install MPLAB IPE
which you can use with the PICkit 3 to program the chip. See geoffg.net/programming_pics.html for details.
These are the connections required for programming the 28-pin chip:
2.3 to 3.6V
26mA
PICKit 3 1 28
Connector
10K
1 - MCLR 27
2 - Vcc 4
3 - GND
4 - PGD
5 - PGC
6 - NC 5
8
20
+
19 47µF 16V
Ceramic or
Tantalum
13
44-pin Chips
Programming these is similar to programming the 28-pin version. Refer to the following table for the pin
connections on the microcontroller:
PICkit 3 Description 44-pin chip
47µF 16V Tantalum Capacitor to GND 7
1 - MCLR Master Reset (active low) 18
2 - Vcc Power Supply (3.3V) 17, 28 and 40
3 - GND Ground 6, 16, 29 and 39
4- PGD Programming Data 21
5 - PGC Programming Clock 22
6 - NC Not used
Notes:
 A pullup resistor of 10 K is required between the MCLR pin and Vcc.
 The microcontroller being programmed can be powered by the PICkit 3 but it is recommended that a
separate power supply be used. When the PICkit 3 supplies the power pin 2 (Vcc) on the PICkit 3 will
become an output supplying the power to the chip being programmed.

Console Connection
To write and debug your BASIC programs and configure the Micromite you use the console. This is a serial
interface running at 38400 baud which uses TTL signal levels. This is similar to the RS232 interface on older
personal computers but the TTL signal level is inverted and swings from zero to 3.3V.
There are many USB to serial converters on the market. These provide a TTL level serial interface on one side
and a USB interface on the other. When connected to your computer the converter will appear as a virtual
serial port. Recommended are converters based on the Silicon Labs CP2102 chip, they can be found on eBay
for a few dollars (search for "CP2102") and work perfectly with the Micromite. You should avoid converters
based on the FTDI FT232RL chip as many Chinese manufacturers use non genuine chips which will not work
with the current Windows drivers.
The serial interface side of the converter will generally have a ground pin and a 3.3V power output pin and this
can be used to power the Micromite. The converter will also have two pins marked TX (or similar) for transmit
and RX (or similar) for receive. The TX pin of the serial converter must go to the RX pin of the Micromite and
the RX pin must go to the TX pin.
If you have a serial converter that operates at 5V you can still use it with the Micromite. All you need do is
place a 1K resistor in series with the transmit signal from the converter. The resistor will limit the current to a
safe level.
Below is a typical connection using the CP2102 converter. Note that the 3.3V output from the converter can be
as high as 4.3V so check its voltage first if you want to use it to power the Micromite (maximum is 3.6V).
USB Pin 11 (28-pin MM) or pin 33 (44-pin MM)

Pin 12 (28-pin MM) or pin 34 (44-pin MM)
CP2102
USB – Serial
Converter
When you plug the USB side of the converter into your
computer you may have to load a driver to make it work with
the operating system. Once this is done you should note the port
number created by your computer for the virtual serial
connection. In Windows this can be done by starting Device
Manager and checking the "Ports (COM & LPT)" entry for a
new COM port as shown on the right.
Terminal Emulator
You also need a terminal emulator program on your desktop
computer. This program acts like an old fashioned computer
terminal where it will display text received from a remote
computer and any key presses will be sent to the remote
computer over the serial link.
The terminal emulator that you use should support VT100
emulation as that is what the editor built into the Micromite
expects. For Windows users it is recommended that you use
Tera Term as this has a good VT100 emulator and is known to
work with the XModem protocol which you can use to transfer
programs to and from the Micromite (Tera Term can be
downloaded from: http://tera-term.en.lo4d.com/).
The terminal emulator and the serial port that it is using should be
set to the Micromite standard of 38400 baud, 8 data bits and one
stop bit. The screen shot on the right shows the setup for Tera
Term. Note that the "Port:" setting will vary depending on which
USB port your USB to TTL serial converter was plugged into.

If you are using Tera Term do not set a delay between characters and if you are using Putty set the backspace
key to generate the backspace character.
When you have the serial port and terminal emulator setup you can apply power to the Micromite and you
should see the MMBasic banner and prompt on your screen similar to that shown below.
Troubleshooting
If you cannot see the startup banner try disconnecting the USB-serial converter and join its TX and RX pins.
Then try typing something into the terminal emulator. You should see your characters echoed back, if not it
indicates a fault with the converter or the terminal emulator.
If the USB-serial converter checks out the fault could be related to the console connection to the Micromite.
Make sure that TX connects to RX and vice versa and that the baudrate is 38400. If you have an oscilloscope
you should be able to see a burst of activity on the Micromite's TX line on power up. This is the Micromite
sending its startup banner.
Apple Macintosh
The Apple Macintosh (OS X) is somewhat easier as it has the device driver and terminal emulator built in.
First start the application ‘Terminal’ and at the prompt list the connected serial devices by typing in:
ls /dev/tty.*.
The USB to serial converter will be listed as something like /dev/tty.usbmodem12345. While still at the
Terminal prompt you can run the terminal emulator at 38400 baud by using the command:
screen/dev/tty.usbmodem12345 38400
By default the function keys will not be correctly defined for use in the Micromite's built in program editor so
you will have to use the control sequences as defined in the section Full Screen Editor of this manual.. To
avoid this you can reconfigure the terminal emulator to generate these codes when the appropriate function
keys are pressed.
Shortcut Keys
When you are using a VT100 compatible terminal emulator on the console you can use the following function
keys to insert a command at the command prompt:
F2 RUN
F3 LIST
F4 EDIT
F10 AUTOSAVE
F11 XMODEM RECEIVE
F12 XMODEM SEND
Pressing the key will insert the text at the command prompt, just as if it had been typed on the keyboard.

Quick Start Tutorial
The following assumes that you have programmed MMBasic into a suitable microcontroller and that you have
the console connected to a suitable terminal emulator (see the previous chapter).
Basic Circuit
The basic circuit for the 28-pin Micromite is shown below. It is recommended that you experiment with it
using a plug in breadboard with jumper leads. Later, when you have finalised your design, you can create a
printed circuit board to hold the final circuit.
Note that the 10K resistor is necessary if you later need to update the Micromite firmware using a PIC
programmer. If this will never happen you can replace it with a wire link (ie, connect pin 1 direct to 3.3V).
Power Supply
2.3 to 3.6V 26mA
Can be 2 x AA batteries
or a nominal 3.3V
power supply 1 28
10K
27
Serial Console
VT100 Terminal or
USB to TTL Converter
38400 baud
8 bits no parity one stop bit 8
20
TTL Voltage Levels
+
Data from Micromite 19 47µF 16V
Rx
11
Ceramic or
Serial
Tx
Data to Micromite 12 Tantalum
Terminal
Gnd
13
Power Supply
The Micromite needs a power supply between 2.3V and 3.6V connected as shown above. Normally the current
drain is 26mA plus the drain of any external components (LEDS, etc). Two alkaline AA cells can provide a
convenient power source or you can use a conventional power supply.
Generally it is a good design technique to place a 100nF ceramic capacitor close to each of the power supply
pins but this is not critical and they are not shown in this diagram.
The capacitor connected to pin 20 is used to decouple and stabilise the 1.8V voltage regulator internal to the
PIC32 chip. It must be a high quality capacitor (not an electrolytic) and should have a minimum value of 10 µF
with an ESR (Equivalent Series Resistance) of less than 1Ω. The recommended capacitor is a 47 µF 16V
tantalum or a 10 µF 16V X7R multilayer ceramic.
A Simple Program
Assuming that you have correctly connected a terminal emulator to the Micromite and have the command
prompt (the greater than symbol as shown above, ie, > ) you can enter a command line followed by the enter
key and it will be immediately run.
For example, if you enter the command PRINT 1/7 you should see this:
> PRINT 1/7
0.142857

>
This is called immediate mode and is useful for testing commands and their effects.
To enter a program you can use the EDIT command which is fully described later in this manual. However to
get a quick feel for how it works, try this sequence (your terminal emulator must be VT100 compatible):
 At the command prompt type EDIT followed by the ENTER key.
 The editor should start up and you can enter this line: PRINT "Hello World"
 Press the F1 key in your terminal emulator (or CTRL-Q which will do the same thing). This tells the
editor to save your program and exit to the command prompt.
 At the command prompt type RUN followed by the ENTER key.
 You should see the message: Hello World
Congratulations. You have just written and run your first program on the Micromite. If you type EDIT again
you will be back in the editor where you can change or add to your program.
Flashing a LED
Connect a LED to pin 15 as shown in the diagram on the right.
Then use the EDIT command to enter the following program:
SETPIN 15, DOUT
DO 15
PIN(15) = 1
PAUSE 300 82 LED
PIN(15) = 0 ohms
PAUSE 300
LOOP
When you have saved and run this program you should be greeted by the LED flashing on and off. It is not a
great program but it does illustrate how your Micromite can interface to the physical world via your
programming.
The chapter "Using the I/O pins" later in this manual provides a full description of the I/O pins and how to
control them.
Setting the AUTORUN Option

You now have the Micromite doing something useful (if you can call flashing a LED useful). Assuming that
this is all that you want the Micromite to do you can then instruct it to always run this program whenever power
is applied.
To do this you first need to regain the command prompt and you can do this by entering CTRL-C at the
console. This will interrupt the running program and return you to the command prompt.
Then enter the command:
OPTION AUTORUN ON
This instructs MMBasic to automatically run your program whenever power is applied. To test this you can
remove the power and then re apply it. The Micromite should start up flashing the LED.
If this is all that you want you can disconnect the serial console and it will sit there flashing the LED on and off
forever. If ever you wanted to change something (for example the pause between on and off) you can attach
your terminal emulator to the console, interrupt the program with a CTRL-C and edit it as needed.
This is the great benefit of the Micromite, it is very easy to write and change a program.

Using MMBasic
Commands and Program Input

At the command prompt you can enter a command and it will be immediately run. Most of the time you will
do this to tell the Micromite to do something like run a program or set an option. But this feature also allows
you to test out commands at the command prompt.
To enter a program the easiest method is to use the EDIT command. This will invoke the full screen program
editor which is built into the Micromite and is described later in this manual. It includes advanced features
such as search and copy, cut and paste to and from a clipboard.
You could also compose the program on your desktop computer using something like Notepad and then
transfer it to the Micromite via the XModem protocol (see the XMODEM command) or by streaming it up the
console serial link (see the AUTOSAVE command).
A third and very convenient method of writing and debugging a program is to use MMEdit. This is a program
running on your Windows computer which allows you to edit your program on your computer then transfer it to
the Micromite with a single click of the mouse. MMEdit was written by Jim Hiley and can be downloaded for
free from https://www.c-com.com.au/MMedit.htm.
With all of these methods of entering and editing a program the result is saved in non volatile flash memory
(this is transparent to the user). With the program held in flash memory it means that it will never be lost, even
when the power is unexpectedly interrupted or the processor restarted.
One thing that you cannot do is use the old BASIC way of entering a program which was to prefix each line
with a line number. Line numbers are optional in MMBasic so you can still use them if you wish but if you
enter a line with a line number at the prompt MMBasic will simply execute it immediately.
Line Numbers, Program Structure and Editing

The structure of a program line is:
[line-number] [label:] command arguments [: command arguments] …
A label or line number can be used to mark a line of code.
A label has the same specifications (length, character set, etc) as a variable name but it cannot be the
same as a command name. When used to label a line the label must appear at the beginning of a line
but after a line number (if used), and be terminated with a colon character (:).
Commands such as GOTO can use labels or line numbers to identify the destination (in that case the label does
not need to be followed by the colon character). For example:
GOTO xxxx
- - -
xxxx: PRINT "We have jumped to here"
Multiple commands separated by a colon can be entered on the one line (as in INPUT A : PRINT B).
Running Programs
A program is set running by the RUN command. You can interrupt MMBasic and the running program at any
time by typing CTRL-C on the console input and MMBasic will return to the command prompt.
You can list a program in memory with the LIST command. This will print out the program while pausing
every 24 lines.
You can completely erase the program by using the NEW command.
A program in the Micromite is held in non volatile flash memory. This means that it will not be lost if the
power is removed and, if you have the AUTORUN feature turned on, the Micromite will start by automatically
running the program when power is restored (use the OPTION command to turn AUTORUN on).
Setting Options
Many options can be set by using commands that start with the keyword OPTION. They are listed in the
commands section of this manual. For example, you can set the baud rate of the console with the command:
OPTION BAUDRATE 9600

Micromite Special Features
Saved Variables
Because the Micromite does not necessarily have a normal storage system (such as an SD card) it needs to have
a facility to save some data that can be recovered when power is restored. This can be done with the VAR
SAVE command which will save the variables listed on its command line in non volatile flash memory. The
space reserved for saved variables is 2KB on the standard Micromite and 4K on the Micromite Plus.
These variables can be restored with the VAR RESTORE command which will add all the saved variables to
the variable table of the running program. Normally this command is placed near the start of a program so that
the variables are ready for use by the program.
This facility is intended for saving calibration data, user selected options and other items which change
infrequently. It should not be used for high speed saves as you may wear out the flash memory.
The flash in the PIC32 chips used for the Micromite have a high endurance of over 20,000 writes and erases.
With normal use this will never be reached but it can be exceeded by a program that repeatedly saves variables.
For example, a program that saved a set of variables once a second would wear out the flash in six hours while
a program that saved the same data once a day would run for over 50 years and still not wear out the flash.
If you do want to save data often it would be worth adding a real time clock chip to the Micromite design. The
RTC SETREG and RTC GETREG commands can then be used to store and retrieve data from the RTC's
battery backed memory. See the RTC command for more details. Another option is to use a Microchip 11XX
series EEPROM which can be rewritten up to a million times. A driver for these is included in the Embedded C
Modules folder in the Micromite firmware zip file.
CPU Speed Control

MMBasic provides the ability to control the clock speed of the Micromite via the CPU command. The current
drawn by the chip is proportional to the clock speed so this command can be used to balance the requirements
of performance and low current drain. The default speed on power up or reset is 40MHz.
The available clock speeds and typical current draw are:
CPU Speed Typical Current Draw
48 MHz 31 mA
40 MHz (default) 26 mA
30 MHz 21 mA
20 MHz 15 mA
10 MHz 10 mA
5 MHz 6 mA
1 MHz Note 1 1.5 mA
0.5 MHz Note 1 1 mA
The Micromite Plus can run up to 120 MHz. See the Micromite Plus Manual for more details.
When the clock speed is changed all the serial ports (including the console) will be unaffected although there
may be a small glitch at the time of the change. The internal clocks and timers will also be unaffected. PWM,
SPI and I2C will have their speeds changed proportionally so if this is not required they should be closed before
the change and reopened after.
Note 1: CPU speeds of 1MHz and 0.5MHz are intended for applications where minimising the power
consumption is critical. At these speeds the BASIC program will run noticeably slower and the following
commands and features will not work; tick timers (ie, SETTICK), I2C functions, PULSE, TEMPR(), IR and
counting inputs (ie, frequency, period, etc). COM2: will not work and the other ports (serial, SPI, PWM, etc)
will have their maximum speed severely limited.
At 1MHz the maximum console speed is 4800 baud and at 0.5MHz it is 2400 baud. This means that to
continue using the console the default speed (38400 baud) must be changed using OPTION BAUDRATE
before the CPU command is used.

CPU Sleep
The CPU SLEEP command will put the processor to sleep for a certain number of seconds or monitor the
WAKEUP pin for a wakeup signal. During sleep the current drain is less than 40 µA.
Normal use for the command is CPU SLEEP sec and in that case the CPU will sleep for the specified number
of seconds (sec). The sleep time can be quite short (say 5 seconds) and, on waking up, the program can make a
quick check and if there is nothing to do go back to sleep again. Because the time awake would be so short the
average current drain would be small. Alternatively the sleep can be aborted early by a change in state of an
I/O pin. Eg: CPU SLEEP sec, abortpin. Note that due to the characteristics of the PIC32 microcontroller it
could take the Micromite up to a second before it will react to the change on abortpin.
If the timeout is not specified this command will automatically configure the WAKEUP pin as a digital input.
During sleep this pin will be monitored and the CPU woken up when its input changes state (ie, goes from high
to low or low to high). The wakeup signal could be a button press, an incoming signal or some other external
interrupt. This form of wakeup us very fast (< 1ms).
In this mode the sleep function will also work with the IR command (for receiving key presses from a remote
control) which shares the same I/O pin as the wakeup function. This means that an IR signal can be used to
wakeup the Micromite which will then immediately decode the signal. The program can then do whatever it
needs to do in response to the remote control key press then go back to sleep and wait for the next command.
Reducing Sleep Current
The sleep current can be affected by many factors other than the base sleep current (which can be as low as
40µA). These are some of the factors to consider:
 Don't leave I/O pins floating. If an I/O pin is not held high or low by external circuitry set it to an output.
 Disconnect the console.
 I/O pins will still source or sink current, even in sleep. Before entering sleep make sure that all I/O pins
are in a state that will not do this.
 Close any communications channels that are open. This especially includes serial and I2C.
 Stop any PWM or SERVO outputs.
 Disable any I/O pins that are used for measuring frequency, period and/or counting.
If you are having difficulty achieving a low sleep current consider connecting a Micromite into a simple circuit
with nothing attached and set all I/O pins to digital outputs. Use NEW to clear the program memory and
measure the current drawn when CPU SLEEP is entered at the command prompt and the console disconnected.
This is the target current draw (it should be around 40µA) and you can then measure the effect as you add
external circuitry and software features.
Watchdog Timer
The main use for the Micromite is as an embedded controller. It can be programmed in MMBasic and when
the program is debugged and ready for "prime time" the AUTORUN configuration setting can be turned on.
The chip will then automatically run its program when power is applied and act as a custom integrated circuit
performing some special task. The user need not know anything about what is running inside the chip.
However there is the possibility that a fault in the program could cause MMBasic to generate an error and
return to the command prompt. This would be of little use in an embedded situation as the Micromite would
not have anything connected to the console. Another possibility is that the BASIC program could get itself
stuck in an endless loop for some reason. In both cases the visible effect would be the same… the program
would stop running until the power was cycled.
To guard against this the watchdog timer can be used. This is a timer that counts down to zero and when it
reaches zero the processor will be automatically restarted (the same as when power was first applied), this will
occur even if MMBasic was sitting at the command prompt. Following the restart the automatic variable
MM.WATCHDOG will be set to true to indicate that the restart was caused by a watchdog timeout.
The WATCHDOG command should be placed in strategic locations in the program to keep resetting the timer
and therefore preventing it from counting down to zero. Then, if a fault occurs, the timer will not be reset, it
will count down to zero and the program will be restarted (assuming the AUTORUN option is set).
PIN Security
Sometimes it is important to keep the data and program in an embedded controller confidential. In the
Micromite this can be done by using the OPTION PIN command. This command will set a pin number (which

is stored in flash) and whenever the Micromite returns to the command prompt (for whatever reason) the user at
the console will be prompted to enter the PIN number. Without the correct PIN the user cannot get to the
command prompt and their only option is to enter the correct PIN or reboot the Micromite. When it is rebooted
the user will still need the correct PIN to access the command prompt.
Because an intruder cannot reach the command prompt they cannot list or copy a program, they cannot change
the program or change any aspect of MMBasic or the Micromite. Once set the PIN can only be removed by
providing the correct PIN as set in the first place. If the number is lost the only method of recovery is to reset
MMBasic as described below (which will erase the program).
There are other time consuming ways of accessing the data (such as using a PIC32 programmer to examine the
flash memory) so this should not be regarded as the ultimate security but it does act as a significant deterrent.
The Serial Console

Using the OPTION BAUDRATE command the baud rate of the console can be changed to any speed up to
230400 bps. Changing the console baud rate to a higher speed makes the full screen editor much faster in
redrawing the screen. If you have a reliable connection to the Micromite it is worth changing the speed to at
least 115200.
Once changed the console baud rate will be permanently remembered unless another OPTION BAUDRATE
command is used to change it. Using this command it is possible to accidently set the baud rate to an invalid
speed and in that case the only recovery is to reset MMBasic as described below.
When running as an embedded controller the serial console may no longer be required for programming. On
the standard Micromite it can then be used as a third serial port and OPTION BAUDRATE used to set the
required speed. If you do this it might be worth using the OPTION BREAK command to disable the break key
to prevent an unintended CTRL-C in the console receive data from halting the running program.
Other useful options are OPTION CONSOLE NOECHO which will stop MMBasic from automatically echoing
characters received on the console and OPTION CONSOLE INVERT which will invert the data on the transmit
and receive lines so that it can be used with RS232 devices.
Resetting MMBasic
MMBasic can be reset to its original configuration using either one of two methods:
 The chip can be reprogrammed with the Micromite firmware using a PIC32 programmer.
 Sending a stream of exclamation marks (!) to the console Rx pin at 38400 baud during its startup.
In the first 100 ms after powering up the Micromite will set the console to 38400 baud and check to see if
an exclamation mark is received. If so, it will then wait for two seconds to see if it is going to get more
than 30 of them in that time. If this is the case the Micromite will reset itself to its initial defaults and
send the message "MMBasic reset completed" to the console.
This reset can be accomplished by simply setting the terminal emulator to 38400 baud and holding down
the exclamation key and rely on the automatic keyboard repeat while powering up the Micromite (on
most keyboards this requires holding down shift and the number one key). This will even work if the
console has been set to a non standard baud rate.
Either method will result in the program memory and saved variables being completely erased and all options
(security PIN, console baud rate, etc) will be reset to their initial defaults.
Single, Secure HEX File

If you write a program for the Micromite and set the following options:
OPTION BREAK 0
OPTION AUTORUN ON
you will end up with a program that cannot be stopped or interrupted. To further bullet proof it you could use
the watchdog timer and OPTION PIN.
You can then use a PICkit3 and MPLAB IPE to read the complete flash memory of the Micromite and export it
as a hex file. This will contain the Micromite firmware as well as your BASIC program and the above options.
This file can be sent to someone as custom firmware for a compatible PIC32 chip. They can load the hex file
and it will immediately start running your program. To them it will be indistinguishable from firmware written
in C (other than the startup banner produced by MMBasic). They do not have to load MMBasic and they do
not need know anything about programming for the Micromite.

Delayed Start Up
The Micromite will start up in about 100ms but in some cases it might be 2.3 to 3.6V
necessary to delay the start up to allow other circuitry (such as a USB-to-serial
bridge) to start up first. 50K
This can be accomplished by delaying the rising edge of the voltage on pin 1 (on
the 28-pin chip) or 18 (on the 44-pin chip) which will have the effect of holding 10K e
1 ti
the Micromite in reset. A suitable circuit is shown on the right. The delay is set
m
by the combination of the 50K resistor and the 47 µF capacitor and, with the o
rc
values shown, will delay start up by about 350ms. + i
The 10K resistor is there to ensure the safe discharge of the 47 µF capacitor when 47µF M
the power is removed and to allow a PIC programmer to be connected if you later
need to update the Micromite firmware.

LCD Displays
The standard Micromite includes support for colour LCD display panels using the ILI9341 controller and an SPI
interface. These have a 240x320 pixel colour TFT display, come in a variety of sizes (2.2”, 2.4" and 2.8”) and are
low cost (typically US$8). The Micromite Plus also supports this display in addition to many more ranging in
size from 1.44" to 8". See the Micromite Plus Manual for more details.
On eBay you can find suitable displays by searching for the controller’s name (ILI9341).
There are many similar displays on the market however some have subtle
differences that could prevent them from working with the Micromite.
MMBasic was tested with the displays illustrated to the right so, if you wish to
guarantee success make sure your display matches the photographs and the
specifications listed below.
The ILI9341 based displays use an SPI interface and have the following basic
specifications:
 A 2.2, 2.4 or 2.8 inch display
 Resolution of 240 x 320 pixels and a colour depth of 262K/65K
 A ILI9341 controller with a SPI serial interface
The display illustrated also has a touch sensitive facility which is fully supported
by MMBasic. There are versions of this display without the touch controller
(the 16-pin IC on the bottom right of the PCB) but there is not much point in
purchasing these as the price difference is small.
There is a version which uses a TFT panel that requires the colours to be inverted. This is supported by the
Micromite by specifying the controller type as ILI9341_I.
Connecting SPI Based LCD Panels

The SPI based display controllers share the Micromite's SPI interface with the touch controller (if present) and the
BASIC program running on the Micromite. Sharing the SPI channel is essentially transparent to the BASIC
program – see the description of the SPI communications function in Appendix D for an explanation of how to do
this.
The following table lists the connections required between the LCD display board and the Micromite:
ILI9341 28-pin 44-pin

Description
Display Micromite Micromite
T_IRQ Touch Interrupt Configurable
T_DO Touch Data Out (MISO) Pin 14 Pin 41
T_DIN Touch Data In (MOSI) Pin 3 Pin 20
T_CS Touch Chip Select Configurable
T_CLK Touch SPI Clock Pin 25 Pin 14
SDO (MISO) Display Data Out (MISO) Pin 14 Pin 41
LED Power supply for the backlight (see below)
SCK Display SPI Clock Pin 25 Pin 14
SDI (MOSI) Display Data In (MOSI) Pin 3 Pin 20
D/C Display Data/Command Control Configurable
RESET Display Reset (when pulled low) Configurable
CS Display Chip Select Optional - Configurable
GND Ground
VCC 5V supply (the controller draws less than 10 mA)

Note: Be careful to ground yourself when handling the display as the ILI9341 controller is sensitive to static
discharge and can be easily destroyed.
Where a Micromite connection is listed as "configurable" the specific pin should be specified with the OPTION
LCDPANEL or OPTION TOUCH commands (see below).
The backlight power (the LED connection) should be supplied from the main 5V supply via a current limiting
resistor. A typical value for this resistor is 18Ω which will result in a LED current of about 63 mA. The value of
this resistor can be varied to reduce the power consumption or to provide a brighter display.
Important: Care must be taken with display panels that share the SPI port between a number of devices (display
controller, touch, etc). In this case all the Chip Select signals must be configured in MMBasic or disabled by a
permanent connection to 3.3V. If this is not done any unconnected Chip Select pins will float causing the wrong
controller to respond to commands on the SPI bus.
Configuring MMBasic
To use the display MMBasic must be configured using the OPTION LCDPANEL command which is normally
entered at the command prompt. Every time the Micromite is restarted MMBasic will automatically initialise the
display. This command can also be embedded in a program with certain conditions – see the section "Special
Functions and the Library" for more details.
The syntax is:
OPTION LCDPANEL controller, orientation, D/C pin, reset pin [,CS pin]
Where:
'controller' can be either ILI9341 or ILI9341_I. Most panels require ILI9341 however some TFT panels require
that the colours be inverted and in that case ILI9341_I should be specified.
'orientation' can be LANDSCAPE, PORTRAIT, RLANDSCAPE or RPORTRAIT. These can be abbreviated to
L, P, RL or RP. The R prefix indicates the reverse or "upside down" orientation.
'D/C pin' and 'reset pin' are the Micromite I/O pins to be used for these functions. Any free pin can be used.
'CS pin' can also be any free I/O pin but is optional. If a touch controller is not used this parameter can be left off
the command and the CS pin on the LCD display wired permanently to ground. If the touch controller is used this
pin must then be specified and connected to a Micromite I/O pin.
As an example, this is the command that will configure the Micromite for the display used in the Micromite LCD
Backpack project:
OPTION LCDPANEL ILI9341, L, 2, 23, 6
In some circumstances it may be necessary to interrupt power to the LCD panel while the Micromite is running
(eg, to save battery power) and in that case the GUI RESET LCDPANEL command can be used to reinitialise
the display the same as in power up.
If the LCD panel is no longer required the command OPTION LCDPANEL DISABLE can be used which will
return the I/O pins for general use.
To test the display you can enter the command GUI TEST LCDPANEL. You should see an animated display of
colour circles being rapidly drawn on top of each other. Press the space key on the console’s keyboard to stop the
test.
Important: The above test may not work if the display has a touch controller and the touch controller has not been
configured (ie, the touch Chip Select pin is floating). In this case configure the touch controller (see below) and
then retry GUI TEST LCDPANEL.
NOTE: The CPU speed must be 20 MHz or greater.
To verify the configuration you can use the command OPTION LIST to list all options that have been set
including the configuration of the LCD panel.
ILI9488 3.5" Display and Other Loadable Drivers

The ILI9488 3.5" display makes a nice alternative to the ILI9341 display described above. It is larger (3.5") and
has many more pixels (480 x 320) and it is perfect for when you need a larger screen size without having to move
to the SSD1963 based displays supported by the Micromite Plus.
This and a number of other LCD panels are supported by loadable display drivers. These act exactly the same as
the built in LCD driver so all the graphic commands built into MMBasic will work with them. The loadable
drivers are located in the CFunctions subdirectory in the firmware distribution zip file. See the documentation
accompanying the driver for details of how to connect the LCD panel and configure the driver.

Touch Support
Most ILI9341 based LCD panels are supplied with a resistive touch sensitive panel and associated controller
chip. To use the touch feature in MMBasic the touch controller must first be connected to the Micromite (see
the above chapter for the details) and then configured (see below).
Configuring Touch
To use the touch facility MMBasic must be configured using the OPTION TOUCH command which is normally
entered at the command prompt. This should be done after the LCD panel has been configured. Every time the
Micromite is restarted MMBasic will automatically initialise the touch controller. This command can also be
embedded in a program with certain conditions – see the section "Special Functions and the Library".
The syntax is:
OPTION TOUCH T_CS pin, T_IRQ pin
Where:
'T_CS pin' and 'T_IRQ pin' are the Micromite I/O pin numbers to be used for chip select and touch interrupt
respectively (any free pins can be used).
If the touch facility is no longer required use the command OPTION TOUCH DISABLE to disable the touch
feature and return the I/O pins for general use (the 'T_CS pin' should be held high to disable the controller).
Calibrating the Touch Screen

Before the touch facility can be used it must be calibrated using the GUI CALIBRATE command.
This command will present a target in the top left corner of the screen. Using a pointy but blunt object such as
a toothpick press exactly on the centre of the target and hold it down for at least a second. MMBasic will
record this location and then continue the calibration by sequentially displaying the target in the other three
corners of the screen for touch and calibration.
The calibration routine may warn that the calibration was not accurate. This is just a warning and you can still
use the touch feature if you wish but it would be better to repeat the calibration using more care.
Following calibration you can test the touch facility using the GUI TEST TOUCH command. This command
will blank the screen and wait for a touch. When the screen is touched a white dot will be placed on the display
marking the position on the screen. If the calibration was carried out successfully the dot should be displayed
exactly under the location of the stylus on the screen.
To exit the test routine you can press the space bar on the console’s keyboard.
Touch Functions
To detect if and where the screen is touched you can use the following functions in a BASIC program:
 TOUCH(X)
Returns the X coordinate of the currently touched location.
 TOUCH(Y)
Returns the Y coordinate of the currently touched location.
Both functions return -1 if the screen is not being touched. The Micromite Plus also provides a number of
additional functions. See the Micromite Plus Manual for more details.
Touch Interrupts
An interrupt can be set on the IRQ pin number that was specified when the touch facility was configured. To
detect touch down the interrupt should be configured as INTL (ie, high to low).
For example, if the command OPTION TOUCH 7, 15 was used to configure touch the following program will
print out the X and Y coordinates of any touch on the screen:
SETPIN 15, INTL, MyInt
DO : LOOP
SUB MyInt
PRINT TOUCH(X) TOUCH(Y)
END SUB
The interrupt can be cancelled with the command SETPIN pin, OFF.

Using an LCD Panel
There are eight basic drawing commands that you can use within MMBasic programs on the Micromite to
interact with an attached LCD display. The Micromite Plus also supports these plus a series of more powerful
GUI commands. See the Micromite Plus Manual for more details.
All coordinates and measurements on the screen are done in terms of pixels with the X coordinate being the
horizontal position and Y the vertical position. The top left corner of the screen has the coordinates X = 0 and
Y = 0 and the values increase as you move down and to the right of the screen.
Read Only Variables

There are four read only variables which provide useful information about the display currently connected:
 MM. HRES
Returns the width of the display (the X axis) in pixels.
 MM. VRES
Returns the height of the display (the Y axis) in pixels.
 MM.FONTHEIGHT
Returns the height of the current default font (in pixels). All characters in a font have the same height.
 MM.FONTWIDTH
Returns the width of a character in the current default font (in pixels). All characters in a font have the
same width.
Colours
Colour is specified as a true colour 24 bit number where the top eight bits represent the intensity of the red
colour, the middle eight bits the green intensity and the bottom eight bits the blue. The easiest way to generate
this number is with the RGB() function which has the form:
RGB(red, green, blue)
A value of zero for a colour represents black and 255 represents full intensity. The RGB() function also
supports a shortcut where you can specify common colours by naming them. For example, RGB(red) or
RGB(cyan). The colours that can be named using the shortcut form are white, black, blue, green, cyan, red,
magenta, yellow, brown and gray.
MMBasic will automatically translate all colours to the format required by the individual display controller
which, in the case of the ILI9341 controller, is 64K colours in the 565 format.
Note that the 24 bit number representing colour (ie, returned by the RGB() function) is too large to be accurately
stored in a floating point variable, instead the variable should be declared as an integer. Similarly, arguments
should be declared as integer if you are passing a colour value to a subroutine or function.
The default for commands that require a colour parameter can be set with the COLOUR command. This is
handy if your program uses a consistent colour scheme, you can then set the defaults and use the short version
of the drawing commands throughout your program.
The COLOUR command takes the format:
COLOUR foreground-colour, background-colour
Fonts
MMBasic for the 28 and 44-pin Micromites includes one built in font which is 8 pixels wide by 13 pixels high
and includes all 95 standard ASCII characters with the back quote character (60 hex or 96 decimal) replaced
with the degree symbol (º). Within MMBasic this is referred to as font #1. The Micromite Plus has six built in
fonts (refer to the Micromite Plus Manual for more details).
If required, additional fonts can be embedded in a BASIC program. The MMBasic firmware zip file includes
over a dozen fonts covering a wide range of character sets including a symbol font (Dingbats) which is handy
for creating on screen icons, etc. These fonts work exactly same as the built in font (ie, selected using the
FONT command or specified in the TEXT command).
The format of an embedded font is:
DefineFont #Nbr
hex [[ hex[…]
hex [[ hex[…]
END DefineFont

It must start with the keyword "DefineFont" followed by the font number (which may be preceded by an
optional # character). Any font number in the range of 1 to 16 can be specified. The body of the font is a
sequence of 8-digit hex words with each word separated by one or more spaces or a new line. The font
definition is terminated by an "End DefineFont " keyword.
The font number specified in the DefineFont command can be the same as the built in font and in that case the
embedded font will replace the built in font. Note that on the Micromite Plus you cannot redefine fonts 1 or 6.
When a BASIC program is saved to program memory MMBasic will search through it looking for any
embedded fonts and the font table will be updated to include them. During execution embedded fonts will be
skipped over and this means that they can be placed anywhere in the program.
Embedded fonts can also be saved to the library area. When this is done the font is, for all intent and purposes,
permanently added to the MMBasic language. In addition MMBasic will strip out the hex codes in the font
definition (because they are no longer needed) and this will save a considerable amount of memory. See the
LIBRARY command for details on how to use the library.
The default font used by MMBasic is font #1 however that can be changed with the FONT command:
FONT font-number, scaling
Where 'font-number' is a number which can be optionally preceded by a hash (#) character. 'scaling' is optional
and is a number in the range of 1 to 15. The font will be multiplied by the scaling factor making the displayed
character correspondingly wider and taller. For example, specifying 'scaling' of 2 will double the height and
width. If not specified the scaling factor will be 1 (ie, no scaling).
Drawing Commands
Most drawing commands have optional parameters. You can completely leave these off the end of a command
or you can use two commas in sequence to indicate a missing parameter. For example, the fifth parameter of
the LINE command is optional so you can use this format:
LINE 0, 0, 100, 100, , rgb(red)
Optional parameters are indicated below by italics, for example: font.
In the following commands C is the drawing colour and defaults to the current foreground colour. FILL is the
fill colour which defaults to -1 which indicates that no fill is to be used.
The drawing commands are:
 CLS C
Clears the screen to the colour C. If C is not specified the current default background colour will be used.
 PIXEL X, Y, C
Illuminates a pixel. If C is not specified the current default foreground colour will be used.
 LINE X1, Y1, X2, Y2, LW, C
Draws a line starting at X1 and Y1 and ending at X2 and Y2.
LW is the line’s width and is only valid for horizontal or vertical lines. It defaults to 1 if not specified or if
the line is a diagonal.
 BOX X, Y1, W, H, LW, C, FILL
Draws a box starting at X and Y1 which is W pixels wide and H pixels high.
LW is the width of the sides of the box and can be zero. It defaults to 1.
 RBOX X, Y1, W, H, R, C, FILL
Draws a box with rounded corners starting at X and Y1 which is W pixels wide and H pixels high.
R is the radius of the corners of the box. It defaults to 10.
 CIRCLE X, Y, R, LW, A, C, FILL
Draws a circle with X and Y as the centre and a radius R. LW is the width of the line used for the
circumference and can be zero (defaults to 1). A is the aspect ratio which is a floating point number and
defaults to 1. For example, an aspect of 0.5 will draw an oval where the width is half the height.
 TEXT X, Y, STRING, ALIGNMENT, FONT, SCALE, C, BC
Displays a string starting at X and Y. ALIGNMENT is 0, 1 or 2 characters (a string expression or variable
is also allowed) where the first letter is the horizontal alignment around X and can be L, C or R for LEFT,
CENTER or RIGHT aligned text and the second letter is the vertical alignment around Y and can be T, M
or B for TOP, MIDDLE or BOTTOM aligned text. The default alignment is left/top. The Micromite Plus
can also use an additional code letter to rotate the text (see the Micromite Plus Manual for the details).

FONT and SCALE are optional and default to that set by the FONT command. C is the drawing colour and
BC is the background colour. They are optional and default to that set by the COLOUR command.
 GUI BITMAP X, Y, BITS, WIDTH, HEIGHT, SCALE, C, BC
Displays the bits in a bitmap starting at X and Y. HEIGHT and WIDTH are the dimensions of the bitmap
as displayed on the LCD panel and default to 8x8. SCALE, C and BC are the same as for the TEXT
command. The bitmap can be an integer or a string variable or constant and is drawn using the first byte as
the first bits of the top line (bit 7 first, then bit 6, etc) followed by the next byte, etc. When the top line has
been filled the next line of the displayed bitmap will start with the next bit in the integer or string.
Example
As an example the following program will draw a simple digital clock on an ILI9341 based LCD display. The
program will terminate and return to the command prompt if the display screen is touched.
First the display and touch options must be configured by entering commands similar to these at the command
prompt:
OPTION TOUCH 7, 15
These settings specify an ILI9341 based display in the landscape orientation and uses pins 2, 23 and 6 for the
LCD and pins 7 and 15 for the touch controller (all on the 28-pin Micromite). They suit the Micromite LCD
Backpack (see next chapter) but your configuration could be different.
Next the touch feature should be calibrated by entering this command and following the calibration procedure.
GUI CALIBRATE
Finally you can enter and run the program:

CONST DBlue = RGB(0, 0, 128) ' A dark blue colour
COLOUR RGB(GREEN), RGB(BLACK) ' Set the default colours
FONT 1, 3 ' Set the default font
BOX 0, 0, MM.HRes-1, MM.VRes/2, 3, RGB(RED), DBlue
DO
TEXT MM.HRes/2, MM.VRes/4, TIME$, "CM", 1, 4, RGB(CYAN), DBlue
TEXT MM.HRes/2, MM.VRes*3/4, DATE$, "CM"
IF TOUCH(X) <> -1 THEN END
LOOP
The program starts by defining a constant with a value corresponding to a dark blue colour and then sets the
defaults for the colours and the font. It then draws a box with red walls and a dark blue interior.
Following this the program enters a continuous loop where it performs three functions:
1. Displays the current time inside the previously drawn box. The string is drawn centred both horizontally
and vertically in the middle of the box. Note that the TEXT command overrides both the default font and
colours to set its own parameters.
2. Draws the date centred in the lower half of the screen. In this case the TEXT command uses the default
font and colours previously set.
3. Checks for a touch on the screen. This is indicated when the TOUCH(X) function returns something
other than -1. In that case the program will terminate.
The screen display should look like this (the font used in this illustration is different):

Micromite LCD Backpack
The Micromite LCD Backpack is a popular project which
combines the 28-pin Micromite with a touch sensitive LCD panel
using the ILI9341 controller.
The PCB carrying the Micromite is designed to piggy back onto
the LCD panel making a neat two board sandwich which can be
used as the core of many projects that require an easily
programmable microcontroller with a colourful touch sensitive
LCD display as the user interface.
With less than a dozen components the Micromite LCD Backpack can be built in under half an hour.
The Micromite LCD Backpack is described on this web page: http://geoffg.net/MicromiteBackpack.html

And there are currently five projects on the Micromite website which are based on it. These are the:
Parking Assistant: http://geoffg.net/ParkingAssistant.html
Boat Computer: http://geoffg.net/BoatComputer2.html
Super Clock: http://geoffg.net/SuperClock.html
DDS Signal Generator: http://geoffg.net/SignalGenerator.html
Air Quality Monitor: http://geoffg.net/AirQualityMonitor.html
This chapter of the manual is intended to provide a "fast start" for people who have built the backpack and just
want to quickly get it going.
Programming MMBasic into the PIC32

When construction of the backpack is completed the first task is to program the PIC32 microcontroller with the
Micromite firmware. This includes the BASIC interpreter and management software.
There are two ways to do this depending on the version of the Micromite LCD Backpack that you have:
Micromite LCD Backpack Version 1
This version of the backpack requires that you use an
external programmer. The best programmer for the job
is a cheap clone of the PICkit3. See this page for a full
description: http://geoffg.net/programming_pics.html
The backpack PCB has a six pin connector labelled
ICSP which is designed to mate with the PICkit3
programmer as shown in the photo.
This version of the backpack has its own built in PIC32 programmer using a suitably programmed PIC16F1455
microcontroller (dubbed the "Microbridge"). This page describes the Microbridge and how to transfer the
firmware to it for programming into the PIC32: http://geoffg.net/microbridge.html
The Micromite firmware comes as a file with an extension of .hex. You should download the latest version
from: http://geoffg.net/micromite.html#Downloads and use the above method to program it into the PIC32.
Connecting to the Console

The next task is to connect a terminal emulator to the Micromite's console. The console is a serial interface
over which you can issue commands to configure the chip, load the BASIC program and run it. MMBasic also
uses the console to display error messages. Again, how you do this varies depending on the version of the
Micromite LCD Backpack that you have:
For this version you will need a USB to serial converter which plugs into a USB port on your desktop computer
and at the other end connects to the Micromite's serial console. From your computer's point of view it will look
like a serial port (via USB) while the connection to the Micromite Plus is a standard serial interface with TTL
signals levels. The full description of this process is provided earlier in this manual. Look for the chapter
labelled "Console Connection".

This version has its own built in USB to serial converter using the PIC16F1455 microcontroller which also
acted as the PIC32 programmer ("Microbridge"). See http://geoffg.net/microbridge.html for more details.
Configuring MMBasic
With the console connected you should have access to the console and the command prompt ">". You then
need to configure the Micromite for the LCD and touch connections to suit the Micromite LCD Backpack. To
do this you should issue the following commands at the command prompt:
OPTION TOUCH 7, 15
You then need to calibrate the touch panel using this command:
GUI CALIBRATE
This will cause MMBasic to draw a sequence of four targets (the first is
shown on the right). Using a pointy but blunt object (eg, a toothpick) press
on the exact centre of the target and MMBasic will step onto the next target
and so on until all four targets have been processed.
The full details of these setup commands are described in the previous
chapters of this manual.
Loading the BASIC program

Loading BASIC code into the Micromite is done over the console using either the AUTOSAVE or XMODEM
commands. This requires you to have a terminal emulator running on your desktop machine and connected to
the console of the Micromite.
The AUTOSAVE command puts the Micromite into a mode where anything received on the console will be
saved to the program memory. This means that you can simply copy the text and paste it into the terminal
emulator (eg, Tera Term) which will send it to the Micromite. From the Micromite’s perspective pasting text
into the terminal emulator is the same as if a high speed typist was typing in the program. To terminate the
AUTOSAVE command you need to press the Control-Z keys in the terminal emulator and the Micromite will
save the program to flash memory and return to the command prompt.
The XMODEM command is a little more sophisticated, it uses the XModem protocol to transfer the data
including an integrity check. The full command is:
XMODEM RECEIVE
This instructs the Micromite to look for an XModem connection on the console. After running this command
you should then instruct your terminal emulator to send the file using the XModem protocol. In Tera Term this
is done by using the following menu selection:
File->Transfer->XMODEM->Send
When the complete file has been sent the Micromite will save it in program memory and return to the command
prompt.
Saving Fonts in the Library

Some programs require that you load the fonts separately and save them to the library. The library is a special
area in the Micromite where fonts and program modules can be stored (see the chapter "Special Functions and
the Library" later in this manual). MMBasic will compress the data in the library which is why some programs
need to use the library. If the program that you are loading has a separate font file then you need to load that
first, then use the command LIBRARY SAVE. That will transfer the code to the library and delete it from
main memory.
Finally you can load the main BASIC program and start it by entering the command RUN.

Special Device Support
To make it easier for a program to interact with the external world the Micromite includes drivers for a number
of common peripheral devices.
These are:
 Infrared remote control receiver and transmitter
 The DS18B20 temperature sensor and DHT22 temperature/humidity sensor
 LCD display modules
 Numeric keypads
 Battery backed clock
 Ultrasonic distance sensor
Infrared Remote Control Decoder

You can easily add a remote control to your project using the IR command. When enabled this function will
run in the background and interrupt the running program whenever a key is pressed on the IR remote control.
It will work with any NEC or Sony compatible remote controls including ones that generate extended
messages. Most cheap programmable remote controls will generate either protocol and using one of these you
can add a sophisticated flair to your Micromite based project. 3.3V
The NEC protocol is also used by many other manufacturers
including Apple, Pioneer, Sanyo, Akai and Toshiba so their
branded remotes can be used.
To detect the IR signal you need an IR receiver connected to
IR Receiver
the IR pin (pin 16 on a 28-pin chip) as illustrated in the
diagram. The IR receiver will sense the IR light, demodulate
+5V
the signal and present it as a TTL voltage level signal to this
pin. Setup of the I/O pin is automatically done by the IR Micromite
command. 16
NEC remotes use a 38kHz modulation of the IR signal and
suitable receivers tuned to this frequency include the Vishay
TSOP4838, Jaycar ZD1952 and Altronics Z1611A .
Sony remotes use a 40 kHz modulation but receivers for this
frequency can be hard to find. Generally 38 kHz receivers will
work but maximum sensitivity will be achieved with a 40 kHz receiver.
To setup the decoder you use the command:
IR dev, key, interrupt
Where dev is a variable that will be updated with the device code and key is the variable to be updated with the
key code. Interrupt is the interrupt subroutine to call when a new key press has been detected. The IR
decoding is done in the background and the program will continue after this command without interruption.
This is an example of using the IR decoder:
IR DevCode, KeyCode, IR_Int ' start the IR decoder
DO
' < body of the program >
LOOP
SUB IR_Int ' a key press has been detected

PRINT "Received device = " DevCode " key = " KeyCode
END SUB
IR remote controls can address many different devices (VCR, TV, etc) so the program would normally examine
the device code first to determine if the signal was intended for the program and, if it was, then take action
based on the key pressed. There are many different devices and key codes so the best method of determining
what codes your remote generates is to use the above program to discover the codes.

The IR function uses the same I/O pin as the wakeup signal for the CPU SLEEP command and it is possible to
combine them so that an incoming IR signal will wake the Micromite which will then decode the IR signal. In
this way you can have a Micromite running on battery power that will wake up on an IR signal, do something
based on the signal, then go back to sleep.
The following is an example:
IR DevCode, KeyCode, IR_Int ' start the IR decoder
DO
CPU SLEEP ' now sleep until a signal
LOOP
SUB IR_Int ' a key press has been detected

< do some work based on the key press >
END SUB ' return to sleep again
3.3V +5V
Infrared Remote Control Transmitter
Using the IRSEND command you can transmit a 12 bit Sony infrared
remote control signal. This is intended for Micromite to Micromite 58 ohms
communications but it will also work with Sony equipment that uses
12 bit codes. Note that all Sony products require that the message be
sent three times with a 26 ms delay between each message. IR
In previous versions of the Micromite firmware this command was Micromite LED
built into MMBasic but now it is distributed as a CSub module
which works exactly the same. See the file IRSend.pdf which is BC338
1K
included in the Embedded C Modules folder in the Micromite
firmware zip file.
The circuit on the right illustrates what is required. The transistor is
used to drive the infrared LED because the output of the Micromite is limited to about 10mA. This circuit
provides about 50 mA to the LED.
To send a signal you use the command:
IRSEND pin, dev, key
Where pin is the I/O pin used, dev is the device code to send and key is the key code. Any I/O pin on the
Micromite can be used and you do not have to set it up beforehand (IRSEND will automatically do that).
The modulation frequency used is 38 kHz and this matches the common IR receivers (described in the previous
page) for maximum sensitivity when communicating between two Micromites.
Measuring Temperature
The TEMPR() function will get the temperature from a DS18B20
temperature sensor. This device can be purchased on eBay for about $5 in a
3V to
variety of packages including a waterproof probe version. 5V
The DS18B20 can be powered separately by a 3V to 5V supply or it can 4.7K
operate on parasitic power from the Micromite as shown on the right. Any
Multiple sensors can be used but a separate I/O pin and a 4.7K pullup resistor Micromite
is required for each one. I/O Pin
To get the current temperature you just use the TEMPR() function in an Normal Power
expression. For example:
PRINT "Temperature: " TEMPR(pin)
Where 'pin' is the I/O pin to which the sensor is connected. You do not have
3V to
to configure the I/O pin, that is handled by MMBasic. 5V
The returned value is in degrees C with a resolution of 0.25 ºC and is accurate 4.7K
to ±0.5 ºC. If there is an error during the measurement the returned value Any
will be 1000. Micromite
I/O Pin
The time required for the overall measurement is 200ms and the running
program will halt for this period while the measurement is being made. This
Parasitic Power
also means that interrupts will be disabled for this period. If you do not want
this you can separately trigger the conversion using the TEMPR START

command then later use the TEMPR() function to retrieve the temperature reading. The TEMPR() function
will always wait if the sensor is still making the measurement.
For example:
TEMPR START 15
< do other tasks >
PRINT "Temperature: " TEMPR(15)
Measuring Humidity and Temperature

The HUMID command will read the humidity and temperature from a DHT22 humidity/temperature sensor.
This device is also sold as the RHT03 or AM2302 but all are compatible and can be purchased on eBay for
under $5.
In previous versions of the Micromite firmware this command was built into MMBasic but now it is distributed
as a CSub module which works the same. See the file Humid.pdf which is included in the Embedded C
Modules folder in the Micromite firmware zip file.
3V to
The DHT22 can be powered from 3.3V or 5V (5V is
5V
recommended) and it should have a pullup resistor on
the data line as shown. This is suitable for long cable 4.7K
runs (up to 20 meters) but for short runs the resistor can
be omitted as the Micromite also provides an internal Any
weak pullup. Micromite
I/O Pin
To get the temperature or humidity you use the HUMID
command with three arguments as follows:
HUMID pin, tVar, hVar
Where 'pin' is the I/O pin to which the sensor is connected. You can use any I/O pin but if the DHT22 is
powered from 5V it must be 5V capable. The I/O pin will be automatically configured by MMBasic.
'tVar' is a floating point variable in which the temperature is returned and 'hVar' is a second variable for the
humidity. Both of these variables must be declared first as floats (using DIM). The temperature is returned as
degrees C with a resolution of one decimal place (eg, 23.4) and the humidity is returned as a percentage
relative humidity (eg, 54.3).
For example:
DIM FLOAT temp, humidity
HUMID pin, temp, humidity
PRINT "The temperature is" temp " and the humidity is" humidity
Real Time Clock Interface

Using the RTC GETTIME command it is easy to get the current time from a PCF8563, DS1307, DS3231 or
DS3232 real time clock as well as compatible devices such as the M41T11. These integrated circuits are
popular and cheap, will keep accurate time even with the power removed and can be purchased for $2 to $8 on
eBay. Complete modules including the battery can also be purchased on eBay for a little more.
The PCF8563 and DS1307 will keep time to
within a minute or two over a month while the 3.3V
DS3231 and DS3232 are particularly precise +
and will remain accurate to within a minute Lithium 3V
button cell
over a year.
4.7K 4.7K battery
These chips are I2C devices and should be
connected to the I2C I/O pins of the 8 3
Micromite. This circuit shows a typical circuit 18 5
2
for the DS1307. The other chips have similar 32.768
28-pin
DS1307 kHz
circuits (check their data sheets). Micromite 17 6 crystal
1
Internal pullup resistors (100KΩ) are applied
to the I2C I/O pins so in many cases external 4
resistors (as shown in the diagram) are not
needed.

Before you can use the chip its time must be first set. That is done with the RTC SETTIME command which
uses the format RTC SETTIME year, month, day, hour, minute, second. Note that the hour must be in 24 hour
format.
For example, the following will set the real time clock to 4PM on the 10th November 2021:
RTC SETTIME 2021, 11, 10, 16, 0, 0
To get the time you use the RTC GETTIME command which will read the time from the real time clock chip
and set the clock inside the Micromite. Normally this command will be placed at the beginning of the program
or in the subroutine MM.STARTUP so that the time is set on power up.
The clock in the standard 28 and 44-pin Micromite can drift by up to two or three seconds in an hour so to keep
it accurate over a long period the RTC can be polled at regular intervals using the SETTICK command.
For example:
RTC GETTIME ' set the time at startup
SETTICK 12 * 3600000, SetTime, 4 ' interrupt every 12 hours
< normal program >
SUB SetTime ' interrupt called every 12 hours
RTC GETTIME ' reset the time
END SUB
Measuring Distance
Using a HC-SR04 ultrasonic sensor and the DISTANCE() CFunction you can measure the distance to a target.
This device can be found on eBay for about $4 and it will measure the distance to a target from 3cm to 3m. It
works by sending an ultrasonic sound pulse and measuring the time it
takes for the echo to be returned.
Compatible sensors are the SRF05, SRF06, Parallax PING and the DYP-
ME007 (which is waterproof and therefore good for monitoring the level
of a water tank).
In previous versions of the Micromite firmware this function was built
into MMBasic but now it is distributed as a CFunction module which
works the same. See the file Distance.pdf which is included in the
Embedded C Modules folder in the Micromite firmware zip file.
On the Micromite you use the DISTANCE function as follows:
d = DISTANCE(trig, echo)
Where trig is the I/O pin connected to the "trig" input of the sensor and echo is the pin connected the "echo"
output of the sensor. You can also use 3-pin devices and in that case only one pin number is specified.
The value returned is the distance in centimetres to the target. The I/O pins are automatically configured by
this function but note that they should be 5V capable as the HC-SR04 is a 5V device.
LCD Display
The LCD command will display text on a standard LCD module with the
minimum of programming effort.
This command will work with LCD modules that use the KS0066,
HD44780 or SPLC780 controller chip and have 1, 2 or 4 lines. Typical
displays include the LCD16X2 (futurlec.com), the Z7001
(altronics.com.au) and the QP5512 (jaycar.com.au). eBay is another
good source where prices can range from $10 to $50.
To setup the display you use the LCD INIT command:
LCD INIT d4, d5, d6, d7, rs, en
d4, d5, d6 and d7 are the numbers of the I/O pins that connect to inputs D4, D5, D6 and D7 on the LCD module
(inputs D0 to D3 and R/W on the module should be connected to ground). 'rs' is the pin connected to the
register select input on the module (sometimes called CMD or DAT). 'en' is the pin connected to the enable or
chip select input on the module.

Any I/O pins on the Micromite can be used and you do not have to set them up beforehand (the LCD command
automatically does that for you). The following shows a typical set up.
To display characters on the module you use the LCD command:

LCD line, pos, data$
Where line is the line on the display (1 to 4) and pos is the position on the line where the data is to be written
(the first position on the line is 1). data$ is a string containing the data to write to the LCD display. The
characters in data$ will overwrite whatever was on that part of the LCD.
The following shows a typical usage where d4 to d7 are connected to pins 2 to 4 on the Micromite, rs is
connected to pin 23 and en to pin 24..
LCD INIT 2, 3, 4, 5, 23, 24

LCD 1, 2, "Temperature"
LCD 2, 6, STR$(TEMPR(15)) ' DS18B20 connected to pin 15
Note that this example also uses the TEMPR() function to get the temperature (described above).
Keypad Interface
A keypad is a low tech method of entering data into a Micromite based system. The Micromite supports either
a 4x3 keypad or a 4x4 keypad and the monitoring and decoding of key presses is done in the background.
When a key press is detected an interrupt will be issued where the program can deal with it.
Examples of a 4x3 keypad and a 4x4 keypad are the Altronics S5381 and S5383 (go to www.altronics.com).
To enable the keypad feature you use the command:
KEYPAD var, int, r1, r2, r3, r4, c1, c2, c3, c4
Where var is a variable that will be updated with the key code and int is the name of the interrupt subroutine to
call when a new key press has been detected. r1, r2, r3 and r4 are the pin numbers used for the four row
connections to the keypad (see the diagram below) and c1, c2, c3 and c4 are the column connections. c4 is only
used with 4x4 keypads and should be omitted if you are using a 4x3 keypad.
Any I/O pins on the Micromite can be used and you do not have to set them up beforehand, the KEYPAD
command will automatically do that for you.

+3.3V
R1
1 2 3 20
R2
4 5 6 21
R3
7 8 9 22
R4
10 0 11 23
Micromite
C1
C2
C3
C4
The detection and decoding of key presses is done in the background and the program will continue after this
command without interruption. When a key press is detected the value of the variable var will be set to the
number representing the key (this is the number inside the circles in the diagram above). Then the interrupt
will be called.
For example:
Keypad KeyCode, KP_Int, 2, 3, 4, 5, 21, 22, 23 ' 4x3 keyboard
DO
< body of the program >
LOOP
SUB KP_Int ' a key press has been detected

PRINT "Key press = " KeyCode
END SUB

Full Screen Editor
An important productivity feature of the Micromite is the full screen editor. This will work with any VT100
compatible terminal emulator (Tera Term is recommended).
The full screen program editor is invoked with the EDIT command. The cursor will be automatically
positioned at the last place that you were editing at or, if your program had just been stopped by an error, the
cursor will be positioned at the line that caused the error.
If you are used to an editor like Notepad you will find that the operation of this editor is familiar. The arrow
keys will move your cursor around in the text, home and end will take you to the beginning or end of the line.
Page up and page down will do what their titles suggest. The delete key will delete the character at the cursor
and backspace will delete the character before the cursor. The insert key will toggle between insert and
overtype modes. About the only unusual key combination is that two home key presses will take you to the
start of the program and two end key presses will take you to the end.
At the bottom of the screen the status line will list the various function keys used by the editor and their action.
In more details these are:
ESC This will cause the editor to abandon all changes and return to the command prompt with
the program memory unchanged. If you have changed the text you will be asked if you
really what want to abandon your changes.
F1: SAVE This will save the program to program memory and return to the command prompt.
F2: RUN This will save the program to program memory and immediately run it.
F3: FIND This will prompt for the text that you want to search for. When you press enter the
cursor will be placed at the start of the first entry found.
SHIFT-F3 Once you have used the search function you can repeatedly search for the same text by
pressing SHIFT-F3.
F4: MARK This is described in detail below.
F5: PASTE This will insert (at the current cursor position) the text that had been previously cut or
copied (see below).

If you pressed the mark key (F4) the editor will change to the mark mode. In this mode you can use the arrow
keys to mark a section of text which will be highlighted in reverse video. You can then delete, cut or copy the
marked text. In this mode the status line will change to show the functions of the function keys in the mark
mode. These keys are:
ESC Will exit mark mode without changing anything.
F4: CUT Will copy the marked text to the clipboard and remove it from the program.
F5: COPY Will just copy the marked text to the clipboard.
DELETE Will delete the marked text leaving the clipboard unchanged.
You can also use control keys instead of the functions keys listed above. These control keystrokes are:
LEFT Ctrl-S RIGHT Ctrl-D UP Ctrl-E DOWN Ctrl-X
HOME Ctrl-U END Ctrl-K PageUp Ctrl-P PageDn Ctrl-L
DEL Ctrl-] INSERT Ctrl-N F1 Ctrl-Q F2 Ctrl-W
F3 Ctrl-R ShiftF3 Ctrl-G F4 Ctrl-T F5 Ctrl-Y
If you are using Tera Term, Putty, MMEdit or GFXterm as the terminal emulator it is also possible to position
the cursor by left clicking the PC's mouse in the terminal emulator's window.
The best way to learn the full screen editor is to simply fire it up and experiment.
The editor is a very productive method of writing a program. With the command EDIT you can write your
program on the Micromite. Then, by pressing the F2 key, you can save and run the program. If your program
stops with an error you can press the function key F4 which will run the command EDIT and place you back in
the editor with the cursor positioned at the line that caused the error. This edit/run/edit cycle is very fast.
Using the OPTION BAUDRATE command the baud rate of the console can be changed to any speed up to
230400 bps. Changing the console baud rate to a higher speed makes the full screen editor much faster in
redrawing the screen. If you have a reliable connection to the Micromite it is worth changing the speed to at
least 115200.
The editor expects that the terminal emulator is set to 24 lines per screen with each line 80 characters wide.
Both of these assumptions can be changed with the OPTION DISPLAY command to suit non standard
displays.
Note that a terminal emulator can lose its position in the text with multiple fast keystrokes (like the up and
down arrows). If this happens you can press the HOME key twice which will force the editor to jump to the
start of the program and redraw the display.
Colour Coded Editor Display

The editor has the ability to colour code the edited program with keywords, numbers and comments displayed
in different colours. By default the output is not colour coded but this feature can be enabled with the
command:
OPTION COLOURCODE ON
or disabled with:
OPTION COLOURCODE OFF
This setting is saved in flash memory and is automatically applied on startup.
Note:
 This feature requires a terminal emulator that can interpret the appropriate escape codes and respond
correctly. It works correctly with Tera Term however Putty needs its default background colour to be
changed to white (Settings >> Colours >> Default Background >> Modify).
 Colour coding the editor’s output requires many extra characters to be sent to the terminal emulator and
this can slow down the screen update at 38400 baud. If colour coding is used it is recommended that the
baud rate be set to a higher speed as discussed above.

Defining and Using Variables
Variables are a way for a program to store numbers or text, MMBasic on the Micromite supports three different
types of variables:
1. Floating point.
These can store a number with a decimal point and fraction (eg, 45.386) and also very large numbers.
However, they will lose accuracy when many significant digits of precision are required. Floating point
variables are specified by adding the suffix '!' to a variable's name (eg, i!, nbr!, etc). They are also the
default when a variable is created without a suffix (eg, i, nbr, etc).
2. 64-bit signed integer.
These can store positive or negative numbers with up to 19 decimal digits without losing accuracy but
they cannot store fractions (ie, the part following the decimal point). These are specified by adding the
suffix '%' to a variable's name. For example, i%, nbr%, etc. Note that during arithmetic operations
(particularly addition and multiplication) no check is made for an overflow which may result in the final
value requiring more than the number of digits supported. In that case the result will be nonsense.
3. A String.
A string will store a sequence of characters (eg, "Tom"). Each character in the string is stored as an eight
bit number and can therefore have a decimal value of 0 to 255. String variable names are terminated with
a '$' symbol (eg, name$, s$, etc). Strings can be up to 255 characters long.
Note that it is illegal to use the same variable name with different types. Eg, using nbr! and nbr% in the
same program would cause an error.
Most programs use floating point variables as these can deal with the numbers used in typical situations and are
more intuitive when dealing with division and fractions. So, if you are not bothered with the details, always use
floating point.
When a constant number is used it will be assumed that it is an integer if a decimal point or exponent is not
used. For example, 1234 will be interpreted as an integer and 1234.0 will be interpreted as a floating point
number. String constants are always surrounded by double quote marks (eg, "text string").
OPTION DEFAULT
A variable can be used without a suffix (ie, !, % or $) and in that case MMBasic will use the default type of
floating point. For example, the following will create a floating point variable:
Nbr = 1234
However the default can be changed with the OPTION DEFAULT command. For example, OPTION
DEFAULT INTEGER will specify that all variables without a specific type will be integer. So, the following
will create an integer variable:
OPTION DEFAULT INTEGER
Nbr = 1234
The default can be set to FLOAT (which is the default when a program is run), INTEGER, STRING or NONE.
In the latter case all variables must be specifically typed otherwise an error will occur.
The OPTION DEFAULT command can be placed anywhere in the program and changed at any time but good
practice dictates that if it is used it should be placed at the start of the program and left unchanged.
OPTION EXPLICIT
By default MMBasic will automatically create a variable when it is first referenced. So, Nbr = 1234 will
create the variable and set it to the number 1234 at the same time. This is convenient for short and quick
programs but it can lead to subtle and difficult to find bugs in large programs. For example, in the third line of
this fragment the variable Nbr has been misspelt as Nr. As a consequence the variable Nr would be created
with a value of zero and the value of Total would be wrong.
Nbr = 1234
Incr = 2
Total = Nr + Incr
The OPTION EXPLICIT command tells MMBasic to not automatically create variables. Instead they must be
explicitly defined using the DIM or LOCAL commands (see below) before they are used.

If the OPTION EXPLICIT command was used as shown below the error would become obvious when the
program was run:
> LIST
OPTION EXPLICIT
DIM Nbr, Incr, Total
Nbr = 1234
Incr = 2
Total = Nr + Incr
>
> RUN
[5] Total = Nr + Incr
Error: NR is not declared
>
The use of OPTION EXPLICIT is recommended to support good programming practice. If it is used it should
be placed at the start of the program before any variables are used.
DIM and LOCAL

The DIM and LOCAL commands can be used to define a variable and set its type and are mandatory when the
OPTION EXPLICIT command is used.
The DIM command will create a global variable that can be seen and used throughout the program including
inside subroutines and functions. However, if you require the definition to be visible only within a subroutine
or function, you should use the LOCAL command at the start of the subroutine or function. LOCAL has
exactly the same syntax as DIM.
If LOCAL is used to specify a variable with the same name as a global variable then the global variable will be
hidden to the subroutine or function and any references to the variable will only refer to the variable defined by
the LOCAL command. Any variable created by LOCAL will vanish when the program leaves the subroutine.
At its simplest level DIM and LOCAL can be used to define one or more variables based on their type suffix or
the OPTION DEFAULT in force at the time. For example:
DIM nbr%, s$
But it can also be used to define one or more variables with a specific type when the type suffix is not used:
DIM INTEGER nbr, nbr2, nbr3, etc
In this case nbr, nbr2, nbr3, etc are all created as integers. When you use the variable within a program you do
not need to specify the type suffix. For example, MyStr in the following works perfectly as a string variable:
DIM STRING MyStr
MyStr = "Hello"
The DIM and LOCAL commands will also accept the Microsoft practice of specifying the variable's type after
the variable with the keyword "AS". For example:
DIM nbr AS INTEGER, s AS STRING
In this case the type of each variable is set individually (not as a group as when the type is placed before the list
of variables).
The variables can also be initialised while being defined. For example:
DIM INTEGER a = 5, b = 4, c = 3
DIM s$ = "World", i% = H8FF8F
DIM msg AS STRING = "Hello" + " " + s$
The value used to initialise the variable can be an expression including user defined functions.
The DIM or LOCAL commands are also used to define an array and all the rules listed above apply when
defining an array. For example, you can use:
DIM INTEGER nbr(10), nbr2, nbr3(5,8), etc
When initialising an array the values are listed as comma separated values with the whole list surrounded by
brackets. For example:
DIM INTEGER nbr(5) = (11, 12, 13, 14, 15, 16)
or
DIM days(7) AS STRING = ("","Sun","Mon","Tue","Wed","Thu","Fri","Sat")

STATIC
Inside a subroutine or function it is sometimes useful to create a variable which is only visible within the
subroutine or function (like a LOCAL variable) but retains its value between calls to the subroutine or function.
You can do this by using the STATIC command. STATIC can only be used inside a subroutine or function and
uses the same syntax as LOCAL and DIM. The difference is that its value will be retained between calls to the
subroutine or function (ie, it will not be initialised on the second and subsequent calls).
For example, if you had the following subroutine and repeatedly called it, the first call would print 5, the
second 6, the third 7 and so on.
SUB Foo
STATIC var = 5
PRINT var
var = var + 1
END SUB
Note that the initialisation of the static variable to 5 (as in the above example) will only take effect on the first
call to the subroutine. On subsequent calls the initialisation will be ignored as the variable had already been
created on the first call.
As with DIM and LOCAL the variables created with STATIC can be float, integers or strings and arrays of
these with or without initialisation.
CONST
Often it is useful to define an identifier that represents a value without the risk of the value being accidently
changed - which can happen if variables were used for this purpose (this practice encourages another class of
difficult to find bugs).
Using the CONST command you can create an identifier that acts like a variable but is set to a value that cannot
be changed. For example:
CONST InputVoltagePin = 26
CONST MaxValue = 2.4
The identifiers can then be used in a program where they make more sense to the casual reader than simple
numbers. For example:
IF PIN(InputVoltagePin) > MaxValue THEN SoundAlarm
A number of constants can be created on the one line:
CONST InputVoltagePin = 26, MaxValue = 2.4, MinValue = 1.5
The value used to initialise the constant is evaluated when the constant is created and can be an expression
including user defined functions.
The type of the constant is derived from the value assigned to it; so for example, MaxValue above will be a
floating point constant because 2.4 is a floating point number. The type of a constant can also be explicitly set
by using a type suffix (ie, !, % or $).
Mixing Floating Point and Integers

MMBasic automatically handles conversion of numbers between floating point and integers. If an operation
mixes both floating point and integers (eg, PRINT A% + B!) the integer will be converted to a floating point
number first, then the operation performed and a floating point number returned. If both sides of the operator
are integers then an integer operation will be performed and an integer returned.
The one exception is the normal division ("/") which will always convert both sides of the expression to a
floating point number and then return a floating point number. For integer division you should use the integer
division operator "\".
Functions will return a float or integer depending on their characteristics. For example, PIN() will return an
integer when the pin is configured as a digital input but a float when configured as an analog input.
If necessary you can convert a float to an integer with the INT() function. It is not necessary to specifically
convert an integer to a float but if it was needed the integer value could be assigned to a floating point variable
and it will be automatically converted in the assignment.

64-bit Unsigned Integers
The Micromite supports 64-bit signed integers. This means that there are 63 bits for holding the number and
one bit (the most significant bit) which is used to indicate the sign (positive or negative). However it is
possible to use full 64-bit unsigned numbers as long as you do not do any arithmetic on the numbers.
64-bit unsigned numbers can be created using the &H, &O or &B prefixes to a number and these numbers can
be stored in an integer variable. You then have a limited range of operations that you can perform on these
numbers. They are << (shift left), >> (shift right), AND (bitwise and), OR (bitwise or), XOR (bitwise
exclusive or), = (equal to) and <> (not equal to). Arithmetic operators such as +, -, etc may be confused by a
64-bit unsigned number and could return nonsense results.
To display 64-bit unsigned numbers you should use the HEX$(), OCT$() or BIN$() functions.
For example, the following 64-bit unsigned operation will return the expected results:
X% = &HFFFF0000FFFF0044
Y% = &H800FFFFFFFFFFFFF
X% = X% AND Y%
PRINT HEX$(X%, 16)
Will display "800F0000FFFF0044"

Using the I/O pins
Digital Inputs
A digital input is the simplest type of input configuration. If the input voltage is higher than 2.5V the logic
level will be true (numeric value of 1) and anything below 0.65V will be false (numeric value of 0). The inputs
use a Schmitt trigger input so anything in between these levels will retain the previous logic level. Pins marked
as 5V are 5V tolerant and can be directly connected to a circuit that generates up to 5.5V without the need for
voltage dropping resistors.
In your BASIC program you would set the input as a digital input and use the PIN() function to get its level.
For example:
SETPIN 23, DIN
IF PIN(23) = 1 THEN PRINT "High"
The SETPIN command configures pin 23 as a digital input and the PIN() function will return the value of that
pin (the number 1 if the pin is high). The IF command will then execute the command after the THEN
statement if the input was high. If the input pin was low the program would just continue with the next line in
the program.
The SETPIN command also recognises a couple of options that will connect an internal resistor from the input
to either the supply or ground. This is called a "pullup" or "pulldown" resistor and is handy when connecting to
a switch as it saves having to install an external resistor to place a voltage across the contacts.
Analog Inputs
Pins marked as ANALOG can be configured to measure the voltage on the pin. The input range is from zero to
3.3V and the PIN() function will return the voltage. For example:
> SETPIN 23, AIN
> PRINT PIN(23)
2.345
>
You will need a voltage divider if you want to measure voltages greater than 3.3V. For small voltages you may
need an amplifier to bring the input voltage into a reasonable range for measurement.
The measurement uses the analog power pin (pin 28 on the 28-pin chip and 17 on the 44-pin chip) as the
reference voltage and MMBasic scales the reading by assuming that the voltage on this pin is exactly 3.3V.
Normally the Micromite is powered from a voltage regulator so this assumption is correct. However, when
battery power is used, the supply voltage can vary which will cause inaccurate readings. In that case the
program should scale the reading accordingly. For example:
A = (PIN(x) / 3.3) * PowerV
where "PowerV" is the voltage on the analog power pin.
The measurement of voltage is very sensitive to noise on the Analog Power and Ground pins. For accurate and
repeatable voltage measurements care should be taken with the PCB design to isolate the analog circuit from
the digital circuits and ensure that the Analog Power supply is as noise free as possible. Note that if the voltage
on an analog input is greater than the voltage on the Analog Power pin it can cause damage or a “CPU
Exception” (ie, crash) when an attempt is made to read that voltage.
Counting Inputs
The pins marked as COUNT can be configured as counting inputs to measure frequency, period or just count
pulses on the input.
For example, the following will print the frequency of the signal on pin 15:
> SETPIN 15, FIN
> PRINT PIN(15)
110374
>
In this case the frequency is 110.374 kHz.

By default the gate time is one second which is the length of time that MMBasic will use to count the number
of cycles on the input and this means that the reading is updated once a second with a resolution of 1 Hz. By
specifying a third argument to the SETPIN command it is possible to specify an alternative gate time between
10 ms and 100000 ms. Shorter times will result in the readings being updated more frequently but the value
returned will have a lower resolution. The PIN() function will always return the frequency in Hz regardless of
the gate time used.
For example, the following will set the gate time to 10ms with a corresponding loss of resolution:
> SETPIN 15, FIN, 10
> PRINT PIN(15)
110300
>
For accurate measurement of signals less than 10 Hz it is generally better to measure the period of the signal.
When set to this mode the Micromite will measure the number of milliseconds between sequential rising edges
of the input signal. The value is updated on the low to high transition so if your signal has a period of (say) 100
seconds you should be prepared to wait that amount of time before the PIN() function will return an updated
value.
The COUNTING pins can also count the number of pulses on their input. When a pin is configured as a
counter (for example, SETPIN 15,CIN) the counter will be reset to zero and Micromite will then count every
transition from a low to high voltage. The counter can be reset to zero again by executing the SETPIN
command a second time (even though the input was already configured as a counter).
The response to input pulses is very fast and the Micromite can count pulses as narrow as 10 nS . The
frequency response depends on the load on the processor (ie, the number of counting inputs and if serial or I2C
communications is used). It can be as high as 800 kHz with no other activity but is normally about 300 kHz.
Digital Outputs
All I/O pins can be configured as a standard digital output. This means that when an output pin is set to logic
low it will pull its output to zero and when set high it will pull its output to 3.3V. In MMBasic this is done
with the PIN command. For example PIN(15) = 0 will set pin 15 to low while PIN(15) = 1 will set it
high. When operating in this mode, a pin is capable of sourcing 10 mA which is sufficient to drive a LED or
other logic circuits running at 3.3V.
The "OC" option on the SETPIN command makes the output pin open collector. This means that the output
driver will pull the output low (to zero volts) when the output is set to a logic low but will go to a high
impedance state when set to logic high. If you then connect a pull-up resistor to 5V (on pins that are 5V
tolerant) the logic high level will be 5V (instead of 3.3V using the standard output mode). The maximum pull-
up voltage in this mode is 5.5V.
Pulse Width Modulation

The PWM (Pulse Width Modulation) command allows the Micromite to generate square waves with a program
controlled duty cycle. By varying the duty cycle you can generate a program controlled voltage output for use
in controlling external devices that require an analog input (power supplies, motor controllers, etc). The PWM
outputs are also useful for driving servos and for generating a sound output via a small transducer.
There are two PWM controllers; the first has three outputs and the second two to give a total of five PWM
outputs. The frequency of each controller can be independently set from 20 Hz to 500 kHz and the duty cycle
for each output (ie, five outputs) can also be independently set from between 0% and 100% with a 0.1%
resolution when the frequency is below 25 kHz (above 25 kHz the resolution is 1% or better up to 250 kHz).
When the Micromite is powered up or the PWM OFF command is used the PWM outputs will be set to high
impedance (they are neither off nor on). So, if you want the PWM output to be low by default (zero power in
most applications) you should use a resistor to pull the output to ground when it is set to high impedance.
Similarly, if you want the default to be high (full power) you should connect the resistor to 3.3V.
Interrupts
Interrupts are a handy way of dealing with an event that can occur at an unpredictable time. An example is
when the user presses a button. In your program you could insert code after each statement to check to see if
the button has been pressed but an interrupt makes for a cleaner and more readable program.

When an interrupt occurs MMBasic will execute a special section of code and when finished return to the main
program. The main program is completely unaware of the interrupt and will carry on as normal.
Any I/O pin that can be used as a digital input can be configured to generate an interrupt using the SETPIN
command with up to ten interrupts active at any one time. Interrupts can be set up to occur on a rising or falling
digital input signal (or both) and will cause an immediate branch to the specified user defined subroutine. The
target can be the same or different for each interrupt. Return from an interrupt is via the END SUB or EXIT
SUB commands. Note that no parameters can be passed to the subroutine however within the interrupt
subroutine calls to other subroutines are allowed.
If two or more interrupts occur at the same time they will be processed in order of the interrupts as defined with
SETPIN. During the processing of an interrupt all other interrupts are disabled until the interrupt subroutine
returns. During an interrupt (and at all times) the value of the interrupt pin can be accessed using the PIN()
function.
Interrupts can occur at any time but they are disabled during INPUT statements. Also interrupts are not
recognised during some long hardware related operations (eg, the TEMPR() function) although they will be
recognised if they are still present when the operation has finished.. When using interrupts the main program is
completely unaffected by the interrupt activity unless a variable used by the main program is changed during
the interrupt.
Because interrupts run in the background they can cause difficult to diagnose bugs. Keep in mind the following
factors when using interrupts:
 For most programs MMBasic will respond to an interrupt in under 30µs however some commands (such
as the TEMPR() function) can block interrupts for up to 200ms and it is possible for an interrupt (eg, a
button press) to occur and vanish within this window and in that case it will never be recognised.
 When inside an interrupt all other interrupts are blocked so your interrupts should be short and exit as
soon as possible. For example, never use PAUSE inside an interrupt. If you have some lengthy
processing to do you should simply set a flag and immediately exit the interrupt, then your main program
loop can detect the flag and do whatever is required.
 The subroutine that the interrupt calls (and any other subroutines called by it) should always be exclusive
to the interrupt. If you must call a subroutine that is also used by an interrupt you must disable the
interrupt first (you can reinstate it after you have finished with the subroutine).
 Remember to disable an interrupt when you have finished needing it – background interrupts can cause
strange and non-intuitive bugs.
In addition to interrupts generated by the change in state of an I/O pin, an interrupt can also be generated by
other sections of MMBasic including timers and communications ports. The list of all these interrupts (in high
to low priority ranking) is:
1. CFunction Interrupt
2. ON KEY
3. I2C Slave Rx
4. I2C Slave Tx
5. COM1: Serial Port
6. COM2: Serial Port
7. COM3: Serial Port (MM+ only)
8. COM4: Serial Port (MM+ only)
9. GUI Int Down (MM+ only)
10. GUI Int Up (MM+ only)
11. WAV Finished (MM+ only)
12. IR Receive
13. I/O Pin Interrupts in order of definition
14. Tick Interrupts (1 to 4 in that order)
As an example: If an ON KEY interrupt occurred at the same time as a COM1: interrupt the ON KEY interrupt
subroutine would be executed first and then, when the interrupt subroutine finished, the COM1: interrupt
subroutine would then be executed.

Timing
MMBasic has a number of features that make it easy to time events and control external circuitry that needs
timing.
MMBasic maintains an internal clock. You can get the current date and time using the DATE$ and TIME$
functions and you can set them by assigning the new date and time to them. The calendar will start from zero
when the Micromite is first powered up but by using the I2C feature you can easily get the time from a real time
clock chip like the PCF8563.
The PAUSE command will freeze the execution of the program for a specified number of milliseconds. So, to
create a 12ms wide pulse you could use the following:
SETPIN 4, DOUT
PIN(4) = 1
PAUSE 12
PIN(4) = 0
You can also create a pulse using the PULSE command. This will generate very narrow pulses (eg, 20µs) or
long pulses up to several days. Long pulses are run in the background and the program will continue
uninterrupted.
Another useful feature is the TIMER function which acts like a stopwatch. You can set it to any value (usually
zero) and it will count upwards every millisecond.
A timing function is also provided by the SETTICK command. This command will generate an interrupt at
regular intervals (specified in milliseconds). Think of it as the regular "tick" of a watch. For example, the
following code fragment will print the current time and the voltage on pin 2 every second. This process will
run independently of the main program which could be doing something completely unrelated.
SETPIN 2, AIN
SETTICK 1000, DOINT
DO
‘ main processing loop
LOOP
SUB DOINT ‘ tick interrupt

PRINT TIME$, PIN(2)
END SUB
The second line sets up the "tick" interrupt, the first parameter of SETTICK is the period of the interrupt
(1000ms) and the second is the starting label of the interrupt code. Every second (ie, 1000 ms) the main
processing loop will be interrupted and the program starting at the label DOINT will be executed.
Up to four "tick" interrupts can be setup. These interrupts have the lowest priority.
The accuracy of the Micromite's internal clock can vary by a little due to manufacturing tolerances and
temperature. To compensate for this the OPTION CLOCKTRIM command can be used to trim the clock to a
more accurate value.

Defined Subroutines and Functions
Defined subroutines and functions are useful features to help in organising programs so that they are easy to
modify and read. A defined subroutine or function is simply a block of programming code that is contained
within a module and can be called from anywhere within your program. It is the same as if you have added
your own command or function to the language.
For example, assume that you would like to have the command FLASH added to MMBasic, its job would be to
flash a LED on pin 2. You could define a subroutine like this:
SUB FLASH
SETPIN 2, DOUT
PIN(2) = 1
PAUSE 100
PIN(2) = 0
END SUB
Then, in your program you just use the command FLASH to flash the LED. For example:
IF A <= B THEN FLASH
If the FLASH subroutine was in program memory you could even try it out at the command prompt, just like
any command in MMBasic. The definition of the FLASH subroutine can be anywhere in the program but
typically it is at the start or end. If MMBasic runs into the definition while running your program it will simply
skip over it.
Subroutine Arguments
Defined subroutines can have arguments (sometimes called parameter lists). In the definition of the subroutine
they look like this:
SUB MYSUB (arg1, arg2$, arg3)
<statements>
<statements>
END SUB
And when you call the subroutine you can assign values to the arguments. For example:
MYSUB 23, "Cat", 55
Inside the subroutine arg1 will have the value 23, arg2$ the value of "Cat", and so on. The arguments act
like ordinary variables but they exist only within the subroutine and will vanish when the subroutine ends. You
can have variables with the same name in the main program and they will be different from arguments defined
for the subroutine (at the risk of making debugging harder).
When calling a subroutine you can supply less than the required number of values. For example:
MYSUB 23
In that case the missing values will be assumed to be either zero or an empty string. For example, in the above
case arg2$ will be set to "" and arg3 will be set to zero. This allows you to have optional values and, if the
value is not supplied by the caller, you can take some special action.
You can also leave out a value in the middle of the list and the same will happen. For example:
MYSUB 23, , 55
Will result in arg2$ being set to "".
Rather than using the type suffix (eg, the $ in arg2$) you can use the suffix AS <type> in the definition of the
subroutine argument and then the argument will be known as the specified type, even when the suffix is not
used. For example:
SUB MYSUB (arg1, arg2 AS STRING, arg3)
IF arg2 = "Cat" THEN …
END SUB
If you do not define the type of the argument it will default to float or that set by OPTION DFAULT. Further,
if you used OPTION DEFAULT NONE to force you to define the type of all variables you will also have to
define them in the subroutine or function definition.

Local Variables
Inside a subroutine you will need to use variables for various tasks. In portable code you do not want the name
you chose for such a variable to clash with a variable of the same name in the main program. To this end you
can define a variable using LOCAL within the subroutine.
For example, this is our FLASH subroutine but this time we have extended it to take an argument (nbr) that
specifies how many times to flash the LED.
SUB FLASH ( nbr )
LOCAL INTEGER count
SETPIN 2, DOUT
FOR count = 1 TO nbr
PIN(2) = 1
PAUSE 100
PIN(2) = 0
PAUSE 150
NEXT count
END SUB
The counting variable (count) is declared as LOCAL within the subroutine which means that (like the
argument list) it only exists within the subroutine and will vanish when the subroutine exits. You can have a
variable called count in your main program and it will be different from the variable count in your
subroutine.
If you do not declare the variable as LOCAL within the subroutine and OPTION EXPLICIT is not in force it
will be created within your program and be visible in your main program and subroutines, just like a normal
variable.
You can also use local variables in the target for GOSUBs. For example:
GOSUB MySub
...
MySub:
LOCAL X, Y
FOR X = 1 TO ...
FOR Y = 5 TO ...
<statements>
RETURN
The variables X and Y will only be valid until the RETURN statement is reached and will be different from
variables with the same name in the main body of the program.
Defined Functions
Defined functions are similar to defined subroutines with the main difference being that the function is used to
return a value in an expression. For example, if you wanted a function to convert a temperature from degrees
Celsius to Fahrenheit you could define:
FUNCTION Fahrenheit(C)
Fahrenheit = C * 1.8 + 32
END FUNCTION
Then you could use it in an expression:
Input " Enter a temperature in Celsius: ", t
PRINT "That is the same as" Fahrenheit(t) "F"
You could also define the reverse:
FUNCTION Celsius(F)
Celsius = (F - 32) * 0.5556
END FUNCTION
The rules for the argument list in a function are similar to subroutines. The only difference is that brackets are
required around the argument list when you are calling a function, even if there are no arguments (they are
optional when calling a subroutine).
To return a value from the function you assign a value to the function's name within the function. If the
function's name is terminated with a $, a % or a ! the function will return that type, otherwise it will return
whatever the OPTION DEFAULT is set to.

You can also specify the type of the function by adding AS <type> to the end of the function definition. For
example:
FUNCTION Fahrenheit(C) AS FLOAT
The suffix ! specifies floating point so you can also use this:
FUNCTION Fahrenheit!(C)
Within the function the function's name acts like a standard variable (a float in this case).
As another example, let us say that you need a function to format time in the AM/PM format:
FUNCTION MyTime$(hours, minutes)
LOCAL h
h = hours
IF hours > 12 THEN h = h - 12
MyTime$ = STR$(h) + ":" + STR$(minutes)
IF hours <= 12 THEN
MyTime$ = MyTime$ + "AM"
ELSE
MyTime$ = MyTime$ + "PM"
ENDIF
END FUNCTION
As you can see, the function name is used as an ordinary local variable inside the subroutine. It is only when
the function returns that the value assigned to MyTime$ is made available to the expression that called it.
This example also illustrates that you can use local variables within functions just like subroutines.
Passing Arguments by Reference

If you use an ordinary variable (ie, not an expression) as the value when calling a subroutine or a function, the
argument within the subroutine/function will point back to the variable used in the call and any changes to the
argument will also be made to the supplied variable. This is called passing arguments by reference.
For example, you might define a subroutine to swap two values, as follows:
SUB Swap a, b
LOCAL t
t = a
a = b
b = t
END SUB
In your calling program you would use variables for both arguments:
Swap nbr1, nbr2
And the result will be that the values of nbr1 and nbr2 will be swapped.
For this to work the type of the variable passed (eg, nbr1) and the defined argument (eg, a) must be the same
(in the above example both default to float).
Unless you need to return a value via the argument you should not use an argument as a general purpose
variable inside a subroutine or function. This is because another user of your routine may unwittingly use a
variable in their call and that variable will be "magically" changed by your routine. It is much safer to assign
the argument to a local variable and manipulate that instead.
Passing Arrays
Single elements of an array can be passed to a subroutine or function and they will be treated the same as a
normal variable. For example, this is a valid way of calling the Swap subroutine (discussed above):
Swap dat(i), dat(i + 1)
This type of construct is often used in sorting arrays.
You can also pass one or more complete arrays to a subroutine or function by specifying the array with empty
brackets instead of the normal dimensions. For example, a(). In the subroutine or function definition the
associated parameter must also be specified with empty brackets. The type (ie, float, integer or string) of the
argument supplied and the parameter in the definition must be the same.
In the subroutine or function the array will inherit the dimensions of the array passed and these must be
respected when indexing into the array. If required the dimensions of the array could be passed as additional
arguments to the subroutine or function so it could correctly manipulate the array. The array is passed by

reference which means that any changes made to the array within the subroutine or function will also apply to
the supplied array.
For example, when the following is run the words "Hello World" will be printed out:
DIM MyStr$(5, 5)
MyStr$(4, 4) = "Hello" : MyStr$(4, 5) = "World"
Concat MyStr$()
PRINT MyStr$(0, 0)
SUB Concat arg$()
arg$(0,0) = arg$(4, 4) + " " + arg$(4, 5)
END SUB
Early Exit
There can be only one END SUB or END FUNCTION for each definition of a subroutine or function. To exit
early from a subroutine (ie, before the END SUB command has been reached) you can use the EXIT SUB
command. This has the same effect as if the program reached the END SUB statement. Similarly you can use
EXIT FUNCTION to exit early from a function.
Recursion
Recursion is where a subroutine or function calls itself. You can do recursion in MMBasic but there are a
number of issues (these are a direct consequence of the limited memory on microcontrollers):
 There is a fixed limit to the depth of recursion. In the Micromite and Micromite Plus this is 50 levels.
 If you have many arguments to the subroutine or function and many LOCAL variables (especially
strings) you could easily run out of memory before reaching the 50 level limit.
 Any FOR…NEXT loops and DO…LOOPs will be corrupted if the subroutine or function is recursively
called from within these loops.
Example of a Defined Function

There is often the need for a special command or function to be implemented in MMBasic but in many cases
these can be constructed using a defined subroutine or function which will then act exactly the same as a built
in command or function.
For example, sometimes there is a requirement for a TRIM function which will trim specified characters from
the start and end of a string. The following provides an example of how to construct such a simple function in
MMBasic.
The first argument to the function is the string to be trimmed and the second is a string containing the
characters to trim from the first string. RTrim$() will trim the specified characters from the end of the string,
LTrim$() from the beginning and Trim$() from both ends.
' trim any characters in c$ from the start and end of s$

Function Trim$(s$, c$)
Trim$ = RTrim$(LTrim$(s$, c$), c$)
End Function
' trim any characters in c$ from the end of s$

Function RTrim$(s$, c$)
RTrim$ = s$
Do While Instr(c$, Right$(RTrim$, 1))
RTrim$ = Mid$(RTrim$, 1, Len(RTrim$) - 1)
Loop
End Function
' trim any characters in c$ from the start of s$

Function LTrim$(s$, c$)
LTrim$ = s$
Do While Instr(c$, Left$(LTrim$, 1))
LTrim$ = Mid$(LTrim$, 2)
Loop
End Function

As an example of using these functions:
S$ = " ****23.56700 "
PRINT Trim$(s$, " ")
Will give "****23.56700"
PRINT Trim$(s$, " *0")
Will give "23.567"
PRINT LTrim$(s$, " *0")
Will give "23.56700"

Special Functions and the Library
There are a number of features of the Micromite that enable the advanced user to add features to MMBasic and
perform special operations at startup. Most programs will not need to use these features but they are handy for
the advanced user who needs more control over the Micromite.
Embedded C Routines
It is possible to add program modules that are written in the C language or MIPS assembler to MMBasic. They
are called CFunctions or CSubs and to the BASIC program they look the same as the MMBasic built in
functions and subroutines. Generally these modules can run much faster than a BASIC program and can more
easily access the special hardware features of the PIC32 microcontroller.
The firmware distribution for the Micromite includes a subdirectory titled "Embedded C Modules" which
contains a selection of embedded C routines and fonts plus notes on how use this feature and write your own
embedded C modules and create embedded fonts.
The Library
Using the LIBRARY feature it is possible to create BASIC functions, subroutines and embedded fonts and add
them to MMBasic to make them permanent and part of the language. For example, you might have written a
series of subroutines and functions that perform sophisticated bit manipulation; these could be stored as a
library and become part of MMBasic and perform the same as other built in functions that are already part of
the language. An embedded font can also be added the same way and used just like a normal font.
To install components into the library you need to write and test the routines as you would with any normal
BASIC routines. When they are working correctly you can use the LIBRARY SAVE command. This will
transfer the routines (as many as you like) to a non visible part of flash memory where they will be available to
any BASIC program but will not show when the LIST command is used and will not be deleted when a new
program is loaded or NEW is used. However, the saved subroutines and functions can be called from within
the main program and can even be run at the command prompt (just like a built in command or function).
Some points to note:
 Library routines act exactly like normal BASIC code and can consist of any number of subroutines,
functions, embedded C routines and fonts. The only difference is that they do not show when a program
is listed and are not deleted when a new program is loaded.
 Library routines can create and access global variables and are subject to the same rules as the main
program – for example, respecting OPTION EXPLICIT if it is set.
 When the routines are transferred to the library MMBasic will compress them by removing comments,
extra spaces, blank lines and the hex codes in embedded C routines and fonts. This makes the library
space efficient, especially when loading large fonts. Following the save the program area is cleared.
 You can use the LIBRARY SAVE command multiple times. With each save the new contents of the
program space are appended to the already existing code in the library.
 You can use line numbers in the library but you cannot use a line number on an otherwise empty line as
the target for a GOTO, etc. This is because the LIBRARY SAVE command will remove any blank lines.
 You can use READ commands in the library but they will default to reading DATA statements in the
main program memory. If you want to read from DATA statements in the library you must use the
RESTORE command before the first READ command. This will reset the pointer to the library space.
As an example you could save the following into the library:
CFunction CPUSpeed
00000000 3c02bf81 8c45f000 8c43f000 3c02003d 24420900 7ca51400 70a23002
3c040393 34848700 7c6316c0 00c41021 00621007 3c03029f 24636300 10430005
00402021 00002821 00801021 03e00008 00a01821 3c0402dc 34846c00 00002821
00801021 03e00008 00a01821
End CFunction
This would have the effect of adding a new function (called CPUSpeed) to MMBasic. You could even run it at
the command prompt:
> PRINT CPUSpeed()
40000000

You can see what is in the library by using the LIBRARY LIST command which will list the contents of the
library space. In addition the MEMORY command can be used to display the amount of flash memory used by
the library.
To delete the routines in the library space you use the LIBRARY DELETE command. This will clear the space
and return the flash memory used by the library back to the general pool used by normal programs. The only
other way to delete a library is to reset MMBasic to its original configuration as described in the chapter
"Resetting MMBasic" earlier in this manual.
Program Initialisation
The library can also include code that is not contained within a subroutine or function. This code (if it exists)
will be run automatically before a program starts running (ie, via the RUN command). This feature can be used
to initialise constants or setup MMBasic in some way. For example, if you wanted to set some constants you
could include the following lines in the library code:
CONST TRUE = 1
CONST FALSE = 0
For all intents and purposes the identifiers TRUE and FALSE have been added to the language and will be
available to any program that is run on the Micromite.
MM.STARTUP
There may be a need to execute some code on initial power up, regardless of the program in main memory.
Perhaps to initialise some hardware, set some options or print a custom startup banner. This can be
accomplished by creating a subroutine with the name MM.STARTUP and saving it in the library space (see
above). When the Micromite is first powered up or reset it will search for this subroutine and, if found, it will
be run once.
For example, if the Micromite has a real time clock attached, the library could contain the following code:
SUB MM.STARTUP
RTC GETTIME
END SUB
This would cause the internal clock within MMBasic to be set to the current time on every power up or reset.
Using MM.STARTUP is similar to using the OPTION AUTORUN feature, the difference being that the
AUTORUN option will cause the whole program in memory to be run from the start where MM.STARTUP
will just run the code within the subroutine. The AUTORUN option and MM.STARTUP can be used together
and in that case the MM.STARTUP subroutine is run first, then the program in main memory.
Note that you should not use MM.STARTUP for general setup of MMBasic (like dimensioning arrays, opening
communication channels, etc) before running a program. The reason is that when you use the RUN command
MMBasic will clear the interpreter's state ready for a fresh start. If you do want to setup MMBasic like this you
can place the code for this in the LIBRARY (but not in a subroutine or function) as this is run after the RUN
command has reset the interpreter's state but before the program in main memory is run.
MM.PROMPT
If a subroutine with this name exists it will be automatically executed by MMBasic instead of displaying the
command prompt. This can be used to display a custom prompt, set colours, define variables, etc all of which
will be active at the command prompt.
This subroutine can be located in the library space (recommended) or in the main program.
Note that MMBasic will clear all variables and I/O pin settings when a program is run so anything set in this
subroutine will only be valid for commands typed at the command prompt (ie, in immediate mode). To
initialise variables, constants, communications, etc for use inside a BASIC program the code for this should be
placed in the LIBRARY (but not in a subroutine or function).
As an example the following will display a custom prompt:
SUB MM.PROMPT
PRINT TIME$ "> ";
END SUB
Note that while constants can be defined they will not be visible because a constant defined inside a subroutine
is local to a subroutine. However, DIM will create variables that are global that that should be used instead.

Flow Diagram
The operation of MMBasic at startup and the interaction between the library and the special functions is best
illustrated using a flow diagram. The following is a high level diagram (for example, it does not show the
complications caused by the CONTINUE command) but it does place the functions of MM.STARTUP and
MM.PROMPT into context:

Embedding Configuration Options in a Program
Normally configurations options such as OPTION LCDPANEL are entered at the command prompt to
configure the Micromite for an attached display panel, touch controller, etc. The drivers for these devices are
enabled at startup so after using the option command the Micromite will immediately restart (ie, reboot). The
user does not notice this (because it is quick) but this it is the reason why the commands should be entered at
the command prompt and not in a program.
For most users entering the commands at the prompt is sufficient. However, for various reasons sophisticated
users might need to embed these commands in a program and it is possible to do this if a few simple rules are
followed. These are:
 The commands must be at the start of the programs (they may be preceded by comments).
 They should be in the same order as they would be entered at the command prompt. For example
OPTION LCDPANEL should come before OPTION TOUCH.
 They should be thoroughly tested at the command prompt before being embedded in a program as errors
may not be detected and can cause the Micromite to behave strangely.
 They must be followed by the command OPTION SAVE.
When MMBasic finds configuration commands in a program it will record the settings without restarting the
processor. Then, when it encounters the OPTION SAVE command, all the settings will be saved to flash and
the processor will be restarted to enable all the drivers at the same time. After the restart the program will be
run again but this time the configuration commands and OPTION SAVE command will have no effect because
the devices are already configured and the drivers enabled.
The calibration parameters for the touch controller can also be configured in this way. To do this you should
use GUI CALIBRATE to calibrate the touch screen at the command prompt in the normal way. Then use
OPTION LIST which will list the calibration parameters as something like:
GUI CALIBRATE 0, 252, 306, 932, 730
This string must be included before the OPTION SAVE so that the touch calibration settings will be saved
along with the other options.
This restart only occurs once at the first time the configuration options are encountered. If another program
with different embedded options is run MMBasic will detect the change, reconfigure the drivers and execute
another reboot and re run the program.
Errors in the configuration commands (for example the same I/O pin allocated to two different functions) are
often detected during the reboot. However, this is not guaranteed so the configuration commands should be
thoroughly tested at the command prompt before being embedded in a program.
This is an example of the sequence to configure a Micromite for use in the Micromite LCD Backpack:
OPTION LCDPANEL ILI9341, LANDSCAPE, 2, 23, 6
OPTION TOUCH 7, 15
GUI CALIBRATE 0, 252, 306, 932, 730
OPTION SAVE

Electrical Characteristics
Power Supply
Voltage range: 2.3 to 3.6V (3.3V nominal). Absolute maximum 4.0V.
Current draw: 31 mA to 6 mA depending on the clock speed.
Current in sleep: 40 µA (plus current draw from the I/O pins).
Digital Inputs
Logic Low: 0 to 0.65V
Logic High: 2.5V to 3.3V on normal pins
2.5V to 5.5V on pins rated at 5V
Input Impedance: >1 MΩ. All digital inputs are Schmitt Trigger buffered.
Frequency Response: Up to 300 kHz (pulse width 20 nS or more) on the counting inputs (pins 15 to 18).
Analog Inputs
Voltage Range: 0 to 3.3V
Accuracy: Analog measurements are referenced to the supply voltage on pin 28 and the
ground on pin 27. If the supply voltage is precisely 3.3V the typical accuracy of
readings will be ±1%.
Input Impedance: >1 MΩ (for accurate readings the source impedance should be < 5K)
Digital Outputs
Typical current draw or sink ability on any I/O pin: 10 mA
Absolute maximum current draw or sink on any I/O pin: 15 mA
Absolute maximum current draw or sink for all I/O pins combined: 200 mA
Maximum open collector voltage: 5.5V
Timing Accuracy
All timing functions (the timer, tick interrupts, PWM frequency, baud rate, etc) are dependent on the
internal clock. The Micromite uses a fast RC oscillator which has a specified tolerance of ±0.9% but
typically is within ±0.1% at 24ºC.
PWM Output
Frequency range: 20 Hz to 500 kHz
Duty cycle: 0% to 100% with 0.1% resolution below 25 kHz
Serial Communications Ports

Console: Default 38400 baud. Range is 100 bps to 230400 bps (at 40 MHz).
COM ports Default 9600 baud. Range is 10 bps to 230400 bps (at 40 MHz). The maximum is
limited by the clock speed. See Appendix A for details.
Other Communications Ports

SPI 10 Hz to 10 MHz (at 40 MHz). Limited to one quarter of the clock speed.
I2C 10kHz to 400 kHz.
1-Wire: Fixed at 15 kHz.
Flash Endurance
Over 20,000 erase/write cycles.
Every program save incurs one erase/write cycle. In a normal program development it is highly unlikely
that more than a few hundred program saves would be required.
Saved variables (VAR SAVE command) and configuration options (the OPTION command) also use one
erase/write cycle each time the command is used. Usage of the VAR SAVE command should be limited to
an average of once a day over the entire life of the chip (50 years).

MMBasic Characteristics
Naming Conventions
Command names, function names, labels, variable names, etc are not case sensitive, so that "Run" and "RUN"
are equivalent and "dOO" and "Doo" refer to the same variable.
The type of a variable can be specified in the DIM command or by adding a suffix to the end of the variable's
name. For example the suffix for an integer is '%' so if a variable called nbr% is automatically created it will be
an integer. There are three types of variables:
1. Floating point. These can store a number with a decimal point and fraction (eg, 45.386) and also very
large numbers. However, they will lose accuracy when more than seven significant digits are stored or
manipulated. The suffix is '!' and floating point is the default when a variable is created without a suffix
2. 64-bit integer. These can store numbers with up to 19 decimal digits without losing accuracy but they
cannot store fractions (ie, the part following the decimal point). The suffix for an integer is '%'
3. Strings. These will store a string of characters (eg, "Tom"). The suffix for a string is the '$' symbol
(eg, name$, s$, etc) Strings can be up to 255 characters long.
Variable names and labels can start with an alphabetic character or underscore and can contain any alphabetic
or numeric character, the period (.) and the underscore (_). They may be up to 32 characters long. A variable
name or a label must not be the same as a command or a function or one of the following keywords: THEN,
ELSE, TO, STEP, FOR, WHILE, UNTIL, MOD, NOT, AND, OR, XOR, AS. Eg, step = 5 is illegal.
Constants
Numeric constants may begin with a numeric digit (0-9) for a decimal constant, &H for a hexadecimal
constant, &O for an octal constant or &B for a binary constant. For example &B1000 is the same as the
decimal constant 8. Constants that start with &H, &O or &B are always treated as 64-bit integer constants.
Decimal constants may be preceded with a minus (-) or plus (+) and may be terminated with 'E' followed by an
exponent number to denote exponential notation. For example 1.6E+4 is the same as 16000.
If the decimal constant contains a decimal point or an exponent, it will be treated as a floating point constant;
otherwise it will be treated as a 64-bit integer constant.
String constants are surrounded by double quote marks ("). Eg, "Hello World".
Operators and Precedence

The following operators, in order of precedence, are recognised. Operators that are on the same level (for
example + and -) are processed with a left to right precedence as they occur on the program line.
Arithmetic operators:
^ Exponentiation (eg, b^n means bn)
* / \ MOD Multiplication, division, integer division and modulus (remainder)
+ - Addition and subtraction
Shift operators:
x << y x >> y These operate in a special way. << means that the value returned
will be the value of x shifted by y bits to the left while >> means the
same only right shifted. They are integer functions and any bits
shifted off are discarded and any bits introduced are set to zero.
Logical operators:
NOT invert the logical value on the right (eg, NOT a=b is a<>b)
<> < > <= =< Inequality, less than, greater than, less than or equal to, less than or
>= => equal to (alternative version), greater than or equal to, greater than or
equal to (alternative version)
= equality
AND OR XOR Conjunction, disjunction, exclusive or

For Microsoft compatibility the operators AND, OR and XOR are integer bitwise operators. For example,
PRINT (3 AND 6) will output the number 2. Because these operators can act as both logical operators (for
example, IF a=5 AND b=8 THEN …) and as a bitwise operators (eg, y% = x% AND &B1010) the interpreter
will be confused if they are mixed in the same expression. So, always evaluate logical and bitwise expressions
in separate expressions.
The other logical operations result in the integer 0 (zero) for false and 1 for true. For example, the statement
PRINT 4 >= 5 will print the number zero on the output and the expression A = 3 > 2 will store +1 in A.
The NOT operator will invert the logical value on its right (it is not a bitwise invert). It is also the highest in
precedence so it will bind tightly to the next value. For normal use the logic expression to be negated should be
placed in brackets. For example, IF NOT (A = 3 OR A = 8) THEN …
String operators:
+ Join two strings
<> < > <= =< Inequality, less than, greater than, less than or equal to, less than or
>= => equal to (alternative version), greater than or equal to, greater than or
equal to (alternative version)
= Equality
String comparisons respect case. For example "A" is greater than "a".
Implementation Characteristics
Maximum program size (as plain text) is 53KB. Note that MMBasic tokenises the program when it is stored in
flash so the final size in flash might vary from the plain text size.
Maximum length of a command line is 255 characters.
Maximum length of a variable name or a label is 32 characters.
Maximum number of dimensions to an array is 8.
Maximum number of arguments to commands that accept a variable number of arguments is 50.
Maximum number of nested FOR…NEXT loops is 10.
Maximum number of nested DO…LOOP commands is 10.
Maximum number of nested GOSUBs, subroutines and functions (combined) is 50.
Maximum number of nested multiline IF…ELSE…ENDIF commands is 10.
Maximum number of user defined subroutines and functions (combined): 100 (200 in the Micromite Plus)
Maximum number of interrupt pins that can be configured: 10
Numbers are stored and manipulated as single precision floating point numbers or 64-bit signed integers. The
maximum floating point number allowable is 3.40282347e+38 and the minimum is 1.17549435e-38. The
Micromite Plus uses double precision (see the Micromite Plus User Manual).
The range of 64-bit integers (whole numbers) that can be manipulated is ± 9223372036854775807.
Maximum string length is 255 characters.
Maximum line number is 65000.
Maximum number of background pulses launched by the PULSE command is 5.
Compatibility
MMBasic implements a large subset of Microsoft’s GW-BASIC. There are numerous differences due to
physical and practical considerations but most standard BASIC commands and functions are essentially the
same. An online manual for GW-BASIC is available at http://www.antonis.de/qbebooks/gwbasman/index.html
and this provides a more detailed description of the commands and functions.
MMBasic also implements a number of modern programming structures documented in the ANSI Standard for
Full BASIC (X3.113-1987) or ISO/IEC 10279:1991. These include SUB/END SUB, the DO WHILE …
LOOP, the SELECT…CASE statements and structured IF .. THEN … ELSE … ENDIF statements.

Predefined Read Only Variables
Detailed Listing
These variables are set by MMBasic and cannot be changed by the running program.
MM.VER The version number of the firmware as a floating point number in the form
aa.bbcc where aa is the major version number, bb is the minor version
number and cc is the revision number. For example version 5.03.00 will
return 5.03 and version 5.03.01 will return 5.0301.
MM.DEVICE$ A string representing the device or platform that MMBasic is running on.
Currently this variable will contain one of the following:
"Maximite" on the standard Maximite and compatibles.
"Colour Maximite" on the Colour Maximite and UBW32.
"Colour Maximite 2" on the Colour Maximite 2.
"DuinoMite" when running on one of the DuinoMite family.
"DOS" when running on Windows in a DOS box.
"Generic PIC32" for the generic version of MMBasic on a PIC32.
"Micromite" on the PIC32MX150/250
"Micromite MkII" on the PIC32MX170/270
"Micromite Plus" on the PIC32MX470
"Micromite Extreme" on the PIC32MZ series
MM.ERRNO If a statement caused an error which was ignored these variables will be set
MM.ERRMSG$ accordingly. MM.ERRNO is a number where non zero means that there was
an error and MM.ERRMSG$ is a string representing the error message that
would have normally been displayed on the console. They are reset to zero
and an empty string by RUN, ON ERROR IGNORE or ON ERROR SKIP.
MM.HRES Integers representing the horizontal and vertical resolution of the LCD
MM.VRES display panel (if configured) in pixels.
MM.FONTHEIGHT Integers representing the height and width of the current font (in pixels).
MM.FONTWIDTH
MM.WATCHDOG An integer which is true if MMBasic was restarted as the result of a

Watchdog timeout (see the WATCHDOG command). False if MMBasic
started up normally.
MM.I2C Following an I2C write or read command this integer variable will be set to
indicate the result of the operation as follows:
0 = The command completed without error.
1 = Received a NACK response
2 = Command timed out
MM.ONEWIRE Following a 1-Wire reset function this integer variable will be set to indicate
the result of the operation as follows:
0 = Device not found.
1 = Device found

Commands
Detailed Listing
Note that the commands related to the I2C, 1-Wire, and SPI communications functions are not listed here but
are described in the appendices at the end of this document.
Square brackets indicate that the parameter or characters are optional.
‘ (single quotation mark) Starts a comment and any text following it will be ignored. Comments can
be placed anywhere on a line.
? (question mark) Shortcut for the PRINT command.
AUTOSAVE Enter automatic program entry mode.
or This command will take lines of text from the console serial input and save
AUTOSAVE CRUNCH them to memory. This mode is terminated by entering Control-Z which will
then cause the received data to be saved into program memory overwriting
the previous program.
The CRUNCH option instructs MMBasic to remove all comments, blank
lines and unnecessary spaces from the program before saving. This can be
used on large programs to allow them to fit into limited memory. CRUNCH
can be abbreviated to the single letter C.
At any time this command can be aborted by Control-C which will leave
program memory untouched.
This is one way of transferring a BASIC program into the Micromite. The
program to be transferred can be pasted into a terminal emulator and this
command will capture the text stream and store it into program memory. It
can also be used for entering a small program directly at the console input.
BOX x, y, w, h [, lw] [,c] Draws a box on the attached LCD panel with the top left hand corner at 'x'
[,fill] and 'y' with a width of 'w' pixels and a height of 'h' pixels.
'lw' is the width of the sides of the box and can be zero. It defaults to 1.
'c' specifies the colour and defaults to the default foreground colour if not
specified.
'fill' is the fill colour. It can be omitted or set to -1 in which case the box will
not be filled.
See the chapter "Basic Drawing Commands" for a definition of the colours
and graphics coordinates.
CFUNCTION name type [,type] Defines the binary code for an embedded machine code program module
hex [[ hex[…] written in C or MIPS assembler. The module will appear in MMBasic as the
command or function 'name' and can be used in the same manner as a built-
hex [[ hex[…]
in command or function.
END CFUNCTION
This command specifies the hex codes for the module. This code is
automatically programmed into MMBasic when the program is saved. Each
or 'hex' must be exactly eight hex digits representing the bits in a 32-bit word.
 Each 'hex' word must be separated by one or more spaces and multiple
CSUB name(type [, type]) rtype lines of 'hex' words can be used. The command must be terminated by
hex [[ hex[…] a matching END CSUB or END CFUNCTION.
hex [[ hex[…]  The first 'hex' word must be the offset (in 32-bit words) to the entry
point of the embedded routine (usually the function main()).
END CSUB
 Multiple embedded routines can be used in a program with each
defining a different module with a different 'name'.
 During execution MMBasic will skip over any CSUB or CFUNCTION
commands so they can be placed anywhere in the program.
Any errors in the data format will be reported when the program is saved.
The type of each parameter can be specified in the definition. For example:
CSub MySub integer, integer, string

This specifies that there will be three parameters, the first two being integers
and the third a string.
As well as defining the types of the parameters a CFunction can also specify
the type of the value returned. For example, the following returns a string:
CFunction MyFunct(integer, string) string
The 'name' created by these commands can be used as a normal command or
function within MMBasic.
The arguments passed have three caveats:
 Up to ten values can be specified as arguments ('arg1', 'arg2', etc) and
they will be passed to the embedded C routine as pointers to the
memory space allocated to each value (ie, the result of the expression).
 If a variable or array is specified as an argument the C routine will
receive a pointer to the memory allocated to the variable or array and
the C routine can change this memory to return a value to the caller.
 In the case of arrays, they should be passed with empty brackets. eg,
arg(). In the C function the argument will be supplied as a pointer to
the first element of the array.
For more details refer to the "Embedded C Modules" documentation in the
Micromite firmware file.
CIRCLE x, y, r [,lw] [, a] [, Draw a circle on the video output centred at 'x' and 'y' with a radius of 'r' on
c] [, fill] the attached LCD panel. ‘lw’ is optional and is the line width (defaults to 1).
'c' is the optional colour and defaults to the current foreground colour if not
specified.
The optional 'a' is a floating point number which will define the aspect ratio.
If the aspect is not specified the default is 1.0 which gives a standard circle
not be filled.
CLEAR Delete all variables and recover the memory used by them.
See ERASE for deleting specific array variables.
CLOSE [#]nbr [,[#]nbr] … Close the serial communications port(s) previously opened with the file
number ‘nbr’. The # is optional.
This command will wait for any characters remaining in the transmit buffer
to be sent before closing the port.
Also see the OPEN command.
CLS [colour] Clears the LCD panel's screen. Optionally 'colour' can be specified which
will be used for the background when clearing the screen.
COLOUR fore [, back] Sets the default colour for commands (PRINT, etc) that display on the on the
or attached LCD panel. 'fore' is the foreground colour, 'back' is the background
COLOR fore [, back] colour. The background is optional and if not specified will default to black.
CONST id = expression Create a constant identifier which cannot be changed once created.
[, id = expression] … etc 'id' is the identifier which follows the same rules as for variables. The
identifier can have a type suffix (!, %, or $) but it is not required. If it is
specified it must match the type of 'expression'.
'expression' is the value of the identifier and it can be a normal expression
(including user defined functions) which will be evaluated when the constant
is created.
A constant defined outside a sub or function is global and can be seen
throughout the program. A constant defined inside a sub or function is local
to that routine and will hide a global constant with the same name.

CONTINUE Resume running a program that has been stopped by an END statement, an
error, or CTRL-C. The program will restart with the next statement
following the previous stopping point.
Note that it is not always possible to resume the program correctly – this
particularly applies to complex programs with graphics, nested loops and/or
nested subroutines and functions.
CONTINUE DO Skip to the end of a DO/LOOP or a FOR/NEXT loop. The loop condition
or will then be tested and if still valid the loop will continue with the next
iteration.
CONTINUE FOR
CPU speed Set the clock speed of the processor.
'speed' is set in MHz and on the 28/44 pin Micromite it can be either 48, 40,
30, 20, 10, 5, 1 or 0.5.
On the Micromite Plus it can be 120, 100, 80, 60, 48, 40, 30, 20, 10 or 5.
Current drawn by the chip is proportional to the clock speed, so by halving
the clock speed the current drain is roughly halved. The default speed of the
CPU when power is applied is 40 MHz on the 28/44 pin Micromite and
100MHz on the Micromite Plus.
When the speed is changed all timing functions in MMBasic will be
automatically corrected to keep the correct time and the console baud rate
will be unchanged. The serial communications ports can remain open during
the speed change and their speed will be adjusted accordingly. Note that
there may be a glitch while changing speed and some characters may be lost
or corrupted.
The speed of any SPI, I2C and PWM functions open at the time will change
with the clock speed. For this reason they should be closed before this
command is used and reopened after.
The speeds of 1MHz and 0.5MHz are intended for power sensitive
applications and have a number of limitations:
 The maximum console speed is 4800 baud and 2400 baud respectively.
 The following commands/features will not work; tick timers (ie,
SETTICK), I2C functions, PULSE, TEMPR(), IR and counting inputs
(ie, frequency, period, etc).
 COM2: is unavailable.
 The maximum speed of serial, SPI and PWM ports will be limited.
CPU SLEEP Put the CPU to sleep. In this mode the running program will be halted and
or the current drain reduced to about 40 µA.
CPU SLEEP seconds [, abortpin] In the first form the WAKEUP pin (see the pinout tables at the start of this
manual) will be automatically configured as a digital input and any change
in its state (ie, from high to low or low to high) will wakeup the CPU. The
time required to "wake up" in this mode is less than 1 ms.
The IR command shares the WAKEUP pin and if it is running the CPU will
be awakened by the remote key press and MMBasic will immediately
decode the signal and execute the IR interrupt.
In the second form (CPU SLEEP seconds) the command will put the CPU to
sleep for the specified number of 'seconds' (accuracy is ±20%). The TIMER
function and the internal clock/calendar will be updated when the sleep
finishes.
The timed sleep can be terminated early if 'abortpin' is specified. This can
be any I/O pin and any change in its state (ie, from high to low or low to
high) will abort the sleep. It can take up to a second for the abort signal to
be recognised so the change of state must be maintained for at least this
time.
Notes:

 The CPU will go to sleep in the middle of the SLEEP command and
when awakened continue with normal program execution.
 All communications (serial, SPI, I2C and 1-Wire) and PWM will be
frozen during sleep. When the CPU comes out of sleep they will resume
normal processing. It is recommended that they be closed before
entering sleep as they will add to the current drawn by the chip in sleep.
 External circuitry and program features can cause extra current drain
while in sleep. See the section Micromite Special Features for the steps
that should be taken to minimise the current drawn during sleep.
 All timing functions will freeze during the sleep, this includes the real
time clock and background pulse commands.
 CTRL-C on the console will not bring the chip out of sleep.
CPU RESTART Will force a restart of the processor.
This will clear all variables and reset everything (eg, timers, COM ports, I2C,
etc) similar to a power up situation but without the power up banner.
If OPTION AUTORUN has been set the program in memory will restart.
DATA constant[,constant]... Stores numerical and string constants to be accessed by READ.
In general string constants should be surrounded by double quotes ("). An
exception is when the string consists of just alphanumeric characters that do
not represent MMBasic keywords (such as THEN, WHILE, etc). In that
case quotes are not needed.
Numerical constants can also be expressions such as 5 * 60.
DATE$ = "DD-MM-YY" Set the date of the internal clock/calendar.
or DD, MM and YY are numbers, for example: DATE$ = "28-7-2014"
DATE$ = "DD/MM/YY" The date is set to "01-01-2000" on power up.
DEFINEFONT #Nbr This will define an embedded font which can be used alongside or to replace
hex [[ hex[…] the built in font(s) used on an attached LCD panel. These work exactly same
as the built in fonts (ie, selected using the FONT command or specified in
hex [[ hex[…]
the TEXT command).
END DEFINEFONT
See the Embedded Fonts folder in the Micromite distribution zip file for a
selection of embedded fonts and a full description of how to create them.
'#Nbr' is the font's reference number (from 1 to 16). It can be the same
number as a built in font and in that case it will replace the built in font.
Each 'hex' must be exactly eight hex digits and be separated by spaces or
new lines from the next.
 Multiple lines of 'hex' words can be used with the command terminated
by a matching END DEFINEFONT.
 Multiple embedded fonts can be used in a program with each defining a
different font with a different font number.
 During execution MMBasic will skip over any DEFINEFONT
commands so they can be placed anywhere in the program.
 Any errors in the data format will be reported when the program is
saved.
DIM [type] decl [,decl]... Declares one or more variables (ie, makes the variable name and its
where 'decl' is: characteristics known to the interpreter).
var [length] [type] [init] When OPTION EXPLICIT is used (as recommended) the DIM, LOCAL or
STATIC commands are the only way that a variable can be created. If this
'var' is a variable name with
option is not used then using the DIM command is optional and if not used
optional dimensions
the variable will be created automatically when first referenced.
'length' is used to set the
The type of the variable (ie, string, float or integer) can be specified in one of
maximum size of the string to 'n'
three ways:
as in LENGTH n

'type' is one of FLOAT or By using a type suffix (ie, !, % or $ for float, integer or string). For
INTEGER or STRING (the type example:
can be prefixed by the keyword DIM nbr%, amount!, name$
AS - as in AS FLOAT)
By using one of the keywords FLOAT, INTEGER or STRING immediately
'init' is the value to initialise the after the command DIM and before the variable(s) are listed. The specified
variable and consists of: type then applies to all variables listed (ie, it does not have to be repeated).
= <expression> For example:
For a simple variable one DIM STRING first_name, last_name, city
expression is used, for an array a
By using the Microsoft convention of using the keyword "AS" and the type
list of comma separated
keyword (ie, FLOAT, INTEGER or STRING) after each variable. If you
expressions surrounded by use this method the type must be specified for each variable and can be
brackets is used. changed from variable to variable.
For example:
DIM amount AS FLOAT, name AS STRING
Examples: Floating point or integer variables will be set to zero when created and
DIM nbr(50) strings will be set to an empty string (ie, ""). You can initialise the value of
DIM INTEGER nbr(50) the variable with something different by using an equals symbol (=) and an
DIM name AS STRING expression following the variable definition. For example:
DIM a, b$, nbr(100), strn$(20) DIM STRING city = "Perth", house = "Brick"
DIM a(5,5,5), b(1000) The initialising value can be an expression (including other variables) and
will be evaluated when the DIM command is executed. See the chapter
DIM strn$(200) LENGTH 20
"Defining and Using Variables" for more examples of the syntax.
DIM STRING strn(200)
As well as declaring simple variables the DIM command will also declare
LENGTH 20
arrayed variables (ie, an indexed variable with a number of dimensions).
DIM a = 1234, b = 345 Following the variable's name the dimensions are specified by a list of
DIM STRING strn = "text" numbers separated by commas and enclosed in brackets. For example:
DIM x%(3) = (11, 22, 33, 44) DIM array(10, 20)
Each number specifies the number of elements in each dimension. Normally
the numbering of each dimension starts at 0 but the OPTION BASE
command can be used to change this to 1.
The above example specifies a two dimensional array with 11 elements (0 to
10) in the first dimension and 21 (0 to 20) in the second dimension. The
total number of elements is 231 and because each floating point number on
the Micromite requires 4 bytes a total of 924 bytes of memory will be
allocated (floating point on the Micromite Plus and integers are different and
require 8 bytes per element).
Strings will default to allocating 255 bytes (ie, characters) of memory for
each element and this can quickly use up memory when defining arrays of
strings. In that case the LENGTH keyword can be used to specify the
amount of memory to be allocated to each element and therefore the
maximum length of the string that can be stored. This allocation ('n') can be
from 1 to 255 characters.
For example: DIM STRING s(5, 10) will declare a string array with
66 elements consuming 16,896 bytes of memory while:
DIM STRING s(5, 10) LENGTH 20
Will only consume 1,386 bytes of memory. Note that the amount of
memory allocated for each element is n + 1 as the extra byte is used to track
the actual length of the string stored in each element.
If a string longer than 'n' is assigned to an element of the array an error will
be produced. Other than this, string arrays created with the LENGTH
keyword act exactly the same as other string arrays. This keyword can also
be used with non array string variables but it will not save any memory.
In the above example you can also use the Microsoft syntax of specifying the
type after the length qualifier. For example:
DIM s(5, 10) LENGTH 20 AS STRING

Arrays can also be initialised when they are declared by adding an equals
symbol (=) followed by a bracketed list of values at the end of the
declaration. For example:
DIM INTEGER nbr(4) = (22, 44, 55, 66, 88)
or DIM s$(3) = ("foo", "boo", "doo", "zoo")
Note that the number of initialising values must match the number of
elements in the array including the base value set by OPTION BASE. If a
multi dimensioned array is initialised then the first dimension will be
initialised first followed by the second, etc.
Also note that the initialising values must be after the LENGTH qualifier (if
used) and after the type declaration (if used).
DO This structure will loop forever; the EXIT DO command can be used to
<statements> terminate the loop or control must be explicitly transferred outside of the
LOOP loop by commands like GOTO or EXIT SUB (if in a subroutine).
DO WHILE expression Loops while "expression" is true (this is equivalent to the older WHILE-
<statements> WEND loop, also implemented in MMBasic). If, at the start, the expression
LOOP is false the statements in the loop will not be executed, not even once.
DO Loops until the expression following UNTIL is true. Because the test is
<statements> made at the end of the loop the statements inside the loop will be executed at
LOOP UNTIL expression least once, even if the expression is true.
EDIT Invoke the full screen editor.
All the editing keys work with a VT100 terminal emulator so editing can
also be accomplished over the console serial link. The editor has been tested
with Tera Term and PuTTY running on a Windows PC.
On entry the cursor will be automatically positioned at the last line edited or,
if there was an error when running the program, the line that caused the
error.
The editing keys are:
Left/Right arrows Moves the cursor within the line.
Up/Down arrows Moves the cursor up or down a line.
Page Up/Down Move up or down a page of the program.
Home/End Moves the cursor to the start or end of the line. A
second Home/End will move to the start or end of the
program.
Delete Delete the character over the cursor. This can be the
line separator character and thus join two lines.
Backspace Delete the character before the cursor.
Insert Will switch between insert and overtype mode.
Escape Key Will close the editor without saving (confirms first).
F1 Save the edited text and exit.
F2 Save, exit and run the program.
F3 Invoke the search function.
SHIFT F3 Repeat the search using the text entered with F3.
F4 Mark text for cut or copy (see below).
F5 Paste text previously cut or copied.
When in the mark text mode (entered with F4) the editor will allow you to
use the arrow keys to highlight text which can be deleted, cut to the
clipboard or simply copied to the clipboard. The status line will change to
indicate the new functions of the function keys.
The editor will work with lines wider than the screen but characters beyond
the screen edge will not be visible. You can split such a line by inserting a
new line character and the two lines can be later rejoined by deleting the
inserted new line character.

ELSE Introduces an optional default condition in a multiline IF statement.
See the multiline IF statement for more details.
ELSEIF expression THEN Introduces an optional secondary condition in a multiline IF statement.
or See the multiline IF statement for more details.
ELSE IF expression THEN
END End the running program and return to the command prompt.
END FUNCTION Marks the end of a user defined function. See the FUNCTION command.
Each function must have one and only one matching END FUNCTION
statement. Use EXIT FUNCTION if you need to return from a function
from within its body.
ENDIF Terminates a multiline IF statement.
or See the multiline IF statement for more details.
END IF
END SUB Marks the end of a user defined subroutine. See the SUB command.
Each sub must have one and only one matching END SUB statement. Use
EXIT SUB if you need to return from a subroutine from within its body.
ERASE variable [,variable]... Deletes variables and frees up the memory allocated to them. This will work
with arrayed variables and normal (non array) variables. Arrays can be
specified using empty brackets (eg, dat()) or just by specifying the
variable's name (eg, dat).
Use CLEAR to delete all variables at the same time (including arrays).
ERROR [error_msg$] Forces an error and terminates the program. This is normally used in
debugging or to trap events that should not occur.
EXIT DO EXIT DO provides an early exit from a DO...LOOP
EXIT FOR EXIT FOR provides an early exit from a FOR...NEXT loop.
EXIT FUNCTION EXIT FUNCTION provides an early exit from a defined function.
EXIT SUB EXIT SUB provides an early exit from a defined subroutine.
The old standard of EXIT on its own (exit a do loop) is also supported.
FONT [#]font-number, scaling This will set the default font for displaying text on an LCD panel.
Fonts are specified as a number. For example, #2 (the # is optional) See the
chapter "Basic Drawing Commands" for details of the available fonts.
'scaling' can range from 1 to 15 and will multiply the size of the pixels
making the displayed character correspondingly wider and higher. Eg, a
scale of 2 will double the height and width.
FOR counter = start TO finish Initiates a FOR-NEXT loop with the 'counter' initially set to 'start' and
[STEP increment] incrementing in 'increment' steps (default is 1) until 'counter' is greater than
'finish'.
The ‘increment’ can be an integer or floating point number. Note that
using a floating point fractional number for 'increment' can
accumulate rounding errors in 'counter' which could cause the loop to
terminate early or late.
'increment' can be negative in which case 'finish' should be less than 'start'
and the loop will count downwards.
See also the NEXT command.
FUNCTION xxx (arg1 Defines a callable function. This is the same as adding a new function to
[,arg2, …]) [AS <type>} MMBasic while it is running your program.
<statements> 'xxx' is the function name and it must meet the specifications for naming a
<statements> variable. The type of the function can be specified by using a type suffix
xxx = <return value> (ie, xxx$) or by specifying the type using AS <type> at the end of the

END FUNCTION functions definition. For example:
FUNCTION xxx (arg1, arg2) AS STRING
'arg1', 'arg2', etc are the arguments or parameters to the function (the
brackets are always required, even if there are no arguments). An array is
specified by using empty brackets. ie, arg3(). The type of the argument
can be specified by using a type suffix (ie, arg1$) or by specifying the type
using AS <type> (ie, arg1 AS STRING).
The argument can also be another defined function or the same function if
recursion is to be used (the recursion stack is limited to 50 nested calls).
To set the return value of the function you assign the value to the function's
name. For example:
FUNCTION SQUARE(a)
SQUARE = a * a
END FUNCTION
Every definition must have one END FUNCTION statement. When this is
reached the function will return its value to the expression from which it was
called. The command EXIT FUNCTION can be used for an early exit.
You use the function by using its name and arguments in a program just as
you would a normal MMBasic function. For example:
PRINT SQUARE(56.8)
When the function is called each argument in the caller is matched to the
argument in the function definition. These arguments are available only
inside the function.
Functions can be called with a variable number of arguments. Any omitted
arguments in the function's list will be set to zero or a null string.
Arguments in the caller's list that are a variable and have the correct type
will be passed by reference to the function. This means that any changes to
the corresponding argument in the function will also be copied to the caller's
variable and therefore may be accessed after the function has ended. Arrays
are passed by specifying the array name with empty brackets (eg, arg()) and
are always passed by reference and must be the correct type.
You must not jump into or out of a function using commands like GOTO,
GOSUB, etc. Doing so will have undefined side effects including the
possibility of ruining your day.
GOTO target Branches program execution to the target, which can be a line number or a
label.
GUI BITMAP x, y, bits [, Displays the bits in a bitmap on an LCD panel starting at 'x' and 'y' on an
width] [, height] [, scale] [, c] attached LCD panel.
[, bc] 'height' and 'width' are the dimensions of the bitmap as displayed on the LCD
panel and default to 8x8.
'scale' is optional and defaults to that set by the FONT command.
'c' is the drawing colour and 'bc' is the background colour. They are optional
and default to the current foreground and background colours.
The bitmap can be an integer or a string variable or constant and is drawn
using the first byte as the first bits of the top line (bit 7 first, then bit 6, etc)
followed by the next byte, etc. When the top line has been filled the next
line of the displayed bitmap will start with the next bit in the integer or
string.

GUI CALIBRATE This command is used to calibrate the touch feature on an LCD panel. It
Or will display a series of targets on the screen and wait for each one to be
precisely touched.
GUI CALIBRATE c1,c2,c3,c4,c5
The second version allows the calibration parameters to be entered directly
without having to go through the manual calibration process. The
parameters 'c1', 'c2', etc can be found by running a normal calibration
process then using OPTION LIST which will list the parameters for that
LCD panel. This is useful when the command is embedded in a program.
GUI RESET LCDPANEL Will reinitialise the configured LCD panel. Initialisation is automatically
done when the Micromite starts up but in some circumstances it may be
necessary to interrupt power to the LCD panel (eg, to save battery power)
and this command can then be used to reinitialise the display.
GUI TEST LCDPANEL Will test the display or touch feature on an LCD panel.
or With GUI TEST LCDPANEL an animated display of colour circles will be
GUI TEST TOUCH rapidly drawn on top of each other.
With GUI TEST TOUCH the screen will blank and wait for a touch which
will cause a white dot to be placed on the display marking the touch position
on the screen.
Any character entered at the console will terminate the test.
IF expr THEN stmt [: stmt] Evaluates the expression ‘expr' and performs the statement following the
or THEN keyword if it is true or skips to the next line if false. If there are more
statements on the line (separated by colons (:) they will also be executed if
IF expr THEN stmt ELSE stmt
true or skipped if false. The ELSE keyword is optional and if present the
statement(s) following it will be executed if 'expr' resolved to be false.
The ‘THEN statement’ construct can be also replaced with:
GOTO linenumber | label’.
This type of IF statement is all on one line.
IF expression THEN Multiline IF statement with optional ELSE and ELSEIF cases and ending
<statements> with ENDIF. Each component is on a separate line.
[ELSEIF expression THEN Evaluates 'expression' and performs the statement(s) following THEN if the
<statements>] expression is true or optionally the statement(s) following the ELSE
[ELSE statement if false. The ELSEIF statement (if present) is executed if the
<statements>] previous condition is false and it starts a new IF chain with further ELSE
ENDIF and/or ELSEIF statements as required.
One ENDIF is used to terminate the multiline IF.
INPUT ["prompt$";] var1 [,var2 Will take a list of values separated by commas (,) entered at the console and
[, var3 [, etc]]] will assign them to a sequential list of variables.
For example, if the command is: INPUT a, b, c
And the following is typed on the keyboard: 23, 87, 66
Then a = 23 and b = 87 and c = 66
The list of variables can be a mix of float, integer or string variables. The
values entered at the console must correspond to the type of variable.
If a single value is entered a comma is not required (however that value
cannot contain a comma).
‘prompt$’ is a string constant (not a variable or expression) and if specified
it will be printed first. Normally the prompt is terminated with a semicolon
(;) and in that case a question mark will be printed following the prompt. If
the prompt is terminated with a comma (,) rather than the semicolon (;) the
question mark will be suppressed.
INPUT #nbr, Same as above except that the input is read from a serial port previously
list of variables opened for INPUT as ‘nbr’. See the OPEN command.

IR dev, key , int Decodes NEC or Sony infrared remote control signals.
or An IR Receiver Module is used to sense the IR light and demodulate the
IR CLOSE signal. It should be connected to the IR pin (see the pinout tables). This
command will automatically set that pin to an input.
The IR signal decode is done in the background and the program will
continue after this command without interruption. 'dev' and 'key' should be
numeric variables and their values will be updated whenever a new signal is
received ('dev' is the device code transmitted by the remote and 'key' is the
key pressed).
'int' is a user defined subroutine that will be called when a new key press is
received or when the existing key is held down for auto repeat. In the
interrupt subroutine the program can examine the variables 'dev' and 'key' and
take appropriate action.
The IR CLOSE command will terminate the IR decoder and return the I/O
pin to a not configured state.
Note that for the NEC protocol the bits in 'dev' and 'key' are reversed. For
example, in 'key' bit 0 should be bit 7, bit 1 should be bit 6, etc. This does
not affect normal use but if you are looking for a specific numerical code
provided by a manufacturer you should reverse the bits. This describes how
to do it: http://www.thebackshed.com/forum/forum_posts.asp?TID=8367
See the chapter "Special Hardware Devices" for more details.
KEYPAD var, int, r1, r2, r3, r4, Monitor and decode key presses on a 4x3 or 4x4 keypad.
c1, c2, c3 [, c4] Monitoring of the keypad is done in the background and the program will
or continue after this command without interruption. 'var' should be a numeric
KEYPAD CLOSE variable and its value will be updated whenever a key press is detected.
'int' is a user defined subroutine that will be called when a new key press is
received. In the interrupt subroutine the program can examine the variable
'var' and take appropriate action.
r1, r2, r3 and r4 are pin numbers used for the four row connections to the
keypad and c1, c2, c3 and c4 are the column connections. c4 is optional and
is only used with 4x4 keypads. This command will automatically configure
these pins as required.
On a key press the value assigned to 'var' is the number of a numeric key (eg,
'6' will return 6) or 10 for the * key and 11 for the # key. On 4x4 keypads
the number 20 will be returned for A, 21 for B, 22 for C and 23 for D.
The KEYPAD CLOSE command will terminate the keypad function and
return the I/O pin to a not configured state.
LET variable = expression Assigns the value of 'expression' to the variable. LET is automatically
assumed if a statement does not start with a command. For example:
Var = 56
LCD INIT d4, d5, d6, d7, rs, en Display text on an LCD character display module. This command will work
or with most 1-line, 2-line or 4-line LCD modules that use the KS0066,
HD44780 or SPLC780 controller (however this is not guaranteed).
LCD line, pos, text$
The LCD INIT command is used to initialise the LCD module for use. 'd4'
or
to 'd7' are the I/O pins that connect to inputs D4 to D7 on the LCD module
LCD CLEAR (inputs D0 to D3 should be connected to ground). 'rs' is the pin connected to
or the register select input on the module (sometimes called CMD). 'en' is the
LCD CLOSE pin connected to the enable or chip select input on the module. The R/W
input on the module should always be grounded. The above I/O pins are
automatically set to outputs by this command.
When the module has been initialised data can be written to it using the LCD
command. 'line' is the line on the display (1 to 4) and 'pos' is the character
location on the line (the first location is 1). 'text$' is a string containing the

text to write to the LCD display.
'pos' can also be C8, C16, C20 or C40 in which case the line will be cleared
and the text centred on a 8 or 16, 20 or 40 line display. For example:
LCD 1, C16, "Hello"
LCD CLEAR will erase all data displayed on the LCD and LCD CLOSE
will terminate the LCD function and return all I/O pins to the not configured
state.
LCD CMD d1 [, d2 [, etc]] These commands will send one or more bytes to an LCD display as either a
or command (LCD CMD) or as data (LCD DATA). Each byte is a number
between 0 and 255 and must be separated by commas. The LCD must have
LCD DATA d1 [, d2 [, etc]]
been previously initialised using the LCD INIT command (see above).
These commands can be used to drive a non standard LCD in "raw mode" or
they can be used to enable specialised features such as scrolling, cursors and
custom character sets. You will need to refer to the data sheet for your LCD
to find the necessary command and data values.
LIBRARY SAVE The library is a special segment of program memory that can contain
or program code such as subroutines, functions and CFunctions. These
routines are not visible to the programmer but are available to any program
LIBRARY DELETE
running on the Micromite and act the same as built in commands and
or functions in MMBasic. See the chapter "Special Functions and the Library"
LIBRARY LIST earlier in this manual for a full explanation.
LIBRARY SAVE will take whatever is in normal program memory,
compress it (remove redundant data such as comments) and append it to the
library area (main program memory is then empty). The code in the library
will not show in LIST or EDIT and will not be deleted when a new program
is loaded or NEW is used.
LIBRARY DELETE will remove the library and recover the memory used.
LIBRARY LIST will list the contents of the library.
Note that any code in the library that is not contained within a subroutine or
function will be executed immediately before a program is run. This can be
used to initialise constants, set options, etc.
LINE x1, y1, x2, y2 [, LW [, C]] On an attached LCD display this command will draw a line starting at the
coordinates ‘x1’ and ‘y1’ and ending at ‘x2’ and ‘y2’.
‘LW’ is the line’s width and is only valid for horizontal or vertical lines. It
defaults to 1 if not specified or if the line is a diagonal. ‘C’ is an integer
representing the colour and defaults to the current foreground colour.
LINE INPUT [prompt$,] Reads an entire line from the console input into ‘string-variable$’.
string-variable$ ‘prompt$’ is a string constant (not a variable or expression) and if specified
it will be printed first.
Unlike INPUT, this command will read a whole line, not stopping for
comma delimited data items.
A question mark is not printed unless it is part of ‘prompt$’.
LINE INPUT #nbr, Same as above except that the input is read from a serial communications
string-variable$ port previously opened for INPUT as ‘nbr’. See the OPEN command.
LIST List a program on the serial console.
or LIST on its own will list the program with a pause at every screen full.
LIST ALL LIST ALL will list the program without pauses. This is useful if you wish to
transfer the program in the Micromite to a terminal emulator on a PC that
has the ability to capture its input stream to a file.

LOCAL variable [, variables] Defines a list of variable names as local to the subroutine or function.
See DIM for the full syntax. This command uses exactly the same syntax as DIM and will create
variables that will only be visible within the subroutine or function. They
will be automatically discarded when the subroutine or function exits.
LOOP [UNTIL expression] Terminates a program loop: see DO.
MEMORY List the amount of memory currently in use. For example:
Flash:
21K (35%) Program (805 lines)
1K ( 1%) 2 CFunctions
1K ( 1%) 4 Saved Variables
37K (63%) Free
RAM:
9K (16%) 5 Variables
18K (32%) General
26K (52%) Free
Notes:
 Memory usage is rounded to the nearest 1K byte.
 Program memory is cleared by the NEW command.
 General memory is used by serial I/O buffers, etc.
 Variables and the general memory spaces are cleared by many
commands (eg, NEW, RUN, etc) as well as the specific commands
CLEAR and ERASE.
 When a program is loaded it is first buffered in RAM which limits the
maximum program size. MMBasic tokenises the program when it is
stored in flash so the final size in flash might vary from this.
NEW Deletes the program in flash and clears all variables including saved
variables.
NEXT [counter-variable] [, NEXT comes at the end of a FOR-NEXT loop; see FOR.
counter-variable], etc The ‘counter-variable’ specifies exactly which loop is being operated on. If
no ‘counter-variable’ is specified the NEXT will default to the innermost
loop. It is also possible to specify multiple counter-variables as in:
NEXT x, y, z
ON ERROR ABORT This controls the action taken if an error occurs while running a program and
or applies to all errors discovered by MMBasic including syntax errors, wrong
data, missing hardware, etc.
ON ERROR IGNORE
ON ERROR ABORT will cause MMBasic to display an error message, abort
or
the program and return to the command prompt. This is the normal behaviour
ON ERROR SKIP [nn] and is the default when a program starts running.
or ON ERROR IGNORE will cause any error to be ignored.
ON ERROR CLEAR ON ERROR SKIP will ignore an error in a number of commands (specified by
the number 'nn') executed following this command. 'nn' is optional, the default
if not specified is one. After the number of commands has completed (with an
error or not) the behaviour of MMBasic will revert to ON ERROR ABORT.
If an error occurs and is ignored/skipped the read only variable MM.ERRNO
will be set to non zero and MM.ERRMSG$ will be set to the error message
that would normally be generated. These are reset to zero and an empty string
by ON ERROR CLEAR. They are also cleared when the program is run and
when ON ERROR IGNORE and ON ERROR SKIP are used.
ON ERROR IGNORE can make it very difficult to debug a program so it is
strongly recommended that only ON ERROR SKIP be used.

ON KEY target Setup an interrupt which will call 'target' user defined subroutine whenever
there is one or more characters waiting in the serial console input buffer.
Note that all characters waiting in the input buffer should be read in the
interrupt subroutine otherwise another interrupt will be automatically
generated as soon as the program returns from the interrupt.
To disable this interrupt, use numeric zero for the target, ie: ON KEY 0
OPEN comspec$ AS [#]fnbr Will open a serial communications port for reading and writing. Two ports
are available (COM1: and COM2:) and both can be open simultaneously.
For a full description with examples see Appendix A.
Using ‘fnbr’ the port can be written to and read from using any command or
function that uses a file number.
OPTION AUTORUN OFF | ON Instruct MMBasic to automatically run the program stored in flash when it
starts up or is restarted by the WATCHDOG command. This is turned off
by the NEW command but other commands that might change program
memory (EDIT, etc) do not change this setting.
Entering the break key (default CTRL-C) at the console will interrupt the
running program and return to the command prompt despite this option.
OPTION BASE 0 | 1 Set the lowest value for array subscripts to either 0 or 1.
This must be used before any arrays are declared and is reset to the default of
0 on power up.
OPTION BAUDRATE nbr Set the baud rate for the console to 'nbr'. This change is made immediately
and will be remembered even when the power is cycled. The baud rate
should be limited to the speeds listed in Appendix A for COM1.
Using this command it is possible to set the console to an unworkable baud
rate and in this case MMBasic should be reset as described in the chapter
"Resetting MMBasic". This will reset the baud rate to the default of 38400.
OPTION BREAK nn Set the value of the break key to the ASCII value 'nn'. This key is used to
interrupt a running program.
The value of the break key is set to CTRL-C key at power up but it can be
changed to any keyboard key using this command (for example, OPTION
BREAK 4 will set the break key to the CTRL-D key).
Setting this option to zero will disable the break function entirely.
OPTION CASE Change the case used for listing command and function names when using
UPPER | LOWER | TITLE the LIST command. The default is TITLE but the old standard of MMBasic
can be restored using OPTION CASE UPPER.
This option will be remembered even when the power is removed.
OPTION CLOCKTRIM ±n Trim the frequency of the internal oscillator on the 28 and 44-pin
Micromites. This oscillator is used as the basis for all timing (eg, date, time,
pause, PWM frequency, serial baudrate, etc).
'n' is the trim value which can range from -31 to +31 (this equates to an
adjustment range of about -12.5% to +12.5%). On power up the trim value
is zero.
Note that this will also affect the console baudrate and an excessive trim
value could make it impossible to communicate with the Micromite.
OPTION COLOURCODE ON Turn on or off colour coding for the editor's output. Keywords will be in
or cyan, numbers in red, etc. The default is off.
OPTION COLOURCODE OFF Notes:
 This setting is saved in flash memory and is applied on startup.
 Colour coding requires a terminal emulator that can interpret the
appropriate escape codes. It works correctly with Tera Term however
Putty needs its default background colour to be changed to white.

 If colour coding is used it is recommended that the baud rate for the
serial console be set to a high speed.
 The keyword COLORCODE (USA spelling) can also be used.
OPTION CONSOLE ECHO Used to set options for the console serial port.
or NOECHO will turn off the echoing of characters received at the console.
OPTION CONSOLE NOECHO ECHO will re enable the echo. The default is ECHO at bootup and the option
is reset to ECHO whenever the program returns to the command prompt. This
or
option is useful when the console is used as a third general purpose serial port.
OPTION CONSOLE INVERT
INVERT will invert the data polarity on both the console transmit and receive
or lines. This allows the console to be used with RS232 signals without a
OPTION CONSOLE converter (see the chapter "Low Cost RS-232 Interface" in Appendix A). It
NOINVERT also allows the use of a PICAXE style programming cable.
or NOINVERT will restore the console to its normal operation and is the default.
OPTION CONSOLE AUTO AUTO will automatically invert the data polarity on the console depending on
the signal level at power up (a low input means that the console will be
inverted). This will automatically switch between TTL serial and RS232
serial input. Note that there is a 200ms startup delay when AUTO is used.
OPTION DEFAULT FLOAT | Used to set the default type for a variable which is not explicitly defined.
INTEGER | STRING | NONE If OPTION DEFAULT NONE is used then all variables must have their type
explicitly defined.
When a program is run the default is set to FLOAT for compatibility with
previous versions of MMBasic.
OPTION DISPLAY lines [,chars] Set the characteristics of the display terminal used for the console. Both the
LIST and EDIT commands need to know this information to correctly
format the text for display.
'lines' is the number of lines on the display and 'chars' is the width of the
display in characters. The default is 24 lines x 80 chars and when changed
this option will be remembered even when the power is removed.
Note that the documentation for the VT100 ASCII Video Terminal initially
listed incorrect specifications for the composite video. If you are using this
project with the Micromite check the website http://geoffg.net/terminal.html
for the correct specifications.
OPTION EXPLICIT Placing this command at the start of a program will require that every variable
be explicitly declared using the DIM command before it can be used in the
program.
This option is disabled by default when a program is run. If it is used it must
be specified before any variables are used.
OPTION LCDPANEL ILI9341, Configures the Micromite and Micromite Plus to work with an attached LCD
orientation, D/C pin, reset pin panel using the ILI9341controller. If ILI9341_I is specified the colours will
[,CS pin] be inverted (this is required by some TFT display panels).
or 'orientation' can be LANDSCAPE, PORTRAIT, RLANDSCAPE or
OPTION LCDPANEL RPORTRAIT. These can be abbreviated to L, P, RL or RP. The R prefix
ILI9341_I, orientation, D/C pin, indicates the reverse or "upside down" orientation.
reset pin [,CS pin] 'C/D pin' and 'reset pin' are the Micromite I/O pins to be used for these
or functions. Any free pin can be used. 'CS pin' can also be any I/O pin but is
optional. If the LCD panel does not have a touch controller this parameter can
OPTION LCDPANEL
be left off the command and the CS pin on the LCD display wired
DISABLE
permanently to ground. Otherwise the touch MUST be separately configured
and this pin must be specified and connected to a Micromite I/O pin.
The CPU speed must be 20 MHz or greater.

OPTION LIST This will list the settings of any options that have been changed from their
default setting and are the type that is saved in flash. This command is useful
when configuring options that reserve I/O pins (ie, OPTION LCDPANEL or
OPTION TOUCH) and you need to know what pins are in use.
OPTION PIN nbr Set 'nbr' as the PIN (Personal Identification Number) for access to the
console prompt. 'nbr' can be any non zero number of up to eight digits.
Whenever a running program tries to exit to the command prompt for
whatever reason MMBasic will request this number before the prompt is
presented. This is a security feature as without access to the command
prompt an intruder cannot list or change the program in memory or modify
the operation of MMBasic in any way. To disable this feature enter zero for
the PIN number (ie, OPTION PIN 0).
A permanent lock can be applied by using 99999999 for the PIN number.
If a permanent lock is applied or the PIN number is lost the only way to
recover is to reset MMBasic as described in the chapter "Resetting
MMBasic" (this will also erase the program memory).
OPTION RESET Reset all saved options (including the PIN) to the default values.
OPTION SAVE Used to save configuration options that are embedded in a program. See the
section "Special Functions and the Library" for more details.
OPTION TAB 2 | 4 | 8 Set the spacing for the tab key. Default is 2.
OPTION TOUCH T_CS pin, Configures MMBasic for the touch sensitive feature of an attached LCD panel.
T_IRQ pin 'T_CS pin' and 'T_IRQ pin' are the Micromite I/O pins to be used for chip
or select and touch interrupt respectively (any free pins can be used).
OPTION TOUCH DISABLE
PAUSE delay Halt execution of the running program for ‘delay’ ms. This can be a
fraction. For example, 0.2 is equal to 200 µs. The maximum delay is
2147483647 ms (about 24 days).
Note that interrupts will be recognised and processed during a pause.
PIN( pin ) = value For a ‘pin’ configured as digital output this will set the output to low
(‘value’ is zero) or high (‘value’ non-zero). You can set an output high or
low before it is configured as an output and that setting will be the default
output when the SETPIN command takes effect.
See the function PIN() for reading from a pin and the command SETPIN for
configuring it. Refer to the chapter "Using the I/O pins" for a general
description of the Micromite's input/output capabilities.
PIXEL x, y [,c] Set a pixel on an attached LCD panel to a colour. 'x' is the horizontal
coordinate and 'y' is the vertical coordinate of the pixel. 'c' is a 24 bit
number specifying the colour. 'c' is optional and if omitted the current
foreground colour will be used.
POKE BYTE addr%, byte Will set a byte or a word within the PIC32 virtual memory space.
or POKE BYTE will set the byte (ie, 8 bits) at the memory location 'addr%' to
POKE WORD addr%, word% 'byte'. 'addr%' should be an integer.
or POKE WORD will set the word (ie, 32 bits) at the memory location 'addr%'
to 'word%'. 'addr%' and 'word%' should be integers.
POKE INTEGER addr%, int%
POKE INTEGER will set the MMBasic integer (ie, 64 bits) at the memory
or
location 'addr%' to int%'. 'addr%' and int%' should be integers.
POKE FLOAT addr%, float!
POKE FLOAT will set the word (ie, 32 bits) at the memory location 'addr%'
or to 'float!'. 'addr%' should be an integer and 'float!' a floating point number.

POKE VAR var, offset, byte POKE VAR will set a byte in the memory address of 'var'. 'offset' is the
or ±offset from the address of the variable. An array is specified as var().
POKE VARTBL, offset, byte POKE VARTBL will set a byte in MMBasic's variable table. 'offset' is the
±offset from the start of the variable table. Note that a comma is required
after the keyword VARTBL.
For backwards compatibility the old form of POKE hiword, loword, val is
still accepted. In this case the address is specified by ‘hiword’ which is the
top 16 bits of the address while ‘loword’ is the bottom 16 bits.
This command is for expert users only. The PIC32 maps all control
registers, flash (program) memory and volatile (RAM) memory into a single
address space so there is no need for INP or OUT commands. The PIC32
Data Sheet lists the details of this address space (RAM starts at
0xA0000000).
PORT(start, nbr [,start, nbr]…) = Set a number of I/O pins simultaneously (ie, with one command).
value 'start' is an I/O pin number and the lowest bit in 'value' (bit 0) will be used to
set that pin. Bit 1 will be used to set the pin 'start' plus 1, bit 2 will set pin
'start'+2 and so on for 'nbr' number of bits. I/O pins used must be numbered
consecutively and any I/O pin that is invalid or not configured as an output
will cause an error. The start/nbr pair can be repeated if an additional group
of output pins needed to be added.
For example; PORT(15, 4, 23, 4) = &B10000011
Will set eight I/O pins. Pins 15 and 16 will be set high while 17, 18, 23, 24
and 25 will be set to a low and finally 26 will be set high.
This command can be used to conveniently communicate with parallel
devices like LCD displays. Any number of I/O pins (and therefore bits) can
be used from 1 to the number of I/O pins on the chip.
See the PORT function to simultaneously read from a number of pins.
PRINT expression Outputs text to the serial console followed by a carriage return/newline pair.
[[,; ]expression] … etc Multiple expressions can be used and must be separated by either a:
 Comma (,) which will output the tab character
 Semicolon (;) which will not output anything (it is just used to separate
expressions).
 Nothing or a space which will act the same as a semicolon.
A semicolon (;) or a comma (,) at the end of the expression list will suppress
the output of the carriage return/newline pair at the end of a print statement.
When printed, a number is preceded with a space if positive or a minus (-) if
negative but is not followed by a space. Integers (whole numbers) are
printed without a decimal point while fractions are printed with the decimal
point and the significant decimal digits. Large or small floating point
numbers are automatically printed in scientific number format.
The function TAB() can be used to space to a certain column and the STR$()
function can be used to justify or otherwise format strings.
PRINT #nbr, expression Same as above except that the output is directed to a serial communications
[[,; ]expression] … etc port previously opened as ‘nbr’. See the OPEN command.
PULSE pin, width Will generate a pulse on 'pin' with duration of 'width' ms. 'width' can be a
fraction. For example, 0.01 is equal to 10µs and this enables the generation
of very narrow pulses. The minimum is 5 µs at 40 MHz to 40 µs at 5 MHz.
The generated pulse is of the opposite polarity to the state of the I/O pin
when the command is executed. For example, if the output is set high the
PULSE command will generate a negative going pulse. Notes:
 'pin' must be configured as an output.
 For a pulse of less than 3 ms the accuracy is ± 1 µs.
 For a pulse of 3 ms or more the accuracy is ± 0.5 ms.

 A pulse of 3 ms or more will run in the background. Up to five different
and concurrent pulses can be running in the background and each can
have its time changed by issuing a new PULSE command or it can be
terminated by issuing a PULSE command with zero for 'width'.
PWM 1, freq, 1A Generate a pulse width modulated (PWM) output for driving analogue
or circuits, sound output, etc.
PWM 1, freq, 1A, 1B There are a total of five outputs designated as PWM in the diagrams on
pages 6 and 7 (they are also used for the SERVO command). Controller 1
or
can have one, two or three outputs while controller 2 can have one or two
PWM 1, freq, 1A, 1B, 1C outputs. Both controllers are independent and can be turned on and off and
or have different frequencies.
PWM 2, freq, 2A '1' or '2' is the controller number and ‘freq’ is the output frequency (between
or 20 Hz and 500 kHz) . 1A, 1B and 1C are the duty cycle for each of the
PWM 2, freq, 2A, 2B controller 1 outputs while 2A and 2B are the duty cycle for the controller 2
outputs. The specified I/O pins will be automatically configured as outputs
or while any others will be unaffected and can be used for other duties.
PWM channel, STOP The duty cycle for each output is independent of the others and is specified
as a percentage. If it is close to zero the output will be a narrow positive
pulse, if 50 a square wave will be generated and if close to 100 it will be a
very wide positive pulse. For frequencies below 25 kHz the duty cycle will
be accurate to 0.1%.
The output will run continuously in the background while the program is
running and can be stopped using the STOP command. The frequency and
duty cycle can be changed at any time (without stoping the output) by
issuing a new PWM command.
The PWM function will take control of any specified outputs and when
stopped the pins will be returned to a high impedance "not configured" state.
RANDOMIZE nbr Seed the random number generator with ‘nbr’.
On power up the random number generator is seeded with zero and will
generate the same sequence of random numbers each time. To generate a
different random sequence each time you must use a different value for ‘nbr’
(the TIMER function is handy for that).
RBOX x, y, w, h [, r] [,c] Draws a box with rounded corners on an attached LCD panel starting at 'x'
[,fill] and 'y' which is 'w' pixels wide and 'h' pixels high.
'r' is the radius of the corners of the box. It defaults to 10.
'c' specifies the colour and defaults to the default foreground colour if not
specified.
not be filled.
READ variable[, variable]... Reads values from DATA statements and assigns these values to the named
variables. Variable types in a READ statement must match the data types in
DATA statements as they are read. See also DATA and RESTORE.
REM string REM allows remarks to be included in a program.
Note the Microsoft style use of the single quotation mark (‘) to denote
remarks is also supported and is preferred.
RESTORE [line] Resets the line and position counters for the READ statement.
If ‘line’ is specified the counters will be reset to the beginning of the
specified line. ‘line’ can be a line number or label.
If ‘line’ is not specified the counters will be reset to the start of the program.

RTC GETTIME RTC GETTIME will get the current date/time from a PCF8563, DS1307,
DS3231 or DS3232 real time clock and set the internal MMBasic clock
accordingly. The date/time can then be retrieved with the DATE$ and
TIME$ functions.
RTC SETTIME year, month, RTC SETTIME will set the time in the clock chip. 'hour' must use 24 hour
day, hour, minute, second notation. On the Micromite Plus the RTC SETTIME command will also
accept a single string argument in the format of dd/mm/yy hh:mm. This
means the date/time could be entered by the user using a GUI
FORMATBOX with the DATETIME2 format.
RTC SETREG reg, value The RTC SETREG and GETREG commands can be used to set or read the
RTC GETREG reg, var contents of registers within the chip. 'reg' is the register's number, 'value' is
the number to store in the register and 'var' is a variable that will receive the
number read from the register. These commands are not necessary for
normal operation but they can be used to manipulate special features of the
chip (alarms, output signals, etc). They are also useful for storing temporary
information in the chip's battery backed RAM.
These chips are I2C devices and must be connected to the two I2C pins with
appropriate pullup resistors. If the I2C bus is already open the RTC
command will use the current settings, otherwise it will temporarily open the
connection with a speed of 100 kHz.
RUN Run the program held in flash memory. On the Micromite Plus RUN file$
can be used and this will load and run a file residing on the SD card.
SELECT CASE value Executes one of several groups of statements, depending on the value of an
CASE testexp [[, testexp] …] expression. 'value' is the expression to be tested. It can be a number or
<statements> string variable or a complex expression.
<statements> 'testexp' is the value that is to be compared against. It can be:
CASE ELSE  A single expression (ie, 34, "string" or PIN(4)*5) to which it may equal
<statements>  A range of values in the form of two single expressions separated by the
<statements> keyword "TO" (ie, 5 TO 9 or "aa" TO "cc")
END SELECT  A comparison starting with the keyword "IS" (which is optional). For
example: IS > 5, IS <= 10.
When a number of test expressions (separated by commas) are used the
CASE statement will be true if any one of these tests evaluates to true.
If 'value' cannot be matched with a 'testexp' it will be automatically matched to
the CASE ELSE. If CASE ELSE is not present the program will not execute
any <statements> and continue with the code following the END SELECT.
When a match is made the <statements> following the CASE statement will
be executed until END SELECT or another CASE is encountered when the
program will then continue with the code following the END SELECT.
An unlimited number of CASE statements can be used but there must be
only one CASE ELSE and that should be the last before the END SELECT.
Example:
SELECT CASE nbr%
CASE 4, 9, 22, 33 TO 88
statements
CASE IS < 4, IS > 88, 5 TO 8
statements
CASE ELSE
statements
END SELECT
Each SELECT CASE must have one and one only matching END SELECT
statement. Any number of SELECT…CASE statements can be nested inside
the CASE statements of other SELECT…CASE statements.

SERVO 1 [, freq], 1A Generate a constant stream of positive going pulses for driving a servo.
or The Micromite has two servo controllers with the first being able to control
SERVO 1 [, freq], 1A, 1B up to three servos and the second two servos. Both controllers are
independent and can be turned on and off and have different frequencies.
or
This command uses the I/O pins that are designated as PWM in the diagrams
SERVO 1 [, freq], 1A, 1B, 1C on pages 6 and 7 (the two commands are very similar).
or '1' or '2' is the controller number. ‘freq’ is the output frequency (between
SERVO 2 [, freq], 2A 20Hz and 1000 Hz) and is optional. If not specified it will default to 50 Hz
or 1A, 1B and 1C are the pulse widths for each of the controller 1 outputs while
SERVO 2 [, freq], 2A, 2B 2A and 2B are the pulse widths for the controller 2 outputs. The specified
or I/O pins will be automatically configured as outputs while any others will be
unaffected and can be used for other duties.
SERVO channel, STOP
The pulse width for each output is independent of the others and is specified
in milliseconds, which can be a fractional number (ie, 1.536). For accurate
positioning the output resolution is about 0.005 ms. The minimum value is
0.01ms while the maximum is 18.9ms. Most servos will accept a range of
0.8ms to 2.2ms.
The output will run continuously in the background while the program is
running and can be stopped using the STOP command. The pulse widths of
the outputs can be changed at any time (without stoping the output) by
issuing a new SERVO command.
The SERVO function will take control of any specified outputs and when
stopped the pins will be returned to a high impedance "not configured" state.
SETPIN pin, cfg [, option] Will configure an external I/O pin. Refer to the chapter "Using the I/O pins"
for a general description of the Micromite's input/output capabilities.
'pin' is the I/O pin to configure, ‘cfg’ is the mode that the pin is to be set to
and 'option' is an optional parameter. 'cfg' is a keyword and can be any one
of the following:
OFF Not configured or inactive
AIN Analog input (ie, measure the voltage on the input).
DIN Digital input
If 'option' is omitted the input will be high impedance
If 'option' is the keyword "PULLUP" a simulated resistor will
be used to pull up the input pin to 3.3V If the keyword
"PULLDOWN" is used the pin will be pulled down to zero
volts. The pull up/down is a constant current of about 50µA.
FIN Frequency input
'option' can be used to specify the gate time (the length of time
used to count the input cycles). It can be any number between 10
ms and 100000 ms. Note that the PIN() function will always
return the frequency correctly scaled in Hz regardless of the gate
time used. If 'option' is omitted the gate time will be 1 second.
PIN Period input
'option' can be used to specify the number of input cycles to
average the period measurement over. It can be any number
between 1 and 10000. Note that the PIN() function will
always return the average period of one cycle correctly scaled
in ms regardless of the number of cycles used for the average.
If 'option' is omitted the period of just one cycle will be used.
CIN Counting input
DOUT Digital output
'option' can be "OC" in which case the output will be open
collector (or more correctly open drain). The functions PIN()
and PORT() can also be used to return the value on one or

more output pins .
Previous versions of MMBasic used numbers for 'cfg' and the mode OOUT.
For backwards compatibility they will still be recognised.
See the function PIN() for reading inputs and the statement PIN()= for
setting an output. See the command below if an interrupt is configured.
SETPIN pin, cfg, target [, Will configure ‘pin’ to generate an interrupt according to ‘cfg’. Any I/O pin
option] capable of digital input can be configured to generate an interrupt with a
maximum of ten interrupts configured at any one time.
'cfg' is a keyword and can be any one of the following:
OFF Not configured or inactive
INTH Interrupt on low to high input
INTL Interrupt on high to low input
INTB Interrupt on both (ie, any change to the input)
‘target' is a user defined subroutine which will be called when the event
happens. Return from the interrupt is via the END SUB or EXIT SUB
commands. 'option' can be the keywords "PULLUP" or "PULLDOWN" as
specified for a normal input pin (SETPIN pin DIN). If 'option' is omitted the
input will be high impedance.
This mode also configures the pin as a digital input so the value of the pin
can always be retrieved using the function PIN().
Refer to the chapter "Using the I/O pins" for a general description of the
Micromite's input/output capabilities.
SETTICK period, target [, nbr] This will setup a periodic interrupt (or "tick").
Four tick timers are available ('nbr' = 1, 2, 3 or 4). 'nbr' is optional and if not
specified timer number 1 will be used.
The time between interrupts is ‘period’ milliseconds and ‘target' is the
interrupt subroutine which will be called when the timed event occurs.
The period can range from 1 to 2147483647 ms (about 24 days).
These interrupts can be disabled by setting ‘period’ to zero
(ie, SETTICK 0, 0, 3 will disable tick timer number 3).
STATIC variable [, variables] Defines a list of variable names which are local to the subroutine or function.
See DIM for the full syntax. These variables will retain their value between calls to the subroutine or
function (unlike variables created using the LOCAL command).
This command uses exactly the same syntax as DIM. The only difference is
that the length of the variable name created by STATIC and the length of the
subroutine or function name added together cannot exceed 32 characters.
Static variables can be initialised to a value. This initialisation will take
effect only on the first call to the subroutine (not on subsequent calls).
SUB xxx (arg1 [,arg2, …]) Defines a callable subroutine. This is the same as adding a new command to
<statements> MMBasic while it is running your program.
<statements> 'xxx' is the subroutine name and it must meet the specifications for naming a
END SUB variable.
'arg1', 'arg2', etc are the arguments or parameters to the subroutine. An array
is specified by using empty brackets. ie, arg3(). The type of the argument
can be specified by using a type suffix (ie, arg1$) or by specifying the type
using AS <type> (ie, arg1 AS STRING).
Every definition must have one END SUB statement. When this is reached
the program will return to the next statement after the call to the subroutine.
The command EXIT SUB can be used for an early exit.
You use the subroutine by using its name and arguments in a program just as
you would a normal command. For example: MySub a1, a2
When the subroutine is called each argument in the caller is matched to the
argument in the subroutine definition. These arguments are available only

inside the subroutine. Subroutines can be called with a variable number of
arguments. Any omitted arguments in the subroutine's list will be set to zero
or a null string.
Arguments in the caller's list that are a variable and have the correct type
will be passed by reference to the subroutine. This means that any changes
to the corresponding argument in the subroutine will also be copied to the
caller's variable and therefore may be accessed after the subroutine has
ended. Arrays are passed by specifying the array name with empty brackets
(eg, arg()) and are always passed by reference. Brackets around the
argument list in both the caller and the definition are optional.
TEMPR START pin [, precision] This command can be used to start a conversion running on a DS18B20
temperature sensor connected to 'pin'.
Normally the TEMPR() function alone is sufficient to make a temperature
measurement so usage of this command is optional.
This command will start the measurement on the temperature sensor. The
program can then attend to other duties while the measurement is running
and later use the TEMPR() function to get the reading. If the TEMPR()
function is used before the conversion time has completed the function will
wait for the remaining conversion time before returning the value.
Any number of these conversions (on different pins) can be started and be
running simultaneously.
'precision' is the resolution of the measurement and is optional. It is a
number between 0 and 3 meaning:
0 = 0.5ºC resolution, 100 ms conversion time.
1 = 0.25ºC resolution, 200 ms conversion time (this is the default).
TEXT x, y, string$ Displays a string on an attached LCD panel starting at 'x' and 'y'.
[,alignment$] [, font] [, scale] ‘string$’ is the string to be displayed. Numeric data should be converted to a
[, c] [, bc] string and formatted using the Str$() function.
' alignment$' is a string expression or string variable consisting of 0, 1 or 2
letters where the first letter is the horizontal alignment around 'x' and can be
L, C or R for LEFT, CENTER, RIGHT and the second letter is the vertical
alignment around 'y' and can be T, M or B for TOP, MIDDLE, BOTTOM.
The default alignment is left/top.
For example. “CM” will centre the text vertically and horizontally.
The 'alignment$' string can be a constant (eg, “CM”) or it can be a string
variable. For backwards compatibility with earlier versions of MMBasic the
string can also be unquoted (eg, CM).
In the Micromite Plus a third letter can be used in the alignment string to
indicate the rotation of the text. This can be 'N' for normal orientation, 'V'
for vertical text with each character under the previous running from top to
bottom, 'I' the text will be inverted (ie, upside down), 'U' the text will be
rotated counter clockwise by 90º and 'D' the text will be rotated clockwise by
90º
'font' and 'scale' are optional and default to that set by the FONT command.
'c' is the drawing colour and 'bc' is the background colour. They are optional
and default to the current foreground and background colours.
TIME$ = "HH:MM:SS" Sets the time of the internal clock. MM and SS are optional and will default
or to zero if not specified. For example TIME$ = "14:30" will set the clock to
14:30 with zero seconds.
TIME$ = "HH:MM"
The time is set to "00:00:00" on power up.

or
TIME$ = "HH"
TIMER = msec Resets the timer to a number of milliseconds. Normally this is just used to
reset the timer to zero but you can set it to any positive integer.
See the TIMER function for more details.
TRACE ON TRACE ON/OFF will turn on/off the trace facility. This facility will print
or the number of each line (counting from the beginning of the program) in
square brackets as the program is executed. This is useful in debugging
TRACE OFF
programs.
or
Micromite Plus only: TRACE LIST will list the last 'nn' lines executed in
TRACE LIST nn the format described above. MMBasic on the Micromite Plus is always
logging the lines executed so this facility is always available (ie, it does not
have to be turned on).
VAR SAVE var [, var]… VAR SAVE will save one or more variables to non volatile flash memory
or where they can be restored later (normally after a power interruption).
VAR RESTORE 'var' can be any number of numeric or string variables and/or arrays. Arrays
are specified by using empty brackets. For example: var()
or
VAR RESTORE will retrieve the previously saved variables and insert them
VAR CLEAR
(and their values) into the variable table.
The VAR SAVE command can be used repeatedly. Variables that had been
previously saved will be updated with their new value and any new variables
(not previously saved) will be added to the saved list for later restoration.
VAR CLEAR will erase all saved variables. Also, the saved variables will
be automatically cleared by the NEW command or when a new program is
loaded via AUTOSAVE, XMODEM, etc.
This command is normally used to save calibration data, options, and other
data which does not change often but needs to be retained across a power
interruption. Normally the VAR RESTORE command is placed at the start
of the program so that previously saved variables are restored and
immediately available to the program when it starts.
Notes:
 The storage space available to this command is 2KB on the standard 28
and 44 pin Micromites or 4KB on the Micromite Plus.
 Using VAR RESTORE without a previous save will have no effect and
will not generate an error.
 If, when using RESTORE, a variable with the same name already exists
its value will be overwritten.
 Saved arrays must be declared (using DIM) before they can be restored.
 Be aware that string arrays can rapidly use up all the memory allocated
to this command. The LENGTH qualifier can be used when a string
array is declared to reduce the size of the array (see the DIM command).
This is not needed for ordinary string variables.
 While writing data to flash memory VAR SAVE needs to temporarily
halt all PIC32 interrupts and this can disrupt any send/receive on COM2
and I2C as well as the counting inputs and IR send/receive. On the
Micromite Plus COM2 will be unaffected but any sound output at the
time may be distorted.
WATCHDOG timeout Starts the watchdog timer which will automatically restart the processor
or when it has timed out. This can be used to recover from some event that
disabled the running program (such as an endless loop or a programming or
WATCHDOG OFF
other error that halts a running program). This can be important in an
unattended control situation.
'timeout' is the time in milliseconds (ms) before a restart is forced. This

command should be placed in strategic locations in the running BASIC
program to constantly reset the watchdog timer (to ‘timeout’) and therefore
prevent it from counting down to zero.
If the timer count does reach zero (perhaps because the BASIC program has
stopped running) the Micromite will be automatically restarted and the
automatic variable MM.WATCHDOG will be set to true (ie, 1) indicating
that an error occurred. On a normal startup MM.WATCHDOG will be set to
false (ie, 0).
At any time WATCHDOG OFF can be used to disable the watchdog timer
(this is the default on a reset or power up). The timer is also turned off when
the break character (normally CTRL-C) is used on the console to interrupt a
running program.
XMODEM SEND Transfers a BASIC program to or from a remote computer using the
or XModem protocol. The transfer is done over the serial console connection.
XMODEM RECEIVE XMODEM SEND will send the current program held in the Micromite's
program memory to the remote device. XMODEM RECEIVE will accept a
or
program sent by the remote device and save it into the Micromite's program
XMODEM CRUNCH memory overwriting the program currently held there. Note that the data is
buffered in RAM which limits the maximum program size.
The CRUNCH option works like RECEIVE but it instructs MMBasic to
remove all comments, blank lines and unnecessary spaces from the program
before saving. This can be used on large programs to allow them to fit into
limited memory.
SEND, RECEIVE and CRUNCH can be abbreviated to S, R and C.
Micromite Plus only:
With the Micromite Plus you can also specify 'file$' which will transfer the
XMODEM SEND file$ data to/from a file on the SD card. If the file already exists it will be
or overwritten when receiving a file.
XMODEM RECEIVE file$ The XModem protocol requires a cooperating software program running on
the remote computer and connected to its serial port. It has been tested on
Tera Term running on Windows and it is recommended that this be used.
After running the XMODEM command in MMBasic select:
File -> Transfer -> XMODEM -> Receive/Send
from the Tera Term menu to start the transfer.
The transfer can take up to 15 seconds to start and if the XMODEM
command fails to establish communications it will return to the MMBasic
prompt after 60 seconds and leave the program memory untouched.
Download Tera Term from http://ttssh2.sourceforge.jp/

Functions
Detailed Listing
Note that the functions related to communications functions (I2C, 1-Wire, and SPI) are not listed here but are
described in the appendices at the end of this document.
Square brackets indicate that the parameter or characters are optional.
ABS( number ) Returns the absolute value of the argument 'number' (ie, any negative sign is
removed and a positive number is returned).
ACOS( number ) Returns the inverse cosine of the argument 'number' in radians.
ASC( string$ ) Returns the ASCII code (ie, byte value) for the first letter in ‘string$’.
ASIN( number ) Returns the inverse sine value of the argument 'number' in radians.
ATN( number ) Returns the arctangent of the argument 'number' in radians.
BIN$( number [, chars]) Returns a string giving the binary (base 2) value for the 'number'.
'chars' is optional and specifies the number of characters in the string with
zero as the leading padding character(s).
CHR$( number ) Returns a one-character string consisting of the character corresponding to

the ASCII code (ie, byte value) indicated by argument 'number'.
CINT( number ) Round numbers with fractional portions up or down to the next whole
number or integer.
For example, 45.47 will round to 45
45.57 will round to 46
-34.45 will round to -34
-34.55 will round to -35
See also INT() and FIX().
COS( number ) Returns the cosine of the argument 'number' in radians.
DATE$ Returns the current date based on MMBasic’s internal clock as a string in the
form "DD-MM-YYYY". For example, "28-07-2022".
The internal clock/calendar will keep track of the time and date including
leap years. To set the date use the command DATE$ =.
DEG( radians ) Converts 'radians' to degrees.
EOF( [#]nbr ) For a serial communications port this function will return true if there are no
characters waiting in the receive buffer. #0 can be used which refers to the
console's input buffer.
The # is optional. Also see the OPEN, INPUT and LINE INPUT commands
and the INPUT$ function.
EXP( number ) Returns the exponential value of 'number', ie, ex where x is 'number'.

FIX( number ) Truncate a number to a whole number by eliminating the decimal point and
all characters to the right of the decimal point.
For example 9.89 will return 9 and -2.11 will return -2.
The major difference between FIX() and INT() is that FIX() provides a true
integer function (ie, does not return the next lower number for negative
numbers as INT() does). This behaviour is for Microsoft compatibility.
See also CINT() .
HEX$( number [, chars]) Returns a string giving the hexadecimal (base 16) value for the 'number'.
INKEY$ Checks the console input buffer and, if there is one or more characters
waiting in the queue, will remove the first character and return it as a single
character in a string.
If the input buffer is empty this function will immediately return with an
empty string (ie, "").
INPUT$(nbr, [#]fnbr) Will return a string composed of ‘nbr’ characters read from a serial
communications port opened as 'fnbr'. This function will return as many
characters as are waiting in the receive buffer up to ‘nbr’. If there are no
characters waiting it will immediately return with an empty string.
#0 can be used which refers to the console's input buffer.
The # is optional. Also see the OPEN command.
INSTR( [start-position,] string- Returns the position at which 'string-pattern$' occurs in 'string-searched$',
searched$, string-pattern$ ) beginning at 'start-position'. If 'start-position' is not provided it will default
to 1.
Both the position returned and 'start-position' use 1 for the first character, 2
for the second, etc.
The function returns zero if 'string-pattern$' is not found.
INT( number ) Truncate an expression to the next whole number less than or equal to the
argument. For example 9.89 will return 9 and -2.11 will return -3.
This behaviour is for Microsoft compatibility, the FIX() function provides a
true integer function.
See also CINT() .
LEFT$( string$, nbr ) Returns a substring of ‘string$’ with ‘nbr' of characters from the left
(beginning) of the string.
LEN( string$ ) Returns the number of characters in 'string$'.
LCASE$( string$ ) Returns ‘string$’ converted to lowercase characters.
LOC( [#]fnbr ) For a serial communications port opened as 'fnbr' this function will return the
number of bytes received and waiting in the receive buffer to be read.
#0 can be used which refers to the console's input buffer.
The # is optional.

LOF( [#]fnbr ) For a serial communications port opened as 'fnbr' this function will return the
space (in characters) remaining in the transmit buffer.
Note that when the buffer is full MMBasic will pause when adding a new
character and wait for some space to become available.
The # is optional.
LOG( number ) Returns the natural logarithm of the argument 'number'.
MAX( arg1 [, arg2 [, …]] ) Returns the maximum or minimum number in the argument list.
or Note that the comparison is a floating point comparison (integer arguments
MIN( arg1 [, arg2 [, …]] ) are converted to floats) and a float is returned.
MID$( string$, start ) Returns a substring of ‘string$’ beginning at ‘start’ and continuing for ‘nbr’
or characters. The first character in the string is number 1.
MID$( string$, start, nbr ) If ‘nbr’ is omitted the returned string will extend to the end of ‘string$’
OCT$( number [, chars]) Returns a string giving the octal (base 8) representation of 'number'.
PEEK(BYTE addr%) Will return a byte or a word within the PIC32 virtual memory space.
or BYTE will return the byte (8-bits) located at 'addr%'
PEEK(WORD addr%) WORD will return the word (32-bits) located at 'addr%'
or INTEGER will return the integer (64-bits) located at 'addr%'
PEEK(INTEGER addr%) FLOAT will return the floating point number (32-bits) located at 'addr%'
or VARADDR will return the address (32-bits) of the variable 'var' in memory.
PEEK(FLOAT addr%) An array is specified as var().
or CFUNADDR will return the address (32-bits) of the CFunction 'cfun' in
memory. This address can be passed to another CFunction which can then
PEEK(VARADDR var)
call it to perform some common process.
or
VAR, will return a byte in the memory allocated to 'var'. An array is
PEEK(CFUNADDR cfun) specified as var().
or VARTBL, will return a byte in the memory allocated to the variable table
PEEK(VAR var, ±offset) maintained by MMBasic. Note that there is a comma after the keyword
or VARTBL.
PEEK( VARTBL, ±offset) PROGMEM, will return a byte in the memory allocated to the program.
or Note that there is a comma after the keyword PROGMEM.
PEEK( PROGMEM, ±offset) Note that 'addr%' should be an integer.
For backwards compatibility PEEK( hiword, loword ) is still accepted. In
this case the address is specifies by ‘hiword’ which is the top 16 bits of the
address while ‘loword’ is the bottom 16 bits.
This command is for expert users only. The PIC32 maps all control
registers, flash (program) memory and volatile (RAM) memory into a single
address space so there is no need for INP or OUT commands. The
PIC32MX170 Family Data Sheet lists the details of this address space (RAM
starts at 0xA0000000, Program Flash starts at 0x9D000000 and Boot Flash
starts at 0x9FC00000).
PI Returns the value of pi.

PIN( pin ) Returns the value on the external I/O ‘pin’. Zero means digital low, 1 means
digital high and for analogue inputs it will return the measured voltage as a
floating point number.
Frequency inputs will return the frequency in Hz. A period input will return
the period in milliseconds while a count input will return the count since
reset (counting is done on the positive rising edge). The count input can be
reset to zero by resetting the pin to counting input (even if it is already so
configured).
This function will also return the state of a pin configured as an output.
Also see the SETPIN and PIN() = commands. Refer to the chapter "Using
the I/O pins" for a general description of the Micromite's input/output
capabilities.
PORT(start, nbr [,start, nbr]…) Returns the value of a number of I/O pins in one operation.
'start' is an I/O pin number and its value will be returned as bit 0. 'start'+1 will
be returned as bit 1, 'start'+2 will be returned as bit 2, and so on for 'nbr'
number of bits. I/O pins used must be numbered consecutively and any I/O pin
that is invalid or not configured as an input will cause an error. The start/nbr
pair can be repeated up to 25 times if additional groups of input pins need to
be added.
This function will also return the state of a pin configured as an output. It
can be used to conveniently communicate with parallel devices like memory
chips. Any number of I/O pins (and therefore bits) can be used from 1 to the
number of I/O pins on the chip.
See the PORT command to simultaneously output to a number of pins.
PULSIN( pin, polarity ) Measures the width of an input pulse from 1µs to 1 second with 0.1µs
or resolution.
PULSIN( pin, polarity, t1 ) 'pin' is the I/O pin to use for the measurement, it must be previously
configured as a digital input. 'polarity' is the type of pulse to measure, if
or
zero the function will return the width of the next negative pulse, if non zero
PULSIN( pin, polarity, t1, t2 ) it will measure the next positive pulse.
't1' is the timeout applied while waiting for the pulse to arrive, 't2' is the
timeout used while measuring the pulse. Both are in microseconds (µs) and
are optional. If 't2' is omitted the value of 't1' will be used for both timeouts.
If both 't1' and 't2' are omitted then the timeouts will be set at 100000 (ie,
100ms).
This function returns the width of the pulse in microseconds (µs) or -1 if a
timeout has occurred. With a CPU speed of 40MHz the measurement is
accurate to ±0.5% and ±0.5µs. At other speeds the measurement is slightly
less accurate.
Note that this function will cause the running program to pause while the
measurement is made and interrupts will be ignored during this period.
RAD( degrees ) Converts 'degrees' to radians.
RGB(red, green, blue) Generates an RGB true colour value.

or 'red', 'blue' and 'green' represent the intensity of each colour. A value of zero
RGB(shortcut) represents black and 255 represents full intensity.
'shortcut' allows common colours to be specified by naming them. The
colours that can be named are white, black, blue, green, cyan, red, magenta,
yellow, brown and gray. For example, RGB(red) or RGB(cyan).
Note that the value returned is an integer and, if it is to be saved, the variable
should be declared as an integer to retain the accuracy of the number.

RIGHT$( string$, number-of- Returns a substring of ‘string$’ with ‘number-of-chars’ from the right (end)
chars ) of the string.
RND( number ) Returns a pseudo-random number in the range of 0 to 0.999999. The

or 'number' value is ignored if supplied. The RANDOMIZE command reseeds
the random number generator.
RND
SGN( number ) Returns the sign of the argument 'number', +1 for positive numbers, 0 for 0,
and -1 for negative numbers.
SIN( number ) Returns the sine of the argument 'number' in radians.
SPACE$( number ) Returns a string of blank spaces 'number' characters long.
SQR( number ) Returns the square root of the argument 'number'.
STR$( number ) Returns a string in the decimal (base 10) representation of 'number'.
or If 'm' is specified sufficient spaces will be added to the start of the number to
STR$( number, m ) ensure that the number of characters before the decimal point (including the
negative or positive sign) will be at least 'm' characters. If 'm' is zero or the
or
number has more than 'm' significant digits no padding spaces will be added.
STR$( number, m, n )
If 'm' is negative, positive numbers will be prefixed with the plus symbol and
or negative numbers with the negative symbol. If 'm' is positive then only the
STR$( number, m, n, c$ ) negative symbol will be used.
'n' is the number of digits required to follow the decimal place. If it is zero
the string will be returned without the decimal point. If it is negative the
output will always use the exponential format with 'n' digits resolution. If 'n'
is not specified the number of decimal places and output format will vary
automatically according to the number.
'c$' is a string and if specified the first character of this string will be used as
the padding character instead of a space (see the 'm' argument).
Examples:
STR$(123.456) will return "123.456"
STR$(-123.456) will return "-123.456"
STR$(123.456, 1) will return "123.456"
STR$(123.456, -1) will return "+123.456"
STR$(123.456, 6) will return " 123.456"
STR$(123.456, -6) will return " +123.456"
STR$(-123.456, 6) will return " -123.456"
STR$(-123.456, 6, 5) will return " -123.45600"
STR$(-123.456, 6, -5) will return " -1.23456e+02"
STR$(53, 6) will return " 53"
STR$(53, 6, 2) will return " 53.00"
STR$(53, 6, 2, "*") will return "****53.00"
STRING$( nbr, ascii ) Returns a string 'nbr' bytes long consisting of either the first character of
or string$ or the character representing the ASCII value 'ascii' which is an
integer or float number in the range of 0 to 255.
STRING$( nbr, string$ )
TAB( number ) Outputs spaces until the column indicated by 'number' has been reached on
the console output.

TAN( number ) Returns the tangent of the argument 'number' in radians.
TEMPR( pin ) Return the temperature measured by a DS18B20 temperature sensor

connected to 'pin' (which does not have to be configured). The CPU speed
must be 20 MHz or above.
The returned value is degrees C with a default resolution of 0.25ºC. If there
is an error during the measurement the returned value will be 1000.
The time required for the overall measurement is 200ms and interrupts will
be ignored during this period. Alternatively the TEMPR START command
can be used to start the measurement and your program can do other things
while the conversion is progressing. When this function is called the value
will then be returned instantly assuming the conversion period has expired.
If it has not, this function will wait out the remainder of the conversion time
before returning the value.
The DS18B20 can be powered separately by a 3V to 5V supply or it can
operate on parasitic power from the Micromite.
TIME$ Returns the current time based on MMBasic's internal clock as a string in the
form "HH:MM:SS" in 24 hour notation. For example, "14:30:00".
To set the current time use the command TIME$ = .
TIMER Returns the elapsed time in milliseconds (eg, 1/1000 of a second) since reset.
The timer is reset to zero on power up or a CPU restart and you can also
reset it by using TIMER as a command. If not specifically reset it will
continue to count up forever (it is a 64 bit number and therefore will only
roll over to zero after 200 million years).
TOUCH(X) Will return the X or Y coordinate of the location currently touched on an

or LCD panel.
TOUCH(Y) If the screen is not being touched the function will return -1.
UCASE$( string$ ) Returns ‘string$’ converted to uppercase characters.
VAL( string$ ) Returns the numerical value of the ‘string$’. If 'string$' is an invalid number
the function will return zero.
This function will recognise the &H prefix for a hexadecimal number, &O
for octal and &B for binary.

Obsolete Commands and Functions
Detailed Listing
These commands and functions are mostly included to assist in converting programs written for Microsoft
BASIC. For new programs the corresponding modern commands in MMBasic should be used.
Note that these commands may be removed in the future to recover memory for other features.
GOSUB target Initiates a subroutine call to the target, which can be a line number or a label.
The subroutine must end with RETURN.
New programs should use defined subroutines (ie, SUB…END SUB).
IF condition THEN linenbr For Microsoft compatibility a GOTO is assumed if the THEN statement is
followed by a number. A label is invalid in this construct.
New programs should use: IF condition THEN GOTO linenbr | label
IRETURN Returns from an interrupt when the interrupt destination was a line number
or a label.
New programs should use a user defined subroutine as an interrupt
destination. In that case END SUB or EXIT SUB will cause a return from
the interrupt.
ON nbr GOTO | GOSUB ON either branches (GOTO) or calls a subroutine (GOSUB) based on the
target[,target, target,...] rounded value of 'nbr'; if it is 1, the first target is called, if 2, the second
target is called, etc. Target can be a line number or a label.
New programs should use SELECT CASE.
SPC( number ) This function returns a string of blank spaces 'number' bytes long. It is
similar to the SPACE$() function and is only included for Microsoft
compatibility.
POS For the console, returns the current cursor position in the line in characters.
RETURN RETURN concludes a subroutine called by GOSUB and returns to the

statement after the GOSUB.
TROFF Turns the trace facility off; see TRON.
TRON Turns on the trace facility. This facility will print the number of each line
(counting from the beginning of the program) in square brackets as the
program is executed. This is useful in debugging programs.
New programs should use the TRACE command.
WHILE expression WHILE initiates a WHILE-WEND loop.

The loop ends with WEND, and execution reiterates through the loop as long
WEND as the 'expression' is true.
This construct is included for Microsoft compatibility. New programs
should use the DO WHILE … LOOP construct.

Appendix A – Serial Communications
Serial Communications
On the standard Micromite (28 or 44-pin) two serial ports are available for asynchronous serial communications
labelled COM1: and COM2:. On the Micromite Plus (64 or 100-pin) up to four serial ports can be used (see the
Micromite Plus Manual for the details).
After being opened the serial port will have an associated file number and you can use any commands that operate
with a file number to read and write to/from it. A serial port is also closed using the CLOSE command.
The following is an example:
OPEN "COM1:4800" AS #5 ‘ open the first serial port with a speed of 4800 baud
PRINT #5, "Hello" ‘ send the string "Hello" out of the serial port
dat$ = INPUT$(20, #5) ‘ get up to 20 characters from the serial port
CLOSE #5 ‘ close the serial port
The OPEN Command

A serial port is opened using the command:
OPEN comspec$ AS #fnbr
‘fnbr’ is the file number to be used. It must be in the range of 1 to 10. The # is optional.
‘comspec$’ is the communication specification and is a string (it can be a string variable) specifying the serial
port to be opened and optional parameters. The default is 9600 baud, 8 data bits, no parity and one stop bit.
It has the form "COMn: baud, buf, int, int-trigger, DE, 9BIT, INV, OC, S2" where:
 ‘n’ is the serial port number for either COM1: or COM2:.
 ‘baud’ is the baud rate – see Baud Rate below for the limits in the speed Default is 9600.
 ‘buf’ is the receive buffer size in bytes (default size is 256). The transmit buffer is fixed at 256 bytes.
 ‘int’ is a user defined subroutine which will be called when the serial port has received some data. The
default is no interrupt.
 ‘int-trigger’ sets the trigger condition for calling the interrupt subroutine. If it is a normal number the
interrupt subroutine will be called when this number of characters has arrived in the receive queue.
Alternatively, if the number (in the range of 1 to 255) is prefixed with an equals character (=) the
interrupt subroutine will be called when a character with this ASCII value has arrived in the receive
queue. For example, if the following was used "COM1: 300, 256, MyInt, =13" the interrupt
subroutine will be called when a carriage return character (ASCII value of 13 decimal) was received.
All parameters except the serial port name (COMn:) are optional. If any one parameter is left out then all the
following parameters must also be left out and the defaults will be used.
Five options can be added to the end of 'comspec$' These are DE, 9BIT, INV, OC and S2:
 ‘DE’ will enable the Data output Enable (EN) signal for RS485. See the section "IEEE 485" for details.
 '9BIT' will specify that 9 bit transmit and receive is to be used. See the section "IEEE 485" for details.
 'INV' specifies that the transmit and receive polarity is inverted (COM1: only).
 ‘OC’ will force the transmit pin (and DE on COM1:) to be open collector. This option can be used on
both COM1: and COM2:. The default is normal (0 to 3.3V) output.
 'S2' specifies that two stop bits will be sent following each character transmitted. (COM1: only)
Input/Output Pin Allocation

When a serial port is opened the pins used by the port will be automatically set to input or output as required
and the SETPIN and PIN commands will be disabled for the pins. When the port is closed (using the CLOSE
command) all pins used by the serial port will be set to a not-configured state and the SETPIN command can
then be used to reconfigure them.
The connections for each COM port are shown in the pinout diagrams in the beginning of this manual. Note
that Tx means an output from the Micromite and Rx means an input to the Micromite. The enable pin (the EN
signal for RS485) is an output.
The signal polarity is standard for devices running at TTL voltages (for RS232 voltages see below). Idle is
voltage high, the start bit is voltage low, data uses a high voltage for logic 1 and the stop bit is voltage high.

These signal levels allow you to directly connect to devices like GPS modules (which generally use TTL
voltage levels).
When a serial port is opened MMBasic will enable an internal pullup resistor (to Vdd) on the Rx (receive data)
pin. This has a value of about 100K and its purpose is to prevent the input from floating if it is left
unconnected. Normally this is fine but it can cause a problem if you have an external resistor in series with the
Rx pin, in that case this resistor and the pullup resistor will form a voltage divider limiting how high or low the
voltage on the Rx pin can swing and that in turn might mean that the input signal is not recognised. The
solution is to use the embedded C routine ChangePin to turn off the pullup after the serial port has been
opened. ChangePin is included in the Micromite distribution file (the zip file) in the Embedded C Modules
folder.
Note that a pullup resistor is also applied to the console's Rx pin and it too can be disabled using ChangePin.
Baud Rate
On the 28 and 44-pin Micromites COM1: is implemented using the onboard UART in the PIC32 while COM2: is
implemented in software and therefore cannot run as fast. The maximum speed for both COM ports is limited by
the CPU's speed as listed below (the CPU speed can be changed with the CPU SPEED command):
CPU Speed COM1: Maximum COM2: Maximum

48 MHz 282000 19200
40 MHz (default) 230400 19200
30 MHz 115200 9600
20 MHz 115200 9600
10 MHz 57600 4800
5 MHz 38400 2400
Note that below these limits any baud rate can be chosen, for example 1111 bps is a valid speed for both ports.
On the Micromite Plus much greater speeds can be specified for all four possible serial ports (see the Micromite
Plus Manual for the details).
Examples
Opening a serial port using all the defaults:
OPEN "COM2:" AS #2
Opening a serial port specifying only the baud rate (4800 bits per second):
OPEN "COM2:4800" AS #1
Opening a serial port specifying the baud rate (9600 bits per second) and receive buffer size (1KB):
OPEN "COM1:9600, 1024" AS #8
The same as above but with two stop bits enabled:
OPEN "COM1:9600, 1024, S2" AS #8
An example specifying everything including an interrupt, an interrupt level, inverted and two stop bits:
OPEN "COM1:19200, 1024, ComIntLabel, 256, INV, S2" AS #5
Reading and Writing

Once a serial port has been opened you can use any command or function that uses a file number to read from
and write to the port. Data received by the serial port will be automatically buffered in memory by MMBasic
until it is read by the program and the INPUT$() function is the most convenient way of doing that. When
using the INPUT$() function the number of characters specified will be the maximum number of characters
returned but it could be less if there are less characters in the receive buffer. In fact the INPUT$() function will
immediately return an empty string if there are no characters available in the receive buffer.
The LOC() function is also handy; it will return the number of characters waiting in the receive buffer (ie, the
maximum number characters that can be retrieved by the INPUT$() function). Note that if the receive buffer
overflows with incoming data the serial port will automatically discard the oldest data to make room for the
new data.
The PRINT command is used for outputting to a serial port and any data to be sent will be held in a memory
buffer while the serial port is sending it. This means that MMBasic will continue with executing the commands
after the PRINT command while the data is being transmitted. The one exception is if the output buffer is full
and in that case MMBasic will pause and wait until there is sufficient space before continuing. The LOF()

function will return the amount of space left in the transmit buffer and you can use this to avoid stalling the
program while waiting for space in the buffer to become available.
If you want to be sure that all the data has been sent (perhaps because you want to read the response from the
remote device) you should wait until the LOF() function returns 256 (the transmit buffer size) indicating that
there is nothing left to be sent.
Serial ports can be closed with the CLOSE command. This will wait for the transmit buffer to be emptied then
free up the memory used by the buffers, cancel the interrupt (if set) and set all pins used by the port to the not
configured state. A serial port is also automatically closed when commands such as RUN and NEW are issued.
Interrupts
The interrupt subroutine (if specified) will operate the same as a general interrupt on an external I/O pin (see
the chapter "Using the I/O pins" for a description).
When using interrupts you need to be aware that it will take some time for MMBasic to respond to the interrupt
and more characters could have arrived in the meantime, especially at high baud rates. For example, if you
have specified the interrupt level as 200 characters and a buffer of 256 characters then quite easily the buffer
will have overflowed by the time the interrupt subroutine can read the data. In this case the buffer should be
increased to 512 characters or more. Similarly, if the interrupt has been set to trigger on a certain character
there may have been more characters received following that character by the time the interrupt subroutine has
been called.
Additional Serial Ports

Additional serial ports can be added to the Micromite by using the SerialTx and SerialRx embedded C modules.
These are included in the "Embedded C Modules" folder in the Micromite firmware zip file.
IEEE 485
The 'DE' option in the OPEN comspec$ for COM1: specifies that the Data output Enable (ENABLE) signal for
the IEEE 485 protocol will be generated. This signal will appear on pin 7 on the 28-pin chip and is normally
high. Just before a byte is transmitted this output will go low and when the byte has finished transmission the
output will go high again. Note that this polarity is the opposite of that used in the Maximite family and an
inverter is normally required to drive the DE input of an IEEE 485 transceiver.
Many IEEE 485 systems also use 9 bits of data for transmit and receive. The 9th bit is used to indicate that an
address is being sent or received. To accommodate this the '9BIT' option in the OPEN comspec$ for COM1:
can be used. With this option all data sent must be sent in pairs of bytes – the first byte is the 9th bit and the
second is the data (the other 8 bits). The first byte should be either the ASCII character '1' to indicate that the
9th bit should be set or '0' for not set. This 9th bit is then applied to the second byte in the pair and together they
represent the 9 bits of data to send.
For example, the following fragment of code will send three 9 bit data items. The first is an address (bit 9 is
high) and the second two are the data (bit 9 is low):
OPEN "COM1: 4800, 9BIT" as #1
PRINT "1" + CHR$(211);
PRINT "0" + CHR$(23);
PRINT "0" + CHR$(0);
Note that in the PRINT commands the automatic CR/LF is suppressed by the use of the semicolon.
Received data is similar. The 9bit data is translated into two characters – the first is the ASCII character '1' or
'0' indicating the state of the 9th bit in the data received and the second character is the other 8 bits. This means
that a BASIC program must read the data as pairs and apply logic to determine the value of the 9th bit (the first
character) and then take the appropriate action with the second character.
For example:
IF LOC(#1) >= 2 THEN ' check that we have at least two bytes
A$ = INPUT$(1, #1) : B$ = INPUT$(1, #1)
IF A$ = "1" THEN
' B$ contains an address
ELSE
' B$ contains some data
ENDIF
ENDIF

MMBasic does not check that data is printed or read to/from the COM port in pairs. If your program
inadvertently sends or reads a single character it will disrupt all subsequent communications.
Note also that in 9 bit mode the size of the transmit and receive buffers are effectively halved because each
9 bit data item is stored as two bytes.
Low Cost RS-232 Interface

The RS-232 signalling system is used by modems, hardwired serial ports on a PC, test equipment, etc. It is the
same as the serial TTL system used on the Micromite with two exceptions:
 The voltage levels of RS-232 are +12V and -12V where TTL serial uses +3.3V and zero volts.
 The signalling is inverted (the idle voltage is -12V, the start bit is +12V, etc).
It is possible to purchase cheap RS-232 to TTL converters on the Internet but it would be handy if the
Micromite could directly interface to RS-232.
The first issue is that the signalling polarity is inverted with respect to TTL. On the Micromite COM1: can be
specified to invert the transmit and receive signal (the 'INV' option) so that is an easy fix.
For the receive data (that is the ±12V signal from the remote RS-232 device) it is easy to limit the voltage using
a series resistor of (say) 10KΩ and two diodes that will clamp the input voltage to the 3.3V rail and ground.
The input impedance of the Micromite is very high so the resistor will not cause a voltage drop but it does
mean that when the signal swings to the maximum ±12V it will be safely clipped by the diodes.
For the transmit signal (from the Micromite to the RS-232 device) you can connect this directly to the input of
the remote device. The Micromite will only swing the signal from zero to 3.3V but most RS-232 inputs have a
threshold of about +1V so the Micromite's signal will still be interpreted as a valid signal.
These measures break the rules for RS-232 signalling, but if you only want to use it over a short distance (a
metre or two) it should work fine.
To summarise, use this circuit (the pin numbers are for a 28-pin chip):
And open COM1: with the invert option. For example:

OPEN "COM1: 4800, INV" AS #1

Appendix B – I2C Communications
I2C Communications
The Inter Integrated Circuit (I2C) bus was developed by Philips (now NXP) for the transfer of data between
integrated circuits. This implementation was written by Gerard Sexton and the standard definition of I2C is
provided by this document: http://www.nxp.com/documents/user_manual/UM10204.pdf
There are four commands that can be used in I2C master mode:
I2C OPEN speed, Enables the I2C module in master mode.

timeout [, PU] ‘speed’ is a value between 10 and 400 (for bus speeds 10 kHz to 400 kHz).
‘timeout’ is a value in milliseconds after which the master send and receive
commands will be interrupted if they have not completed. The minimum value is
100. A value of zero will disable the timeout (though this is not recommended).
'PU' (if specified) will enable weak pullups (about 100K) on both the clock and
data lines. I2C normally requires lower value resistors (typically 10K) but for
short signal lines at slow speed this may be all that is required.
I2C WRITE addr, Send data to the I2C slave device.

option, sendlen, ‘addr’ is the slave’s I2C address.
senddata [,sendata
‘option’ is a number between 0 and 3 (normally this is set to 0)
....]
1 = Keep control of the bus after the command (a stop condition will not be sent
at the completion of the command)
2 = Treat the address as a 10 bit address
3 = Combine 1 and 2 (hold the bus and use 10 bit addresses).
‘sendlen’ is the number of bytes to send.
‘senddata’ is the data to be sent - this can be specified in various ways (all values
sent will be between 0 and 255):
 The data can be supplied as individual bytes on the command line.
Example: I2C WRITE &H6F, 0, 3, &H23, &H43, &H25
 The data can be in a one dimensional array specified with empty brackets (ie,
no dimensions). ‘sendlen’ bytes of the array will be sent starting with the first
element. Example: I2C WRITE &H6F, 0, 3, ARRAY()
 The data can be a string variable (not a constant).
Example: I2C WRITE &H6F, 0, 3, STRING$
I2C READ addr, Get data from the I2C slave device.
option, rcvlen, rcvbuf ‘addr’ is the slave’s I2C address.
‘option’ is a number between 0 and 3 (normally this is set to 0)
1 = Keep control of the bus after the command (a stop condition will not be sent
at the completion of the command)
2 = Treat the address as a 10 bit address
3 = Combine 1 and 2 (hold the bus and use 10 bit addresses).
‘rcvlen’ is the number of bytes to receive.
‘rcvbuf’ is the variable or array used to save the received data - this can be:
 A string variable. Bytes will be stored as sequential characters in the string.
 A one dimensional array of numbers specified with empty brackets. Received
bytes will be stored in sequential elements of the array starting with the first.
Example: I2C READ &H6F, 0, 3, ARRAY()
 A normal numeric variable (in this case rcvlen must be 1).

I2C CLOSE Disables the master I2C module and returns the I/O pins to a "not configured" state.
They can then be configured using SETPIN. This command will also send a stop
if the bus is still held.
And similarly there are four commands for the slave mode:
I2C SLAVE OPEN Enables the I2C module in slave mode.

addr, mask, option, ‘addr’ is the slave I2C address.
send_int, rcv_int
‘mask’ is the address mask (normally 0, bits set as 1 will always match). This
allows the slave to respond to multiple addresses.
‘option’ is a number between 0 and 3 (normally this is set to 0).
1 = allows MMBasic to respond to the general call address. When this occurs
the value of MM.I2C will be set to 4.
2 = treat the address as a 10 bit address
3 = combine 1 and 2
‘send_int’ is the subroutine to be invoked when the module has detected that the
master is expecting data.
‘rcv_int is the subroutine to be called when the module has received data from the
master. Note that this is triggered on the first byte received so your program might
need to wait until all the data is received.
I2C SLAVE WRITE Send the data to the I2C master. This command should be used in the send
sendlen, senddata interrupt (ie in the 'send_int' subroutine when the master has requested data).
[,sendata ....] Alternatively a flag can be set in the interrupt subroutine and the command
invoked from the main program loop when the flag is set.
‘sendlen is the number of bytes to send.
‘senddata’ is the data to be sent. This can be specified in various ways, see the I2C
WRITE commands for details.
I2C SLAVE READ Receive data from the I2C master device. This command should be used in the
rcvlen, rcvbuf, rcvd receive interrupt (ie in the 'rcv_int' subroutine when the master has sent some
data). Alternatively a flag can be set in the receive interrupt subroutine and the
command invoked from the main program loop when the flag is set.
‘rcvlen’ is the maximum number of bytes to receive.
‘rcvbuf’ is the variable to receive the data. This can be specified in various ways,
see the I2C READ commands for details.
‘rcvd’ is a variable that, at the completion of the command, will contain the actual
number of bytes received (which might differ from ‘rcvlen’).
I2C SLAVE CLOSE Disables the slave I2C module and returns the external I/O pins 12 and 13 to a "not
configured" state. They can then be configured using SETPIN.
Following an I2C write or read command the automatic variable MM.I2C will be set to indicate the result of the
operation as follows:
0 = The command completed without error.
1 = Received a NACK response
2 = Command timed out
Additional I2C Ports

Additional I2C master ports can be added to the Micromite by using the I2CPort embedded C module. This is
included in the "Embedded C Modules" folder in the Micromite firmware zip file.

7 and 8 Bit Addressing
The standard addresses used in these commands are 7-bit addresses (without the read/write bit). MMBasic will
add the read/write bit and manipulate it accordingly during transfers.
Some vendors provide 8-bit addresses which include the read/write bit. You can determine if this is the case
because they will provide one address for writing to the slave device and another for reading from the slave. In
these situations you should only use the top seven bits of the address.
For example: If the read address is 9B (hex) and the write address is 9A (hex) then using only the top seven bits
will give you an address of 4D (hex). A simple way of finding the address is to take the 8 bit write address and
divide it by 2.
Another indicator that a vendor is using 8-bit addresses instead of 7-bit addresses is to check the address range.
All 7-bit addresses should be in the range of 08 to 77 (hex). If your slave address is greater than this range then
probably your vendor has specified an 8-bit address.
10 Bit Addressing
10-bit addressing was designed to be compatible with 7-bit addresses, allowing developers to mix the two types
of devices on a single bus. Devices that use 10-bit addresses will be clearly identified as such in their data
sheets.
In 10-bit addressing the slave address is sent in two bytes with the first byte beginning with a special bit pattern
to indicate that a 10 bit address is being used. This process is automatically managed by MMBasic when the
'option' argument is set for 10-bit addressing. 10-bit addresses can be in the range of 0 to 3FF (hex).
Master/Slave Modes
The master and slave modes can be enabled simultaneously; however, once a master command is in progress,
the slave function will be "idle" until the master releases the bus. Similarly, if a slave command is in progress,
the master commands will be unavailable until the slave transaction completes.
In master mode, the I2C send and receive commands will not return until the command completes or a timeout
occurs (if the timeout option has been specified).
The slave mode uses an MMBasic interrupt to signal a change in status and in this routine the Micromite should
write/read the data as specified by the I2C master. This operates the same as a general interrupt on an external
I/O pin.
I/O Pins
Refer to pinout charts at the beginning of this manual for the pin numbers used for the I2C data line (SDA) and
clock (SCL). Both of these pins should have external pullup resistors installed (typical values are 10 KΩ for
100 kHz or 2 KΩ for 400 kHz). Weak pullups (about 100K) on both the clock and data lines can also be
specified in the I2C OPEN command. I2C normally requires lower value resistors but for short signal lines at
slow speeds this may be all that is required.
When the I2C CLOSE command is used the I/O pins are reset to a "not configured" state. Then can then be
configured as per normal using SETPIN.
When running the I2C bus at above 150 kHz the cabling between the devices becomes important. Ideally the
cables should be as short as possible (to reduce capacitance) and also the data and clock lines should not run
next to each other but have a ground wire between them (to reduce crosstalk).
If the data line is not stable when the clock is high, or the clock line is jittery, the I2C peripherals can get
"confused" and end up locking the bus (normally by holding the clock line low). If you do not need the higher
speeds then operating at 100 kHz is the safest choice.

Appendix C – 1-Wire Communications
1-Wire Communications
The 1-Wire protocol was developed by Dallas Semiconductor to communicate with chips using a single
signalling line. This implementation was written for MMBasic by Gerard Sexton.
There are three commands that you can use:

ONEWIRE RESET pin Reset the 1-Wire bus
ONEWIRE WRITE pin, flag, length, data [, data…] Send a number of bytes
ONEWIRE READ pin, flag, length, data [, data…] Get a number of bytes
Where:
pin - The Micromite I/O pin to use. It can be any pin capable of digital I/O.
flag - A combination of the following options:
1 - Send reset before command
2 - Send reset after command
4 - Only send/recv a bit instead of a byte of data
8 - Invoke a strong pullup after the command (the pin will be set high and open drain disabled)
length - Length of data to send or receive
data - Data to send or variable to receive.
The number of data items must agree with the length parameter.
And the automatic variable
MM.ONEWIRE Returns true if a device was found
Note: The CPU speed must be 10 MHz or above.

After the command is executed, the I/O pin will be set to the not configured state unless flag option 8 is used.
When a reset is requested the automatic variable MM.ONEWIRE will return true if a device was found. This
will occur with the ONEWIRE RESET command and the ONEWIRE READ and ONEWIRE WRITE
commands if a reset was requested (flag = 1 or 2).
For users of MMBasic on earlier devices

This implementation of the 1-Wire protocol is generally compatible with previous versions with the following
differences:
 The commands are now two words where previously they were one word. For example, OWWRITE is
now ONEWIRE WRITE.
 You cannot use an array or string variable for 'data'. One or more numeric variables are required.
 The reset command (ONEWIRE RESET) does not accept a 'presence' variable (use the MM.ONEWIRE
variable instead).
 The OWSEARCH command and the OWCRC8() and OWCRC16() functions are not implemented.
The 1-Wire protocol is often used in communicating with the DS18B20 temperature measuring sensor and to
help in that regard MMBasic includes the TEMPR() function which provides a convenient method of directly
reading the temperature of a DS18B20 without using these functions.

Appendix D – SPI Communications
SPI Communications
The Serial Peripheral Interface (SPI) communications protocol is used to send and receive data between
integrated circuits. The Micromite acts as the master (ie, it generates the clock).
I/O Pins
The SPI OPEN command will automatically configure the relevant I/O pins. The SPI pinouts are listed at the
start of the manual. MISO stands for Master In Slave Out and because the Micromite is always the master that
pin will be configured as an input. Similarly MOSI stands for Master Out Slave In and that pin will be
configured as an output.
When the SPI CLOSE command is used these pins will be returned to a "not configured" state. They can then
be configured as per normal using SETPIN.
SPI Open
To use the SPI function the SPI channel must be first opened.
The syntax for opening the SPI channel is:
SPI OPEN speed, mode, bits
Where:
 ‘speed’ is the speed of the clock. It is a number representing the clock speed in Hz. The maximum is
one quarter the CPU speed (ie, 10000000 at a CPU speed of 40 MHz).
 'mode' is a single numeric digit representing the transmission mode – see Transmission Format below.
 'bits' is the number of bits to send/receive. This can be 8, 16 or 32.
 It is the responsibility of the program to separately manipulate the CS (chip select) pin if required.
Transmission Format
The most significant bit is sent and received first. The format of the transmission can be specified by the 'mode'
as shown below. Mode 0 is the most common format.
Mode Description CPOL CPHA
0 Clock is active high, data is captured on the rising edge and output on the falling edge 0 0
1 Clock is active high, data is captured on the falling edge and output on the rising edge 0 1
2 Clock is active low, data is captured on the falling edge and output on the rising edge 1 0
3 Clock is active low, data is captured on the rising edge and output on the falling edge 1 1
For a more complete explanation see: http://en.wikipedia.org/wiki/Serial_Peripheral_Interface_Bus
Standard Send/Receive
When the SPI channel is open data can be sent and received using the SPI function. The syntax is:
received_data = SPI(data_to_send)
Note that a single SPI transaction will send data while simultaneously receiving data from the slave.
‘data_to_send’ is the data to send and the function will return the data received during the transaction.
‘data_to_send’ can be an integer or a floating point variable or a constant.
If you do not want to send any data (ie, you wish to receive only) any number (eg, zero) can be used for the
data to send. Similarly if you do not want to use the data received it can be assigned to a variable and ignored.
Bulk Send/Receive
Data can also be sent in bulk:
SPI WRITE nbr, data1, data2, data3, … etc
or
SPI WRITE nbr, string$
or
SPI WRITE nbr, array()

In the first method 'nbr' is the number of data items to send and the data is the expressions in the argument list
(ie, 'data1', data2' etc). The data can be an integer or a floating point variable or a constant.
In the second or third method listed above the data to be sent is contained in the 'string$' or the contents of
'array()' (which must be a single dimension array of integer or floating point numbers). The string length, or the
size of the array must be the same or greater than nbr. Any data returned from the slave is discarded.
Data can also be received in bulk:
SPI READ nbr, array()
Where 'nbr' is the number of data items to be received and array() is a single dimension integer array where the
received data items will be saved. This command sends zeros while reading the data from the slave.
SPI Close
If required the SPI channel can be closed as follows (the I/O pins will be set to inactive):
SPI CLOSE
Additional SPI Ports

Additional SPI ports can be added to the Micromite by using the SPIPort embedded C module. This is included
in the "Embedded C Modules" folder in the Micromite firmware zip file.
Using the SPI with the Colour LCD and Touch Features
The standard 28 and 44-pin Micromites have only one SPI channel so this must be shared between the display
and touch controllers (if these features are used) and the BASIC program. The Micromite Plus has two SPI
channels so this issue does not occur with this version.
To share the SPI port with a LCD display on the standard Micromite it must be opened in BASIC and closed
again without any intervening commands that might cause MMBasic to send/receive data to the display or
touch controllers. This includes commands such as CLS, LINE, etc and the TOUCH() function.
The following provides an example. The SPI port is opened and closed within the one function with no
intervening graphic or touch commands:
PIN(26) = 1 ' preset the pin high before it is setup
SETPIN 26, DOUT ' pin 26 will be used as the enable signal
CIRCLE 100, 100, 50 ' draw a circle (uses the SPI port)
nbr% = ReadSPI%() ' get the SPI data
x% = TOUCH(X) ' get the X touch location (uses the SPI port)
nbr2% = ReadSPI%() ' get the SPI data for a second time
y% = TOUCH(Y) ' get the Y touch location (uses the SPI port)
END
' function to get the SPI data

FUNCTION ReadSPI%()
SPI OPEN 4000000,0,8 ' 4MHz speed, mode 0, 8bits
PIN(26) = 0 ' chip select low
SPI write 3,3,0,0 ' send a command
SPI read 1, ReadSPI% ' and get the response
PIN(26) = 1 ' chip select high
SPI CLOSE
END FUNCTION
Examples
The following example shows how to use the SPI port for general I/O. It will send a command 80 (hex) and
receive two bytes from the slave SPI device using the standard send/receive function:
PIN(10) = 1 : SETPIN 10, DOUT ' pin 10 will be used as the enable signal
SPI OPEN 5000000, 3, 8 ' speed is 5 MHz and the data size is 8 bits
PIN(10) = 0 ' assert the enable line (active low)
junk = SPI(&H80) ' send the command and ignore the return
byte1 = SPI(0) ' get the first byte from the slave
byte2 = SPI(0) ' get the second byte from the slave
PIN(10) = 1 ' deselect the slave
SPI CLOSE ' and close the channel

The following is similar to the example given above but this time the transfer is made using the bulk
send/receive commands:
OPTION BASE 1 ' our array will start with the index 1
DIM data%(2) ' define the array for receiving the data
PIN(10) = 1 : SETPIN 10, DOUT ' pin 10 will be used as the enable signal
SPI OPEN 5000000, 3, 8 ' speed is 5 MHz, 8 bits data
PIN(10) = 0 ' assert the enable line (active low)
SPI WRITE 1, &H80 ' send the command
SPI READ 2, data%() ' get two bytes from the slave
PIN(10) = 1 ' deselect the slave
SPI CLOSE ' and close the channel

Micromite Manual

Uploaded by

Copyright:

Available Formats

Micromite Manual

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Micromite Manual

Uploaded by

Copyright:

Available Formats

Micromite

For updates to this manual and more details on MMBasic go to

I2C Support is Copyright 2011 Gerard Sexton.

On the Micromite Plus:

This manual is distributed under a Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Australia

Micromite User Manual Page 2

Micromite User Manual Page 3

Micromite User Manual Page 4

PICMX150 Series Chips

Micromite User Manual Page 5

Micromite User Manual Page 6

CONSOLE Rx (DATA IN) 34 11 PWM 2B | DIGITAL | ANALOG

The notation is the same as described for the 28-pin version.

Micromite User Manual Page 7

Micromite User Manual Page 8

USB Pin 11 (28-pin MM) or pin 33 (44-pin MM)

Micromite User Manual Page 9

Micromite User Manual Page 10

Micromite User Manual Page 11

Setting the AUTORUN Option

Micromite User Manual Page 12

Commands and Program Input

Line Numbers, Program Structure and Editing

Micromite User Manual Page 13

CPU Speed Control

Micromite User Manual Page 14

Micromite User Manual Page 15

The Serial Console

Single, Secure HEX File

Micromite User Manual Page 16

Micromite User Manual Page 17

Connecting SPI Based LCD Panels

ILI9341 28-pin 44-pin

Micromite User Manual Page 18

ILI9488 3.5" Display and Other Loadable Drivers

Micromite User Manual Page 19

Calibrating the Touch Screen

Micromite User Manual Page 20

Read Only Variables

Micromite User Manual Page 21

Micromite User Manual Page 22

Finally you can enter and run the program:

BOX 0, 0, MM.HRes-1, MM.VRes/2, 3, RGB(RED), DBlue

Micromite User Manual Page 23

The Micromite LCD Backpack is described on this web page: http://geoffg.net/MicromiteBackpack.html

Programming MMBasic into the PIC32

Connecting to the Console

Micromite User Manual Page 24

Loading the BASIC program

Saving Fonts in the Library

Micromite User Manual Page 25

Infrared Remote Control Decoder

SUB IR_Int ' a key press has been detected

Micromite User Manual Page 26

SUB IR_Int ' a key press has been detected

Micromite User Manual Page 27

Measuring Humidity and Temperature

Real Time Clock Interface

Micromite User Manual Page 28

Micromite User Manual Page 29