Tag Archives: Pi4J

Raspberry Christmas Hat

Leave a reply

What’s the story Rory?
2020/12/24

Today I want to show some Christmas project ideas using Hats. Yes, another blog about Raspberry PI.

Thanks to their GPIO headers, most Pi computers can connect to devices called HATs, which stands for Hardware Attached on Top.

Theses are the Hats that I have and they came from ThePiHut

Christmas Tree Programmable Kit – Link

I think this hat comes in 3 different sets, one just with white LEDs, one with just red LEDs and one with mixed white and red LEDs and you can find the Pre-soldered version as well.
From the Python API you can get the GPIO numbers to use with PI4j

SnowPi – Link

The SnowPi is a discontinued item, but you can find it in ThePiHut.
From the Python API you can get the GPIO numbers to use with PI4j

During 2020 there was another successful Kickstarter project for the SnowPi RGB. This is a new version of the Snowman. There is no soldering required and it now has color NeoPixels instead of single color LEDs.

3D Xmas Tree for Raspberry Pi – Link

After a while, they release an RGB version as well. Like all the others you can find the Pre-soldered version as well.
From the code sample, you can get the GPIO numbers to use with PI4j

Raspberry Pi Christmas Tree Star – Link

From the Python API you can get the GPIO numbers to use with PI4j

The idea here is that all hats are just boards with some LEDs, and this makes the project like an electronics project for blinking LEDs.
We can use the PWM idea, “Pulse Width Modulation” that I already explained here, but let me explain from the LEDs perspective.

From Wikipedia

The term duty cycle describes the proportion of ‘on’ time to the regular interval or ‘period’ of time; a low duty cycle corresponds to low power because the power is off for most of the time. Duty cycle is expressed in percent, 100% being fully on. When a digital signal is on half of the time and off the other half of the time, the digital signal has a duty cycle of 50% and resembles a “square” wave. When a digital signal spends more time in the on state than the off state, it has a duty cycle of >50%. When a digital signal spends more time in the off state than the on state, it has a duty cycle of <50%. Here is a pictorial that illustrates these three scenarios.

You can find examples and samples for all Hats in Python, but because I support the #JavaOnRaspberryPi idea, let’s see how to use them with Java.
Remember to use the hashtag #JavaOnRaspberryPi on Twitter to show the world Raspberry Pi with Java.

PI4J
You can check my post to start with PI4J but for these hats what you need to understand is the Pwm Example

1
2
3
com.pi4j.wiringpi.Gpio.pwmSetMode(com.pi4j.wiringpi.Gpio.PWM_MODE_MS);
com.pi4j.wiringpi.Gpio.pwmSetRange(100);
com.pi4j.wiringpi.Gpio.pwmSetClock(500);

The idea is that “setPwm()” can be 0, to turn off, 100, to turn on and any value between 0 and 100 to create a fade.

1
2
3
setPwm(0)
setPwm(100)
setPwm(value);

Now you can not just turn on and off, but you can also pulse, blink and add a fade effect.

Here is my forest project from 2018.

Of course, you can do some Christmas ideas with any other hat.

Sensehat http://www.igfasouza.com/blog/sense-hat/

You can create your Christmas tree using my Micronaut example. GitHub Or just using this.

E-ink display

I know that 4tronix has some Christmas Micro Bit hats and people did some hack around to use with a Raspberry PI, But If you know any other Christmas Hat, please let me know in the comments.

As a good developer, I always get confused about Christmas and Halloween as 25 Dec is equal to 31 Oct

PumpkinPi https://thepihut.com/products/halloween-pumpkinpi-for-raspberry-pi

Some other Christmas ideas
https://www.raspberrypi.org/blog/tag/christmas/

Raspberry Pi Servo Java Duke Robot

Leave a reply

What’s up?
2020/10/12

This post is to show how I created a Java Duke Servo demo with a Raspberry Pi. This is another blog about Java on Raspberry Pi.

Interfacing a Servo Motor with Raspberry Pi is an interesting topic as Servo Motors are the main components of a Robot and with the help of Raspberry Pi, you can have endless opportunities in Robotics.

Because today we celebrate children’s day in Brazil, I came with the idea to show this simple robot example using a servo motor and a Raspberry Pi. And nothing better than a Java Duke servo demo to show Java on Raspberry Pi.

Components

  • SG90 Micro-servo motor
  • Jumper wires (generic)
  • Raspberry Pi 3b or Arduino

Idea

