Spi in pi4j Bibliothek

matze86

Aktives Mitglied
Hallo liebes Forum, das ist mein 1. Beitrag.
Ich lerne gerade neben der Arbeit als Fernstudium Informatiker und da bin ich gerade bei Java angekommen als Schwerpunkt.
Vorher hatte ich mir Python angeeignet (was mir sehr geholfen hat, denn da weiß man schon viele Strukturen in der Programmierung).

Jetzt möchte ich neben den Java lernen vom Fernstudium auch etwas als "Hobby" üben. Das heißt ich möchte mein erworbenes Wissen nutzen und mir NACH UND NACH etwas selbst schreiben.
Ich habe einen Raspberry 4. Angeschlossen eine Matrix 8x8. Die möchte ich ansteuern. Das Datenblatt habe ich da.
Jetzt muss ich das Modul Spi damit ich Zugriff auf das SPI des Raspi zur Matrix habe.

Jetzt stellt sich mir die Frage, was alles aus dem Modul benötigt wird.
Habe schon Vorschläge im Netzt gefunden, aber bin noch nicht richtig schlau geworden.
Auf der API-Seite gibt es SpiDevice, SpiFactory, SpiChannel und SpiMode.
Was benötige ich, damit ich auf die Matrix eine LED zum leuchten bringen kann?
Gruß
 

Oneixee5

Bekanntes Mitglied

matze86

Aktives Mitglied
OK danke, habe hier ein Example gefunden, ist gut erklärt, nur mit verschiedenen Anweisungen weiß ich noch nicht bescheid, das werde ich demnächst bei der Durcharbeitung der Schulung erfahren.
 

matze86

Aktives Mitglied
Vielen dank für die Hilfe. Habe mir das ganze mal genau angeschaut.
Hier ist das Datenblatt der Matrix auf Seite 6.
Heißt bei
Spi.write(command, data)
wird bei 'command' der Befehl aus Seite 6 genommen z.b. Intensity für Heligkeit wird die Hex 0xA als command geschrieben und als Helligkeitsstufe 0-15 in byte. Also so: Spi.write((byte) 0xA, (byte) 15) richtig?
 

matze86

Aktives Mitglied
2. Reihe, 5. LED... das wäre bei der dritten Ziffer die LED links oben (lt. Tabelle 6 Segment F)? Wenn Decode Mode aus ist (0x09, 0x00), dann würde ich sagen, dass das 0x03, 0x02 wäre.
Ich bin von Tabelle 2 ausgegangen, das z.B. Digit 1 (0x01) der Befehl für die 2. Reihe ist.
Ist denn die Tabelle 6 nicht für 7-Segment gedacht?
 

mihe7

Top Contributor
Wie kommst du bei 5. Spalte auf 0x10?

Aus dem Code:

Java:
            for (int onColumn = 0; onColumn < 8; onColumn++) {
                for (int row = 1; row <= 8; row++) {
                    spi.write((byte) row, (byte) (1 << (8 - onColumn)));
                }
                System.out.println("Col " + onColumn + " is on");
                Thread.sleep(waitBetween);
            }
Je nachdem, ob man von 0 oder 1 aus zählt, gilt für die 5. Spalte ja onColumn == 4 oder onColumn == 5 und dem entsprechend 8 - onColumn entweder 4 oder 3.

1 << 4 wäre 16 (0x10)
1 << 3 dagegen 8 (0x08)
 

matze86

Aktives Mitglied
OK so kompliziert, ich dachte spalte 1 0x01, Spalte 2 0x02 us.w.

Also wenn man die die Spalte 4 z.B. ansteuern möchte , dann muss man 8 - 4 = 4. dann wird die Binäre 1 um 4 Stellen (durch <<) nach links verschoben und bekommt als Ergebnis 10000 in binär also 0x10 in Hex.
Warum so kompliziert?
Kann man so aus dem Datenblatt nicht heraus lesen.
Und die Digit 0 bis Digit 7 sind dann die commands derReihen? Digit 0 1. Reihe u.s.w.?
 

mihe7

Top Contributor
Warum so kompliziert?
Weil Du mit den Daten einfach nur Leitungen schaltest. Die Bits D7-D0 entsprechen den Segmentleitungen: "When no-decode is selected, data bits D7–D0 correspond to the segment lines of the MAX7219/MAX7221" Die genaue Berechnung hängt also damit zusammen, wie das Ding mit der Anzeige verdrahtet ist.
 

