Introduction

In this research document, there is an inquiry into what Basic is and the
commands used for programming in it.

BASIC is a programming language that was created for educational purposes; it was the language used
the microcomputers of the 80s. They are still very well known today and have a lot of
dialects very different from the original.

The creators of BASIC were John George Kemeny and Thomas Eugene Kurtz in 1964.
invented to allow students to write programs using time-sharing computer terminals
shared. With BASIC, the aim was to create a programming language much simpler than those that
they existed at that time.

BASIC

In computer programming, BASIC, which stands for Beginner's All-purpose Symbolic Instruction Code
(Symbolic code of general-purpose instructions for beginners in Spanish) is a family of languages
of high-level programming. The original BASIC, Dartmouth BASIC, was designed in 1964 by John George.
Kemeny and Thomas Eugene Kurtz at Dartmouth College in New Hampshire, United States, as a means
to make programming easier on computers for students (and teachers) who were not from science backgrounds. Back then,
almost all computer use required coding custom software, which meant it was restricted to
people with training as scientists and mathematicians. BASIC was originally developed as a
teaching tool. Language and its variants became widely available in the
microcomputers at the end of the years 1970 and in the years
1980. BASIC remains popular to this day from today in a handful
of highly modified dialects, and in new languages
influenced by BASIC such as Microsoft Visual Basic
or Gambas in GNU/Linux. In the year 2006, 59% of the
developers for the .NET platform they used Visual Basic
.NET as your only language

Basic Compilers
Free:

Small Basic is a compiler for Windowscreated by Microsoft, free, designed for beginners.
You can read more about [Link] the blog.
ASIC, version 4.00Basic compiler, similar to QuickBasic, compressed with ZIP, 260 K.
UBasic, version 8.30, Basic interpreter, similar to GwBasic, compressed with ZIP, 338 K.
Information aboutVisual Basic, the visual tool for Windows created by Microsoft, based on the
Basic language. Is it possible to download the version "Control Creation Edition, which does not allow creating files
EXE but yes ActiveX controls, after filling out a form on Microsoft's website.
RapidQIt is a free Visual Basic compiler that is available for Windows and Linux. It also
allows you to create applications "in text mode", and even write old programs with line numbers....
Information aboutXBasic, another Visual Basic compiler, also free (but harder to handle) and
also available for Windows and for Linux.
DarkBasicIt is a Basic compiler for Windows, designed to easily create games.
EnvelopeIt is a Basic Visual compiler that imitates Microsoft's Visual Basic.
YabasicIt's a Basic interpreter in console (text) mode that is available for Windows and various
Unix systems, which include the source code of the interpreter.
Bywater BasicIt is similar, for Linux and Dos.
Free Basicit is a cross-platform open-source compiler that aims to be as
compatible possible with QBasic and QuickBasic.
QuickForwardit is an open-source compiler that incorporates a development environment and aims to
be highly compatible with QuickBasic 4.5.
NewBasicit is a project to create an open-source Basic compiler,
multiplatform, object-oriented and compiled to Byte-Code (like Java).
B++(o B-improved) is also a Basic project for Windows oriented to objects.
SpeedBasicit is a curious project with an integrated environment that allows creating visual programs, and that
convert the Basic sources to C++ so that they can then be compiled with Visual C++ 6, MinGW or
Borland C++ 5.5
ExtremeBasicit is a compiler for Windows and Mac that includes a development environment and allows
create GUI applications (graphical user interfaces). The Windows version needs the compiler of
C++ MinGW.
wxBasicit is a cross-platform Basic compiler (Windows and Linux) that relies on the libraries
wxWindows.
SmallBasicIt is a simple compiler with versions for Windows, DOS, Linux, and PalmOS.
The 'Express' version of Visual Basic 2005 seems to be available for free download from the website of
Microsoft, [Link]/vstudio/express/vb/

Not free:

QBasic was a text-mode Basic interpreter that was included in the latest versions of MS-DOS.
QuickBasic was a text mode Basic compiler for MS-DOS developed by Microsoft. As far as I know
yes, its development is no longer continued and it cannot be downloaded (legally at least) from anywhere.
 Visual Basic is a Basic compiler for Windows, created by Microsoft, visual, designed for creating with
