Posts by Prittzl

Ich nehme Alles zurück. Ich hatte ein falsches Schaltbild.

Der Optokoppler ist ein 817C;

Der braucht eine Spannung von U=5V am Eingang, wobei dann ein Strom von I = 5 mA fließt.

Das Relaismodul ist dann wohl am einfachsten mit einem Levelshifter "IIC I2C Logic Level Converter Bi-Directional" o.Ä. zur Anpassung an einen Raspberry zu gebrauchen.

Gnom

Im Schaltplan kann ich keinen Optokoppler erkennen. Lediglich einen Transistor J3Y. Der hat ein hfe von 85 bis 300.

Selbst bei einem hfe von 85 geht der J3Y ab einem Strom unter Ic = 0,32 A in die Sättigung.

jar

Ich habe mir den Schaltplan des Moduls "Keyes_SRly" im Internet angesehehen.

Darauf ist zu erkennen, dass sich in der Zuleitung zur Basis des Transistors eine Leuchtdiode und ein Vorwiderstand befindet.

Damit die LED leuchtet wird etwa ein Basistrom von 5 mA fließen. Eine rote LED benötigt ca. U = 2,7 V. D.h es wird ein Widerstand von 470Ω eingebaut sein.

Wenn die LED durch einen 270Ω Ohm Widerstand ersetzt wird, ist der Vorwiderstand der Basis insgesamt R = 470Ω + 270Ω = 720Ω.

Bei einer Spannung am GPIO von U = 3,3V und einer Basis-Emitterspannung von 0,6V fließt ein Basisstrom von ca. I= 3,75 mA.

Bei einem hfe = 150 des Transistors, kann der Kollektorstrom dann Ic = 0,56 A betragen. Dass sollte für den Spulenstrom des Relais reichen.

Hallo ElectronicMaker

Wenn Du die Leuchtdiode auf dem Keyes_SRly durch einen 270Ω Widerstand ersetzt, wird das Relais arbeiten.

Raumsonde

Hallo Raumsonde

Den Raspberry mit "Visual Studio" zu programmieren ist eine Supersache.

Ich selbst prorgrammiere den Raspberry "seit" VS 2015.

Vorher habe ich mit Eclipse und Cross-Compiling gearbeitet. Das heißt, der C-Code wurde auf dem PC übersetzt. Anschließend wurde der ausführbare Code in den Raspberry hinein geladen.

"Visual Studio" arbeitet mit Remote-Compiling. Dabei wird der Source-Code zum Raspberry geladen und auf dem Raspberry via GCC bzw. G++ überstetzt.

Der Vorteil beim beim Remote-Compiling ist, dass der Wechsel zu einer anderen Hardware (Cortex, Banana Pi, ... usw.) sehr leicht zu bewerstelligen ist, da die Systeme ja ihren eigenen gcc immer mitbringen.

Da lediglich immer nur die aktuell geänderten C-Dateien kopiert und neu übersetzt werden, spielt auch selbst bei sehr großen Projekten die Übersetzungszeit keine Rolle.

Breakpoints können "on the fly" gesetzt und gelöscht werden. Zudem sind Breakpoints auf Daten-Zugriff möglich, d.h., ein Programm wird angehalten, wenn eine oder mehrere gewählte Variablen gelesen oder beschrieben werden.

Variableninhalte können natürlich auch gesichtet und geändert werden.

Nach der Installation von VS 2022 wird auch schon ein kleines Projekt für den Raspberry angeboten, um den Einstieg zu erleichtern.

Das Programm lässt eine Leuchtdiode blinken. Dabei wird vorausgesetzt, dass "WiringPi" installiert ist.

Zudem kann man damit auch mit einem Windows PC Programme für einen Linux PC schreiben und debuggen.

Hallo Georgi96

Um die Zustände von 32 GPIO-Pins zu lesen benötigt der Raspberry nicht einmal 1 Nanosekunde.

Das ist ein Maschinenbefehl.

Ich habe das jetzt einmal ausprobiert mit einem Raspberry- Compute-Modul mit einem CPU-Kern.

Das Auslesen eines GPIO-Ports (32 Bit) und das Schreiben der Daten von 4 Pins in die die Datei auf der Ram-Disk jede μ-Sekunde geht ganz gut.

Das liegt daran, dass mir als Taktgeber der Timer des BCM2835 zur Verfügung steht, und der zappelt mit der Frequenz von 1MHz.

Wenn man dem 5ten Pin des GPIO-Ports einen externen Takt zuführt, geht 's sicherlich noch schneller.

Somit kannst Du die Daten aus der Datei auslesen und plotten.

Das Projekt ist mit Visual-Studio in C für den Raspberry geschrieben, ich kann es Dir gerne zukommen lassen.

Gruß

Prittzl