matze86

Aktives Mitglied
Ich habe die Matrix mal Test-weise angeschlossen, mit Python getestet und es funzt, das heißt richtig angeschlossen.

Jetzt mal mit den Vorschlags Beispiel Programm getestet, aber kein Erfolg. Kommt immer Fehlermeldung.

Hier mal mein Code:
Java:
import com.pi4j.io.spi.SpiChannel;
import com.pi4j.io.spi.SpiDevice;
import com.pi4j.io.spi.SpiFactory;
import com.pi4j.util.Console;
import com.pi4j.io.spi.*;
import java.io.IOException;

    
import java.util.Random;

public class testraspi {
    public static void main(String[] args) {
        showCols(SpiDevice,1000);
    }
    


        /**
         * Highlight all rows one by one.
         *
         * @param spi SpiDevice
         * @param waitBetween Number of milliseconds to wait between every row output
         */
        public static void showRows(SpiDevice spi, int waitBetween) {
            try {
                for (int onRow = 1; onRow <= 8; onRow++) {
                    for (int row = 1; row <= 8; row++) {
                        spi.write((byte) row, (onRow == row ? (byte) 0xff : (byte) 0x00));
                    }
                    System.out.println("Row " + onRow + " is on");
                    Thread.sleep(waitBetween);
                }
            } catch (Exception ex) {
                System.err.println("Error during row demo: " + ex.getMessage());
            }
        }

        /**
         * Highlight all columns one by one.
         *
         * @param spi SpiDevice
         * @param waitBetween Number of milliseconds to wait between every column output
         */
        public static void showCols(SpiDevice spi, int waitBetween) {
            try {
                for (int onColumn = 0; onColumn < 8; onColumn++) {
                    for (int row = 1; row <= 8; row++) {
                        spi.write((byte) row, (byte) (1 << (8 - onColumn)));
                    }
                    System.out.println("Col " + onColumn + " is on");
                    Thread.sleep(waitBetween);
                }
            } catch (Exception ex) {
                System.err.println("Error during column demo: " + ex.getMessage());
            }
        }

        /**
         * Demo mode which generates specified number of cycles of random enabled LEDs.
         *
         * @param spi SpiDevice
         * @param numberOfLoops Number of random outputs to be generated
         * @param waitBetween Number of milliseconds to wait between random screens
         */
        public static void showRandomOutput(SpiDevice spi, int numberOfLoops, int waitBetween) {
            try {
                Random r = new Random();
                int min = 0;
                int max = 255;

                for (int loop = 1; loop <= numberOfLoops; loop++) {
                    for (int row = 1; row <= 8; row++) {
                        spi.write((byte) row, (byte) (r.nextInt((max - min) + 1) + min));
                    }
                    System.out.println("Random effect " + loop);
                    Thread.sleep(waitBetween);
                }
            } catch (Exception ex) {
                System.err.println("Error during random demo: " + ex.getMessage());
            }
        }
    }


Jetzt kommt im Terminal die Fehlerausgabe
estraspi.java:13: error: cannot find symbol showCols(SpiDevice,1000); ^ symbol: variable SpiDevice location: class testraspi 1 error

Was mache ich verkehrt?
 

mihe7

Top Contributor
SpiDevice ist eine Klasse, Du brauchst eine Instanz dieser Klasse. Beispielcode dazu findest Du in https://github.com/FDelporte/JavaOn.../src/main/java/be/webtechie/pi4jgpio/App.java in Zeilen 21-23:
Java:
            SpiDevice spi = SpiFactory.getInstance(SpiChannel.CS0,
                    SpiDevice.DEFAULT_SPI_SPEED, // default spi speed 1 MHz
                    SpiDevice.DEFAULT_SPI_MODE); // default spi mode 0
Dann müsstest Du den Aufruf von showCols noch zu
Java:
showCols(spi, 1000);
ändern.
 

matze86

Aktives Mitglied
Jetzt habe ich es soweit am laufen. Jetzt kann ich die einzelnen LED extra ansteuern.
Man muss
Java:
spi.write((byte) 2, (byte) 64);
eingeben, dann leuchtet von der 2. Reihe, das 2. LED. 128 wäre dann das 1. LED.
Es wird also (1 << (8 - LED)) von Binär ins duale System umgerechnet. Das wusste ich nicht.
Jetzt frage ich mich nur, wie ich diese 7-Segment angezeigt bekomme. Habe schon von Decode Modus 01 bis FF alles durchgespielt. In Tabelle 5 ist alles beschrieben, nur ich bekomme nix drauf.

