Month: July 2024

In our last post we looked at Eclipse as a development environment on the Raspberry Pi. In this post we will look at Microsoft Visual Studio as an alternative. We picked these two to focus on because they are what most professional developers use in other environments. If you are planning on learning tools that will help with a career or job, there are the two that are recommended.

The key benefits for Visual Studio are that it works on multiple platforms (Windows, MacOS, and Linux), supports multiple languages ( C++, C#, Go, Java, Python ), supports multiple tools (ESLint, JSHint , PowerShell ), supports complex searching and multi-screen editing, and more.

Visual Studio is easily installed with an sudo apt-get install code command.

Instructions can be found at https://code.visualstudio.com/docs/setup/raspberry-pi on how to install and configure the environment.

Once the code is installed it appears on the pull-down menu from the top of the screen.

When the environment is first installed, a welcome window appears that walks you through the configuration. The first option is to select the languages that will be supported in the development environment.

We select Python first.

After a couple of minutes we can install C/C++ support.

Finally, we can select Java as our third language to support.

We will start with a Java Project. To create a new project, go to Files -> New File

Select New Java Project.

with no build tools

We select a folder to work in, HelloWorld

In this folder we create a new file

Adding the .java extension to the file name automatically classifies it as a Java file.

As we start typing Visual Studio start suggesting ways of completing the statement. In this example, the code suggested is for the main() routine to start the program.

As we type Visual Studio shows options for calls to the call you are using. In this example we started typing System. The IDE showed us multiple options including the out method call. Once we select out we have the option of various ways of outputting data. We select the printf() routine to print a string to the console.

If your code had errors or warnings they would appear on the left side of the line in question and hovering over the red or yellow icon will give more detail on what the problem could potentially be.

At this point we have the option of setting breakpoints, debugging the code, or simply running the code and looking at the console output.

Selecting the Run option we can see the output to the console

In the console window we see the compilation steps required and command line needed to run the code along with the output from the program to the console.

To build a Python file, click on File -> New File

We want to select a Text File type.

The IDE then asks what language we want the file to be.

If we save the file with a “.py” extension it automatically defaults to Python. Alternatively, we can click on Select a language to go to a pull-down menu and define the language type.

In this example, we can add the print() statement and run the program as a Python program.

If we wanted to do something similar with C/C++ we start with File -> New File

We then click to get a pull-down for language selection

From the Select a language link we get a list of potential programming languages.

We select C or C++ and get an option on what compiler to use

We select the default install gcc which will generate our C file.

From here we can Select Run which will compile and run the code. We can look at the compile output by clicking on the C/C++ header on the bottom right corner or look at the console output by clicking on the cppdbg header in the same area.

In summary, we have a professional development environment that supports Python, Java, and C/C++ in our Raspberry Pi environment. The installation was easy. The addition of additional languages was simple. The editing and debugging of the code is much better than the default IDE tools installed by default on the Linux operating system. At this point we can truly start developing applications using either the Eclipse IDE or Visual Studio IDE using tools and processes that professional developers use.

Before we dive into what is an IDE, it is important to note that there are a variety of development environments available for the Raspberry Pi. We will not be covering more than a couple of them because so much goes into picking a development environment. Many of the tools that are available are specific to a programming language are good for that language but are not very good with other languages.

An IDE, or Integrated Development Environment, is a software application that combines various tools for software development into a single program. IDEs help programmers be more productive by making it easier to edit, build, test, and package software code.

It is important to note that building a program can be done with a simple editor, a compiler, and simple test procedures. In theory, and IDE will help with all phases of this development. Given the large number of tools available on the Raspberry Pi, we will focus on two which are generic and “mainstream” for professional programmers (Eclipse and Microsoft Studio) and work with Python, C/C++, and Java. In this posting we will focus on Eclipse getting it to work with all three languages.

Eclipse (https://www.eclipse.org/) is an integrated development environment (IDE) used in computer programming. It contains a base workspace and an extensible plug-in system for customizing the environment. The Eclipse Foundation helps develop and distribute the code as free and publicly available.

Unfortunately, you can’t use apt-get to install the eclipse IDE. To install the software package you need to download the software then execute an installer. The software can be downloaded from https://www.eclipse.org/downloads/packages/ using the Linux AArch64 framework.

From a VNC or console connection into your Raspberry PI, launch a web browser and download the code

Once the tar.gz file is downloaded it can be extracted so that we can execute the installer.

The eclipse-installer/eclipse-inst can be executed to begin the installation.

Executing the eclipse-inst gives us the option of what development language to install initially. We will choose the C/C++ environment.

Launching the IDE brings up the development environment. From here we can create our hello world example as we did from the command line.

We can create a new C/C++ project

With an IDE we have other options available to us. A Makefile, for example, allows us to automate building our binary from one or multiple source files. From the New project we select Make and Makefile Project then Next.

We name the project and select create sample code and sample Makefile.

When we click Finish we get two new files created, HelloWorld.cpp and Makefile.

Some differences from the code generated are the use of iostream rathern than stdout.h and using the “<<” rather than printf(). In this exampke, argc and argv are included in the main() function definition to accept input parameters from the command line.

For our example we will change the iostream and way we print to the standard way using printf(). Selecting Project -> Build All allows us to build the binary.

Running the Build All will compile the HelloWorld.cpp file and show any problems or errors in the code. If we jump out of the development environment we note that there is a build folder that contains the compiled cod and runnable binary.

We can run the binary from the IDE and see the output in the console.

Note that we can run or single-step into the code the see what each instruction performs. You can also set breakpoints to stop when you get to a specific place to look at things like variables or parameters that exist or are passed into a specific point in the code. An IDE makes this happen very easily and significantly helps with debugging.

Now that we have a stable C/C++ development environment we can do the same for Java by going to the Install Software and searching for Java.

Clicking Next downloads a JDK and the Java development environment. The IDE needs to be restarted to provide the new environment.

To create a Java project, Create New Project.

From there, select Java Project.

Enter a name and click Next

Now that we have a project, we need to create a Java class that will contain our main() function. File -> New -> Class.

We define the java class HelloWorldJ and check create a main routine.

We add the System.out.printf() line to print our comment.

We can then select Run or Debug as a Java class file. If we set breakpoints as discussed before we can look at variables and runtime conditions at specific points in our code.

Note that the output appears in the console at the bottom of the IDE.

Python is installed and configured similarly. We go to Help -> Marketplace and search for Python.

Click on Install and restart the IDE. To create a Python project, click on New Project and select PyDev Project.

Before the first creation you must configure the interpreter and support libraries.

Clicking on the configure an interpreter allows us to select the Python 3 default installed on the operating system.

Select Choose from list and the IDE will look at all Python binaries on the system.

We will select the python3 in the default /usr/bin directory.

along with the 3.11 support libraries.

I had to resize the popup screen to get to the Finish button at the bottom. This creates the Python project.

We create a new PyDev module and add the print option to the file created.

Now that we have the code available we can run it as a Python binary.

At this point we have an IDE on the Raspberry Pi that can develop C/C++, Java, and Python code. The IDE allows us to develop, debug, and compile all of these languages. We barely covered the surface of what you can do with an IDE but will look at more features in future posts.

One of the nice things about a Raspberry Pi (any version) is the ability to program from the command line or a development environment (IDE). In this posting we will look at some of the programming languages that are pre-installed with the default operating system and how to add a couple more as desired.

Python

Python is a relatively simple programming language. From https://www.python.org/doc/essays/blurb/ the language is

“Python is an interpreted, object-oriented, high-level programming language with dynamic semantics. Its high-level built in data structures, combined with dynamic typing and dynamic binding, make it very attractive for Rapid Application Development, as well as for use as a scripting or glue language to connect existing components together. Python’s simple, easy to learn syntax emphasizes readability and therefore reduces the cost of program maintenance. Python supports modules and packages, which encourages program modularity and code reuse. The Python interpreter and the extensive standard library are available in source or binary form without charge for all major platforms, and can be freely distributed.”

What this means in a nutshell is that Python is easy for building complex things from simple constructs. You can create a description of something like a vehicle and assign a number of wheels to. You can write routines to drive each wheel and potentially turn each wheel simply and easily. The modules and packages allow you to take work of others and use them without having to write everything for yourself. Documentation on Python can be found at https://docs.python.org/3/contents.html and chapter 6 details how to define and import modules https://docs.python.org/3/tutorial/modules.html# so that you can leverage the work of others or share with others.

To test what version of Python is installed on your system, open a command prompt and type

python –version

The command prompt should return a version of level 3 or higher with a sub-version following the dots. To execute a program you can type python to invoke the interpreter and type python commands into the interpreter. The code will be executed as you type it.

The command print() prints to the console what is between the quotes. The exit() command exits the interpreter and takes you back to the command line. Alternatively, you can enter the print and exit commands into a file and type python filename to execute the stored program. Traditionally a python file uses the “.py” extension so if we called our file Hello.py we would type

python Hello.py

It is important to note that capitalization is important on a Linux (or Raspberry Pi) system so make sure the file name and what you load into python match exactly. It is important to note that Hello.py and hello.py are two different files.

C and C++

The C and C++ programming languages are a little more structured than Python and is more useful when trying to define something as an object rather than a thing. If, for example, we wanted to describe a vehicle and the vehicle could be a bicycle, a tricycle, a car, a boat, or a rocket ship we could define how to make it go or make it turn using a common subroutine. The subroutine could then determine that the vehicle is a rocket ship and cause the engines to ignite as opposed to turning a motor on the back wheel to get the bicycle to go. C and C++ are higher level programming languages than Python and a little more difficult to program and learn. Fortunately, they are also more powerful and can do more things. Most operating systems are written in C and C++ allowing you to do things like addressing physical devices on the computer and easily controlling them. The GPIO (general purpose I/O) on the Raspberry Pi can be controlled from a command line using the pinctrl command. This command written in C and talks to the operating system to manage the GPIO pins.

Programs written in C and C++ must be compiled from a source file, typically ending in a “.c” extension. The tool that compiles these programs is default installed on the Raspberry Pi in the form of the gcc compiler.

Compiling a program either generates an object file or an executable. We will start with a simple example as we did with Python but save it as Hello.c instead of Hello.py to tell the compiler that this is a C or C++ file.

#include <stdio.h>

int main() {
printf(“Hello World!”);

return 0;
}

Note the first statement is an include of the stdio.h file. The “.h” extension defines things for the compiler. In this instance it defines that we are looking for a subroutine called main() and will be calling a subroutine called printf(). The main routine is the entry point for our code when we execute our compiled code. We can call it as an integer (the int prefix for main) or static void main(). Having main as an int function means that it return something to the command line when it finishes. If everything works as planned it typically returns a zero as shown in the code. If there is an error something else is returned and the shell language at the command line can do something different on a non-zero return. The printf() subroutine can take a string or combination of strings and variables and print it to the console. In this case we print a simple string.

Compiling the code typically takes two phases. The first phase generates an object file that can be combined with other object files to generate an executable. The -c option for gcc generates a “.o” file extension. If we had multiple object files, as in the case with multiple subroutines or object definitions, we can string them together and generate an executable. If, for example, we wanted to define how to drive a bicycle we might have a file called bicycle.c, turn.c, go.c, and stop.c. The turn subroutine would exist in the turn.c file and get compiled into a turn.o object definition. The same to generate a go.o and stop.o object definitions. We would then use the -o option to tell the compiler to generate a bicycle executable from all four object files.

In this example we compile all of the source files to object files using the “-c” option then combine all of the object files into an executable using the “-o” option. If we type file followed by the file names the operating system shows us what type of file is generated. The “.c” file is a C source file. The “.o” file is a relocatable object compiled for the Raspberry Pi. Finally, the bicycle file is an executable file ready to run on the Raspberry Pi.

The benefit of putting the go, stop, and turn modules in a separate file is that we can define how to make a bicycle go in the go file and this same file can then be used again to make a tricycle go or a car go by expanding the way that the go function operates. Given that a bicycle and tricycle are started by peddling the code can be “reused” for a different object. For a car we have to turn on the engine, put the car in gear, and press the accelerator so the go operation is a little more complex but can be defined in the same file to make development and reusability easier in the long run.

Java

The Java programming language was developed many years after the C and C++ languages and was written to overcome some of the problems with those languages. Java is an object oriented language but the intent is that code is portable from one machine to another. If something is written for a Macintosh it can run on a Windows PC or on a Raspberry Pi with little or no modification.

Unfortunately, Java is typically not installed on the Raspberry Pi and needs to be installed.

To install java the apt-get command can be executed as root to install the compiler and java execution foundation on the Raspberry Pi.

The sudo command allows you to run as root. Your username needs to be in the /etc/sudoers file to allow you to run commands as root. The apt-get command tells the operating system that you are doing something with packages for the operating system. The install option says that you want to install a software package from the internet. The default-jdk tells the command that you want to install the latest java development kit onto your computer. Once you type Y the installation begins.

Once the installation is finished we should be able to type in java –version and see what version of the java development kit was installed.

Using our previous example, we will print Hello World! from java using the following code

class HelloWorld {
public static void main( String []args ) {
System.out.println( “Hello World!” );
}
}

In C/C++ we defined a main routine that was the start of our program. In Java we do the same thing but need to define it a little differently. In Java we have to define main() as a public subroutine that can be called from the operating system and have it accept input variables so that we can pass in parameters from the command line. Rather than using the printf() routine we use the System.out.println() routine. This routine prints a string or a combination of strings and variables to the console (System.out) then exits. Note that there is no return value as there was in our other program because we defined the routine as a static void which means that it does not return anything. We also did not include the stdio.h definition to understand the print subroutine. Java makes assumptions that you will be reading and writing from the system and don’t need to include those definitions. The java interpreter takes care of going form the compiled code to the proper operating system.

To compile Java code we type in javac Hello.java. This generates a “.class” file which can be taken to other machines and executed. We don’t need to recompile our java code for a different operating system or chip architecture. Note that the output of our javac is HelloWorld.class even though we had everything stored in Hello.java. This is caused by our class definition of HelloWorld. Had we named it HelloMom it would have written a HelloMom.class file. To execute the code we type java HelloWorld which reads in the HelloWorld.class file and jumps to the main() function definition.

Note that the .java extension is listed as a C++ source file but is really a Java source file. The .class extension is the compiled object that can be executed from the command line with the java command. Also note that there is no binary generated as there was done with Python or C/C++. If you have multiple files that are needed as we did with the bicycle example we would list all of the class files behind the java command to include all of the class files.

In summary, the default languages that can be used to program your Raspberry Pi include:

• shell programming language
• Python
• C/C++
• (optional) Java

The first three are default installed and Java can be installed with the apt-get command. Other programming languages are available so this is not a complete list. Most are installed as we did with Java. Moving forward we will look at all four of these languages for program examples and the Raspberry Pi.

This is the start of a tutorial to help build a simple platform for robotic control and simple display options. We will start with a Raspberry Pi 4 and Raspberry Pi 5 as the initial platform. In the future we will look at an Arduino board using the Elegoo.com super starter kit Uno R3 Project kit.

This kit contains a bunch of electronic projects as well as an Arduino UNO R3 microcontroller.

Raspberry Pi

The Raspberry Pi 5 is the latest release of a microprocessor board release from raspberrypi.com.

This processor board was released in October of 2023 and is now generally available with 4 GB or 8 GB of memory for between $60 and $100 depending upon where you purchase the memory options.

The Raspberry Pi 4 is a lower power system with similar memory configurations starting at $35 and was released in June 2019.

The main difference between the Raspberry Pi 4 and Raspberry Pi 5 are processing power, display options, and expansion options

Both require a memory card to help boot the operating system and either a WiFi connection, ethernet connection, or keyboard/mouse/HDMI monitor to configure and setup the system.

The first key difference that will be obvious between the two boards is how they get power. The Pi4 gets power from a USB-C power adapter that is limited to 15 Watts (5 Volt/3 Amp minimum). The Pi5 needs a different power supply adapter that can power upto 27 Watts of power (5 Volt/5 Amp maximum).

The microSD memory card is inserted into the back of the Raspberry Pi. This memory card contains the operating system and file system that controls the microcomputer.

The only limitation for the microSD card size is the filesystem size for Linux. The physical size is restricted by definition so the size that we are talking about is the storage capacity. As of this posting in 2014, a 2 TB microSD card is the largest available on the market. The ext4 filesystem on Linux is 256 TB so there is plenty of room for larger microSD cards when they are available.

To get the operating system on the memory card, another operating system like Windows 10 or MacOS are needed to copy the OS image from the internet to the memory card. A USB to memory card adapter is needed.

Not all USB to card adapters can handle a microSD card and might need an adapter to handle the larger card slot.

A good place to start for imaging the operating system is https://www.raspberrypi.com/documentation/computers/getting-started.html which details the parts and software needed for both the Raspberry Pi 4 and 5. The software for Windows can be found at https://www.raspberrypi.com/software/ and is relatively easy to install but does require admin rights to allow you to communicate with the USB port/memory card. The software is relatively simple to use and has three options for installation.

The first option is to select the device (Raspberry Pi 4 or Raspberry Pi 4 or older models) .

The second option is which flavor of the operating system to install. The initial recommendation would be to install a full desktop that allows for connection via keyboard/mouse/HDMI monitor or remote connection across the WiFi network or ethernet network. At some point you might want to install a “headless” system that can only be connected to through a network connection and is typically only a terminal connection and not a full desktop experience. This configuration requires a bit more knowledge of Linux command line options and how to manipulate/configure your system.

You can install a 64 bit or 32 bit operation. The recommendation is to install the 64-bit configuration initially until you find a need for the 32-bot configuration or an application that requires 32-bit only.

The final configuration option is to select the microSD card that gets mounted on the Windows operating system. The drive name and device type will typically be different than this screen shot.

The final option is to configure the WiFi adapter, user/password, and hostname as part of the installation. This is done by clicking on the Edit Settings which gives you access to the optional configuration screens.

In this example we configure the network, add a user, and define the hostname. You will typically need to modify each of these entries to fit your needs.

It is suggested that you configure SSH at this point by going to the services tab and enabling the SSH option.

The simplest recommendation is to use password authentication until you are more familiar with secure shell and using secure communications without a password.

Once all options are defined, write the operating system to the memory card and eject it from your computer.

The copy operation will take a few minutes and write then verify the operation.

Take the microSD card and insert it into the back of the Raspberry Pi. The slot is the same for the Raspberry Pi 4 and Raspberry Pi 5.

Attach the power supply, ethernet cable (if used), keyboard, mouse, and HDMI connector to the Raspberry Pi.

At this point you should see a desktop screen on your monitor/TV and have a successful operating system installation.