Using a cardboard and Duke image to create a servo demo where Duke moves his arm.


I used this image to create my demo.

Control a Servo Motor

To control a Servo Motor, you need to use a technique called Pulse Width Modulation or PWM. In PWM technique, you will be sending a pulse of variable width and the position of the Servo Motor’s shaft will be set by the width or length of the Pulse.

Nice “Pulse Width Modulation” explanation here

The frequency of the PWM signal is a fixed value and is dependent on the type of Servo Motor.
At 50Hz i.e. a period of 20ms, the minimum pulse width is 1ms and the maximum pulse width is 2ms. Most servo motors can have a swept area of 180 degrees i.e. 90 degrees on either side of the neutral position.

When the pulse width of the PWM Signal is 1ms, the position of the servo is the left. The Duty Cycle of this position is (1ms/20ms) x 100 = 5%.

Similarly, for pulse widths of 1.5ms and 2ms, the position of the servo is middle (with a duty cycle of 7.5%) and far right (with a duty cycle of 10%).

  • so for 50hz, one frequency is 20ms
  • duty cycle for 0 degree = (1/20)*100 = 5%
  • duty cycle for 90 degree = (1.5/20)*100 = 7.5%
  • duty cycle for 180 degree = (2/20)*100 = 10%

Note: Be aware here that you need to test and check your servo. You might need to calibrate this number for you.

Schematics

I’m using the SG90 servo motor and you can check the Datasheet here.

The Tower Pro SG90 Servo Motor Consists of three Pins: PWM (Orange or Yellow), VCC (Red), and GND (Brown). The VCC and GND pins must be connected to +5V and GND of the power supply.

PWM or Signal Pin of the Servo Motor must be connected to the PWM Output of the Controller (Raspberry Pi). Based on the width of the Pulses from the PWM signal, the angle of the Servo Motor’s shaft will vary.

1ms pulse for 0 degree (LEFT)
1.5ms pulse for 90 degree (MIDDLE)
2ms pulse for 180 degree (RIGHT)

PI4J

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinPwmOutput;
import com.pi4j.io.gpio.Pin;
import com.pi4j.io.gpio.RaspiPin;
import com.pi4j.util.CommandArgumentParser;


public class TestPwmServoMotor {

    public static void main(String[] args) throws InterruptedException {
        pwm(args);
    }

    /**
     * @param args
     * @throws InterruptedException
     */
    public static void pwm(String[] args) throws InterruptedException{

        final GpioController gpio = GpioFactory.getInstance();

        Pin pin = CommandArgumentParser.getPin(
        RaspiPin.class,    
        RaspiPin.GPIO_00,  
        args);            
        GpioPinPwmOutput pwm = gpio.provisionSoftPwmOutputPin(pin);
        pwm.setPwmRange(100);

        int sleep = 1000;
        for(int i = 0 ;i<10;i++){
             pwm.setPwm(25);
            System.out.println("PWM rate is: " + pwm.getPwm());
            Thread.sleep(sleep);

            pwm.setPwm(15);
            System.out.println("PWM rate is: " + pwm.getPwm());
            Thread.sleep(sleep);

            pwm.setPwm(6);
            System.out.println("PWM rate is: " + pwm.getPwm());
            Thread.sleep(sleep);
        }
        gpio.shutdown();        
        System.out.println("pwm end");

    }
}

Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import RPi.GPIO as GPIO
import time


control = [5,5.5,6,6.5,7,7.5,8,8.5,9,9.5,10]
servo = 22
GPIO.setmode(GPIO.BOARD)
GPIO.setup(servo,GPIO.OUT)
p=GPIO.PWM(servo,50)
p.start(2.5)

try:
       while True:
           for x in range(11):
             p.ChangeDutyCycle(control[x])
             time.sleep(0.03)
             print x
           
           for x in range(9,0,-1):
             p.ChangeDutyCycle(control[x])
             time.sleep(0.03)
             print x
           
except KeyboardInterrupt:
    GPIO.cleanup()

Arduino

And of course, you can do this demo with an Arduino as well.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <Servo.h>


Servo servo

void setup() {
  servo.attach(9);
 
}
void loop() {
  servo.write(0);
  delay(500);
  delay(10000);
  servo.write(90);
  delay(500);
  delay(10000);
  servo.write(180);
  delay(500);
  delay(10000);
  servo.write(90);
  delay(500);
  delay(10000);
  servo.write(0);
  delay(500);
  delay(10000);
}

Results

The next steps are to create a code that transforms text into the flag language