Edit: was ich noch nicht wusste, wenn man ein Modus setzt, der bleibt so lange erhalten bis man ihn überschreibt.
Die LED aus bekomme ich, wenn ich
Java:
spi.write((byte) Reihe, (byte) 0)
setze. Hoffe das ist ok so.
 

mihe7

Top Contributor
dann leuchtet von der 2. Reihe, das 2. LED. 128 wäre dann das 1. LED.
Es wird also (1 << (8 - LED)) von Binär ins duale System umgerechnet. Das wusste ich nicht.
Genau, das hat den Hintergrund, dass Du per OR-Verknüpfung (hier: einfache Addition) mehrere LEDs leuchten lassen kannst. Die 1. und 2. LED wären dann 192. Ausschalten geht genauso nur andersrum. Man setzt und löscht einzelne Bit und jedes Bit steht für eine LED.
 

matze86

Aktives Mitglied
Also müsste ich zum ausschalten nochmal
Java:
spi.write((byte) 2, (byte) 64);
schreiben damit es aus geht?

Ich dachte, Du hast ein Matrix-Display, eine 7-Segment-Anzeige ist was anderes.
In der Beschreibung bzw im Datenblatt steht etwas von der 7-Segment Anzeige. Ja ich habe eine Matrix mit 8x8 und 8x32.
Da dachte ich es geht da auch.

Ich habe mir jetzt ein Raspi 4 zugelegt, da hoffe ich direkt über Eclipse programmieren zu können.
Ich habe viele Sensoren etc.
Da kann ich neben meiner Fernschule noch schön üben und das macht auch Spaß.
Wenn man Spaß hat fällt es auch leichter.

Ich werde nach und nach den Code schreiben. Mit vielen Modulen und und und.
 

mihe7

Top Contributor
Also müsste ich zum ausschalten nochmal
Nein.

1286432168421
11000000
10000000
10100000

1. Zeile: 128+64 = 192 = 1. und 2. LED an, alle anderen aus.
2. Zeile: 128 = 1. LED an, alle anderen aus.
3. Zeile: 128+32 = 160 = 1. und 3. LED an, alle anderen aus.
Willst Du jetzt die 1. LED ausschalten, muss die 128 "weg", bleiben 32 übrig.
 

matze86

Aktives Mitglied
Nein.

1286432168421
11000000
10000000
10100000

1. Zeile: 128+64 = 192 = 1. und 2. LED an, alle anderen aus.
2. Zeile: 128 = 1. LED an, alle anderen aus.
3. Zeile: 128+32 = 160 = 1. und 3. LED an, alle anderen aus.
Willst Du jetzt die 1. LED ausschalten, muss die 128 "weg", bleiben 32 übrig.
Genau, das habe ich jetzt getestet. Und es funktioniert.
Da muss ich später mal sehen wie das mit der Laufschrift wird.

Entweder alle Reihen löschen und um 1 LED verschieben, oder ich mache ne große Berechnung.
 

matze86

Aktives Mitglied
Jetzt habe ich mal die Matrix mit 4 Elementen angeschlossen nachdem das alles mit der einfachen 8x8 geht. Da geht nur die 1. Reihe.
Beim Test (0x0F, 0x01) geht alles.
Im Datenblatt steht dass man den No-Op (0x00) schreiben muss wegen Kaskadierung. Was ist da der Datensatz?
Bekomme das aus den Datenblatt leider nicht gelesen.
Ich dachte man hat dann 4 Reihen mit 32 LED Spalten und kann sie so ansteuern?
 

mihe7

Top Contributor
Im Datenblatt steht dass man den No-Op (0x00) schreiben muss wegen Kaskadierung. Was ist da der Datensatz?
"to write to the fourth chip, sent the desired 16-bit word, followed by three no-op codes (hex 0xX0XX, see Table 2)"

Heißt für mich:

1. Reihe und anzusteuernde LEDs
2. Für den ersten Chip/die erste Matrix keinen no-op, für den zweiten einen, für den dritten zwei und für den vierten drei.

Kann sein, dass Du das mit einem write erledigen musst, also z. B. spi.write(2, 128, 0, 0, 0, 0, 0, 0), um 2. Reihe, 1. LED in der 4. Matrix.
 

matze86