ease of applications with graphical interfaces. It is not free. You can find more information on the page of
Microsoft:[Link]/vbasic.
TurboBasic is a text mode Basic compiler for MsDos created by Borland. As far as I
Yes, its development is not continued, nor can it be downloaded (legally at least) from any site.
TrueBasicIt is an environment created by John G. Kemeny and Thomas E. Kurtz, the original creators of
Basic language in 1964. There are versions for Windows and Mac, but the free download version forces you to stop
work with her every 15 minutes to re-enter.
RealBasicit is a cross-platform compiler for Windows, Macintosh, and Linux, with a good appearance, but
It is not free. A demo version can be downloaded.
iBasicIt is another non-free compiler for Windows, with support for DirectX.
Another non-free but interesting one isPowerBasic.
You can also take a look atPureBasic, which has versions for Windows, Linux, and AmigaOS.

BASIC Language Commands

COMMENTS
Using comments in a program; Although it may be perfectly obvious to all of you, it can be a
extra tool that tomorrow, can help you understand why you implemented that section in
your routine; Furthermore, it must be taken into account that if we share it, someone else can read it and may not have
idea of what you are doing.
It should be clarified that comments use space in the source file (.bas), but they do not do so in the PICAXE.
that these are not uploaded along with the programming routine.
Implement a comment block at the beginning of the program and before each section of the code, it can
describe what the function of the routine we have is, or we can describe in more detail each line of
our program. To recognize the comments, we can go to our settings section of
software, and in the 'editor' tab, we select color preferences in the syntax

With this last action, we will be able to differentiate in our routines the commands, the comments with a color.
different...
Comments begin with an apostrophe (‘) or semicolon (;) and continue until the end of the line.
It is also very common for English-speaking people with old habits from the old BASIC to implement
the keyword "REM"... this word can also be used for comments, but I personally do not.
I advise you, since an error in writing, for example REN, would give us errors in compilation and or
simulation
Well, let's take a look at what I explain directly in our programming software... we configure the
soft as we mentioned earlier and we copied and pasted the following example:

set pin0 to high level

high0; set pin0 to high level
set pin0 to high level

SYMBOL
The symbols in our routines are keywords that identify constants, variables, and addresses in the
program.
The assignment of the symbol is done by putting the command symbol + name of the symbol and followed by this.
We implement the equal sign (=). After these lines, we add the variable or constant.
Symbols can be any word that is not related to a command.
The symbols can contain numeric characters (e.g.: ucontrol1, salida2, etc.) but the first character cannot.
it can be a numeric one (e.g.: 1output).
The use of symbols does not increase the length of the program. In other words, this function has no weight at all in what
refer to the program. Generally, in my case, I implement this command to rename the entries and
microcontroller outputs, that is, it helps me remember what the function of each output is when reading and or
modify my program
The program addresses configured with the command symbol always have to go above the first
instruction or rather, at the beginning of the program.
Once again, we are going to our software and we will run the following example routine:

symbol Led_Rojo = 7 define Led-Rojo as a constant (output7)

symbol Counter = B0 define Counter as a variable (B0)
let Contador = 200 preload the variable Counter with the value 200
start: define a program address
high Red_Led set output 7 to high level '1'
pause Counter wait of 0.2 seconds
low Red_Led set output 7 to low level '0'
pause Counter wait for 0.2 seconds
go to start jump to the address indicated at the beginning

CONSTANTS
Constant calls can be created similarly to variables. It may be more
it is convenient to use a name for the constant instead of implementing a constant number. If the number
it needs to be changed, it can only be changed in some part of the program where the
constant. Within constants, variable data cannot be stored.
The declared constants can be of four types: decimal, hexadecimal, binary, and ASCII.

Decimal numbers are written directly without any prefix.

Hexadecimal numbers are preceded by the dollar sign ($).

Binary numbers precede the percent sign (%).

ASCII values are placed in three quotes ("...").

VARIABLES
Let's look at the types of variable according to the system, as they vary in their application depending on each model.
programming

PICAXE is used when programming PICAXE modules.

BASIC and Extended are used when programming Stamp modules.

