JNI – the Java Native Interface

The Java Native Interface is a framework used to allow Java programs to integrate with other applications written in other programming languages like C and C++.

This feature is quite old now with regards to the JVM and was added in 1.1 to 1.2 of the JVM.

I have started using this feature with a Raspberry Pi as you can access the GPIO pins directly with C without other libraries and this can be integrated with a Java program to control the GPIO pins.

This feature is very useful, as the Pi4J library doesn’t work on all versions of Debian for the Raspberry Pi at the time of blogging this post, since they renamed some features, which broke Pi4J.

I will give an example of how to do this –

Create a file called HelloWorld.java

 
import com.sun.jna.Library;
import com.sun.jna.Native;

public class HelloWorld {
public interface CTest extends Library {
public void helloFromC();
}

public interface GPIO extends Library {
public int main();
}
public static void main(String[] args) {
CTest ctest = (CTest) Native.loadLibrary("ctest", CTest.class);
ctest.helloFromC();

GPIO gpio = (GPIO) Native.loadLibrary("gpio", GPIO.class);
gpio.main();
}
}


Create a file called gpio.c

//
// How to access GPIO registers from C-code on the Raspberry-Pi
// Example program
// 15-January-2012
// Dom and Gert
// Revised: 15-Feb-2013

// Access from ARM Running Linux

#define BCM2708_PERI_BASE 0x20000000
#define GPIO_BASE (BCM2708_PERI_BASE + 0x200000) /* GPIO controller */

#include
#include
#include
#include
#include

#define PAGE_SIZE (4*1024)
#define BLOCK_SIZE (4*1024)

int mem_fd;
void *gpio_map;

// I/O access
volatile unsigned *gpio;

// GPIO setup macros. Always use INP_GPIO(x) before using OUT_GPIO(x) or SET_GPIO_ALT(x,y)
#define INP_GPIO(g) *(gpio+((g)/10)) &= ~(7<<(((g)%10)*3))
#define OUT_GPIO(g) *(gpio+((g)/10)) |= (1<<(((g)%10)*3))
#define SET_GPIO_ALT(g,a) *(gpio+(((g)/10))) |= (((a)<=3?(a)+4:(a)==4?3:2)<<(((g)%10)*3))

#define GPIO_SET *(gpio+7) // sets bits which are 1 ignores bits which are 0
#define GPIO_CLR *(gpio+10) // clears bits which are 1 ignores bits which are 0

#define GET_GPIO(g) (*(gpio+13)&(1<<g)) // 0 if LOW, (1<<g) if HIGH

#define GPIO_PULL *(gpio+37) // Pull up/pull down
#define GPIO_PULLCLK0 *(gpio+38) // Pull up/pull down clock

void setup_io();

void printButton(int g)
{
if (GET_GPIO(g)) // !=0 bit is 1 <- port is HIGH=3.3V
printf("Button pressed!\n");
else // port is LOW=0V
printf("Button released!\n");
}

int main(int argc, char **argv)
{
int g,rep;

// Set up gpi pointer for direct register access
setup_io();

// Switch GPIO 7..11 to output mode

/************************************************************************\
* You are about to change the GPIO settings of your computer. *
* Mess this up and it will stop working! *
* It might be a good idea to 'sync' before running this program *
* so at least you still have your code changes written to the SD-card! *
\************************************************************************/

// Set GPIO pins 7-11 to output
for (g=7; g<=11; g++)
{
INP_GPIO(g); // must use INP_GPIO before we can use OUT_GPIO
OUT_GPIO(g);
}

for (rep=0; rep<10; rep++)
{
for (g=7; g<=11; g++)
{
GPIO_SET = 1<<g;
sleep(1);
}
for (g=7; g<=11; g++)
{
GPIO_CLR = 1<<g;
sleep(1);
}
}

return 0;

} // main

//
// Set up a memory regions to access GPIO
//
void setup_io()
{
/* open /dev/mem */
if ((mem_fd = open("/dev/mem", O_RDWR|O_SYNC) ) < 0) {
printf("can't open /dev/mem \n");
exit(-1);
}

/* mmap GPIO */
gpio_map = mmap(
NULL, //Any adddress in our space will do
BLOCK_SIZE, //Map length
PROT_READ|PROT_WRITE,// Enable reading & writting to mapped memory
MAP_SHARED, //Shared with other processes
mem_fd, //File to map
GPIO_BASE //Offset to GPIO peripheral
);

close(mem_fd); //No need to keep mem_fd open after mmap

if (gpio_map == MAP_FAILED) {
printf("mmap error %d\n", (int)gpio_map);//errno also set!
exit(-1);
}

// Always use volatile pointer!
gpio = (volatile unsigned *)gpio_map;

} // setup_io


Run the Following commands:


javac HelloWorld.java


Create the jni headers file

javah -jni HelloWorld


Do not modify the file above

gcc -shared -I/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/include -I/usr/lib/jvm/jdk-8-oracle-arm32-vfp-hflt/include/linux HelloWorld.c -o libHelloWorld.so


Then to run the application, use

