Hoofdstuk 5 RGB-LED

In dit hoofdstuk leren we hoe u een RGB-LED kunt besturen.
Een RGB-LED heeft 3 LED’s geïntegreerd in één LED-component. Het kan respectievelijk rood, groen en blauw uitstralen licht.
Om dit te doen, heeft het 4 pinnen nodig (zo identificeer je het ook).
De lange pin (1) is de gemeenschappelijk dat is de anode (+) of positieve draad, de andere 3 zijn de kathodes (-) of negatieve draden.
Een weergave van een RGB-LED en het elektronische symbool ervan worden hieronder weergegeven.
Wij kunnen RGB-LED’s verschillende kleuren licht laten uitstralen en helderheid door het regelen van de 3 kathoden (2, 3 en 4) van de RGB-LE

Code Pyton

#!/usr/bin/env python3
########################################################################
# Filename    : ColorfulLED.py
# Description : Random color change ColorfulLED
# Author      : www.freenove.com
# modification: 2023/05/11
########################################################################
from gpiozero import RGBLED
import time
import random

#led = RGBLED(red="J8:11", green="J8:12", blue="J8:13", active_high=False) # define the pins for R:11,G:12,B:13
led = RGBLED(red=17, green=18, blue=27, active_high=False) # define the pins for R:GPIO17,G:GPIO18,B:GPIO27 
# If your RGBLED is a common cathode LED, set active_high to True

def setColor(r_val,g_val,b_val):      # change duty cycle for three pins to r_val,g_val,b_val
    led.red=r_val/100                 # change pwmRed duty cycle to r_val
    led.green = g_val/100             # change pwmRed duty cycle to r_val
    led.blue = b_val/100              # change pwmRed duty cycle to r_val

def loop():
    while True :
        r=random.randint(0,100)  #get a random in (0,100)
        g=random.randint(0,100)
        b=random.randint(0,100)
        setColor(r,g,b)          #set random as a duty cycle value 
        print ('r=%d, g=%d, b=%d ' %(r ,g, b))
        time.sleep(1)
        
def destroy():
    led.close()

if __name__ == '__main__':     # Program entrance
    print ('Program is starting ... ')
    try:
        loop()
    except KeyboardInterrupt:  # Press ctrl-c to end the program.
        destroy()
        print("Ending program")

Code RainbowLED.java (Controleer als de code niet werkt Geany Configuration.)

///usr/bin/env jbang "$0" "$@" ; exit $?

//DEPS org.slf4j:slf4j-api:2.0.12
//DEPS org.slf4j:slf4j-simple:2.0.12
//DEPS com.pi4j:pi4j-core:2.6.0
//DEPS com.pi4j:pi4j-plugin-raspberrypi:2.6.0
//DEPS com.pi4j:pi4j-plugin-gpiod:2.6.0

import com.pi4j.Pi4J;  
import com.pi4j.context.Context;  
import com.pi4j.io.gpio.digital.DigitalOutput;  
import com.pi4j.util.Console;
import java.util.HashMap;  
import java.util.Map;  
import java.util.Random; 

class PWMController implements Runnable {  
    private DigitalOutput pwm;  
	private int pwmFrequency;
	private double pwmDutyCycle;
    private boolean running = true;  
	private long period;  
	private long highTime;  
	private long lowTime;  
	
    public PWMController(DigitalOutput pwm) {  
        this.pwm = pwm;  
		this.pwmFrequency = 1000;
		this.pwmDutyCycle = 0.5;
		this.period = (int) (1000000 / pwmFrequency);  
		this.highTime = (int) (period * pwmDutyCycle);  
		this.lowTime = (int) (period - highTime);  
    }  
  
    @Override  
    public void run() {  
        while (running) {  
            if(highTime!=0){
				pwm.high();  
				delayUs(highTime); 
			}			
			if(lowTime!=0){
				pwm.low();  
				delayUs(lowTime);  
			} 		
        }  
    }  
  
	public void setPwmFrequency(int frequency) {  
        if(frequency!=0){
			this.pwmFrequency = frequency;
			this.period = (int) (1000000 / pwmFrequency);  
			this.highTime = (int) (period * pwmDutyCycle);  
			this.lowTime = (int) (period - highTime); 
		}
		else{
			this.pwmFrequency = 0;
			this.period = (int) (1000);  
			this.highTime = (int) (0);  
			this.lowTime = (int) (period - highTime); 
		}
    }  
	
	public void setPwmDutyCycle(double dutyCycle) {  
        this.pwmDutyCycle = dutyCycle;
		this.highTime = (int) (period * pwmDutyCycle);  
		this.lowTime = (int) (period - highTime); 
    } 

    private void delayUs(long us) {  
        long startTime = System.nanoTime();  
        long endTime = startTime + (us * 1000);  
        while (System.nanoTime() < endTime) {  
        }  
    }  
  
    public void requestStop() {  
        running = false;  
    }  
}

public class RainbowLED {  
    private static final Context pi4j = Pi4J.newAutoContext();  
    private static final Map<Integer, PWMController> pwmControllers = new HashMap<>();  
	
	public static void setPwmConfig(int pin) throws Exception {  
        DigitalOutput led = pi4j.dout().create(pin);  
        PWMController pwmController = new PWMController(led);  
        Thread pwmThread = new Thread(pwmController, "PWM LED Controller " + pin);  
        pwmControllers.put(pin, pwmController);  
        pwmThread.start();  
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {  
            pwmController.requestStop();  
            try {  
                pwmThread.join();  
            } catch (InterruptedException e) {  
                Thread.currentThread().interrupt();  
            }  
        }));  
    } 
	
	public static void ledSetup(int[] pins) {  
        for (int pin : pins) {  
            try {  
                setPwmConfig(pin);  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
        }  
    } 
	
	public static void setLedColor(int[] pins, int r, int g, int b) {  
        if (pins.length >= 3) {  
            PWMController red = pwmControllers.get(pins[0]);  
            PWMController green = pwmControllers.get(pins[1]);  
            PWMController blue = pwmControllers.get(pins[2]);  
            if (red != null) red.setPwmDutyCycle((double) r / 100.0);  
            if (green != null) green.setPwmDutyCycle((double) g / 100.0);  
            if (blue != null) blue.setPwmDutyCycle((double) b / 100.0);  
        }  
    } 
	
    public static void main(String[] args) throws Exception {  
		final var console = new Console();
		int[] LED_PINS = {17, 18, 27}; 
		Random random = new Random();	
		
        try {  
			ledSetup(LED_PINS);
			while (true) {  
				int red = random.nextInt(101);  
				int green = random.nextInt(101);  
				int blue = random.nextInt(101);  
				console.println("R:%d  G:%d, B:%d", red, green, blue);
				setLedColor(LED_PINS, red, green, blue);
				Thread.sleep(500);
			}  
        }  
		finally {  
            for (PWMController controller : pwmControllers.values()) {  
                controller.requestStop();  
            }  
            pi4j.shutdown();  
        }  
    }  
}