The assembler is used with assembly code.

PICAXE
The PICAXE system supports the following variables:
Words:W0, W1, W2, W3, W4, W5, W6
Bytes: DIRS, PINS (solo PICAXE-08), INFRA, KEYVALUE
B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13
Bits: PIN0, PIN1, PIN2, PIN3, PIN4, PIN5, PIN6, PIN7 (together equal PINS)
BIT0, BIT1, BIT2, BIT3, BIT4, BIT4, BIT5, BIT6, BIT7 (collectively equal to B0)
BIT8, BIT9, BIT10, BIT11, BIT12, BIT13, BIT14, BIT15 (jointly equal to B1)
In/Out adds the pseudonyms:
INPUT0, INPUT1, etc. can be used instead of PIN0, PIN1, etc.
OUTPUT0, OUTPUT1, etc. can be used instead of 0, 1, 2, etc.

BASIC
The BASIC mode supports the following variables:
PORT
W0, W1, W2, W3, W4, W5, W6
Bytes:DIRS, PINS
B0, B1, B2, B3, B4, B5, B6, B7, B8, B9, B10, B11, B12, B13
Bits: DIR0, DIR1, DIR2, DIR3, DIR4, DIR5, DIR6, DIR7 (collectively equals DIRS)
BIT0, BIT1, BIT2, BIT3, BIT4, BIT4, BIT5, BIT6, BIT7 (together equal B0)
BIT8, BIT9, BIT10, BIT11, BIT12, BIT13, BIT14, BIT15 (jointly equal to B1)
Note: B12 and B13 (W6) is used within the GOSUB commands as a stack. Therefore
it should not be used as a general purpose record.

EXTENDED
The extended mode supports all BASIC variables.
Additionally: INPUT0, INPUT1, etc. can be used instead of pin0, pin1, etc.
OUTPUT0, OUTPUT1, etc. can be used instead of 0, 1, 2, etc.
Note: B12 and B13 (W6) are used within the GOSUB orders as a stack. Therefore it should not be
to be used as a general purpose record.

ASSEMBLER
The assembly mode supports the same variable models as the extended mode.

GOTO
This command is intended to execute the program that continues with the label declaration.
In other words, this command serves to provide an address where the program will jump and
Continue reading the instructions to proceed with the program.
let's look at a practical example:

start:
high 1 exit 1 at high level
wait for 5 seconds
low 1 exit 1 at low level
wait for 5 seconds
go to start jump to home

GOSUB
This command is designed to jump to the indicated subroutine at the label, saving its address.
returns in the stack memory (snack). Unlike GOTO, when a RETURN is reached, execution continues
with the declaration following the last executed GOSUB.
An unlimited number of subroutines can be used in a program and they can be nested. In other words,
Subroutines can call another subroutine. Each nesting must not exceed four levels.
Example:
start:
let b2 = 15 set b2 to value 15
pause 2000 wait for 2 seconds
gosub flash jump to the flash procedure
let b2 = 5 set b2 to value 5
pause 2000 waiting for 2 seconds
gosub flash jump to the flash procedure
end end of the program

flash
for b0 = 1 to b2 'define the loop with the value b2
high 1 ‘salida 1 a nivel alto
pause 500 wait for 0.5 seconds
low 1 exit 1 at low level
pause 500 waiting for 0.5 seconds
next b0 end of loop
return return to the next line of the call
go to start

In other words, when we execute GOSUB, the program jumps to a label, and when
arrives at the RETURN command, goes back to the next line from where it started with the GOSUB command...
FOR ... NEXT

The FOR ... NEXT loop allows programs to execute a number of statements as many times as defined.
using a variable as a counter. This command is ideal for shortening lines of repetitive programs; maybe
it may not be applicable to many ideas, but in general, with a little skill, it can be adapted to
our needs.... Look at these two simple examples where we want to make an LED blink about 5 times.
times:

symbol led1= output7

example1:
high led1
pause 1000
low led1
pause 1000
high led1
pause 1000
low led1
pause 1000
high led1
pause 1000
low led1
pause 1000
high led1
pause 1000
low led1
pause 1000
high led1
pause 1000
low led1
pause 1000
end