Einen Digitaleingang kann man wie folgt abfragen:

Man definiert eine Integer-Varibale (zähler) und einen Merker (Flag);

In einem Umlaufprogramm (z.B. main) fragt man den Zustand des GPOIs ab.

Ist der Zustand 1 zählt man die Variable um 1 hoch;

Ist der Zustand 0 zählt man die Variable um 1 runter;

Wird der Zählerstand beim hochzählen 10 setzt man den Merker auf 1 und begrenzt den Zähler auf 10;

Wird der Zählerstand beim herunterzählen 0, setzt man den Merker auf 0 und begrenzt den Zähler auf 0;

Nachfolgende Programme, welche den GPIO auswerten sollen, fragen dann den Merker ab anstatt des GPIOs direkt.

Setzen des Merkers ist eine Flanke. Löschen des Merker ist eine Flanke.

Ob man bis 10 oder 100 zählt, hängt vom Abfragezyklus und dem Prellverhalten des Schalters ab.

Mach ich seit über 30 Jahren so. Hat mich noch nie enttäuscht.

Ich habe festgestellt, dass das streched Jessie das letzte Debian Image war, welches auf einem Zero, Pi 3 B+ (und älter) auf Anhieb sicher lief. Beim Buster klemmte das GUI.

Dafür lief das Pi OS auf dem Pi 4 einwandfrei, aber die älteren Debian Versionen nicht.

Ob man die Fehler durch irgendwelche Klimmzüge beheben kann, weiß ich nicht.

Da habe ich viel Zeit mit vertan.

Vielleicht wird es ja mal wieder eine Debian-Version geben, welche auf allen Raspberries auf Anhieb läuft.

Da könnte genausogut stehen

value = 92;

oder

value = 0x5C,

"| 0xC " bedeutet bit 2 und bit 3 werden immer gesetzt

Das geht unter Windows mit Visual Studio.

Dort wird ein Miniprojekt für den Raspberry gleich mit angeboten.

Compilieren und Debuggen funktioniert genauso wie bei Applikationen für den PC.

ARTYUSS

double time_spent(0);

muss meines Erachtens sein:

double time_spent = 0.0L;

Du willst doch eine Variable erstellen und nicht den Protytyp einer Funktion.

Genauso die Deklaration von begin und end

Im Linux-Konsolenfenster sieht man den Text :"so schnell ist der Wind:"

Der Text taucht aber in Deiner Routine gar nicht auf ?

Es wäre hilfreich, den Code zu zeigen, welcher den Text im Linux-Konsolenfenster zur Anzeige bringt.

printf(" %2.4f sec \n", time_spent);

Du weist den Compiler an, eine Zahl vom Typ "float" mit insgesamt 2 Stellen anzuzeigen, möchtest aber 4 Stellen nach dem Komma haben ?

Den Dezimalpunkt mitgezählt, ohne Vorzeichen, 2 Stellen vor dem Komma und 4 Stellen nach dem Komma müsste für eine Variable vom Typ double so aussehen:

printf (" %7.4lf sec \n", time_spent);

Zudem könntest Du die Variablen counter, begin und end als "unsigned long" deklarieren.

Um den Fehler genauer zu beurteilen, könntest Du einmal nachsehen, was angezeigt wird wenn Du folgende Zeile einfügst:

printf ("Byte-Anzahl = %d\n", sizeof (clock_t));

Gruß

Prittzl

hyle

Genau so macht man das, wenn es einfach und schnell gehen soll.

Schalter abfragen, Strings auswerten, usw..

Selbstverständlich gibt es auch pipes, forks, callbacks, Events, wiringpi-schein-Interrupts mit einem Riesenaufwand im Hintergrund.

Wunderbar für den Programmierer, alles auf das System schieben, über nichts nachdenken, und grottenlangsame Programme schreiben. Und wenn es dann klemmt, im Internet was anderes suchen.

Das kann man natürlich alles machen, wenn man nicht Echtzeit programmieren muss und wenn es nicht so schlimm ist, wenn das Programm einmal stehen bleibt.

xxdarkgamerxx

Mit den unsäglichen Delays und Pausen ist das so eine Sache.

Meines Erachtens ist es nicht einzusehen, warum die Hauptschleife angehalten werden soll, wenn sie während der Wartezeit auch andere Dinge erledigen kann.

Grundsätzlich können die Pausen und Delays umgangen werden.

Dazu wird ein Zeitnormal benötigt:

Ich benutze dafür die Register CLO und CHI vom System Timer des BCM2835 im Raspberry.

Unter Linux gibt es die Funktion gettimeoftoday (), die ist aber nicht ganz so schnell wie der System- Timer-Zugriff. Letztlich liefern beide einen Wert, welcher in jeder µ-Sekunde um 1 erhöht wird.