Links

https://pi4j.com/1.2/index.html

https://github.com/Pi4J/pi4j

http://www.ee.ic.ac.uk/pcheung/teaching/DE1_EE/stores/sg90_datasheet.pdf

https://en.wikipedia.org/wiki/Pulse-width_modulation

https://www.electronics-tutorials.ws/blog/pulse-width-modulation.html

https://en.wikipedia.org/wiki/Flag_semaphore

Quarkus Qute with Raspberry PI

Leave a reply

Hey you!
2020/09/22

This post is to show how I created a Quarkus Qute demo with a Raspberry PI. This is another blog about Java on Raspberry PI.

Quarkus is a full-stack, Kubernetes-native Java framework made for Java virtual machines (JVMs) and native compilation, optimizing Java specifically for containers and enabling it to become an effective platform for serverless, cloud, and Kubernetes environments.

Qute is a templating engine designed specifically to meet the Quarkus needs. The usage of reflection is minimized to reduce the size of native images. The API combines both the imperative and the non-blocking reactive style of coding. The engine is based on RESTEasy/JAX-RS. As such, Qute web applications are implemented by defining resource types with methods answering to specific HTTP verbs and accept headers. The only difference being, that HTML pages are returned instead of JSON as in your typical REST-ful data API. The individual pages are created by processing template files.

If you’ve worked with other templating engines before, like me, this will look very familiar to you.

Note: Qute is an experimental feature.

Idea

A simple Quarkus Qute example that shows a 7 segments display and control in real-time a real one with a Raspberry Pi 3 B.
When I was googling about a 7 segment display this site appeared in my result and I came up with the idea.

I suggest you check out my 7 segment display blog before looking at the code.

Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
package com.igor;

import io.quarkus.qute.Template;
import io.quarkus.qute.TemplateInstance;
import javax.inject.Inject;
import javax.transaction.Transactional;
import javax.ws.rs.Consumes;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import org.jboss.resteasy.annotations.providers.multipart.MultipartForm;
import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinDigitalOutput;
import com.pi4j.io.gpio.PinState;
import com.pi4j.io.gpio.RaspiPin;

@Path("hello")
public class HelloResource {

    @Inject
    Template hello;
   
    final GpioController gpio = GpioFactory.getInstance();
    GpioPinDigitalOutput pin01 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_26, "1", PinState.HIGH);
    GpioPinDigitalOutput pin02 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_22, "2", PinState.HIGH);
    GpioPinDigitalOutput pin04 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_07, "3", PinState.HIGH);
    GpioPinDigitalOutput pin05 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_09, "4", PinState.HIGH);
    GpioPinDigitalOutput pin06 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_08, "5", PinState.HIGH);
    GpioPinDigitalOutput pin07 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_15, "6", PinState.HIGH);
    GpioPinDigitalOutput pin09 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_16, "7", PinState.HIGH);
    GpioPinDigitalOutput pin10 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_21, "8", PinState.HIGH);

    @GET
    @Produces(MediaType.TEXT_HTML)
    public TemplateInstance get() {

        return hello.data("field1", "Test").data("field2", "Igor");
    }

    @POST
    @Consumes(MediaType.MULTIPART_FORM_DATA)
    @Transactional
    @Path("/segment")
    public TemplateInstance segmentDisplay(@MultipartForm MessageForm messageForm) {
       
        if(messageForm.segment1 == null && messageForm.segment2 == null &&
                messageForm.segment3 == null && messageForm.segment4 == null &&
                messageForm.segment5 == null && messageForm.segment6 == null &&
                messageForm.segment7 == null && messageForm.segment8 == null) {
            pin01.setShutdownOptions(true, PinState.HIGH);
            pin02.setShutdownOptions(true, PinState.HIGH);
            pin04.setShutdownOptions(true, PinState.HIGH);
            pin05.setShutdownOptions(true, PinState.HIGH);
            pin06.setShutdownOptions(true, PinState.HIGH);
            pin07.setShutdownOptions(true, PinState.HIGH);
            pin09.setShutdownOptions(true, PinState.HIGH);
            pin10.setShutdownOptions(true, PinState.HIGH);
            pin01.high();
            pin02.high();
            pin04.high();
            pin05.high();
            pin06.high();
            pin07.high();
            pin09.high();
            pin10.high();
        }

        display(messageForm);

        return hello.data("field1", "Test").data("field2", "Igor")
                .data("segment1", messageForm.segment1)
                .data("segment2", messageForm.segment2)
                .data("segment3", messageForm.segment3)
                .data("segment4", messageForm.segment4)
                .data("segment5", messageForm.segment5)
                .data("segment6", messageForm.segment6)
                .data("segment7", messageForm.segment7)
                .data("segment8", messageForm.segment8);
    }

    public void display(MessageForm messageForm) {

        if(messageForm.segment1 != null && messageForm.segment1.equals("on")) {
            pin01.low();
        }else {
            pin01.high();
        }
        if(messageForm.segment2 != null && messageForm.segment2.equals("on")) {
            pin02.low();
        }else {
            pin02.high();
        }
        if(messageForm.segment3 != null && messageForm.segment3.equals("on")) {
            pin04.low();
        }else {
            pin04.high();
        }
        if(messageForm.segment4 != null && messageForm.segment4.equals("on")) {
            pin05.low();
        }else {
            pin05.high();
        }
        if(messageForm.segment5 != null && messageForm.segment5.equals("on")) {
            pin06.low();
        }else {
            pin06.high();
        }
        if(messageForm.segment6 != null && messageForm.segment6.equals("on")) {
            pin07.low();
        }else {
            pin07.high();
        }
        if(messageForm.segment7 != null && messageForm.segment7.equals("on")) {
            pin09.low();
        }else {
            pin09.high();
        }
        if(messageForm.segment8 != null && messageForm.segment8.equals("on")) {
            pin10.low();
        }else {
            pin10.high();
        }
    }
}

