Maven vs ZIP

[MysDevLop]

I d/l the OS image and flashed the SSD card, and it runs on the Raspberry PI.

I now want to develop an application to light up an LED strip. So I need the library.

The ONLY way I can get the library is via a Maven .POM file.

I do not want to use Maven. I know that Eclipse has Maven, but I have never needed to use Maven, and I don't expect needing it in the future. Maven would be a one-time learning curve for me.

Would it be possible for the files to be put in a ZIP file? I can d/l that then expand it into my project. Or a JAR file I can include as an external library?

The alternate is to d/l each file (or copy/paste the code) and create a class, then paste the code into that. Very tedious.

Thanks

[taartspi]

https://pi4j.com/about/new-in-v2/ leads to https://pi4j.com/about/download/

You can find the zip files here. I think these should satisfy your eclipse IDE. Tom

[FDelporte]

Another alternative approach if you don't want to use Maven: JBang
https://pi4j.com/examples/jbang/jbang_minimal_example/

[MysDevLop]

Thanks for the response.

Ok, I d/l the libraries. I also need the code for the LEDStrip, so I followed the link from https://pi4j.com/examples/components/ledstrip/ to https://github.com/Pi4J/pi4j-example-components/tree/main/src/main/java/com/pi4j/catalog which I d/l.

The catalog has many errors because of missing classes such as:
import com.pi4j.plugin.mock.provider.spi.MockSpi"
import picocli.CommandLine;
import picocli.CommandLine.Command;
import picocli.CommandLine.Model.CommandSpec;

Also a compiler directive:
@command(name = "Raspberry Pi Example Launcher", version = "1.0.0", mixinStandardHelpOptions = true)
is unknown

And so on. Right now I have 144 errors and 25 warnings in the project.

I understand that this project is written and maintained, and believe me I greatly appreciate the effort.

I am simply trying to connect one or more LED strips to a Raspberry PI 4. I guess I was hoping for an integrated single .jar (with JavaDoc) which could be included in my project, holding all the required classes to light an LED Strip

Thanks

[FDelporte]

Honestly, LED strips are difficult to control from a Linux system as they require very strict timings. In such cases, a microcontroller is more suitable like Arduino, ESP32, Raspberry Pi Pico,...

That's why I researched an alternative approach to still be able to do this from Java, with a separate LED board that can be controlled with another protocol. For instance, the Pixelblaze has serial communication. See https://pi4j.com/examples/jbang/pixelblaze_output_expander/

[MysDevLop]

I've used arduino, in fact they have a very good library known as FastLED. However I am planning to have up to 32 strings of 120 LED lights, and an arduino simply does not have the memory to hold that many LEDs. Each string would go out in turn, so no concurrent processing. Um, I'm using two 16 channel multiplexers, since I know the PI only has two pins suitable for LED strings.

To get around the timing issue, I could break up each string into smaller array sizes, then send out each piece one after another. So for a 120 LED string, I could send 6 sets of 20. Since the information propagates down the string, this should work, and the short burst of sending also should stay within the timings. Or smaller chunks. The PI would be dedicated to only servicing the LED strips, so a minimum of background processes.

Any idea where I can get the missing imports?

[taartspi]

I think both Frank and I thought you wanted single LED operation not WSxxxx led strip or we might have spoken more about timing in the earlier posts. Include files: In those example components you would look into the POM file to see what libraries are needed and what repositories to search. I think that would be a frustrating exercise, just use MAVEN. But back to the timing concerns It is not CPU load but the critical timing of the data sent to the LED strip. I have not used the example component and so I do not know its reliability in controlling the LED strip.

[taartspi]

I did a Neopixel https://github.com/taartspi/pi4j-example-devices/tree/master/src/main/java/com/pi4j/devices/neopixel94v implementation as more of an experiment/exercise. In the readme I document PI firmware modifications to force all peripherals to run at a slower but consistent speed. Doing this and scoping the SPI traffic the data timing looked correct. But making this change lowered the overall PI performance, not drastic, but I did not execute real performance benchmarks. And as this was an experiment I do not intend to further develop my device implementation. All that said, although we like to see the pi4j code in use by various applications, for consistent operation you may end up off loading the actual bit stream transmission to an external device, as Frank mentioned.

[FDelporte]

This is a video from the Pixelblaze creators who did a test with large quantities of data via serial in Java. So that could be a solution for your use case?

IMG_0022_small.mov

[MysDevLop]

Interesting video.

I am not just outputting a light show. I am gathering information from other devices, processing it, then showing the results via an LED strip.

To use another device to drive the LED strip, I would need to add communication between the PI and the device. This adds not only complexity, but also the number of devices required.