java -Djava.library.path=. HelloWorld

If you would like more information, I initially used this website

Advertisements

Unit testing introduction

What are unit tests?

Unit tests are the smallest part of the application that can be tested and are tested in parts.

Why should I care?

Unit tests are important to show if parts of an application are working in the way they are expected to work. For example, if you had a method called int return4() and you expected 4 to be returned, a unit test is written to validate the method returns 4. If it doesn’t, the test fails and is shown up to the tester if written well.

Where can I start unit testing?

For Spring Boot applications, I would recommend the following tutorial. This integrates a unit test with Spring Boot. I would advise you experiment with the tests and see what you can make.

Design Patters, Java and the Factory Pattern

Have you ever looked at a piece of code, project or application and thought “what on earth is going on here”? I have many times and so have many other developers, so ages ago, Design Patterns were introduced to keep coding clean, and organised.

You probably organise your code already closely to a few design patterns without even realising. Today, I’ll introduce the Factory Pattern as a method of structuring your code.

The Factory Pattern allows objects of similar logic to be created to a common interface.

Tutorialspoint has a great example involving shapes.

Summarising the example, you can have a shape factory that creates triangles, squares, circles.

This may seem rather abstract, but for example, you may want to make different types of database connection for customers and want to get their details, which they would have a Customer interface, but a Customer Factory for all the individual details so that they are not exposed to the client.

Getting Started With Spring Boot?

What is Spring Boot?

Spring Boot is a Java framework. Spring Boot shouldn’t be confused with Spring Framework and more information can be found here.

How do I get started?

The Spring Boot webpage is a great place to start. You can install via Maven (or Gradle).

Great, why should I do this?

Spring Boot is great for setting up web services and other applications quickly and without too much complication, but allows the developer to configure parts to make diverse applications without spending too much time setting up the project.

Give it a try and see what you think 🙂

 

How to Make MySQL and Spring-Boot CRUD application for Raspberry Pi

In this post, I will share how to make a very basic Spring Boot application and database with MySQL with Raspberry Pi.

Perquisites:

  • I will assume you know Git and Source Control and you know how to set up a Raspberry Pi.

Lets Start:

Installing MySQL Raspberry Pi

Using some information from this guide, you will need to install MySQL and drivers. Php is not needed for this.

  • Open up your terminal on your Raspberry Pi
  • sudo apt-get install mysql-server --fix-missing
  • Agree  to all of the install terms
  • Create a password for your MySQL database when required
  • sudo apt-get install mysql-client php5-mysql
  • Agree to all of the install terms

MySQL should be installed correctly on your Raspberry Pi.

Installing Maven

You will need Apache Maven to run the application on your Raspberry Pi.

I will summarise this tutorial as this is what I used:

Before starting developing the Application, I advise you use an IDE on a main computer and Git with source control to transfer it over.

  • Create an account on GitHub to store the project that will be created in the next part
  • Once created, clone the repository onto the Raspberry Pi and your laptop or desktop development environment

From Spring Boot’s website we’ll follow this guide.

You should build this application on your GitHub repository that you created earlier and pull it via command line on your Raspberry Pi as this will keep the development fast.

How to Install Java for Development

After the previous post to What is Java I will now provide a quick start up to installing Java, so you can start to develop your own applications.

Is Java Development Kit and Java Runtime Environment installed?

To check this, on linux and mac OS open terminal (for Windows, open cmd) and type:

javac -version
This will show the JDK version.

java -version
Will show the JRE version.

Please note – it is important that the JDK and JRE versions match – for example 1.8.X for both, where X can be any number, if it is 1.7.X and 1.8.X for the JDK or JRE (or vice versa), the code will not compile as Java needs to be the same version for compilation as running.

Typically, on a mac, it would be installed. If not, Oracle’s official installation JDK and JRE will provide the information to install it.

For Linux, here is the official installation JDK and JRE.

For Windows, here are the System Requirements, then install the JDK and JRE.

If things start to go wrong, here are some quick points to check:

  • Is the JDK and JRE installed already?
  • Are the versions the same or different?
  • For Windows – Is the JDK and JRE on your PATH variables?
  • For Mac and Linux – Is $PATH got the correct path to your JDK and JRE?

For further information – please go to Oracle’s Official Website  for installation tips and requirements.

What is Java?

Quoting from Wikipedia – Java is a general-purpose computer programming language that is concurrent, class-based, object-oriented.

So, what does that mean?

  • Java can execute several computations in overlapping time periods – for example, multithreading is used to execute several tasks at the same time.
  • Java has classes – therefore you can use inheritance and encapsulation.
  • Java has objects – you can define attributes of the object and use them in the code.

Other Features Developing Java

  • Java uses a compiler – when developing Java, you need to use a Java Development Kit (JDK) to compile the code into byte code that is run on a Java Virtual Machine (JVM)
  • Write once, run everywhereWikipedia, you can run Java bytecode on any JVM on any machine, what this means is you do not need different flavours of code to run on different systems like Linux and Microsoft – providing they have a JVM, you can run the code on all of them.