Disclaimer – I got the CSS from here

You can get the full code on my GitHub.

Links

https://quarkus.io/

https://quarkus.io/guides/qute

https://quarkus.io/guides/qute-reference

https://propjockey.github.io/bcd7sdd/

https://pi4j.com/1.2/index.html

7 Segment Display

Leave a reply

What’s the crack jack?
2020/09/20

Table of contents

1. 7-Segment Display
2. Cathode vs Anode
3. Components
4. Schematics
5. Code
6. PI4J
7. Links

1. 7-Segment Display

The 7-segment display, also written as “seven segment display”, consists of seven LEDs (hence its name) arranged in a rectangular fashion as shown. Each of the seven LEDs is called a segment because when illuminated the segment forms part of a numerical digit (both Decimal and Hex) to be displayed. An additional 8th LED is sometimes used within the same package thus allowing the indication of a decimal point (DP).


A 7-segment is a packaged set of 8 LEDs (7 number-segments & 1 decimal point).

I have the “hdsp-c1g1” model and it is a Common-Anode.

2. Cathode vs Anode

Common anode means that the anode (positive) side of all of the LEDs is electrically connected at one pin, and each LED cathode has its own pin. So turning on any particular segment will involve running a current from this common anode (positive) pin to the particular cathode (negative) pin for the desired segment.

Common cathode means that the cathodes of all of the LEDs are common and connected to a single pin. The anode for each LED has its own pin. So driving one of these means running a current from the particular anode (positive) pin for the desired segment to the common cathode pin.

The way that you are diving the 7-segment involves using a separate pin to drive each segment, so you use 8 pins of the Arduino to drive the display.

3. Components

  • 1x Arduino
  • 1x Raspberry Pi
  • 1x Common-Anode 7-segment display
  • 8x Resistor 221 ohm
  • 10x Jumper wires (generic)

4. Schematics

Common-Anode 7-segment display

My 7-segment display has its common pins (COM) connected to the +5V pin.
If a pin turns off, the corresponding segment will turn on. It’s because when the pin is on, the voltage difference between the pin and the +5V is 0. It is the same if the +5V was replaced by 0V. We can’t connect the COM to the GND because the LEDs are like diodes so they wouldn’t light up at all.

For Raspberry PI you need to check the GPIO numbers. Note that the pin number is not the same thing as the GPIO number.

For my example here I create a table to map:

5. Code

Arduino

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
void setup()
{
  init();
  /*your setup code here*/
}

void loop()
{
  /*
   * your loop code here
   *
   * use display(num, dp) to display num (0123456789ABCDEF)
   * and the dot (if dp).
   *
   * you can turn off all the leds by writing display().
   */
}

void init()
{
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);
  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
}

