Posts by madman

    Sry, aber ich habe eine allgemeine Frage zu den Pullup und Pulldown-WIderständen.
    Ja, ich habe mir schon Erkärungen dazu ergooglet und auch schon Youtube-Videos geschaut, aber irgendwie find ich ist nirgends das grundlegende Konzept hinter den Widerständen erklärt.


    Nehmen wir folgendes BIld: https://cdn.sparkfun.com/asset…568b6ce395f1b40000000.jpg


    Wofür ist der Pull-Up Widerstand denn nun vorhanden? Es wird immer wieder gesagt, dass ohne den Widerstand der "floating"-State eingenommen werden würde und nicht entscheidbar sein kann ob eine 1 oder eine 0 anliegt.
    Wieso ändert der WIderstand dass denn hier? Der Widerstand begrenzt doch einfach nur den Strom. Warum liegt ohne den Widerstand nicht sicher eine 1 an? Ich erkenne da nur einen Kurzschluss, der von 3,3V zum PIN geht. Aber wie kann hier denn eine 0 am Pin anliegen, wenn 3,3V doch eindeutig komplett zum Pin laufen?


    Oder sind die Widerstände nur dafür da um den Kurzschluss zu verhindern?

    Sry, ich steh da gerade krass auf dem Schlauch. Was meinst du damit, dass ich den Widerstand der LED berechne? Ich will den Vorwiderstand berechnen um die gewünschte Spannung und Stromstärke an der LED zu erhalten.


    Wenn ich eine LED habe die bei 2,2V Leuchtet und ich an der LED eine Spannung von 2,2V erreichen will über den 3,3V Pin mit einer Stromstärke von 5mA, rechne ich um den den Vorwiderstand zu berechnen:
    (3,3V - 2,2V)/5mA = 220Ohm


    Wenn ich eine LED habe die bei 1,1V leuchtet und ich an der LED eine Spannung von 1,1V erreichen will über den 3,3V Pin mit einer Stromstärke von 10mA, rechne ich um den den Vorwiderstand zu berechnen:
    (3,3V - 1,1V)/10mA = 220Ohm


    In beiden Fällen baue ich einen 220 Ohm Widerstand ein. Woher weiß der Raspberry nun dass er die LED mit 2,2V und 5mA oder 1,1V und 10mA betreiben soll, wenn er bis zu 160mA liefern kann?

    Danke für eure ganzen Antworten, die haben mir jetzt ein wenig mehr Klarheit gebracht.
    Das mit dem Vorwiderstand hab ich nun auch verstanden. Jedoch bleibt mir bei dem ganzen Spannungs und Stromzusammenspiel eine Frage offen.


    Nehmen wir mal das ohmsche Gesetz und erhalten R=U/I
    Jetzt hab ich die Raspberry und ne LED(2,2V) und will den Widerstand berechnen.
    Ok, gut, simpel -> U_gesamt = 3,3V, U_led = 2,2V -> U_widerstand = 3,3V-2,2V = 1,1V
    Jetzt wollen wir den Strom auf 5mA begrenzen und erhalten somit einen Vorwiderstand: R= (3,3V-2,2V)/0,005A = 220Ohm


    Macht alles Sinn, aber wieso muss denn jetzt durch den Widerstand zwangsweise der Strom begrenzt werden und nicht die Spannung?
    Wenn ich den 220 Ohm Widerstand einsetze und davon ausgehe, dass die Raspberry z.B. 10mA liefern kann, dann würde folgende Rechnung doch auch korrekt sein:
    220 Ohm = ( 3,3V - 1,1V )/ 10mA
    Nun haben wir die Spannung um 1,1V runtergesetzt und einfach den Stromfluss verdoppelt. Bei gleichbleibendem Widerstand.


    Bin jetzt kein Mathegenie, aber würde mathematisch meiner Meinung nach korrekt sein ;)
    Wenn man davon ausgeht, dass die LED ab 2V leuchtet, würde im 1. Beispiel die LED leuchten, im 2. würde die LED nicht leuchten


    Woher weiß ich bei einer Schaltung beim Raspberry, bei der ich einen gegebenen Widerstand, die gegebene Maximalspannung habe, wie viel Spannung bzw. wie viel Strom anliegt?



    edit: Ich hab genau den AUfbau jetzt mal durchgeführt. Bei mir kamen insgesamt ein Strom von ungefähr 3mA und eine Spannung von 2,55V raus.
    Ergibt insgesamt ein Widerstand von 250Ohm. Also 30Ohm zu viel. Liegt vllt. hier jetzt eben an der Leitfähigkeit der LED und co.

    Hey,
    hab mich gerade mit dem Thema Spannung und Strom auseinandergesetzt und ein bisschen mit dem Multimeter rumgespielt.
    Jetzt stellen sich mir folgende Fragen:


    1) Wenn ich auf meinem Breadboard eine LED über den 3,3V Pin zum leuchten bringe erhalte ich eine Stromstärke von ungefähr 40mA.
    Das ganze ohne Widerstand. Wie kommt das zu stande?
    Gilt also U=3,3V und I=0,04 -> R= 3,3/0,04 = 82,5Ohm -> Also das die Kabel einen 82,5 Ohm Widerstand entsprechen oder wieso kommen 0,04A in den Amperemeter?


    2) Wenn ich auf meinem Breadboard eine LED über den 5V Pin zum leuchten bringe erhalte ich 160mA.
    Ist das das Maximum was rauskäme? Konnte das leider nicht lange verfolgen, da die LED durchgebrannt ist ;)
    Und hiernach wäre der WIderstand nun von den Kabeln und co. ja bei nur ungefähr 30 Ohm.



    (Mir ist schon klar, dass das Breadboard und die Kabeln niemals einen so hohen Widerstand haben, würde nur gern wissen wie die Werte zustande kommen.)



    3) Als ich den +-Pol mit meiner Hand berührt habe (-Pol im GND-Pin)
    fing die LED auch an zu leuchten. Wie kann das sein? Sobald den -Pol aus dem GND-Pin gezogen habe, und ihn z.B. mit dem MInuspol einer beliebigen Batterie verbunden habe, leuchtete die LED nicht mehr.
    Ich dachte die Masse beträgt 0V, wo ist der Unterschied zwischen dem GND-Pin und dem Minuspol einer Batterie?
    Auch die Spanung zeigte 0,01mV an als ich die Verbindung zur LED berührt habe, kann das überhaupt sein, damit dürfte die doch nichtmal glimmen. (hier ist auch gut möglich, dass ich mich vermessen hab, hab leider noch keine Krokodilsklemmen)
    Sobald die Raspberry aus war, hat das alles mit dem Berühren und LED leuchtet nicht mehr funktioniert. Aber ich hab bei den ganzen Versuchen hier keinen Pin in einem Spannungsausgang oder GPIO-Pin gehabt.

    Ich saß jetzt 2 Tage daran, bis ich es endlich geschafft habe meine über meinen Laptop (Ubuntu) komplierten Programme erfolgreich auf der Raspberry auszuführen.
    So dass man nicht direkt auf der Raspberry programieren muss bzw. komplette Projekte übertragen muss.


    Stundenlanges Googlen hat leider auch nichts gebracht. Für diejenigen die ein ähnliches Schicksal erleben hier ein kurzes Beispiel wie ich es letzendlch geschafft habe.


    Als Compiler habe ich Clion verwendet. Clion arbeitet mit CMake über welches man die Kompilierung-Optionen usw. wählen kann.


    1) Der Raspberry verwendet eine andere Architektur als der standard Laptop. (https://de.wikipedia.org/wiki/ARM-Architektur)
    Wir können also nicht einfach unseren standard gc++-Compiler verwenden, sondern müssen den ARM-Compiler verwenden, damit unser Programm später auf der Raspberry ausgeführt werden kann. Hierfür installieren wir einen passenden:

    Quote

    apt-get install g++-4.7-arm-linux-gnueabi
    apt-get install gcc-4.7-arm-linux-gnueabi


    2) Nun haben wir den richtigen Compiler installiert.
    Jetzt könnten wir über unsere Shell das erste "Hello World"-Programm auf unserem Laptop über

    Quote

    arm-linux-gnueabi-g++ helloWorld.cpp -helloWorld.o


    erfolgreich kompilieren und auf der Raspberry ausführen.
    Auf unserem Laptop ist die erstellte helloWorld.o nicht mehr ausführbar, da wir hier nicht die benötigte Architektur besitzen.


    3) Wir wollen vorzugsweise aber ja auf der Raspberry auch unser Breadboard ansprechen. Hierfür benötigen wir wiringPi.h Leider können wir nicht einfach wiringPi auf unserem Laptop installieren und die Bibliothek unserem Projekt hinzufügen.
    Das funtkioniert nicht, da der Compiler versucht auch die Bibliothek auf die Raspberry-Pi-Architektur zu übersetzen, was fehlschlägt, da die Bibliothek bereits für diese Architektur geschrieben wurde.
    Also müssen wir uns die Bibliothek direkt von unserer Raspberry ziehen und diese einbinden, so dass auch diese von dem Compiler umgesetzt werden kann.


    Der Fehler der mich hier fast zum verzweifeln gebracht hat war dieser:

    Quote

    /usr/local/lib/libwiringPi.so: file not recognized: File format not recognized


    Um diesen zu umgehen erstellen wir uns erstmal einen ordner in unserem homeverzeichnis:

    Quote


    cd ~
    mkdir raspberry
    cd raspberry
    mkdir rootfs


    Jetzt wollen wir unsere unsere Bibliothek direkt von der Raspberry beziehen. Das schaffen wir mit folgendem Befehl:

    Quote

    rsync -rl --delete-after --safe-links pi@IPADRESSE:/{lib,usr} $HOME/raspberry/rootfs


    Anstatt IPADRESSE die IP-Adresse des Raspberrys eintragen.


    Nach ein paar Minuten haben wir nun unseren lib und usr Ordner in ~/raspberry/rootfs


    Jetzt können wir uns auch endlich dran machen und unser Projekt in Clion schreiben.
    Wir versuchen den GPIO-Pin 0 (Pin #17) an zu sprechen und eine LED zum blicken zu bringen.


    main.cpp:


    (ich habe übrigends auch wiringPi ganz normal auf meinem Laptop unter /usr/include/ installiert, dazu könnt ihr ein tutorial googlen. ist sehr simpel. Könnt theoretisch auch einfach die durch den von dem raspberry-übertagene wiringPi.h, aus den Dateien die wir von dem raspberry im zuvorigen Schritt übergezogen haben, verlinken)



    Nun kommen wir zum spannden Teil, der CMakeLists.txt:



    Was wir konkret hinzugefügt haben sind die ersten 4 Zeilen, welche das System und den Pfad zu unseren Compilern angeben. Diese müsst ihr ggf. anpassen.
    Dann wurde noch die Zeile mit der CMAK_FIND_ROOT_PATH-Konstante hinzugefügt. HIer bitte euren Benutzernamen eintragen. Dieser Pfad gibt an wo sich das Abbild der Entwicklungsumgebung befindet.


    link_libraries ist der Pfad zurt libwiringPi.so Hier muss zwangsweise die verwendet werden, die wir von der Raspberry bezogen haben.


    Die restlichen Prameter sind nicht sonderlich interessant, könnt ihr bei Interesse Googlen.



    Viel Spaß ;)

    Hey,
    danke für die Antwort.
    Das Problem war weniger wiringPi, vielmehr CMake und die Art wie man dort Libarys hinzufügt etc.


    Hab es jetzt nach langem rumprobieren geschafft:
    SET(CMAKE_CXX_FLAGS "-pthread ${CMAKE_CXX_FLAGS}")
    link_libraries(wiringPi)


    musste in die CMakeLists.txt


    Jetzt wird alles wunderbar kompiliert. Muss jetzt nur noch den -m32 Parameter irgendwie übergeben bekommen, damit ich ein 32-Bit-Programm erhalte, dann sollte alles hoffentlich funktionieren.


    Werd mich da heute abend mal dran setzen.
    Danke erstmal


    edit:// übrigends alles umsonst gemacht.
    Lässt sich ohne "cross compile" natürlich nicht ausführen. dafür brauch man dann ja kein CMake mehr, sondern benutzt ja nen toolchain.. naja..


    Hey, danke für deine Antwort.
    Ja, mit "username" war mein Benutzername gemeint. Hab ich manuell abgeändert.
    Ich hab das ganze jetzt nochmal umstrukturiert und einfach das komplette wiringPI in /usr/includes installiert.


    Wenn ich über meinen Compiler nun
    #include <wiringPi/wiringPi/wiringPi.h>


    einbinde, kommt nicht mehr der fehler, dass wiringPi nicht gefunden wurde.
    Aber nun sieht die Ausgabe wie folgt aus:



    Scanning dependencies of target ledSimple
    [100%] Building CXX object CMakeFiles/ledSimple.dir/main.cpp.o
    Linking CXX executable ledSimple
    CMakeFiles/ledSimple.dir/main.cpp.o: In function `main':
    /home/username/ClionProjects/ledSimple/main.cpp:9: undefined reference to `wiringPiSetup'
    /home/username/ClionProjects/ledSimple/main.cpp:10: undefined reference to `pinMode'
    /home/username/ClionProjects/ledSimple/main.cpp:11: undefined reference to `digitalWrite'
    /home/username/ClionProjects/ledSimple/main.cpp:12: undefined reference to `delay'
    /home/username/ClionProjects/ledSimple/main.cpp:13: undefined reference to `digitalWrite'
    collect2: error: ld returned 1 exit status
    make[3]: *** [ledSimple] Error 1
    make[2]: *** [CMakeFiles/ledSimple.dir/all] Error 2
    make[1]: *** [CMakeFiles/ledSimple.dir/rule] Error 2
    make: *** [ledSimple] Error 2



    Also wiringPi.h wird anscheinend nun gefunden, dennoch können die Funktionen nicht gefunden werden..

    Hey,
    ich wollte jetzt mein erstes LED-Lampen Programm kompilieren, habe aber ein kleines Problem mit meinem Compiler.
    Ich benutze Clion und programmiere in C/++.


    Und zwar habe ich über CMakelist ein neues include-Directory hinzugefügt:
    include_directories("/home/username/wiringPi")


    Ohne Probleme konnte ich jetzt über Clion die wiring.h einbinden:
    #include <wiringpi/wiringPi.h>


    Es wird mir kein Fehler angezeigt und es werden mir auch alle Methoden der wiringPI.h angezeigt usw.
    Wenn ich das ganze nun aber kompilieren will, erhalte ich den Fehler:
    [100%] Building CXX object CMakeFiles/ledSimple.dir/main.cpp.o
    /home/username/ClionProjects/ledSimple/main.cpp:2:31: fatal error: wiringpi/wiringPi.h: No such file or directory
    #include <wiringpi/wiringPi.h>
    ^
    compilation terminated.
    make[3]: *** [CMakeFiles/ledSimple.dir/main.cpp.o] Error 1
    make[2]: *** [CMakeFiles/ledSimple.dir/all] Error 2
    make[1]: *** [CMakeFiles/ledSimple.dir/rule] Error 2
    make: *** [ledSimple] Error 2



    Was muss ich noch abändern, damit das kompilieren ohne Probbleme durchgeführt werden kann?


    Entweder du mountest es per SSH oder du lädst es manuell hoch. Es gibt auch Tools, mit denen sich Verzeichnisse überwachen lassen, die dann bei jeder Änderung dein Programm per SSH hochladen können. Aber warum so viel Aufwand betreiben, wenn es über SSHFS viel einfacher geht?


    Den von dir gebrachten Nachteil bezgl. SSHFS versteh ich nicht. Ich mach das auch über SSH und hab keinerlei Probleme.


    Das manuelle Hochladen stört mich eben, jedes mal wenn ich die kleinsten Änderungen am Skript vornehme alles manuell hochzuladen nervt extremst. Hab das noch aus meinen PHP-Zeiten in grauenhafter Erinnerung.


    SSHFS hat bei mir öfter mal Probleme verursacht wenn bereits Dateien im Ordner vorhanden sind/Raspberry noch nicht gemounted war/Verbindung verloren gegangen ist usw. War bisher aber die beste Lösung. Wollte nur mal fragen, ob alle das hier so machen..




    Oder verwende git/mercury oder andere Versionskontrollsysteme (bekanntestes Beispiel svn oder cvs, empfehle ich aber nicht)


    Danke dir! Das hab ich gesucht. Werd jetzt mal GIT einrichten.


    @gold:
    Kann dir da leider nicht helfen, aber erstell am besten einen eigenen Thread in der Phython-Ecke, dann schauen die Leute rein, die sich damit auskennen ;)

    Hey,
    ich bin komplett frisch dabei und will meine ersten Progrmamierprojekte mit der Raspberry durchführen.


    Vorzugsweise möchte ich an meinem Linux rechner alles programmieren und kompilieren und auf der Raspberry ausführen.
    Jetzt stellt sich mir die Frage wie man das am besten bewerkstelligt ohne bei jedem Test per SSH die Daten manuell zu übertragen.


    Hab jetzt versucht den Raspberry über SSH in nen Ordner zu mounten. Hat aber ein paar Nachteile wenn der Ordner bereits beschrieben war usw. usw.
    Gibt es hier eine effizentere Methode?


    edit:// Achja, ich arbeite mit CLion