Now, let's see this other way of performing the same action:

loop:
for b0 = 1 to 5
high 1
pause 500
low 1
pause 500
next b0
end

Perhaps, since it is a bit difficult to perfectly understand how this command works, we will describe it.
step by step to better understand how this works and what it is for. Once again, we start our
software programming editor, we copy and paste the following lines of instructions that I give as
example below:

loop
for b0 = 1 to 20 define the loop with repetition from 1 to 20
high 1 exit 1 at high level
pause 500 waiting for 0.5 seconds
low 1 exit 1 at a low level
pause 500 wait for 0.5 seconds
next b0 end of loop
pause 2000 wait for 2 seconds
goto loop jump to loop to start again

As we can see in our example (I want to imagine that you are already simulating it); When the program starts,
when the reading enters the counter (for b0 = 1 to 20), preload the value 1 in a memory space
determined (in this case b0) and starts a count that will end when it reaches 20.
In the case of the routine I exemplified, after passing through the instruction to begin with the counter, it continues
reading the rest of the lines and executing any action they entail (high1-pause-low1-pause)
until reaching the line that says "next b0". In this line, what we do is tell the counter to add
an integer in the memory where we store the count (b0) and then jumps automatically to the line where
start the counter (for b0 = 1 to 20) restarting all the actions described above until
to store in memory the value 20 (because that was the instruction we gave when we told it that
count from 1 to 20 with 'for b0 = 1 to 20'... Now, let's notice something strange.... When it reaches 20, instead of returning
to the counter line, now continue reading the next line. In this case, the next line tells us with the
command PAUSE and GOTO, we must introduce a delay and return to the program or label "loop".
Supposedly, after this, since the accountant had recorded the value 20, he should not continue.
counting... Well, I would like to mention that it is not like that, since when the program restarts, the counter
goes back to zero too.
In the case where we want the program to terminate upon reaching a certain count, what
podríamos hacer, es implementar la siguiente rutina:

loop
for b0 = 1 to 20 define the loop with repetition from 1 to 20
high 1 exit 1 at high level
pause 500 wait of 0.5 seconds
low 1 exit 1 at low level
pause 500 wait for 0.5 seconds
next b0 end of loop
pause 2000 wait for 2 seconds
end jump to loop to start again

HIGH
This command is an action that is implemented to set a pin or rather port to a high level (1 logic)
specific output of the microcontroller.
In other words, we use this command to activate an output...

LOW
This command is the complete opposite of the high command, as it sets the specified output pin to low value (0
logical). In other words, we implemented this command to disable an output...

Let's see how the highlow commands work in the following example:

start:
high 1 set output 1 to high level
pause 5000 'wait for 5 seconds
low 1 set output 1 to low level
pause 5000 'wait for 5 seconds
goto start 'jump to the beginning of repetitive loop

INPUT
This command refers to a specific input port; In a way, it converts the Pin number.
specified in an entry. I mean, it's not that we can configure our port as inputs and outputs; A
What I mean is that we define in one line what action we want that defined input to take.
To define our entry, it can be implement the
input command, or we can adopt the number of
port (0 to 7 for the case of the 18x micros) and define it with a
simple IN before the port number entrada (in7 /
input7)
When defining the input command in our program
automatically, we are mentioning that let's go to
working with incoming digital signals in a port
defined... When I refer to signals digital, me
I refer to the signals that can only be in two states...
High or low (5vcc - ovcc / closed - open)
OUTPUT
This command refers to a specific output port; In a certain
way, convert the specified Pin number into an exit. I mean,
As I mentioned earlier in input, it's not that we can
configure our ports as inputs and outputs; A what I
I mean, we define in one line, what action we want that
adopt that defined output. To define our output, it can be
implement the OUTPUT command, or we can adopt the port number (0 to 7 for the case of the
micros 18x) and define the action or state of this port (high 7 - low 7 / high output 7 - low output 7)

To understand a little better what I am explaining to you, again, we copy the following lines and paste them.
in our software to see in the example, how the inputs and outputs of our micro work (note that
In version 5.2 of the software, the states of the microcontroller pins can be visualized in a chart.

start:
gosub i1 jump to the subprocedure i1
gosub i2 jump to the subprocess i2
go to home return to the home tab

i1:
if input1 = 1 then output7 if input 1 equals one, then go to label exit7
pause 500 half a second delay
return return and continue on the next line (in this case gosub i2)

i2:
if in1 = 0 then output6 if input 1 is equal to zero, then go to label exit6
pause 500 half a second delay
return return and continue on the following line (in this case gosub i2)

exit7:
high 7 put in high output 7
low 6 put on low output 6
pause 500 1/2 second delay
goto i2 go to label i2

output6:
high output6 put in high output 6
low output7 put on low output 7
pause 500 half-second delay
go to home go to the homepage

Note: in this example, cite both ways in which we can define or name an entry port or
exit. If they have already simulated this routine, they will see that the software recognizes both of them as the same and not
does not generate any conflict.

END
This command aims to stop the execution of the process and the microcontroller no longer executes.
until we restart it or until we give it the manual instruction to start again with its
cycle. When the microcontroller is stopped by the END command, it enters low power mode. Another
One of the characteristics of this command is that when this instruction is executed, all the input pins and
output, when the line reading reaches this command, they freeze and remain in the state they were in
they find (I/O).
To better see how this command works, let's go to our programming software editor, copy and
we stick in the following lines that I add as an example:

beginning:
let b2 = 5 set b2 to value 5
pause 2000 wait for 2 seconds
gosub flash jump to the flash subprocedure
let b2 = 3 set b2 to value 3
pause 2000 wait for 2 seconds
gosub flash jump to the flash subprocedure
end

flash
for b0 = 1 to b2 define the loop with the value b2
high 1 exit 1 at high level
pause 500 wait for 0.5 seconds
low 1 exit 1 at low level
pause 500 wait for 0.5 seconds
next b0 end of loop
return return to the next line of the call

if…then
if...and...then
if...or...then

These commands are, in themselves, part of a comparison structure with a jump to a specific address.
(always to a label), in the event that the assigned function is fulfilled.
The functions that can be assigned to these comparisons are:

=(equal to)
>= (greater than or equal to)
(greater than)
<(less than)
(less than or equal to)
is not equal to
&(logical AND function)
or (logical OR function)
among others, which we will see later given its complexity....

The basic principle of these three commands is to establish a question (IF...) about the state of a
determined port, compare, read the status, evaluate in terms of TRUE or FALSE and in the event of being
True, the operation after THEN (then...) is executed. If considered false, the operation is not executed.
after the THEN and continues with the reading of the next line.
Let's look at what I mentioned to them in the following way:

if…then
if input 1 = 1 then action 3
translating these terms, we are saying that if input 1 is equal to 1, then go to the label
action3

if…and…then
if input 1 = 1 and input 0 = 1 then action 3
1 is equal to 1 and input 0 is equal to 1, then go to label 'action3')

if...or...then
if input 1 = 1 or input 0 = 1 then action 3
(translating these terms, we are saying that if input 1 equals 1 or input 0 equals 1,
That is, if either of the two inputs is in a high state, then go to the label 'action3')

Let's make it more practical, and let's execute this example:

start:
if pin0 = 1 then flash jump to flash if the value of pin0 is a 1
go to start who jumps to start

flash:
high 1 "set the exit 1 to high value"
pause 5000 wait for 5 seconds
low 1 sets a low value under output 1
go to start jump to start

PAUSE
This command is implemented to generate delays in the jumps between lines and execution of the code.
program. The specification of the delay time is given in 'milliseconds', and this specification of the
time, is 16 bits, so the delays can be up to 65635 milliseconds (66 seconds).
Let's see a practical example:

start:
high 1 set pin 1 to high level
pause 5000 wait for 5 seconds
low 1 set pin 1 to low level
pause 5000 waiting for 5 seconds
go to start jump to the beginning of the loop

WAIT
This command, like the previous one, is implemented to generate delays in the jumps between lines and
execution of the program code. The specification of the delay time is given in 'seconds' and can
having a maximum of 65 seconds, which, if we implement a FOR...NEXT, we can clearly extend it to
more time....
Let's see it more practically in this example:

start:
high 7 set pin 7 as high output
wait 5 wait 5 seconds
low 7 set pin 7 as low output
wait 5 wait 5 seconds
go to start repeat program indefinitely

RETURN
This is a very good command that if we know how to implement, we can make watchdogs faster and
interesting. In itself, this command serves to return from a subroutine, resuming execution in the
statement that follows the GOSUB that called the subroutine.
let's see a simple example in our software:

start:
let b2 = 15 assign the value 15 to the variable b2
pause 2000 wait for 2 seconds
gosub flash call to subroutine flash
let b2 = 5 assign the value 5 to the variable b2
pause 2000 wait for 2 seconds
gosub flash call to subroutine flash
end

flash
for b0 = 1 to b2 'define the loop for the time of b2
high 1 set output 1 to high level
pause 500 wait 0.5 seconds
low 1 set output 1 to low level
pause 500 wait 0.5 seconds
next b0 end of the loop
return return to the next line of call

INFRAIN
This command is implemented to wait for an infrared signal coming from the transmitter at the receiver.
IR.
This command, in addition to being able to implement them in our own projects, we can create our
own IR remote controls or IR repeaters for the entire range of SONY equipment, since
implement the same protocol that this company implements in its products.
The command itself interacts in the program waiting for the infrared signal, and once this signal is received, the
its value is stored in the predefined variable "infra" (it is similar to b0, b1, etc., but for exclusive use for
this command).
Let's see this example.... If you don't have a Sony controller, it doesn't matter, we can simulate it anyway and change the
values from the variable table on the right...

Start:
Wait for a new infrared signal
if infra = 1 then action_on1 'if the value of infra is 1 jump to action_on1
if infra = 2 then accion_on2 'if the value of infra is 1 jump to accion_on2
if infra = 3 then accion_on3 'if the value of infra is 1 jump to accion_on3
if infra = 4 then accion_off1 'if the value of infra is 1 jump to accion_off1
if infra = 5 then accion_off2 'if the value of infra is 1 jump to accion_off2
if infra = 6 then accion_off3 'if the value of infra is 1 jump to accion_off3
go to start

accion_on1:
high 1
go to start
accion_on2:
high 2
go to start
accion_on3:
high 3
go to start
accion_off1:
low1
go to start
accion_off2:
low2
go to start
accion_off3:
low3
go to start

READADC
An analog sensor is capable of measuring and providing information encoded in variable voltages. This signal
input in the analog port of the microcontroller can be represented by values from 0 to 255 (by
For example, in the case of a photoresistor, we could say that 0 is dark, and 255 is intense light...

This command can be implemented to convert an incoming analog signal on the ADC port of the
microcontroller, in digital with an 8-bit resolution. The data obtained from this converted reading (A/D) is
stored in a variable (b0, b1, b2, bX, etc.) which can later be used for any
purpose
NOTE: when implementing this command, it is very important to keep in mind that if we store the
given in a variable of type "b1", it is stored with a resolution of 8 bits... If we store it in a
variable type "w1", the data is stored with a resolution of 10 bits...
Let's look at this simple example first:

start:
readadc 1,b1 read the value and store it in b1
if b1 > 50 then flash jump to flash if b1 > 50
go to start who jumps to start

flash:
high 1 sets pin 1 to high level
pause 5000 wait for 5 seconds
low 1 sets output 1 to low
go to home jump to start
Let’s mention some instructions
If . . Then
Conditional jump to another instruction.
For . . Next
Repeat a series of instructions several times.
Gosub
Call to a subroutine
High
Turn on a pin
Low
Turn off a pin
Serin
Asynchronous serial input on a pin. (RS232)
Serout
Asynchronous series output on a pin. (RS232) Adcin
Read the analog to digital converter
Write
Write to the PIC EEPROM memory
Hpwm
Output to generate pulse width modulation
CONCLUSION

I learned and understood what the Basic language is.

I learned about the various types of commands that exist for programming
in the BASIC language.
I understood that there are several programs that derive from it.

BASIC language but they have a different purpose than BASIC

In other words, they are programmed to program.
to compile a different object like the PICs.
 BIBLIOGRAPHY

[Link]

[Link]

[Link]