I only update each LED strip every two seconds.

Is the timing issue keeping up with a light show, or simply sending RGB to the strip? If it's the light show, then it should work.

At any rate, I have gone through the code path which sends the colors to the LED strip and I should be able to make it work. I have everything in place, so just need to finish putting it together.

Once I have it working, I can reply with the github link to the project, if you are interested?

[FDelporte]

Always interested in projects and code with Pi4J implementations!!!

[MysDevLop]

You have the refresh rate hard coded into the LEDStrip code. I am allowing the user to choose which LED strip type they are using. So I have an enum for the strip type. You can incorporate it into your distribution if you want.

The values are from https://github.com/FastLED/FastLED/wiki/Chipset-reference

The Pulse Width Modulation rate is in the referenced doc, so I have included it, though I don't think you are using it.

I have the amperage draw for when the user specifies the length of the string, I can give them an indication of how much of a power supply they would need.

The Convert.toFileKey() removes spaces and changes to lower case. The EnumNotFoundException creates a message showing the class name, and the unknown key.

I did a stint at IBM, and they (at that time) were using the prefix "iv" for instance variables, "cv" for class variables, and no prefix for block variables. That habit has stuck with me and I find it vastly easier to know where the variable belongs.

/**
 * These are known LED chip types, and their specifications.<br>
 * <br>
 * The list and values are copied from:<br>
 * &nbsp;&nbsp;&nbsp;<b><a href=
 * "https://github.com/FastLED/FastLED/wiki/Chipset-reference">https://github.com/FastLED/FastLED/wiki/Chipset-reference</a></b>
 */
public enum LEDChipType
{
    // the ones which are commented out have an unknown refresh or pwm rate, so later
    // these are persisted, so only add to the list

    APA102_DOTSTAR("APA102/ DOTSTAR", 24_000_000, 20_000, 0.9f),
    // LPD1886("LPD1886", 0, 0),
    LPD8806("LPD8806", 10_000_000, 4_000, 0.0f),
    P9813("P9813", 15_000_000, 4_500, 0.0f),
    // SM16716("SM16716", 0, 0, 0.0f),
    // TLC5940("TLC5940", 0, 0, 0.0f),
    // TLC5947("TLC5947", 0, 0, 0.0f),
    // TLS3001("TLS3001", 0, 0, 0.0f),
    TM1803("TM1803", 400_000, 400, 0.6f),
    TM1804("TM1804", 800_000, 400, 0.6f),
    TM1809_TM1812("TM1809/ TM1812", 800_000, 400, 0.6f),
    TM1829("TM1829", 800_000, 7_000, 6.0f),
    // UCS1903("UCS1903", 400_000, 0, 0.0f),
    // UCS2903("UCS2903", 800_000, 0, 0.0f),
    WS2801("WS2801", 1_000_000, 2_500, 60.0f),
    WS2811("WS2811", 800_000, 400, 5.0f),
    WS2812B_NEOPIXEL("WS2812B/ NEOPIXEL", 800_000, 400, 5.0f);

    private String               ivFileKey;
    private String               ivUserName;

    private int                  ivRefreshRate;
    private int                  ivPWMRate;
    private float                ivMilliAmperage;

    private static LEDChipType[] cvSorted = null;

    private LEDChipType( String key, int refreshRate, int pwmRate, float amperage )
    {
        ivUserName      = key;
        ivFileKey       = Convert.toFileKey( key );

        ivRefreshRate   = refreshRate;
        ivPWMRate       = pwmRate;
        ivMilliAmperage = amperage;
    }

    /**
     * This is the key to be used when persisting the LED type
     */
    public String getFileKey()
    {
        return ivFileKey;
    }

    /**
     * The friendly name presented to the user
     */
    public String getUserName()
    {
        return ivUserName;
    }

    /**
     * The LED chip refresh rate
     */
    public int getRefreshRate()
    {
        return ivRefreshRate;
    }

    /**
     * The LED chip Pulse Width Modulation rate
      */
    public int getPWMRate()
    {
        return ivPWMRate;
    }

    /**
    * The amperage draw of an individual LED in milliamps, or 0.0 if unknown
    */
    public float getMilliAmperage()
    {
        return ivMilliAmperage;
    }

    /**
     * Returns an array of LED Chip types sorted by the user name
     */
    public static LEDChipType[] getSorted()
    {
        if (cvSorted == null)
        {
            TreeMap<String, LEDChipType> sorted = new TreeMap<String, LEDChipType>();

            for (LEDChipType ledChipType : LEDChipType.values())
                sorted.put( ledChipType.getUserName(), ledChipType );

            cvSorted = sorted.values().toArray( new LEDChipType[sorted.size()] );
        }

        return cvSorted;
    }