Aktives Mitglied
Das funktioniert leider nicht, habe auch
Java:
spi.write((byte) 0x00, (byte) 0x000);
getestet. Leider nix.

Und wenn ich alles weg lasse, dann geht auch nur immer die 1. Reihe. Vielleicht ist das Ding kaputt.
 

matze86

Aktives Mitglied
Vielleicht falsch verdrahtet?
Nochmal nachgeschaut, alles 1:1 wie es in der Anleitung steht.
Edit: Mit der Einstellung
Java:
spi.write((byte)1, (byte)2, (byte) 0,(byte) 0, (byte) 0, (byte) 0);
brennen jeweils das 2. LED der 1. Reihe der letzten 2 Matrizen (3 und 4).
Jede andere Einstellung
Java:
spi.write((byte)1, (byte)32, (byte) 0,(byte) 0, (byte) 0, (byte) 0);
geht nichts.
 
Zuletzt bearbeitet:

matze86

Aktives Mitglied
Hier mal der ganze Code.
Java:
    public static void main(String[] args) throws IOException{
        SpiDevice spi = SpiFactory.getInstance(SpiChannel.CS0,
        SpiDevice.DEFAULT_SPI_SPEED, // default spi speed 1 MHz
        SpiDevice.DEFAULT_SPI_MODE); // default spi mode 0

        spi.write((byte) 0x0C,(byte) 0x01); //normal mode

        spi.write((byte) 0x09, (byte) 0x00);//decode mode
        spi.write((byte) 0x0F, (byte) 0x00); // test
        spi.write((byte) 0x0B, (byte) 0x031); //scan limit
        try {
        Thread.sleep(1000);
        spi.write((byte)1, (byte)2, (byte) 0,(byte) 0, (byte) 0, (byte) 0);
    
        }
        catch (InterruptedException e) {
            System.out.println("Thread is interrupted");}
        spi.write((byte) 0x0A, (byte) 15);//helligkeit
 

matze86

Aktives Mitglied
Java:
 public static void main(String[] args) throws IOException{
        SpiDevice spi = SpiFactory.getInstance(SpiChannel.CS0,
        SpiDevice.DEFAULT_SPI_SPEED, // default spi speed 1 MHz
        SpiDevice.DEFAULT_SPI_MODE); // default spi mode 0

        spi.write((byte) 0x0C,(byte) 0x01, (byte) 0,(byte) 0, (byte) 0, (byte) 0);/normal mode

        spi.write((byte) 0x09, (byte) 0x00, (byte) 0,(byte) 0, (byte) 0, (byte) 0);/decode mode
        spi.write((byte) 0x0F, (byte) 0x00 , (byte) 0,(byte) 0, (byte) 0, (byte) 0);// test
        spi.write((byte) 0x0B, (byte) 0x031 , (byte) 0,(byte) 0, (byte) 0, (byte) 0);//scan limit
        try {
        Thread.sleep(1000);
        spi.write((byte)1, (byte)2, (byte) 0,(byte) 0, (byte) 0, (byte) 0);
    
        }
        catch (InterruptedException e) {
            System.out.println("Thread is interrupted");}
        spi.write((byte) 0x0A, (byte) 15, (byte) 0,(byte) 0, (byte) 0, (byte) 0);//helligkeit
Brachte leider keine Besserung. Beim Ausführen gehen die letzten 2 Matrizen aus (am Anfang brennen alle).
Oder liegt es daran, dass ich bei DIN, CS und CLK noch keinen level shifter habe?
 

mihe7

Top Contributor
OK, nochmal nachgesehen. Wenn ich es richtig verstehe, dann musst Du einfach immer für jedes Modul 16-Bit senden. Das no-op würde nur dazu dienen, wenn Du einmal nur ein Modul explizit ansprechen willst.

Probier mal etwas wie:
Java:
public class Test {
    private final int modules;
    private final SpiDevice spi;

    public Test(int modules, SpiDevice device) {
        this.modules = modules;
        this.spi = device;
    }

    public void sendCommand(int command, int value) throws IOException {
        byte[] data = new byte[modules*2];
        for (int i = 0; i < modules; i++) {
            data[2*i] = (byte)(command & 0xff);
            data[2*i+1] = (byte)(value & 0xff);
            spi.write(data);
        }
    }

    public static void main(String[] args) throws IOException{
        Test dev = new Test(4, SpiFactory.getInstance(SpiChannel.CS0,
                SpiDevice.DEFAULT_SPI_SPEED, // default spi speed 1 MHz
                SpiDevice.DEFAULT_SPI_MODE)); // default spi mode 0
        dev.sendCommand(0x0c, 0x01);
        dev.sendCommand(0x09, 0x00);
        dev.sendCommand(0x0f, 0x00);
        dev.sendCommand(0x0b, 0x31);

        dev.sendCommand(0x01, 0x02);
    }
}
Dann sollte auf allen vier Modulen die gleiche LED leuchten.
 

matze86

Aktives Mitglied
Also jetzt habe ich die Reihen mal mit 0 beschaltet. Jetzt leuchten nur noch die, die ich schreibe.
Da leuchten auf jeder Matrix die gleichen LED. Das funktioniert schon mal. aber es gehen nur Reihe 1 und 2. ab reihe 3 ist dunkel.
 

mihe7

Top Contributor
Sehr gut. Die Reihen liegen am Scan-Limit (0x0b, 0x31). Gem. Tabelle 8 müsste Du (0x0b, 0x07) schreiben. Auch die Helligkeit habe ich oben im Code nicht eingestellt.
 

matze86

Aktives Mitglied
OK, da muss ich bloß in den Array die Matrix Nummer schreiben bei der Methode sendCommand ohne for Schleife.
Java:
data[2*2] = (byte)(command & 0xff);
data[2*2+1] = (byte)(value & 0xff);

Jetzt geht alles. Vielen dank für die sehr Große Hilfe. Ohne hätte ich es nie hinbekommen.

Jetzt nochmal zu meinen Verständnis:

Was macht das "& 0xff". Wenn ich es auskommentiere geht das Programm normal weiter.

Es muss mindestens 8 Bits vorhanden sein? Darum "modules*2"?

Man übergibt bei Spi.write einen Array mit den Daten von Command und Daten. Das geht einfach so?
 

mihe7

Top Contributor
Was macht das "& 0xff". Wenn ich es auskommentiere geht das Programm normal weiter.
Macht der Gewohnheit... & ist die bitweise AND-Verknüpfung, 0xff ist 255 (der Wert, wenn die ersten 8 Bit auf 1 stehen). Mit & 0xff werden somit vom int (32 Bit) nur die untersten 8 Bit genommen. Macht Java beim Cast aber sowieso.

Es muss mindestens 8 Bits vorhanden sein? Darum "modules*2"?
Ne, das modules*2 ist da, weil pro Modul 2 Byte (Befehl + Wert) benötigt werden.

Man übergibt bei Spi.write einen Array mit den Daten von Command und Daten. Das geht einfach so?
Ja, dafür gibt es eine Methode in SpiDevice.

Ich sehe gerade noch einen Fehler in meinem Code: Das spi.write gehört aus der Schleife raus, d. h. Zeilen 15 und 16 sind oben vertauscht.

Wie kann ich jetzt jede einzelne einstellen? Also das z.B. nur Matrix 3 LED 1 von Reihe 4 brennt?
Am besten ist, Du merkst Dir in der Klasse Test den aktuellen Zustand der LEDs. Dann kannst Du diese dort setzen oder löschen und kannst unabhängig davon die betreffenden Zeilen an die Module übertragen.
 

matze86

Aktives Mitglied
OK. habe es jetzt geschnallt. Für jede Matrix stehen zwei "00". Wenn man Matrix 3 ansteuern will, dann schreibt man 000011 (1. Reihe 1. LED). Man schreibt für jede Matrix 00, die nicht angesteuert werden soll.
noch ein Beispiel: Es sollen Matrix 2 mit der 5. Reihe und 8. LED angesteuert werden soll. Dann schreibt man 00570000.
Jetzt habe ich es verstanden.
Wie gesagt, das Datenblatt hat mir Rätsel gegeben.

Das spi.write gehört aus der Schleife raus, d. h. Zeilen 15 und 16 sind oben vertauscht.
Habe es getauscht.
 

mihe7

Top Contributor
Es sollen Matrix 2 mit der 5. Reihe und 8. LED angesteuert werden soll. Dann schreibt man 00570000.
Jetzt habe ich es verstanden.
Wo kommt die 7 her? Du meinst 0, 0, 5, 1, 0, 0, 0, 0? Das geht. Du kannst auch alle Module auf einmal "bestücken":
5, 1, 5, 1, 5, 1, 5, 1 wäre dann immer die gleiche LED in allen Modulen.

Da schreibt man sich normalerweise Code, damit man schön damit arbeiten kann :)
 

matze86

Aktives Mitglied
Wo kommt die 7 her?
Die kommt vom Befehl (0x05, 0x07).
Da schreibt man sich normalerweise Code, damit man schön damit arbeiten kann
Ja genau, das habe ich vor, sehr schön zum üben und das macht Spaß.
Ich arbeite erst die Kapitel mit Klassen etc. durch, dann lege ich los.

Das mit den blanken Code ist nur für mich zum Verständnis.
Hatte vor einen halben Jahr Dual-, Hex-, Oktaldezimal Systeme gehabt, jetzt eine schöne Auffrischung.
 
Ähnliche Java Themen
  Titel Forum Antworten Datum
D GPIO Nutzung mit Pi4J Library auf Raspberry funktioniert nicht Java Basics - Anfänger-Themen 3
B tar.gz in Eclipse als Bibliothek einbinden Java Basics - Anfänger-Themen 3
G eigene Bibliothek einbinden Java Basics - Anfänger-Themen 1
E Best Practice Jar-file mit zwei Klassen und externer Bibliothek über Konsole erzeugen Java Basics - Anfänger-Themen 13
J App.jar muss im Projekt App als Bibliothek vorhanden sein?! Java Basics - Anfänger-Themen 1
D Bibliothek runterladen Java Basics - Anfänger-Themen 1
H GSON-Bibliothek für eigene Programme benutzen Java Basics - Anfänger-Themen 2
M Java Bibliothek Javadoc not found Java Basics - Anfänger-Themen 1
I Science Bibliothek Java Basics - Anfänger-Themen 3
redcow Java Standard-Bibliothek Java Basics - Anfänger-Themen 3
G eigene Bibliothek in Java importieren Java Basics - Anfänger-Themen 5
L JDK installieren GUI-Bibliothek installieren Java Basics - Anfänger-Themen 4
O Eclipse Bibliothek standardmäßig einbinden Java Basics - Anfänger-Themen 5
M Ist die Hamcrest Bibliothek auch schon in Junit 4.11 verfügbar? Java Basics - Anfänger-Themen 1
C Jar Datei findet Bibliothek nicht Java Basics - Anfänger-Themen 2
B Neue Bibliothek hinzufügen Java Basics - Anfänger-Themen 2
X Clustering-Bibliothek Java Basics - Anfänger-Themen 4
F JAR als bibliothek einbinden Java Basics - Anfänger-Themen 1
S Methode aus Bibliothek ausrufen Java Basics - Anfänger-Themen 2
B JSF Bibliothek Java Basics - Anfänger-Themen 6
A Meine erste Bibliothek erstellen Java Basics - Anfänger-Themen 24
K Bibliothek per "Struktur" anlegen Java Basics - Anfänger-Themen 5
S Externe Bibliothek zu Resources hinzufügen? Java Basics - Anfänger-Themen 5
S Bibliothek in Eclipse einbinden Java Basics - Anfänger-Themen 2
F Klassen Bibliothek erstellen für Anfänger Java Basics - Anfänger-Themen 8
B Snowball Stemmer Bibliothek nutzen Java Basics - Anfänger-Themen 8
I HUMath Bibliothek einbinden?! Java Basics - Anfänger-Themen 4
0 Objekte übers Netzwerk schicken? Bibliothek? Java Basics - Anfänger-Themen 2
T Bibliothek erstellen Java Basics - Anfänger-Themen 4
F Graphen Bibliothek Java Basics - Anfänger-Themen 38
Schandro Externe Bibliothek OHNE IDE benutzen Java Basics - Anfänger-Themen 5
N system-bibliothek bei eclipse einrichten Java Basics - Anfänger-Themen 2
P Bibliothek wie zB. in Flash Java Basics - Anfänger-Themen 2
B Links verfolgen -- Bibliothek nicht gefunden? Java Basics - Anfänger-Themen 6
G hilfe! zusätzliche java bibliothek einbinden Java Basics - Anfänger-Themen 3
M Spaltengrößen automatisch anpassen mit POI Bibliothek ? Java Basics - Anfänger-Themen 4
M jar-Bibliothek mitgeben Java Basics - Anfänger-Themen 9
L Java Bibliothek scheint zu fehlen Java Basics - Anfänger-Themen 4
feuervogel Integral unter Verwendung der Java-Bibliothek berechnen Java Basics - Anfänger-Themen 10

Ähnliche Java Themen

Neue Themen


Oben