Wenn nun etwas um 2 Millisekunden verzögert werden soll, dann liest man z.B. den aktuellen Inhalt des System-Timers in eine long long Variable und addiert 2000. Mit einer IF-Abfrage prüft man dann, ob der aktuelle Inhalt des System-Timers größer ist, als der Inhalt der long long Variablen. Ist die Bedingung erfüllt, wird das ausgeführt, was verzögert werden sollte, vorher eben nicht.

In C kann das sekündliche Aufblitzen einer LED wie folgt aussehen (in Python eben ähnlich):

#include <stddef.h>
#include <sys/time>



int main (..)

{
   struct timeval  time;
   long long       t;
   int             state;

   gettimeoftoday (&time); // µ-Sekunden seit Systemstart lesen
   t     = time.tv_usec;   // t initialisieren 
   state = 0;
   .
   .
   while (1)  {
      .
      .
      gettimeoftoday (&time);    // µ-Sekunden seit Systemstart lesen
      if  (time.tv_usec > t) {   // Zeit abgelaufen ?
         if  (state == 0)  {     // LED ist ausgeschaltet
            state = 1;
            t = time.tv_usec + 10000; // LED  10 ms einschalten
            LED_einschalten ();
         }
         else {
            state = 0;
            t = time.tv_usec + 990000;  // LED 990 ms ausschalten
            LED_ausschalten ();
         } 
      }
      .
      .
      .
   }
}

Hallo xxdarkgamerxx

Falls kein Debugger zur Verfügung steht, kann man den Fehler finden, indem man an unterschiedlichen Stellen des Programms unterschiedliche Zahlen- und/oder Buchstabenkombinationen ausgibt. Anhand der Ausgaben, kann man den Programmablauf überprüfen und feststellen, wo der Pogrammablauf klemmt.

Ein Programm in eine Pause zu schicken oder in einem Delay stecken zu lassen, führt erfahrungsgemäß oft zu Problemen.

Gruß Prittzl

Ein PIR muss nicht unbedingt ein Bewegungsmelder sein. Das hängt von der Auswertelogik ab.

Man unterscheidet zwischen Bewegungs- und Präsenzmeldern.

Bewegungsmelder schalten bei Änderung, Präsenzmelder schalten solange jemand im Raum ist.

Falls jemand an einem Schreibtisch sitzt und sich wenig bewegt, schaltet ein Bewegungsmelder u.U. ab, ein Präsenzmelder nicht.

Für den Raspberry bietet sich der HC-SR501 an. Der arbeitet mit 3,3V Versorgungsspannung, und besitzt einen Jumper, mit dem er wahlweise als Bewegungsmelder oder Präsenzmelder betrieben werden kann.

Wegen eines möglichen toten Winkels kann man mehrere Senoren einbauen.

Gruß Prittzl

Hallo Marcel2

Das kann man so machen:

#define MAX_LENGTH 1000

#include <stdio.h>

#include <string.h>

char EingabeZeile[MAX_LENGTH+1];

FILE* Datei;

.

.

Datei = fopen (DateiName.txt, "rb");

if (Datei != NULL) {

while (fgets (EingabeZeile, MAX_LENGTH, Datei) {

.

.

.

.

.

}

fclose (Datei);

}

}

}

Wen es interressiert:

Die PRI_BASE_BCM2835 = 0x20000000

Pull-up und Pull-down Widerstände braucht man nicht zu kaufen, die sind im Chip schon eingebaut und sind ca. 50 kOhm groß.

Per Software können die nach Bedarf eingeschaltet werden.

Hallo maximilian99

wenn der Sprung in der Mitte des Messbereiches liegt, kann der Fehler durch folgenden Umstand verursacht werden:

Der HX711 liefert einen 24-Bit-Messwert. Wenn der in einen 4-Byte-Integer (long) eingelesen wird, liefert der HX711

für den Wert 1 das Bitmuster 0x00000001. Für den Wert -1 gibt der HX711 das Bitmuster 0x00FFFFFF aus.

Enthält ein (long) Integer den Wert 0x00FFFFFF wird er als 16777215 interpretiert. Beim 24-Bit-Übergang von 0 nach -1 springt dann der 32-Bit-Wert von 0 nach 16777215 (statt wie erwartet von 0 nach -1).

Um diesem "Fehler" zu begegnen, geht man wie folgt vor:

Man prüft das höchste Bit des 24-Bit-Musters und übertragt dessen Zustand auf auf die höheren Bits.

Nehmen wir an, das Bitmuster des HX711 sei in die Speicherstelle (long value) eingelesen also

long value;

In C sieht die Anpassung dann wie folgt aus:

value = value & 0x800000L ? value | 0xFF000000L : value;

Dann springt auch der Messwert wie gewünscht von 0 nach -1.

Gruß Prittzl