Hardware components | ||||||
_ztBMuBhMHo.jpg?auto=compress%2Cformat&w=48&h=48&fit=fill&bg=ffffff) |
| × | 1 | |||
In a previous tutorial I have featured the Iot BASIC interpreter as an alternative programming language for Arduinos. It is a simple but full featured interpreter language that can be used on all platforms from the smallest 8bit AVR systems up to large 32bit micro controllers.
The main advantage of BASIC is the simplicity. It is an interactive language and debugging of circuits can be done without recompiling and uploading code. The Arduino IDE is only needed for install the BASIC interpreter once. After that a serial terminal is enough to program small applications.
This tutorial is about the language features of IoT BASIC. Many of the Arduino built-in examples are ported to BASIC and explained.
In all examples an Arduino UNO is used. Any other Arduino or supported microcontroller can be used just as well. All the examples here can be used on nearly any board. I will write about different behaviours where it may matter.
The BASIC interpreter presented is a complete and full featured implementation of the language. It supports strings, optionally floating point, arrays, and complex I/O. No part of the Arduino Tinybasic code has been used.
Installing BASIC on an ArduinoTo install the BASIC interpreter, download the sketch IotBasic from my repo https://github.com/slviajero/tinybasic .
Please download the new version in Basic2/IoTBasic. Compile and upload the code to your Arduino. As the UNO is a small board, the language installed is an Integer BASIC, but it has strings, arrays and the capability to save data to the EEPROM. It can process events and has timers.
Next open the serial monitor. Reset the Arduino. You should get the start message and the command prompt. Please make sure that the baud rate is set to 9600 and that the line setting is "New Line". BASIC used NL, i.e. ASCII 10 as new line character.
Basic tells us, that it has 1827 bytes of memory. This is 1024 bytes of EEPROM for program storage and approximately 800 bytes for variable. The programs in the EEPROM stay when you switch off the Arduino. There is also the possibility to store variables in the EEPROM.
For all applications here, the Arduino Serial Monitor is enough. If you want a better serial terminal program, please look into my tutorial BASIC for Arduinos for suggestions.
BASIC basicsOn the command line you can type in interactive commands like
PRINT "Hello World"They are executed immediately. Almost all commands of IoT BASIC can be used interactively. Typing in
PINM LED, 1
DWRITE LED, 1switches on the built-in LED directly. This interactive feature of the language can be a great help if you debug circuits or play with robotics.
If you want to write a program, put line numbers in front of the command. It will then be stored. Lines are executed in their numerical order. If you type in
10 PRINT "Hello World"
20 PRINT "Bye"Built-In Examples the program will be executed. LIST displays the stored line. You can remove one line by just typing its line number. NEW clears the storage. CLR deletes all variables but keeps the program. SAVE stores the program in EEPROM and LOAD loads it to memory.
All examples here are short and can be typed in directly. If you want to upload them instead, use the terminal program in my previous tutorial on BASIC. It has a text upload feature.
Built-In ExamplesArduino's built-in examples showcase the use of C++ to program the Arduino. This tutorial follow the naming conventions and uses some schematics drawings from the page and it is structures in the same way as the C++ original.
Please also consult the manual of IoT BASIC in case you have questions.
Schematics are exactly identical to the ones in Arduino's built-in examples. I link to this page in every example for the concrete schematics drawing.
BASICSAnalog Read Serial - Read a potentiometer, print its state out to the Arduino Serial Monitor(Original in C++).
For this you will need a 10 kOhm potentiometer.
Wire the potentiometer like it is shown in the picture
the middle contact goes to the analog pin A0 and the left and right contact go to 5V and ground (schematics drawing).
Enter the program in the serial monitor
100 V=AREAD(AZERO)
110 PRINT V
120 DELAY 500
130 GOTO 100Then type RUN on the command line. The program will show an analog value between 0 and 1023 depending on the potentiometer position. Press '#' if you want to interrupt the program. The command prompt will return.
AREAD() is the Arduino function analogRead(), AZERO is a constant containing the pin number of the analog in A0. PRINT prints a number to the serial port. The last statement goes to the first line and closes the loop.
There is no setup part of the program. This is not needed here. BASIC always opens a serial connection with 9600 baud. PRINT outputs to this connection.
To save the program for later, type SAVE. You could power down the Arduino now. If you connect it later LOAD will load the saved program from the EEPROM.
Read Analog Voltage - Reads an analog input and prints the voltage to the Serial Monitor(OriginalinC++).
The schematics are just like in the example above. Instead of the numerical value between 0 and 1023 we want the actual voltage displayed. Modify the program to by adding one line.
Adding a line between two other lines is done by simply typing the line number and the statement.
105 V=MAP(V, 0, 1023, 0, 5000)Then type RUN again. The program will output the voltage in millivolts.
MAP is the BASIC equivalent of the Arduino map() function. It converts an integer value from one range to another.
To show the entire program type LIST. The output will be
100 V=AREAD(AZERO )
105 V=MAP(V,0,1023,0,5000)
110 PRINT V
120 DELAY 500
130 GOTO 100Blink - Turn an LED on and off every second(OriginalinC++).
For this you need a LED and and a 220 Ohm resistor.
Wire the LED and resistor like it is shown in the picture:
The LED is connected to ground and via the resistor to pin 13 (schematics drawing). 13 is the default LED pin of an Arduino UNO.
If you had a previous program in memory, you can delete it entirely by typing NEW first. Now, enter the following program in the serial monitor.
10 PINM LED, 1
100 DWRITE LED, 1
110 DELAY 1000
120 DWRITE LED, 0
130 DELAY 1000
140 GOTO 100then type RUN. The led blinks every second.
PINM is the BASIC equivalent of pinMode(), the command sets the build in led pin to output. LED is a constant for the builtin led pin. Numerical values are used in PINM. Input is 0, output is 1 and input_pullup is 2. DWRITE is the equivalent of digitalWrite().
Fading a LED - Demonstrates the use of analog output to fade an LED(Original in C++).
For this example, please connect the LED to pin 9 instead of pin 13. We need a PWM capable pin for for analog output.
Delete an existing program with NEW, then type in the following program
10 L=9
20 B=0
30 F=5
40 PINM L,1
100 AWRITE L,B
110 B=B+F
120 IF B<=0 OR B=>255 THEN F=-F
130 DELAY 30
140 GOTO 100L, B and F are variables. The pin, the initial brightness and the fade amount are assigned to them. Variables in BASIC can be two characters, the first of which needs to be a letter. AWRITE is the BASIC equivalent of analogWrite().
Type RUN and watch the LED fade.
DigitalHow to Wire and Program a Button - Learn how to wire and program a pushbutton to control an LED (Original in C++).
This is one of the most elementary examples in the Arduino built-in section. Read a push button and change the state of the internal LED.
Connect one side of the button to ground with a 10 kOhm resistor and connect digital pin 2 to it. Connect the second side of the button to 5V (original schematic).
Enter NEW to delete an existing program, then type in
10 PINM 2,0
20 PINM LED ,1
100 B=DREAD(2)
110 IF B=1 THEN DWRITE LED, 1 ELSE DWRITE LED, 0
120 GOTO 100Pin 2 is set to input, the LED pin to output mode. In the loop at line 100 the button state is read and the LED state is updated accordingly.
Play a Melody using the PLAY command - Play a melody with a speaker (Original in C++).
The Arduino tone() function can be used to play a melody. The BASIC equivalent to it is the PLAY command.
Wire a speaker to digital output 8 on the Arduino.
Unlike the original Arduino example, I use a standard 8 Ohm speaker for this together with a 300 Ohm resistor to limit the current. If you have a piezo speaker you can connect it directly (original schematic).
Type in the program
10 READ N
20 DIM T(N),D(N)
30 FOR I=1 TO N: READ T(I): NEXT
40 FOR I=1 TO N: READ D(I): NEXT
100 FOR I=1 TO N
110 D=1000/D(I)
120 PLAY 8,T(I),D
130 DELAY D*13/10
140 NEXT
200 DATA 8
210 DATA 247,185,185,208,185,0,233,247
220 DATA 4,8,8,4,4,4,4,4The setup section of the program in line 10 to 40 dimensions two arrays for the frequency and the durations of the notes and then loads the data into these arrays. The actual values are in the DATA statements at the end of the programs. In the main loop from line 100 onwards, the notes are played and a delay statement takes care that they can be heard as separate notes. Any melody can be played with this program. Just enter the number of notes as the first data statement at line 200 and then supply frequencies and durations.
RUN plays a well known melody.
AnalogAnalog In, Out Serial - Read an analog input pin, map the result, and then use that data to dim or brighten an LED (Original in C++).
This demo shows the handling of analog input and output.
Connect a 10kOhm potentiometer like in the first example and add a LED with a 200 Ohm resistor connected to pin 9. As we want to do analog output, a PWM capable pin is needed for this (original schematic).
Type in the following program
100 V=AREAD(AZERO)
110 O=MAP(V,0,1023,0,255)
120 AWRITE 9,O
130 PRINT "sensor=",V,"output=",O
140 DELAY 100
150 GOTO 100and start it with RUN. The LED dims according to the position of the potentiometer and both value are output to the serial connection.
Analog input values are in the range of 0 to 1023 while the output values are from 0 to 255. Mapping of the values is done with the MAP function just like in C++.
Analog Input - Use a potentiometer or photoresistor to control the blinking of an LED (Original in C++).
With the same schematics as used in the previous example we can also control the blink speed of a LED.
10 PINM 9,1
100 D=AREAD(AZERO)
110 DWRITE 9,1
120 DELAY D
130 DWRITE 9,0
140 DELAY D
150 GOTO 100After setting pin 9 to output the loop reads an analog value from 0 to 1023 and uses this value as delay to control the blink speed. Turn the potentiometer to change the blink speed.
The circuit becomes even more interesting if the potentiometer is replaced with a 10 kOhm photoresistor and a 10 kOhm resistor.
Run the same program. The blink speed is now controlled by the brightness of the light on the photoresistor (original schematic).
CommunicationASCII Table - Demonstrates Arduino serial output function (Original in C++).
This is a small demo showing how to output characters. It prints the ASCII table.
Type in the program
10 PRINT "ASCII Table ~ Character Map"
100 FOR I=33 TO 126
120 PRINT I;" ";
130 PUT I
140 PRINT
150 NEXTand type RUN. The decimal value and the ASCII character are displayed.
The program loops through the numbers 33 to 126 and first prints the number and a space. The semicolon at the end of line 120 makes sure that no line feed is done. PUT sends the number I to the serial line as an ASCII character, again without a newline. The last PRINT statement makes sure that we have a newline.
Read ASCII String - Parse a comma-separated string of integers to fade an LED (Original in C++).
This demo shows how to parse numbers and control devices with it. It uses a three color LED (original schematic). The longest pin of the LED is connected to ground. The three colour pins go to 3 for red, 5 for green, and 6 for blue.
Type in the program and run it
10 R=3: G=5: B=6
20 PINM R,1: PINM G,1: PINM B,1
100 PRINT "enter three values"
110 INPUT VR,VG,VB
200 AWRITE R,VR: AWRITE G,VG: AWRITE B,VB
300 GOTO 100First the pins are prepared. In the loop from line 100 on, three values are asked from the user. Unlike the C++ input methods, the BASIC input command accepts comma separated lists, a parse function like in the C++ example is not needed for this demo. After the input of the three numbers, the values are set and the LED is tuned to the colour.
While this program does the job, it is not quite what we want. Entering three numerical values in a line and then scanning it requires a bit more work and requires the use of strings. Type in the lines from 110 to 160 like this:
10 R=3: G=5: B=6
20 PINM R,1: PINM G,1: PINM B,1
100 PRINT "enter three values"
110 INPUT A$
120 VR=VAL(A$)
130 A$=A$(@V+1)
140 VG=VAL(A$)
150 A$=A$(@V+1)
160 VB=VAL(A$)
200 AWRITE R,VR: AWRITE G,VG: AWRITE B,VB
300 GOTO 100The program reads a string A$ from serial. It then parses a numerical value with the VAL() function. The next line uses special a feature or this BASIC implementation. The variable @V contains length information of a conversion. After VAL it has the number of bytes which were processed and converted to a number. The command A$=A$(@V+1) truncates the string by dropping these characters. The next value is parsed with VAL() and the string is truncated one more time. VAL() then reads the last value. BASIC strings are explained in the manual in detail. This is only a first glance on them.
BASIC strings are explained in the manual in detail. This is only a first glance on them.
RUN the program, type in the numerical values separated by spaces and enjoy playing with LED colours.
Control StructuresSwitch (case) Statement, used with sensor input - How to choose between a discrete number of values (Original in C++).
In C++ the switch statement distinguishes between discreet values. BASIC has a similar language feature. This example reads the value of a photoresistor and displays a message on the serial output.
Connect a photoresistor to 5V and to the A0 pin of the Arduino. Use a 10kOhm resistor to pull down A0 to low. If your photoresistor is the very common 10 kOhm type, this will create analog values between 0 and 511 (original schematic).
Type in the program
10 S0=0: S1=550
100 V=AREAD(AZERO)
110 D=MAP(V,S0,S1,1,4)
120 ON D GOSUB 200,210,220,230
130 DELAY 1000
140 GOTO 100
200 PRINT "dark": RETURN
210 PRINT "dim": RETURN
220 PRINT "medium": RETURN
230 PRINT "bright": RETURNthen RUN it. The serial monitor will show your brightness value.
S0 and S1 have the minimum and maximum brightness value. One can adjust the output by changing these values. In the loop from line 100 on, an analog value is read. It is then mapped to values 1 to 4. These values can be used in the ON GOSUB statement which jumps to the respective line and prints the result-
If Statement (Conditional Statement) - Use an if statement to change the output conditions based on changing the input conditions (Original in C++).
If you have only two values to decide from, a simple IF statement is enough. BASIC supports a IF THEN ELSE clause. With the schematics from above, you can use the following program
10 T=100
20 PINM LED,1
100 IF AREAD(AZERO)<T THEN DWRITE LED,1 ELSE DWRITE LED,0
110 DELAY 100
120 GOTO 100The built-in LED pin which is 13 on an Arduino UNO is set to output. In the loop from line 100 the analog read value of the sensor is checked and the LED is switched on once the light drops below the threshold T.
SensorsDetect a Knock - shows you how to use a Piezo element to detect vibration (Original in C++).
A piezo sensor is part of almost every Arduino enthusiast. One can create a simple knock sensor with it.
Connect the black wire of piezo sensor to ground of the Arduino and the red wire to the analog input A0. You also need a 1 MOhm resistor. Piezo sensors can create very short and high pulses when they are touched or knocked. Not much energy is created but is the resistance of the device connected to them is high, this charge created by the piezo element can cause high voltages. Any resistor in the 200kOhm to 1MOhm range will work here to let the charge flow away.
Delete existing programs with NEW and then type in the following program
10 T=100
20 PINM LED, 1
30 S=0
100 V=AREAD(AZERO)
110 IF V<T THEN 100
120 IF S=0 THEN S=1 ELSE S=0
130 DWRITE LED ,S
140 PRINT "Knock!"
150 DELAY 100
160 GOTO 100Start it with RUN. Any knock will be reported on the serial output and the internal LED of the Arduino will change state. Play with the threshold value T to tune the sensitivity.
The program sets the LED pin to output. In the loop it reads analog input A0. If there is no value above the threshold value, the read is repeated. Otherwise the state of the LED stored in variable S is changes, the LED updated, and the value is reported.
Ping Ultrasonic Range Finder - Detect objects with an ultrasonic range finder (Original in C++).
Unlike the original program in Arduino built-in examples, I use an ultrasonic sensor with a separate trigger and echo pin for this example. The HC-SR04 is very common, you find it in almost any Arduino beginner box.
Wire the trigger pin of the sensor to pin 7 of the Arduino and the echo pin to pin 8.
Type in the program, SAVE and RUN it afterwards.
10 E=8
20 T=7
30 PINM E,0
40 PINM T,1
100 DWRITE T,0: DWRITE T,1: DWRITE T,0
110 D=PULSE(E,1,100)
120 IF D=0 THEN 100
130 C=MAP(D,0,10000,0,17241)
140 PRINT "Distance in mm",C
150 DELAY 1000
160 GOTO 100The program outputs the distance of the objects in front of the sensor in mm.
The trigger pin 7 is set to output, while the echo pin 8 is set to input initially. In line 100 a short pulse is send by putting the trigger pin on high. After this the PULSEIN command is used to measure the pulse length. The first argument is the pin, the second indicates that a state change to high is expected and the third argument is the timeout of 100ms. Unlike its C++ equivalent pulseIn() the BASIC function PULSE returns the pulse length in 10 microsecond units. This makes it more compatible with integer arithmetic. The MAP function is used to calculate the distance in milli meters.
More To ComeThis is only a small number of the original Arduino built-in examples to demonstrate the most important commands. More is to come here.
Strings, displays, and the use of sensors and peripherals will be shown in my next tutorials here on BASIC on Arduino.
Comments