void display(int n=-1, boolean dp)
{
  digitalWrite(9, !dp);
  if(num == 0)
  {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 1);
  } else if(num == 1) {
    digitalWrite(2, 1);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 1);
    digitalWrite(6, 1);
    digitalWrite(7, 1);
    digitalWrite(8, 1);
  } else if(num == 2) {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 1);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 1);
    digitalWrite(8, 0);
  } else if(num == 3) {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 1);
    digitalWrite(7, 1);
    digitalWrite(8, 0);
  } else if(num == 4) {
    digitalWrite(2, 1);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 1);
    digitalWrite(6, 1);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 5) {
    digitalWrite(2, 0);
    digitalWrite(3, 1);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 1);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 6) {
    digitalWrite(2, 0);
    digitalWrite(3, 1);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 7) {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 1);
    digitalWrite(6, 1);
    digitalWrite(7, 1);
    digitalWrite(8, 1);
  } else if(num == 8) {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 9) {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 1);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 10) {
    digitalWrite(2, 0);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 1);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 11) {
    digitalWrite(2, 1);
    digitalWrite(3, 1);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 12) {
    digitalWrite(2, 0);
    digitalWrite(3, 1);
    digitalWrite(4, 1);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 1);
  } else if(num == 13) {
    digitalWrite(2, 1);
    digitalWrite(3, 0);
    digitalWrite(4, 0);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 1);
    digitalWrite(8, 0);
  } else if(num == 14) {
    digitalWrite(2, 0);
    digitalWrite(3, 1);
    digitalWrite(4, 1);
    digitalWrite(5, 0);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else if(num == 15) {
    digitalWrite(2, 0);
    digitalWrite(3, 1);
    digitalWrite(4, 1);
    digitalWrite(5, 1);
    digitalWrite(6, 0);
    digitalWrite(7, 0);
    digitalWrite(8, 0);
  } else {
    digitalWrite(2, 1);
    digitalWrite(3, 1);
    digitalWrite(4, 1);
    digitalWrite(5, 1);
    digitalWrite(6, 1);
    digitalWrite(7, 1);
    digitalWrite(8, 1);
  }
}

Raspberry PI – Python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
from gpiozero import LED
from time import sleep

pin01 = LED(2)
pin02 = LED(3)
pin04 = LED(4)
pin05 = LED(5)
pin06 = LED(6)
pin07 = LED(12)
pin09 = LED(14)
pin10 = LED(15)


def clear():
    pin01.on()
    pin02.on()
    pin04.on()
    pin05.on()
    pin06.on()
    pin07.on()
    pin09.on()
    pin10.on()


def display(number):
    if number == 0:
        pin01.off()
        pin02.off()
        pin04.off()
        pin05.on()
        pin06.off()
        pin07.off()
        pin09.off()
        pin10.on()
    if number == 1:
        pin01.on()
        pin02.on()
        pin04.off()
        pin05.on()
        pin06.off()
        pin07.on()
        pin09.on()
        pin10.on()
    if number == 2:
        pin01.off()
        pin02.off()
        pin04.on()
        pin05.on()
        pin06.off()
        pin07.off()
        pin09.on()
        pin10.off()
    if number == 3:
        pin01.on()
        pin02.off()
        pin04.off()
        pin05.on()
        pin06.off()
        pin07.off()
        pin09.on()
        pin10.off()
    if number == 4:
        pin01.on()
        pin02.on()
        pin04.off()
        pin05.on()
        pin06.off()
        pin07.on()
        pin09.off()
        pin10.off()
    if number == 5:
        pin01.on()
        pin02.off()
        pin04.off()
        pin05.on()
        pin06.on()
        pin07.off()
        pin09.off()
        pin10.off()
    if number == 6:
        pin01.off()
        pin02.off()
        pin04.off()
        pin05.off()
        pin06.on()
        pin07.off()
        pin09.off()
        pin10.off()
    if number == 7:
        pin01.on()
        pin02.on()
        pin04.off()
        pin05.on()
        pin06.off()
        pin07.off()
        pin09.on()
        pin10.on()
    if number == 8:
        pin01.off()
        pin02.off()
        pin04.off()
        pin05.on()
        pin06.off()
        pin07.off()
        pin09.off()
        pin10.off()
    if number == 9:
        pin01.on()
        pin02.on()
        pin04.off()
        pin05.off()
        pin06.off()
        pin07.off()
        pin09.off()
        pin10.off()


clear()
sleep(1)
while True:
    for x in range(10):
        display(x)
        sleep(1)

6. PI4J

PI4J provides a friendly object-oriented I/O API and implementation libraries for Java programmers to access the full I/O capabilities of the Raspberry Pi platform. This project abstracts the low-level native integration and interrupts monitoring to enable Java programmers to focus on implementing their application business logic.