    /**
     * Returns the LEDChipType for the given lookup key
     */
    public static LEDChipType getLEDChipType( String key ) throws EnumNotFoundException
    {
        if (key != null)
        {
            key = Convert.toFileKey( key );

            for (LEDChipType type : LEDChipType.values())
                if (type.getFileKey().equals( key ))
                    return type;
        }

        throw new EnumNotFoundException( LEDChipType.class.getName(), key );
    } 
}

[MysDevLop]

Just am going through the PI 4 pins. And what do I find, there is a lot of nomenclature. Also physical pin numbers don't correspond with internal PI4 pin numbers.

Sigh

Ok, here are three more enums if you want them. They are related, so add one, add all :-)

I did these because I hate hard-coded values. Plus the internal pin number is what I set, yet I show the physical pin number to the user for connection.

public enum PI4_PinOut
{
   // keep in order of physical pin, to make sure we don't miss any

    VOLTS_3_3_1(1, -1, "3.3 Volts Power, Pin 1", PI4_PinFunction.POWER_3_3, PI4_PinType.POWER),
    VOLTS_5_2(2, -1, "5 Volts Power, Pin 2", PI4_PinFunction.POWER_5, PI4_PinType.POWER),
    GPIO_2(3, 2, "GPIO 2", PI4_PinFunction.SDA, PI4_PinType.GPIO),
    VOLTS_5_4(4, -1, "5 Volts Power, Pin 4", PI4_PinFunction.POWER_5, PI4_PinType.POWER),
    GPIO_3(5, 3, "GPIO 3", PI4_PinFunction.SCL, PI4_PinType.GPIO),
    GROUND_6(6, -1, "Ground Pin 6", PI4_PinFunction.GROUND, PI4_PinType.GROUND),
    GPIO_4(7, 4, "GPIO 4", PI4_PinFunction.CLOCK, PI4_PinType.GPIO),
    GPIO_14(8, 14, "GPIO 14", PI4_PinFunction.TXD, PI4_PinType.GPIO),
    GROUND_9(9, -1, "Ground Pin 9", PI4_PinFunction.GROUND, PI4_PinType.GROUND),
    GPIO_15(10, 15, "GPIO 15", PI4_PinFunction.RXD, PI4_PinType.GPIO),
    GPIO_17(11, 17, "GPIO 17", PI4_PinFunction.NONE, PI4_PinType.GPIO),
    GPIO_18(12, 18, "GPIO 18", PI4_PinFunction.PCM, PI4_PinType.GPIO),
    GPIO_27(13, 27, "GPIO 27", PI4_PinFunction.NONE, PI4_PinType.GPIO),
    GROUND_14(14, -1, "Ground Pin 14", PI4_PinFunction.GROUND, PI4_PinType.GROUND),
    GPIO_22(15, 22, "GPIO 22", PI4_PinFunction.NONE, PI4_PinType.GPIO),
    GPIO_23(16, 23, "GPIO 23", PI4_PinFunction.NONE, PI4_PinType.GPIO),
    VOLTS_3_3_17(17, -1, "3.3 Volts Power, Pin 17", PI4_PinFunction.POWER_3_3, PI4_PinType.POWER),
    GPIO_24(18, 24, "GPIO 24", PI4_PinFunction.NONE, PI4_PinType.GPIO),
    GPIO_10(19, 10, "GPIO 10", PI4_PinFunction.MOSI, PI4_PinType.GPIO),
    GROUND_20(20, -1, "Ground Pin 14", PI4_PinFunction.GROUND, PI4_PinType.GROUND),
    GPIO_9(21, 9, "GPIO 9", PI4_PinFunction.MISO, PI4_PinType.GPIO),
    GPIO_25(22, 25, "GPIO 25", PI4_PinFunction.NONE, PI4_PinType.GPIO),
    GPIO_11(23, 11, "GPIO 11", PI4_PinFunction.SCLK, PI4_PinType.GPIO),
    GPIO_8(24, 8, "GPIO 8", PI4_PinFunction.CE, PI4_PinType.GPIO),
    GROUND_25(25, -1, "Ground Pin 25", PI4_PinFunction.GROUND, PI4_PinType.GROUND),
    GPIO_7(26, 7, "GPIO 7", PI4_PinFunction.CE, PI4_PinType.GPIO),
    GPIO_0(27, 0, "GPIO 0", PI4_PinFunction.EEPROM, PI4_PinType.GPIO),
    GPIO_1(28, 1, "GPIO 1", PI4_PinFunction.EEPROM, PI4_PinType.GPIO),
    GPIO_5(29, 5, "GPIO 5", PI4_PinFunction.NONE, PI4_PinType.GPIO),
    GROUND_30(30, -1, "Ground Pin 30", PI4_PinFunction.GROUND, PI4_PinType.GROUND),
    GPIO_6(31, 6, "GPIO 6", PI4_PinFunction.NONE, PI4_PinType.GPIO),
    GPIO_12(32, 12, "GPIO 12", PI4_PinFunction.PMW, PI4_PinType.GPIO),
    GPIO_13(33, 13, "GPIO 13", PI4_PinFunction.PMW, PI4_PinType.GPIO),
    GROUND_34(34, -1, "Ground Pin 34", PI4_PinFunction.GROUND, PI4_PinType.GROUND),
    GPIO_19(35, 19, "GPIO 19", PI4_PinFunction.PCM, PI4_PinType.GPIO),
    GPIO_16(36, 16, "GPIO 16", PI4_PinFunction.NONE, PI4_PinType.GPIO),
    GPIO_26(37, 26, "GPIO 26", PI4_PinFunction.NONE, PI4_PinType.GPIO),
    GPIO_20(38, 20, "GPIO 20", PI4_PinFunction.PCM, PI4_PinType.GPIO),
    GROUND_39(39, -1, "Ground Pin 39", PI4_PinFunction.GROUND, PI4_PinType.GROUND),
    GPIO_21(40, 21, "GPIO 21", PI4_PinFunction.PCM, PI4_PinType.GPIO);

    private int             ivPhysicalPin;
    private int             ivInternalPin;
    private String          ivName;
    private PI4_PinFunction ivPI4_PinFunction;
    private PI4_PinType     ivPI4_PinType;

    private PI4_PinOut( int physicalPin, int internalPin, String name, PI4_PinFunction function, PI4_PinType type )
    {
        ivPhysicalPin     = physicalPin;
        ivInternalPin     = internalPin;
        ivName            = name;
        ivPI4_PinFunction = function;
        ivPI4_PinType     = type;
    }

    public String getName()
    {
        return ivName;
    }

    public int getPhysicalPin()
    {
        return ivPhysicalPin;
    }

    public int getInternalPin()
    {
        return ivInternalPin;
    }

    public PI4_PinFunction getPI4_PinFunction()
    {
        return ivPI4_PinFunction;
    }

    public PI4_PinType getPI4_PinType()
    {
        return ivPI4_PinType;
    }

    @Override
    public String toString()
    {
        return ivName;
    }
}

public enum PI4_PinFunction
{
    POWER_3_3("Power 3.3", "Power 3.3 Volts"),
    POWER_5("Power 5", "Power 5 Volts"),

    GROUND("Ground", "Ground"),

    CE("CE", "Chip Enable"),
    CLOCK("GPCLK", "General Purpose Clock"),
    EEPROM("EEPROM", "EEPROM Communication"),
    MISO("MOSI", "Master In Slave Out"),
    MOSI("MOSI", "Master Out Slave In"),
    PCM("PCM", "Pulse-code Modulation"),
    PMW("PMW", "Pulse Wave Modulation"),
    RXD("RXD", "Receive Data"),
    SCL("SDA", "Serial Clock Line"),
    SCLK("SCLK", "Chip Select Clock"),
    SDA("SDA", "Serial Data Line"),
    TXD("TXD", "Transmit Data"),

    NONE("None", "No Designation");

    private String ivFunctionCode;
    private String ivFunctionName;

    private PI4_PinFunction( String functionCode, String functionName )
    {
        ivFunctionCode = functionCode;
        ivFunctionName = functionName;
    }

    public String getFunctionCode()
    {
        return ivFunctionCode;
    }

    public String getFunctionName()
    {
        return ivFunctionName;
    }
}

public enum PI4_PinType
{
    GPIO("General Purpose Input/Output"),
    POWER("Power "),
    GROUND(" Ground");

    private String ivName;

    private PI4_PinType( String name )
    {
        ivName = name;
    }

    public String getName()
    {
        return ivName;
    }
}

[FDelporte]

Hi @MysDevLop , you are right pin numbers are very confusing, you have a physical (=logical) number, a BCM number, and Pi4J V1 was using the WiringPi number which dates to the very first Raspberry Pi's and is again different ;-)

I created a separate library to "document" Pi versions and the pins, e.g. here https://github.com/Pi4J/pi4j-board-info/blob/main/src/main/java/com/pi4j/boardinfo/definition/HeaderPins.java

It's used as the "database" for https://api.pi4j.com/.
I'll check if I can further improve this with some ideas of your enums. Thanks!