Note: Pi4J (by default) uses an abstract pin numbering scheme to help insulate software from hardware changes.Pi4J implements the same pin number scheme as the Wiring Pi

http://wiringpi.com/pins/

This is the Number for the PI 3 B model.

Because the PI4J use a different GPIO number I add a new column in my table;

Raspberry PI – Java – Pi4j

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
package led.example;

import com.pi4j.io.gpio.GpioController;
import com.pi4j.io.gpio.GpioFactory;
import com.pi4j.io.gpio.GpioPinDigitalOutput;
import com.pi4j.io.gpio.PinState;
import com.pi4j.io.gpio.RaspiPin;

public class SevenSegmentsDisplay {

    static GpioPinDigitalOutput pin01 = null;
    static GpioPinDigitalOutput pin02 = null;
    static GpioPinDigitalOutput pin04 = null;
    static GpioPinDigitalOutput pin05 = null;
    static GpioPinDigitalOutput pin06 = null;
    static GpioPinDigitalOutput pin07 = null;
    static GpioPinDigitalOutput pin09 = null;
    static GpioPinDigitalOutput pin10 = null;

    public static void display(int number) {

        if(number == 0) {
            pin01.low();
            pin02.low();
            pin04.low();
            pin05.high();
            pin06.low();
            pin07.low();
            pin09.low();
            pin10.high();
        }
        if(number == 1) {
            pin01.high();
            pin02.high();
            pin04.low();
            pin05.high();
            pin06.low();
            pin07.high();
            pin09.high();
            pin10.high();
        }
        if(number == 2) {
            pin01.low();
            pin02.low();
            pin04.high();
            pin05.high();
            pin06.low();
            pin07.low();
            pin09.high();
            pin10.low();
        }
        if(number == 3) {
            pin01.high();
            pin02.low();
            pin04.low();
            pin05.high();
            pin06.low();
            pin07.low();
            pin09.high();
            pin10.low();
        }
        if(number == 4) {
            pin01.high();
            pin02.high();
            pin04.low();
            pin05.high();
            pin06.low();
            pin07.high();
            pin09.low();
            pin10.low();
        }
        if(number == 5) {
            pin01.high();
            pin02.low();
            pin04.low();
            pin05.high();
            pin06.high();
            pin07.low();
            pin09.low();
            pin10.low();
        }
        if(number == 6) {
            pin01.low();
            pin02.low();
            pin04.low();
            pin05.low();
            pin06.high();
            pin07.low();
            pin09.low();
            pin10.low();
        }
        if(number == 7) {
            pin01.high();
            pin02.high();
            pin04.low();
            pin05.high();
            pin06.low();
            pin07.low();
            pin09.high();
            pin10.high();
        }
        if(number == 8) {
            pin01.low();
            pin02.low();
            pin04.low();
            pin05.high();
            pin06.low();
            pin07.low();
            pin09.low();
            pin10.low();
        }
        if(number == 9) {
            pin01.high();
            pin02.low();
            pin04.low();
            pin05.low();
            pin06.low();
            pin07.low();
            pin09.low();
            pin10.low();
        }

    }

    public static void main(String[] args) {

        final GpioController gpio = GpioFactory.getInstance();

        pin01 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_08);
        pin02 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_09);
        pin04 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_07);
        pin05 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_21);
        pin06 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_22);
        pin07 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_26);
        pin09 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_15);
        pin10 = gpio.provisionDigitalOutputPin(RaspiPin.GPIO_16);

        pin01.setShutdownOptions(true, PinState.HIGH);
        pin02.setShutdownOptions(true, PinState.HIGH);
        pin04.setShutdownOptions(true, PinState.HIGH);
        pin05.setShutdownOptions(true, PinState.HIGH);
        pin06.setShutdownOptions(true, PinState.HIGH);
        pin07.setShutdownOptions(true, PinState.HIGH);
        pin09.setShutdownOptions(true, PinState.HIGH);
        pin10.setShutdownOptions(true, PinState.HIGH);

        try {
            while(true) {
                for (int i = 0; i < 10; i++) {
                    display(i);
                    System.out.println("Number " + i);
                    Thread.sleep(2000);
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            gpio.shutdown();
        }
    }

}

Results

7. Links

https://en.wikipedia.org/wiki/Cathode

https://en.wikipedia.org/wiki/Anode

https://pi4j.com/1.2/index.html

https://github.com/Pi4J/pi4j