Suche Baustein, der in Abhängigkeit von Zeit (Frequenz) schaltet

[Joachim H. (jochen_hr)]

Problem: ich möchte das Fahrradtachosignal, also das, was vom 
Speichenmagnet erzeugt wird, nutzen, um bei einer bestimmten 
Geschwindigkeit einen Schaltvorgang auszulösen, bspw oberhalb 8km/h 
dauerhaft "ein"
Kann mir jemand behilflich sein?
Danke vorab

[pegel (Gast)]

Ich sehe eine Diode in Reihe mit einem Poti, die einen Kondensator mit 
parallelem Widerstand aufladen.
Danach ein Schmitt-Trigger zur Auswertung.

[Sebastian L. (sebastian_l72)]

Genau dazu kann man sehr gut einen Mikrocontroller nehmen.

mit FlipFlop-Zähler und Quarz ginge auch. Ist aber ein bisschen 70er.

1 Transistor der von einer Kapzitität mit Selbstentladung getriggert 
wird ginge auch. Ist wohl die sportlichste Variante.

[Joachim H. (jochen_hr)]

Danke, ahnte schon, daß es auf DiY hinausläuft. Und da ist das Problem 
hinter der Tastatur :D
Noch nie was mit Elektronik gemacht :( Aber da muß ich nun mal durch.
Es geht ja schon damit los, daß ich die elektrischen Werte des Impulses 
der vom Tachosensor kommt nicht kenne. Was ich schalten möchte sind 
allerdings nur max 5V und sehr kleiner Strom,  in etwa der Größe, wie 
auch von Tachosensor.
Mikroprozessor möchte ich für diesen trivialen Anwendungsfall 
ausschließen, da muß ich ja noch viel mehr Aufwand betreiben ;)

[pegel (Gast)]

Es gibt auch noch den:

https://media.digikey.com/pdf/Data%20Sheets/Texas%20Instruments%20PDFs/LM231,%20LM331.pdf

Figure 18. Simple Frequency-to-Voltage Converter

Der gibt eine Spannung aus, je nachdem wie die Frequenz bzw. Pulse pro 
Zeiteinheit ist.

Diese Spannung musst du dann interpretieren.

[Timo N. (tnn85)]

Der Tachsensor (also das Teil, das direkt neben deiner Speiche befestigt 
ist), ist ein sogenanntes Reedrelais. Es schaltet zu, wenn der Magnet 
(der an der Speiche befestigt ist) an ihm vorbeiläuft.
Der Tacho wertet das dann aus und berechnet daraus die 
Winkelgeschwindigkeit des Rads. Mit dem eingestellten Radumfang wird 
dann die Geschwindigkeit berechnet.

So wurde es jedenfalls früher gemacht. Welche anderen Systeme es heute 
gibt (drahtlos und der ganze Müll), kann ich dir nicht sagen.


Wenn du so ein System hast, kannst du wahrscheinlich mit dem Multimeter 
zwischen den beiden Kabel des Reedrelais einen Spannungsimpuls messen, 
wenn du das Rad drehst.
Das kann dann ausgewertet werden (µC, analoges Zeitglied).
Deine erste Aufgabe ist also erst mal das Signal festzustellen/messen.

[Joachim H. (jochen_hr)]

@pegel interessant, muß ich mir mal in Ruhe anschauen, sowas in der Art 
dachte ich als "Baustein"
Wenn man als "Laie" sowas sucht, fehlen einem die Suchbegriffe

[Mick (Gast)]

Es gab mal den MilCandy von SeeedStudio. Weiss nicht, ober der noch 
verfügbar ist. Dieser hat einen Input (in deinem Fall für den 
Magnetschalter) und einen Output. Je nachdem, was du schalten möchtest, 
müsstest du noch ein Relais oder ähnliches anschliessen.

https://www.mouser.com/ds/2/744/Seeed_102990023-1217532.pdf

Dem MilCandy verpasst man dann noch ein entsprechende Programm. Diese 
paar benötigten Zeilen Code kann dir sicherlich hier im Forum jemand 
"spendieren".

[pegel (Gast)]

Timo N. schrieb:
> Deine erste Aufgabe ist also erst mal das Signal festzustellen/messen.

Richtig. Wenn du dich dann für die Frequenz-Spannungswandler Variante 
entscheidest, kann zur Auswertung der LM3914 verwendet werden.

http://www.ti.com/lit/ds/symlink/lm3914.pdf

Damit hast du schon einen einfachen Tacho, bzw. kannst an Stelle der LED 
auch etwas anderes ansteuern.

[Timo N. (tnn85)]

pegel schrieb:
> Es gibt auch noch den:
>
> 
https://media.digikey.com/pdf/Data%20Sheets/Texas%20Instruments%20PDFs/LM231,%20LM331.pdf
>
> Figure 18. Simple Frequency-to-Voltage Converter
>
> Der gibt eine Spannung aus, je nachdem wie die Frequenz bzw. Pulse pro
> Zeiteinheit ist.
>
> Diese Spannung musst du dann interpretieren.

Da steht, dass er eine Frequenz in Abhängigkeit von der Spannung 
ausgibt. Also genau andersherum.

[pegel (Gast)]

Timo N. schrieb:
> Also genau andersherum.

Der macht beides. Siehe Bild 18.

[Joachim H. (jochen_hr)]

@All Wunderbar, so viele nützliche Informationen, da werde ich wohl was 
draus machen können.
Die beiden Varianten R-Glied mit Poti und die mit Transistor und 
se!bstentladender Kapazität scheinen mir die für mich am 
Überschaubarsten Varianten zu sein.
Wobei die anderen Varianten zum "Lernen" nicht" weggelegt" werden. Ich 
kann ja dabei nur etwas hinzugewinnen

[U. M. (oeletronika)]

Hallo,
> Joachim H. schrieb:
> Es geht ja schon damit los, daß ich die elektrischen Werte des Impulses
> der vom Tachosensor kommt nicht kenne.
Da kann ich dem Vorredner (Timo N.) zustimmen.
Kläre ab, was du da für ein Signalgeber hast.
Es wäre aber auch leicht möglich als Randbedingung fest zu definieren, 
dass es ein Reedkontakt ist, der von einem Speichenmagnet ausgelöst 
wird.
Dann hätte man einen sehr gute Ausgangsposition.

> Was ich schalten möchte sind allerdings nur max 5V
Heißt das, 5V stehen als Betriebsspannung stabil zur Verfügung?
Oder woher kommt die Stromversorgung? Gebe genaue Auskunft dazu!

> und sehr kleiner Strom,  in etwa der Größe, wie
> auch von Tachosensor.
Ok, kein Problem. Aber erkläre dich genauer, was du genau schalten 
willst und warum (siehe Fragen unten)!

> Mikroprozessor möchte ich für diesen trivialen Anwendungsfall
> ausschließen, da muß ich ja noch viel mehr Aufwand betreiben ;)
Ja, man muß auch nicht alles mit einem uC machen.
Aber unter Umständen geht es nur mit einem uC vernünftig und bezahlbar.
Das hängt von konkreten Randbedingungen ab, die du noch nicht genannt 
hast.

Ich nenne mal paar Punkte:
- Welche Zustand darf oder soll das Umschaltsignal im Stand einnehmen, 
wenn sich nix bewegt.

- Löst der Schaltvorgang eine Reaktion aus (welche?) oder ist es nur 
eine Anzeige?

- Was ist mit Genauigkeit und Reproduzierbarkeit?

- Was passiert im Grenzbereich, wenn das Signal in kurzer Zeit mal unter 
den Schwellwert fällt und dann wieder darüber steigt -> Da "flattert" 
die Umschaltelektronik! Wir also eine Hysterese benötigt.

- Soll der Schwellwert später evtl doch noch einstellbar sein?

- Welche Zeitkonstanten für die Umschaltung werden gewünscht. Soll es 
eher träge reagieren oder sehr schnell bei Durchfahren des 
Schwellwertes?

- In welchem Zeitrahmen mit welchem Aufwand (Budged) willst du das 
umsetzen. Welche Voraussetzungen hast du.

Ohne solche Fragen vor Anfang an zu klären, führt das nur zu unendlich 
langen Rückfrageorgien und am Ende sind alle frustriert und du bekommtst 
keine Hilfe mehr von Fachleuten (eher von Trollen).
Gruß Öletronika

[Falk B. (falk)]

Siehe Anhang. IC1A arbeitet nur als Pulsformer, um aus dem gefilterten 
Tachokontaktsignal ein knackiges Digitalsignal zu machen. Das braucht 
man für den Trick der nachfolgenden Stufe. Man hätte auch einen 
Schmitt-Trigger nehmen können, aber das wäre ein zusätzlicher IC 
gewesen. IC1B arbeitet als Pulsbreitenmesser. Wenn eine steigende Flanke 
aus IC1A/Q kommt, geht die sowohl zum Monoflop als auch D-FlipFlop. 
Letzteres speichert den aktuellen Zustand von IC1B/Q. Ist der 0, war die 
Periodendauer zu groß bzw. die Geschwindigkeit zu klein. Entsprechend 
umgekehrt wenn die Geschwindigkeit groß genug ist, dann wird ein HIGH 
gespeichert und erscheint am Schaltausgang. Ebenso wird dieser auf LOW 
per Reset zurüch gesetzt, wenn die Geschwindigkeit zu klein wird und 
IC1B/Q zwischenzeitlich auf LOW geht.
Anbei auch gleich ein Layout für einen Lochrasteraufbau.

Ein 26er Reifen hat ca. 2m Umfang, macht bei 8km/h ~ 2,2m/s ~ 1Hz. Also 
muß man mit R5 ca. 1s Pulsbreite einstellen. Die Dimensionierung sollte 
für den Bereich 4-40km/h passen.

[Dieter (Gast)]

NE/ICM/LM555 oder 556 ginge es auch. Erste Stufe ist ein Monoflop 
getriggert von Schaltkontakt. Zweite Stufe ist eine RC-Kombination, die 
vom Monoflopausgang aufgeladen wird. Wird die Schwelle (2/3 Uss) 
erreicht, dann schaltet die nächste Stufe (bei 1/3 Uss wieder aus).

[Joachim H. (jochen_hr)]

@oelektronica also die "Aufgabenstellung": Am "Pedelec" soll der Motor 
erst oberhalb einer definierten Geschwindigkeit zuschalten ( nicht mein 
Wunsch, sondern eines Kollegen.)
Läuft im Originalzustand bspw der Motor oberhalb dieser Geschwindigkeit, 
kann man die Stromzufuhr zum Motor mittels am Bremshebel installierter 
Reedkontakte, deren Betriebsspannung von 5V vom Motorcontroller kommt, 
unterbrechen. Nun soll diese Funktion "Motor stromlos schalten" genau 
über diese Leitung aber grundsätzlich ohne Nutzung der Bremshebel 
Grundeinstellung durch "meinen Baustein" werden. Der Motor wird erst 
zugeschaltet, wenn der Fahrer mit Eigenleistung die voreingestellte 
Geschwindigkeit erreicht. Als Signalgeber für diesen "Baustein" habe ich 
mir nun den Signalgeber vom Tacho vorgestellt.
Hoffe, das ist einigermaßen verständlich (mir ists dieser Wunsch nicht, 
aber ..)

Die Zeit der Wiederkehr des Impulses liegt in etwa bei 1s. Hysterese 
wäre schön, ist mir aber erst einmal um des Prinzip willens unerheblich.
Ich meine, da es sich um einen Freundschaftsdienst handelt, sollte es 
schon kleines Budget bedeuten. Aber wenn ich so R-C-Glied, Transistor, 
Schmitt-Trigger, sehe, sind das keine Kosten.
Und so nen fertigen Baustein um -20€ wäre mir das kein Problem, ich will 
dabei was zu gewinnen.
Arduino wäre schon da, war eigentlich für nen Enkel, aber der wollte was 
anderes. Ich hatte da ne Idee ne Lauflichtschaltung für mich 
umzufunktionieren; noch nicht angegangen.
Tja Voraussetzungen 0 Ahnung. Noch nie was mit Elektronik zu tun gehabt. 
Deswegen, weil mir das jetzt nach den Anregungen machbar erscheint, 
möcht Ichs angehen. Deshalb was ohne Microcontroller.
Hoffe habe das Fragespektrum einigermaßen abgedeckt ;)

[Joachim H. (jochen_hr)]

@falk das ist ja ein Service mannomann. Danke

@Dieter ja den timmer555 hatte ich auch im Visier, nur fehlt mir eben 
das Verständnis die inneren Strukturen zu nutzen, dh was man damit 
anstellen kann.

[G. O. (aminox86)]

Ich werfe 'mal den NE(µA)567 in den Ring.

[pegel (Gast)]

Ich denke die Schaltung von Falk ist die passendste.

Falls es digital sein soll, kann man diese leicht anpassen:

http://www.next.gr/uploads/7/digital-bike-tachometer.gif

[Stefan F. (Gast)]

Ich würde erstmal davon absehen, das Signal vom vorhandenen Tacho 
abzugreifen. Denn der ist auf geringe Stromaufnahme optimiert und sicher 
nicht dafür vorbereitet, eine weitere Last anzusteuern. Ausserdem müsste 
man die technischen Details erst einmal heraus bekommen.

Also installiere einfach einen zweiten Sensor. Darin befindet sich ein 
magnetisch betätigter Kontakt.

Da du nicht imstande bist, die Schaltung selbst zu entwerfen, ist dies 
der ideale Zeitpunkt, den Umgang mit Mikrocontrollern zu erlernen. Denn 
dann brauchst du nur sehr wenige Bauteile:

- Mikrocontroller z.B. ATtiny13A
- Knopfzelle mit Halter Typ CR2032
- Kondensator 100nF
- Widerstand 470 Ohm
- Leuchtdiode (nicht in weiss und nicht in blau)

Später kommt dann noch das Schaltelement dazu, dass du ansteuern willst. 
Vermutlich ein Optokoppler, wieder mit 470 Ohm Vorwiderstand.

Anleitung: http://stefanfrings.de/mikrocontroller_buch/index.html

> Mikroprozessor möchte ich für diesen trivialen Anwendungsfall
> ausschliessen, da muss ich ja noch viel mehr Aufwand betreiben

Nein, ganz im Gegenteil. Das ist ein überschaubares kleines Projekt, 
wirklich.

> Die beiden Varianten R-Glied mit Poti und die mit Transistor und
> selbstentladender Kapazität scheinen mir die für mich am
> Überschaubarsten Varianten zu sein.

Und wenn die Schaltung dann doch nicht so funktioniert, wie gewollt 
(wovon ich zu 99% ausgehe), fängst du nochmal ganz vor vorne an und bist 
wieder nicht imstande, sie selbst zu entwerfen. Ich würde das lassen.

Mit Mikrocontroller wird die Elektronik viel einfacher, als ohne. Das 
beste ist: Du kannst ihre Funktion ohne Lötkolben ändern.

> Die Zeit der Wiederkehr des Impulses liegt in etwa bei 1s.

Was soll das bedeuten?
Du solltest alle Anforderungen gleich zu beginn nennen, sonst mühen sich 
die Helfer mit der Erstellung von Plänen ab, die gleich wieder in die 
Mülltonne wandern. Was hier jetzt wohl wahrscheinlich der Fall ist. 
Damit verärgerst du sie.

[Matthias S. (Firma: matzetronics) (mschoeldgen)]

G. O. schrieb:
> Ich werfe 'mal den NE(µA)567 in den Ring.

Aus mehreren Gründen würde ich den hier nicht nehmen. Erstens ist die 
Detektorfrequenz mit 1Hz hier sehr niedrig und zweitens ist das ja kein 
Baustein, der oberhalb einer Frequenz weiterhin ein Signal ausgibt. Der 
NE567 kann sehr gut eine Frequenz erkennen, aber sonst nix.
Falks Plan ist doch gut, man kanns auch aus CD40xx Bausteinen bauen, 
damit der Betriebsspannungsbereich grösser wird. Oder eben mit MC...

[Stefan F. (Gast)]

Hier mal einen Schaltungsvorschlag mit Mikrocontroller. Der kostet 
übrigens nur ungefähr 1 Euro.

[pegel (Gast)]

Es geht natürlich noch ganz einfach:

Ein Magnet an die Speichen schrauben.
Am Rahmen eine Spule als Abnehmer.
Über eine Diode einen Kondensator laden, der Direkt das Relais steuert.

Das braucht nicht einmal eine Stromversorgung.

[Stefan F. (Gast)]

pegel schrieb:
> Es geht natürlich noch ganz einfach:
Nein, so geht es nicht. Das Relais würde bei jeder Radumdrehung 
klappern.

[pegel (Gast)]

Das kommt auf die Dimensionierung an.
Wenn es erst ein paar Umdrehungen braucht bis genug Ladung im C ist, 
dann nicht.

[pegel (Gast)]

Vielleicht hat das Rad sogar einen Nabendynamo, dann ist der 
schwierigste Teil der Schaltung schon drin.

[Joachim H. (jochen_hr)]

Ich danke allen, die mir hier mit Rat und Tat zur Seite stehen.
Die 3 pdf-books von Stefan(us) habe ich natürlich sofort heruntergeladen 
und von links oben nach rechts unten überflogen. Die werden mir vieles 
verständlicher machen.
Einige Bauteile habe ich ja schon, für Beschaffung fehlender habe ich ja 
Conrad vor Ort.
Also kann ich mich jetzt theoretisch und praktisch ans Werk machen.
Nochmals danke an alle für die Unterstützung.
Noch einen schönen Abend und ein ebensolchen 2. Feiertag

[G. O. (aminox86)]

Matthias S. schrieb:
> Aus mehreren Gründen würde ich den hier nicht nehmen. Erstens ist die
> Detektorfrequenz mit 1Hz hier sehr niedrig und zweitens ist das ja kein
> Baustein, der oberhalb einer Frequenz weiterhin ein Signal ausgibt. Der
> NE567 kann sehr gut eine Frequenz erkennen, aber sonst nix.

Das liest man halt so im Internet und ist nur die halbe Wahrheit. Nach 
Datenblatt liegt der Detektionsbereich des NE567 zwischen 0,01Hz! und 
500kHz. Desweitern kann man den Baustein so beschalten, dass er 
unterhalb der gewählten Frequenz zB '0' ausgibt, oberhalb jedoch '1', 
oder umgekehrt, quasi ein frequenzabhängiger Schalter. Sogar die 
Schalthysterese läßt sich anpassen.

[U. M. (oeletronika)]

Hallo,
> Joachim H. schrieb:
> Also kann ich mich jetzt theoretisch und praktisch ans Werk machen.
> Nochmals danke an alle für die Unterstützung.
ich hätte auch noch eine rel. einfache Schaltung ohne uC, die den Zweck 
erfüllen könnte -> siehe Anhang.
Es braucht nur einen IC 74HC123 (2-fach retriggerbares Monoflop)
https://assets.nexperia.com/documents/data-sheet/74HC_HCT123.pdf

Das erste Monoflop (MF-1) erzeugt am Ausgang Impulse mit 1s Länge.
Diese werden über ein Differenzierglied auf das 2. Monoflop (MF-2) 
gegeben.

Wenn das Rad langsam dreht, so dass die Periodendauer des Sensors länger 
ist als die eingestellte 1s am MF-1, dann fällt das MF-1 vorher wieder 
ab.

Wenn dann wider ein Sensorimpuls kommt, wird MF-1 wieder angetriggert.
Dreht das Rad schneller, so dass der Sensorimpuls kommt, bevor MF-1 
abfällt, bleibt MF-1 ständig aktiv.

MF-2 bekommt also von MF-1 über ein Differenzierglied Impulse, wenn die 
Geschwindigkeit geringe ist und zieht an.
Bei höherer Geschw. bleiben die Impulse aus und MF-2 fällt ab -> Motor 
kann starten. Die Zeitkonstante von MF-2 sollte etwas länger sein, so ca 
4..6 sek.

Eine Effekt hat die Schaltung aber noch.
Im Stand fällt MF-2 natürlich auch nach einiger Zeit ab und der Motor 
wird wieder aktiviert. Da kann aber evtl. sogar sehr vorteilhaftsein, 
quasi an Anfahrhilfe.
Über den Widerstand R21 kann man für die Umschaltschwelle auch noch 
etwas Hysterese auf das MF-1 geben.
Gruß Öletronika

[Stefan F. (Gast)]

Ich bin ziemlich sicher, dass innerhalb der erstem Monate Praxis-Test 
noch weitere Anforderungen dazu kommen. Und dann ist man mit so einer 
hart verdrahteten Schaltung ziemlich aufgeschmissen.

[Axel S. (a-za-z0-9)]

Wenn es ein Spezial-IC sein darf: LM2917. Ist genau dafür gemacht.
Ich habe mal ein paar auf Lüfterplatinen gefunden, die ich aus
einem Altgerät ausgebaut habe. Dienten dort als Alarmsensor bei
Lüfter-Stillstand.

[Daniel (Gast)]

Ein µC ist die erste Wahl. All dies externe Geraffel ist viel zu 
aufwendig & unpräzise. Ein ATTiny ist ausreichend. Das Programm dürfte 
in die Kategorie der Dreizeiler fallen.

[Manuel (Gast)]

Hallo erst mal:

Bin der Manuel und genau der, für den Joachim gefragt hat.
Bin absoluter Arduino Anfänger und habe den UNO Nachbau gerade eben zum 
laufen gebracht. (Blinkprogramm)

Den Sketch stelle ich mir so vor, das wenn am Eingang der Reedkontakt 
vom Fahrrad über 100 Umdrehungen in der Minute misst dann am Ausgang der 
Dreipolige Stecker mit GND  5V  Signal vom Bremseingang des 
Motorkontrollers geöffnet wird. Und der Motor läuft. Über 300 
Umdrehungen  wird der Bremseingang wieder geschlossen und der Motor geht 
aus.

Geht das mit einem Dreizeiler?

[Stefan F. (Gast)]

Arduino UNO ist nicht gerade von uns empfohlen worden. Der eignet sich 
für Batteriebetrieb nicht gut, weil er eine hohe Ruhestromaufnahme hat.

Halte Dich an die obigen Empfehlungen.

> Geht das mit einem Dreizeiler?

Da hat der Daniel Dir einen Bären aufgebunden. Er wollte damit zum 
Ausdruck bringen, dass das für Profis eine relativ einfache Aufgabe ist. 
Drei Zeilen reichen dazu aber nicht, sonst hätte die hier bereits jemand 
hin geschrieben. Es werden wohl eher 100 sein.

[Manuel (Gast)]

Oh, sorry, ich meinte nicht UNO sondern NANO,
Die Stromversorgung geht über den großen Akku vom Rad.

[Christoph db1uq K. (christoph_kessler)]

Ohne Mikrocontroller würde ich auch den LM2907 / LM2917 vorschlagen
https://www.reichelt.de/konverter-f-v-dip-8-lm-2907-dip-p10436.html?&trstct=pol_28
8-poliges DIL-IC 1,55€ bei Reichelt, der LM2917 hat 14 Pins

da der Datenblatt-Link hier ins Leere führt:
http://www.ti.com/lit/ds/symlink/lm2907-n.pdf

Ein Frequenz-Spannungs-Wandler.  Die Applikationsschaltung benötigt noch 
2 Widerstände und 2 Kondensatoren. Für die Schaltschwelle muss man noch 
einen Komparator nachschalten.

[Axel S. (a-za-z0-9)]

Christoph db1uq K. schrieb:

> http://www.ti.com/lit/ds/symlink/lm2907-n.pdf
>
> Ein Frequenz-Spannungs-Wandler.  Die Applikationsschaltung benötigt noch
> 2 Widerstände und 2 Kondensatoren. Für die Schaltschwelle muss man noch
> einen Komparator nachschalten.

Noch nicht mal das. Figure 18. "Speed Switch" auf Seite 15 des 
Datenblatts ist genau die gesuchte Schaltung, die eine Last bestromt, 
wenn eine bestimmte Eingangsfrequenz (bestimmt durch einen Kondensator 
und einen Widerstand) überschritten wird.

[Manuel (Gast)]

Hat denn keiner ein Beispiel Sketch für den NANO
auf Lager, das so halbwegs passt und funktioniert?
Zu Weihnachten so zu sagen.

[m.n. (Gast)]

Doch, auch wenn noch viel mehr dabei erledigt wird: 
http://mino-elektronik.de/fmeter/fm_software.htm#bsp7

Es geht letztlich um eine Frequenz bzw. Drehzahlmessung. Die Anzeige 
kannst Du weglassen und in der Endlosschleife in main() abhängig von der 
gemessenen Frequenz eine Entscheidung einbauen, die das notwendige 
Signal erzeugt.
Schaffst Du das?

Das Signal vom Reedrelais kannst Du einfach mit einem RC-Glied (50 ms) 
entprellen, da der AVR schon Schmitttriggereingänge hat.

[Manuel (Gast)]

Danke erst mal.

Aber die ich suche einen möglichst einfachen Sketch den auch ein 
Anfänger mit etwas studieren verstehen kann. Und dann auch selber 
anpassen kann.
Drehzahl / Schaltkontakt Verhältnis.

Ich würde gerne nur den Reedkontakt abtasten in Verhältnis zur Zeit 
setzen und den Motor dann nur bei Wunsch Geschwindigkeit mit laufen 
lassen.

Denke ich da zu einfach?
Wie ein Fahrradtacho nur ohne Anzeige, stattdessen zwei Schaltpunkte. 
Bei 10 km/h ein und 25 km/h aus.

[Stefan F. (Gast)]

> Ich würde gerne nur den Reedkontakt abtasten in Verhältnis zur Zeit
> setzen und den Motor dann nur bei Wunsch Geschwindigkeit mit laufen
> lassen.

Klingt erstmal gut.

> Denke ich da zu einfach?

Ja vermutlich. Aber der Ansatz ist gut.

Wenn das Ding am Ende angenehm arbeiten soll muss wohl noch etwas mehr 
"Intelligenz" rein. Wenn die Geschwindigkeit z.B. knapp an der 
Schaltschwelle liegt, wirst du nicht wollen, dass der Antrieb immer 
abwechselnd an und aus geschaltet wird. Ein Zweipunktregler (mit zwei 
Schaltschwellen) verbessert das Verhalten. Aber egal, fange einfach mal 
an. Die Ideen zur Verbesserung werden von alleine kommen. Aus diesem 
Grund hatte ich zu einer programmierbaren Lösung geraten.

Du willst also Arduino nutzen. Da kannst du den Millisekunden-Counter 
zur Messung verwenden. Im Prinzip so:

unsinged long time=0;

void loop()
{
  if (Kontakt geschlossen)
  {
    // Zeit-Differenz zum vorherigen Impuls ermitteln
    unsigned long diff=millis()-time;
    time=millis();

    // Abhängig von der Zeitspanne reagieren
    if (diff<500)
    {
       motor einschalten;
    }
    else
    {
        motor aus schalten;
    }

    // Kontakt ggf. entprellen
    delay(10);
  }
}

Zum Abfragen des Sensors und zum Ansteuern des Motors (vermutlich über 
Optokoppler) wirst du die Funktionen pinMode(), digitalRead() und 
digitalWrite() brauchen.

Bevor wir weiter in die Details gehen, solltest du den Schaltplan 
zeigen. Dazu können wir auch Verbesserungstipps geben, zum Beispiel 
bezüglich elektromagnetischer Entstörung.

Und dann musst du noch ausprobieren, wie du den Motor ansteuern kannst. 
Ich bin jetzt einfach mal von einem Optokoppler parallel zum vorhandenen 
Schaltkontakt ausgegangen, dies sollte man frühzeitig überprüfen. 
Besorge Dir einen gewöhnlichen Optokoppler (PC817) und eine 3V 
Knopfzelle (Typ CR2032 oder kleiner), damit kannst du das antesten. Die 
Knopfzelle ist so schwach, dass du sie ausnahmsweise ohen Vorwiderstand 
direkt an den Eingang des Optokopplers halten kannst.

In meinem oben verlinkten Buch Band 2 findest du ein kleines Kapitel 
über Optokoppler.

[Manuel (Gast)]

Danke für die Hilfe!
So habe ich mir das vorgestellt.

Ich bin wie gesagt ganz am Anfang, hatte zuerst Probleme das aktuelle 
Arduino Programm zum laufen zu bekommen auf meinem alten PC.

Ein extra Opptokopler ist glaube ich gar nicht nötig, weil der 
Motorcontoller am Bremskontakt der eigentlich für Bremshebel mit 
Hallsensoren gedacht ist schon GND, 5V und Signal hat, was direkt der 
Arduino bedienen können müsste. Es soll sogar reichen Signal dort auf 
GND zu legen um den Motor ein und aus zu schalten.

Mein Hauptproblem ist der Sketch der den Reedschalter auslesen soll und 
dann den Motor controller an zwei festgelegten Geschwindigkeiten 
schaltet.
Ab 10 kmh an.
Ab 25 kmh aus.

[Stefan F. (Gast)]

Manuel schrieb:
> Ein extra Opptokopler ist glaube ich gar nicht nötig, weil der
> Motorcontoller am Bremskontakt der eigentlich für Bremshebel mit
> Hallsensoren gedacht ist schon GND, 5V und Signal hat, was direkt der
> Arduino bedienen können müsste. Es soll sogar reichen Signal dort auf
> GND zu legen um den Motor ein und aus zu schalten.

Und wie verhinderst du dann einen Kurzschluss, wenn der Mikrocontroller 
"An" sagt und der vorhandene Schaltkontakt "Aus" sagt (oder umgekehrt)? 
Möglicherweise reagiert die Motorsteuerung auch sehr empfindlich auf 
Fremdspannung.

Mit einem Optokoppler bist du auf der Sicheren Seite, damit kannst du 
kaum etwas kaputt machen.

> Es soll sogar reichen Signal dort auf
> GND zu legen um den Motor ein und aus zu schalten.

Eben das kannst du mit einem Optokoppler einfach und sicher machen.

> Mein Hauptproblem ist der Sketch der den Reedschalter auslesen soll
> und dann den Motor controller an zwei festgelegten Geschwindigkeiten
> schaltet.

Der Sketch ist dein Problem? Dann lösche ihn, schon ist das Problem weg 
:-)

Spass beiseite: Du musst dein Problem schon besser beschreiben, damit 
man Dir helfen kann.

[Joachim H. (jochen_hr)]

@stefanus ich meld mich nochmal bez Schwellwert.
Bei dieser Steuerung benötigt man mM nicht unterschiedliche Schaltungen 
um einen Schwellwert.
Hier geht's um Radfahren, da ist eine genaue Geschwindigkeit am 
Schwellwert gar nicht gewünscht/erforderlich. Es soll lediglich beim 
"manuellen" Beschleunigen am unteren Schwellwert der Motor unterstützend 
zugeschaltet werden, um weiter zu beschleunigen. Im anderen Fall, er 
möchte eigentlich nicht schneller fahren; vom Motor her wäre noch weiter 
Unterstützung möglich; soll die Unterstützung wegfallen. Er möchte auch 
nicht konstant die Geschwindigkeit des oberen Schwellwertes fahren, sie 
soll nur  den Motorstrom abschalten. Er fährt also eigentlich immer im 
"Abstand" zur "Schaltgeschwindigkeit".
Natürlich sollte, um das technisch korrekt zu gestalten, so eine 
"Hysterese" in der Schaltung vorhanden sein. Aber für uns "Beginner" 
gestaltet es sich wahrscheinlich einfacher ohne Hysterese.

[Stefan F. (Gast)]

Joachim H. schrieb:
> @stefanus ich meld mich nochmal bez Schwellwert.
> Bei dieser Steuerung benötigt man mM nicht unterschiedliche Schaltungen
> um einen Schwellwert.

Wie willst du dann diese Anforderung umsetzen?:

Manuel schrieb:
> Ab 10 kmh an.
> Ab 25 kmh aus.

Da hat er doch zwei konkrete Schaltschwellen genannt.

[Joachim H. (jochen_hr)]

Mißverständnis; es geht darum: für jeden Schwellwert  je einen 
Schaltpunkt "aufwärts" und einen "abwärts", so wird es doch technisch 
korrekt gehandhabt?

[Stefan F. (Gast)]

Joachim H. schrieb:
> Mißverständnis; es geht darum: für jeden Schwellwert  je einen
> Schaltpunkt "aufwärts" und einen "abwärts", so wird es doch technisch
> korrekt gehandhabt?

Ich denke schon, ja.

[Manuel (Gast)]

Ich wollte eigentlich auch den Strom für den Arduino an den drei Adern 
am Controller abgreifen und der Arduino sollte dann wie sonst der 
Hallsensor im Bremsgriff schalten. Geht das nicht? Wäre das gleiche 
Potenzial wollte mir mal einer einreden...Dann wäre es wohl doch sicher 
das der Arduino ein Relais oder Optokoppler schaltet? Und das Relais 
dann Signal und GND verbindet? Extra Strom mit 5V für den Arduino könnte 
ich auch von meinem Regler für die Beleuchtung abgreifen.

[Stefan F. (Gast)]

Manuel schrieb:
> Ich wollte eigentlich auch den Strom für den Arduino an den drei Adern
> am Controller abgreifen und der Arduino sollte dann wie sonst der
> Hallsensor im Bremsgriff schalten. Geht das nicht?

Ohne technische Informationen zu den Anschlüssen und Signalen des 
Controllers kann man dazu nichts sagen.

Hallsensor? Diese Salamitaktik ist anstrengend. Abr auch hierzu kann ich 
ohne technische Daten nichts weiter sagen.

> Dann wäre es wohl doch sicher
> das der Arduino ein Relais oder Optokoppler schaltet?

Das habe ich empfohlen, unter der Annahme, dass es einfach damit getan 
ist, eine Leitung auf Low (GND) zu ziehen. Aber ich habe inzwischen eher 
das Gefühl, dass ihr wild ratet, anstatt euch auf Fakten und Messungen 
zu stützen.

Was passiert wohl mit dem Hallsensor, wenn der einen High Pegel ausgibt, 
und ein Relais oder Optokoppler dessen Ausgang mit GDN kurzschließt?

Technische Daten müssen her, am Besten Schaltungsunterlagen.

[Manuel (Gast)]

Das war ein Missverständniss.
Es gibt für Pedelecs Bremshebel die Hallsensoren verwenden. Ich habe 
keine sondern nur die Eingänge dafür am Motorcontroller die ich zum 
schalten verwenden will. Schaltpläne von diesen Chinacontroller habe ich 
nicht.

[Manuel (Gast)]

Foto

[Stefan F. (Gast)]

Diese Infos genügen mir nicht. Daraus geht nicht hervor, wie die Signale 
aussehen müssen.

[Joachim H. (jochen_hr)]

Die Bremsschalter sind einfache Reedschalter
Da die meisten ohne Bremsschalter fahren, müßte also "Ruhestellung" 
"Off" sein.

[Manuel (Gast)]

Die Bremshebel mit drei Kabeln haben Hallsensoren und werden verbunden 
mit GND , 5V und Signal.
Siehe mein Foto von der Anleitung.

Aber egal, mir geht es erst mal um den Sketch.
Wenn der Arduino schaltet wie gewünscht ist schon fast alles geschafft. 
Auch wenn man dann noch ein Relais oder Optokoppler nimmt. Und eben dann 
zweipolig an den Controller geht. So wie es die Anleitung auch erklärt.

[pegel (Gast)]

Eigentlich brauchst du nur die aktuelle Geschwindigkeit.
Daraus lässt sich alles andere Berechnen.

Ich würde einfach mal damit anfangen.

[pegel (Gast)]

Das ist recht einfach aufgebaut.
https://www.youtube.com/watch?v=1ycA7TFV4t4

Den Code dazu:
https://github.com/AlexGyver/EnglishProjects/tree/master/Arduino_speedometer

Auch überschaubar. Die Funktion sens() berechnet die Geschwindigkeit.
Der Rest ist Luxus.

[Manuel (Gast)]

Viel zu kompliziert.
Da ich ja die Geschwindigkeit nicht anzeigen möchte damit, würde auch 
reichen die Drehzahl zu messen und darüber ein und aus zu schalten.

[Stefan F. (Gast)]

Manuel schrieb:
> Viel zu kompliziert.
> Da ich ja die Geschwindigkeit nicht anzeigen möchte damit, würde auch
> reichen die Drehzahl zu messen und darüber ein und aus zu schalten.

Du brauchst nichtmal die Drehzahl, sondern nur die Zeitspannen zwischen 
zwei Impulsen. Hast Du Dir mein halbfertiges Code-Beispiel angesehen?

[pegel (Gast)]

Du möchtest die Geschwindigkeit nicht anzeigen, aber damit rechnen 
möchtest du schon.

Wenn du darüber nachdenkst wirst du zwischen den beiden Messmethoden nur 
einen minimalen Unterschied feststellen.

[Manuel (Gast)]

Ich taste mich langsam ran.
Habe das Blinkprogramm so abgeändert,
das nun eine LED am Ausgang 12 leuchtet statt an 13 zu blinken. Nun muss 
ich den Arduino nur noch dazu bewegen das er das nur noch dann macht 
wenn er am Eingang mit dem Reedschalter so ca. 100-300 Umdrehungen 
erkennt.
Nicht lachen, ist mein erster Versuch mit so einem NANO.

[m.n. (Gast)]

Manuel schrieb:
> Aber egal, mir geht es erst mal um den Sketch.

Was wäre, wenn Du Dir das gezeigte, fertige Programm einfach einmal auf 
den Arduino spielst und damit arbeitest? Der zeitliche Aufwand dafür 
dürfte unter fünf Minuten betragen.
Du brauchst es ja zunächt nicht zu verstehen, außer an einer Stelle in 
main() eine kleine if()-Abfrage einzubauen. So könntest Du zumindest 
Deine genauen Anforderungen abklären, bevor dann die ganze Geschichte 
auf einen ATtiny25 'eingedampft' wird.
Zudem könntest Du dann auch erkennen, daß das Einbringen einer Hysterese 
ein Klacks ist.

Vielleicht denkst Du mal darüber nach, bevor Du alles selber können 
willst.

[Manuel (Gast)]

Ja, danke Stefanus,
habe mir das Code Beispiel angesehen.
Aber da fehlt sicher noch einiges.
Und was heißt unsiged / unsigned
In grau und grün?

[Rudi D. (rulixa)]

Joachim H. schrieb:
> Kann mir jemand behilflich sein?
> Danke vorab

Nimm doch einfach einen URalt Drehzahlmesser aus den 60 Jahren mit 2 
Transistoren.

[Stefan F. (Gast)]

Manuel schrieb:
> Aber da fehlt sicher noch einiges.

Ja sicher, ist nur ein Lösungsansatz.

> Und was heißt signed / unsigned

Steht in der Arduino Doku. Erst lesen, dann fragen.

> In grau und grün?

Was in grau und grün?

[Manuel (Gast)]

Im Lösungsansatz ist ein Teil des Textes in grün angezeigt.
Brauche ich eigentlich einen zweiten Reedschalter für den Arduino oder 
kann ich den vom Fahrrad Tacho anzapfen?

[Stefan F. (Gast)]

Manuel schrieb:
> Im Lösungsansatz ist ein Teil des Textes in grün angezeigt.

Das sind Kommentare. Jetzt ist die Zeit gekommen, wo du ein Arduino 
Tutorial durcharbeitest. Ich hatte eigentlich einen anderen Start (mit 
meinen Büchern) vorgeschlagen, aber du hast ja zu Arduino gewechselt. 
Was auch Ok ist, aber dann musst du Dich halt damit befassen.

> Brauche ich eigentlich einen zweiten Reedschalter für den
> Arduino oder kann ich den vom Fahrrad Tacho anzapfen?

Weiter oben hatte ich mit Begründung empfohlen, einen zweiten 
Reedschalter anzubringen.

[Ach Du grüne Neune (Gast)]

Es gibt doch noch den CD4046. Dem sind die kurzen Nadelimpulse vom 
Reedkontakt am Eingang egal. Lediglich müssen je nach Raddurchmesser R1 
und C1 auf die 8km/h angepasst werden.

[Manuel (Gast)]

Wieder ein Erfolg!
Habe jetzt einen Reedschalter am Arduino und die LED blinkt bei jeder 
Magnet Annäherung auf.
Jetzt kommt das schwierige mit zählen nach Zeit ...

Es soll mit einem! Reedschalter gehen.
Notfalls einer für Tacho am Vorderrad und einer für Arduino am Hinterrad 
wegen unterschiedlicher Spannung.

[Stefan F. (Gast)]

Du kannst ruhig beide ans selbe Rad montieren, direkt nebeneinander.

[Manuel (Gast)]

Foto

[Manuel (Gast)]

Der Fahrrad Tacho hat auch nur einen.

[Manuel (Gast)]

Da tut sich nix an der LED...

// Schubabschaltung


unsigned long time_now = 0;
int time=1;
int LED=6;
int taster=7;
int tasterstatus=0;

void setup()
{
pinMode(LED, OUTPUT);
pinMode(taster, INPUT);
}
void loop()
{
tasterstatus=digitalRead(taster);
if (tasterstatus == HIGH);
{
unsigned long diff=millis()-time;
time=millis();
if (diff<500);
{
digitalWrite(LED, HIGH);
}
digitalWrite(LED, LOW);
}
}

[pegel (Gast)]

Bitte den Code richtig einrücken.
Hinter die if Bedingung kein Semikolon, denn damit ist der Befehl 
abgeschlossen.

[Stefan F. (Gast)]

Bitte nenne den Sensor nicht "taster", das ist irreführend. Und benutze 
die Tags zum Formatieren, siehe die Anleitung direkt über dem 
Eingabefeld.

Ich sehe da mehrere Fehler:

1) Die Variable time_now wird nicht benutzt und die Variable time hat 
den falschen Typ. Die Zeitberechnung funktioniert nur dann korrekt, wenn 
die Variable den gleichen Typ hat, wie der Rückgabewert von millis().

2) Hinter "if (tasterstatus == HIGH)" gehört kein Semikolon, ansonsten 
wird der Code-Block dahinter nämlich völlig unabhängig von der Bedingung 
ausgeführt.

3) Wenn diff<500 ist schaltest du die LED an, und direkt danach 
schaltest sie ohne Bedingung (also immer) direkt wieder aus.

4) Du musst nach Erkennung des Impulses noch abwarten, bis der Kontakt 
wieder geöffnet wird. Erst nach dem Öffnen beginnt die nächste 
Auswertung der nächsten Zeitspanne.

5) Der Sensor zieht den Eingang auf Low. Ein interner Pull-Up Widerstand 
zieht ihn auf High.

Außerdem sparst du ein bisschen RAM, wenn du die Konstanten mit #define 
hin schreibst. #define definiert eine simple Textersetzung im Quelltext 
und belegt daher keinen Speicherplatz im (kostbaren) RAM. Noch hast du 
zwar reichlich RAM, aber irgendwann in Zukunft wird Dir diese 
Vorgehensweise helfen.

Konstanten schreibt man normalerweise in Grossbuchstaben, um sie 
sichtbar als Konstante zu kennzeichnen. Technisch ist es egal.

unsigned long time=0;

#define LED 6
#define SENSOR 7;

void setup()
{
    pinMode(LED, OUTPUT);
    pinMode(SENSOR, INPUT_PULLUP);
}

void loop()
{
    // Wenn der Speuchen-Magnet am Sensor ist
    int sensorstatus=digitalRead(SENSOR);
    if (sensorstatus == LOW)
    {
        // Zeit erfassen
        unsigned long diff=millis()-time;
        time=millis();

        // Wenn weniger als 500ms seit dem letzten Impuls
        if (diff<500);
        {
            digitalWrite(LED, HIGH);
        }
        else
        {
           digitalWrite(LED, LOW);
        }

        // Warte, bis der Magnet wieder weg ist
        do
        {
           delay(5); // Zum Entprellen
        }
        while (digitalRead(SENSOR) == LOW)
    }
}

So müsste es gehen. Hast du Fragen zu meinen Änderungen?

Irgendwann können wir uns vielleicht mal über Multi-Tasking mit 
Zustandsautomaten unterhalten, aber momentan möchte ich Dich damit nicht 
überfordern.

[pegel (Gast)]

Du hast auch das Semikolon hinter der if Bedingung drin.

[Stefan F. (Gast)]

pegel schrieb:
> Du hast auch das Semikolon hinter der if Bedingung drin.

Oh Scheiße. Das muss weg.

[Manuel (Gast)]

Apropro Pullup
Bei meinem ersten Versuchsprogramm ging das nur mit einem externen 
Wiederstand am Schalter?
(Das Programm wo ich den Bildschirm fotografiert habe)

[Stefan F. (Gast)]

Manuel schrieb:
> Bei meinem ersten Versuchsprogramm ging das nur mit einem externen
> Wiederstand am Schalter?

Ja, weil du den internen Pull-Up Widerstand des Mikrocontroller nicht 
aktiviert hast.

[Manuel (Gast)]

Ich habe das damit probiert
pinMode(Taster, INPUT_PULLUP);
ging aber nicht.

Im letzten Sketch Vorschlag kommen viele Fehlermeldungen , die erste in 
Zeile 9.

Ich glaube mein Hirn ist zu klein.
Kann mir keiner einen lauffähigen Sketch senden?
Ich könnte dann eher erkennen was ich falsch mache.
So dauert das raten noch Jahre.

[Stefan F. (Gast)]

Manuel schrieb:
> Kann mir keiner einen lauffähigen Sketch senden?

Eigentlich sollst du die Programmiersprache selbst lernen, damit du den 
Sketch auch selbst anpassen kannst.

unsigned long time=0;

#define LED 6
#define SENSOR 7

void setup()
{
    pinMode(LED, OUTPUT);
    pinMode(SENSOR, INPUT_PULLUP);
}

void loop()
{
    // Wenn der Speuchen-Magnet am Sensor ist
    int sensorstatus=digitalRead(SENSOR);
    if (sensorstatus == LOW)
    {
        // Zeit erfassen
        unsigned long diff=millis()-time;
        time=millis();

        // Wenn weniger als 500ms seit dem letzten Impuls
        if (diff<500)
        {
            digitalWrite(LED, HIGH);
        }
        else
        {
           digitalWrite(LED, LOW);
        }

        // Warte, bis der Magnet wieder weg ist
        do
        {
           delay(5); // Zum Entprellen
        }
        while (digitalRead(SENSOR) == LOW);
    }
}

Es war einfach ganz oben ein Semikolon zu viel und ganz unten eins zu 
wenig. Jetzt lerne bitte die Programmiersprache. Programme schreiben 
sich nicht von selbst, so wie Elektronik sich nicht von selbst 
entwickelt.

Entweder lernst du es, oder bezahlst andere dafür. Aber hier für jeden 
kleinen Piep nachzufragen ist langfristig der falsche Weg. Mit Arduino 
ist es so einfach wie nie zuvor.

Einstiegspunkt für das Tutorial: 
https://www.arduino.cc/en/Tutorial/BareMinimum

Dann: https://www.arduino.cc/en/Tutorial/BuiltInExamples

Und hier ist die Referenz-Doku die jeden einzelnen Befehl beschreibt: 
https://www.arduino.cc/reference/en/

[Manuel (Gast)]

Vielen Dank !!! !!! !!!

Es funktioniert! Bei hoher Geschwindigkeit würde die Schubabschaltung 
aktiv werden. Nun muss ich das nur noch anpassen das die 
Schubabschaltung auch bei zu niedriger Geschwindigkeit abschaltet. Ich 
werde mich reinknien.

Versprochen!

Es soll ja so sein das der Motor nur zwischen ca. 10km/h und 25km/h 
läuft.
Werde den Sketch zeigen wenn ich es geschafft habe.
Dann müssen natürlich auch die Werte zur Wunschgeschwindigkeit 
ausprobiert werden. Ich denke aber das ich an dem funktionierenden 
Sketch besser voran kommen werde als völlig im Dunkeln zu tappen.

Was ich nur nicht verstehe ist das mein Sensor auch mit diesem Programm 
nur mit externen 1 kohm Widerstand am Sensor und GND funktioniert.

[Stefan F. (Gast)]

Schau Dir mal diese Anleitung an, wie man Qt Creator als "besseren" 
Editor für Arduino einsetzt. 
http://stefanfrings.de/esp8266/index.html#qtcreator

Du musst dabei allerdings andere Verzeichnisse einstellen (da sich die 
Anleitung auf das ESP8266 Plugin bezieht).

Der Compiler-Pfad ist:
Für C: c:\...\arduino-1.8.7\hardware\tools\avr\bin\avr-gcc.exe
Für C++: c:\...\arduino-1.8.7\hardware\tools\avr\bin\avr-cpp.exe

Als Library Verzeichnis brauchst du alle Verzeichnisse unter
c:\...\arduino-1.8.7\hardware\arduino\avr\libraries\...
und
c:\...\arduino-1.8.7\hardware\arduino\avr\cores\arduino

Das schöne an dem Editor ist, dass er Dir fast alle Fehler schon während 
des Tippens anzeigt und meistens auch in besser verständlicher Form.

[Stefan F. (Gast)]

Manuel schrieb:
> Was ich nur nicht verstehe ist das mein Sensor auch mit diesem Programm
> nur mit externen 1 kohm Widerstand am Sensor und GND funktioniert.

Der Sensor gehört zwischen den Eingang und GND, nicht zwischen den 
EIngang und VCC. Ich habe das weiter oben doch schon skizziert.

[Manuel (Gast)]

Ach Du Scheiße...

ich hatte den GND von der anderen Seite genommen,
und weil das nicht ging aus Verzweiflung 5V genommen.
Muss doch einem alten Mann gesagt werden.
Hatte mich gleich gewundert warum die LED so unterbelichtet geschaut 
hat...
lach...

Dann kann ich ja den Widerstand wieder einmotten.

Echt beeindruckend wie das jetzt funktioniert.

Nochmal Danke !!!!!!

PS:

Wo würde ein Profi ansetzen um nun noch bei niedriger Geschwindigkeit 
den Schub abzuschalten? Ohne die andere Funktion zu versauen?

[Stefan F. (Gast)]

> Wo würde ein Profi ansetzen um nun noch bei niedriger Geschwindigkeit
> den Schub abzuschalten? Ohne die andere Funktion zu versauen?

Schau Dir das an: 
https://www.arduino.cc/reference/en/language/structure/control-structure/else/

Und dann denke mal selber nach.

Wenn du weitere Codes von mir haben willst, dann musst du mich dafür 
bezahlen. Du lässt Dich hier bedienen und den Popo pudern, ignorierst 
sämtliche Hinweise auf Doku und Tutorials, dass es wirklich ärgerlich 
wird.

Bei anderen Fragen helfe ich gerne weiter.

Viel Glück.

[Manuel (Gast)]

ich verstehe was Du meinst, bin auch jetzt schon Dir wirklich sehr 
dankbar.
Muss mich wie gesagt erst mal damit befassen.

if ((diff<500)&&(diff>100))

das ging schon mal nicht...

Ich hatte nur ein einfaches Lehrbuch für Kinder.
Da gab es nicht mal "else"...

[Stefan F. (Gast)]

> if ((diff<500)&&(diff>100))
> das ging schon mal nicht...

Warum nicht?
Wie testest du das eigentlich?

[Manuel (Gast)]

im Moment teste ich mit einem Magneten in der Hand
und einem Reedschalter am Arduino.
Klappt einwandfrei.

Langsam vorbei bewegen = LED aus. ( für Tempo 10-25 )
Schnell vorbei bewegen = Led an.  ( für Tempo über 25 )

Fehlt nur noch:
ganz langsam vorbei bewegen = LED an. ( für Tempo unter 10 )

[Stefan F. (Gast)]

Manuel schrieb:
> Langsam vorbei bewegen = LED aus.

Das ist der Fall >500ms

> Schnell vorbei bewegen = Led an.

Das ist der Fall 100 bis 500ms

Und dann fehlt noch noch <100ms:
Sehr schnell vorbei bewegen -> LED aus

[Manuel (Gast)]

Ich habs!!!!!

if ((diff<200)or(diff>500))

100 hat nicht gepasst für mein schwenken.
Das es "oder" statt "und" heißen muss war sogar mir klar.

Wenn ich schul wäre,
ich würde Dich küssen.

Ist das geil !!!!

[Stefan F. (Gast)]

Jetzt rechne mal die richtigen Zeiten aus. Du muss nur den Radumfang 
ausmessen.

geht das wirklich mit "or"? In C schreibt man eigentlich "||".

[Manuel (Gast)]

Ja,
ich hatte erst im Netz was von && gefunden,
aber dann beim Testen ist mir eingefallen das "Und" ja gar nicht passt.
Also musste "oder" her, und ich dachte das Programm will, weil ja alles 
englisch ist, sicher "or" und ging sofort.
Ein blindes Huhn findet manchmal auch ein Korn...

Ja, das mit dem Radumfang kenne ich vom Tacho und von diversen 
Berechnungen
mit der Motordrehzahl. Es ist ein 20 Zoll Rad und der Motor hat eine 
Nenndrehzahl von 300. Aber bei einem dicken Reifen und vollem Akku ist 
das so knapp über 30 km/h. Deshalb die Schubabschaltung.

Beim langsam fahren ist das Problem, das sobald man die Pedale bewegt 
der Motor voll anschiebt. Deshalb möchte ich das der Motor erst ab ca. 
10 km/h
einsetzt. Es gibt zwar einen Stufenschalter aber das ist unpraktisch da 
immer zweimal drauf zu drücken um von 3 auf 1 zu kommen und das gleiche 
Spiel zurück.

Mit dem zweiten Magnetschalter werde ich wohl so machen müssen.

Die Frage ist nur noch ob ich ein Arduino Relais oder Optokoppler 
brauche
oder ob der Eingang am Controller GND  Signal  5 V nicht der Arduino 
direkt übernehmen kann. Im Prinzip machen ja die Bremsgriffe mit 3 Kabel 
und Hallsensor das Gleiche. GND und 5 V rein und GND und Signal werden 
verbunden bei Hebel Betätigung. Es gibt auch Hebel mit Zwei Leitungen 
und die Verbinden dann Signal und GND direkt ohne 5V.
Notfalls hätte ich für die Relais Variante noch 5V am Akku zur 
Verfügung.

Hätte nie gedacht das es heute schon läuft.
Vielen Dank noch mal !!!

[Stefan F. (Gast)]

Manuel schrieb:
> oder ob der Eingang am Controller GND  Signal  5 V nicht der Arduino
> direkt übernehmen kann

Frage doch nicht immer wieder!
Ich habe mehrfach zum Optokoppler geraten. Dafür habe ich eine Menge 
Gründe, die du allerdings mangels Grundkenntnisse nicht verstehen wirst. 
Mit Optokoppler bist du auf der sicheren Seite.

> Hätte nie gedacht das es heute schon läuft.

Jetzt siehst du, warum Dir so viele Leute zum Mikrocontroller geraten 
haben. Es sollte wohl auch offensichtlich sein, dass weitere Änderungen 
beim Mikrocontroller viel einfacher umzusetzen sind, als bei einer 
gelöteten Schaltung.

Nach diesem ertsen Erfolgserlebnis hast du vielleicht Lust, dich mit dem 
Buch (http://stefanfrings.de/mikrocontroller_buch/index.html) zu 
beschäftigen. So lernst du ein bisschen Grundlagen von Elektronik und 
Grundlagen der Programmierung.

[Manuel (Gast)]

Ja, ich werde mich sicher noch etwas mehr mit der Materie beschäftigen. 
Nun geht es aber erstmal an den Rad Umbau.

Mein Chinamann hat nur Relais auf Platine mit Anschlüssen die der 
Arduino ansteuern kann. Geht ja sicher auch.
Mit Optokopplern kenne ich mich auch nicht aus.

[Stefan F. (Gast)]

Manuel schrieb:
> Mein Chinamann hat nur Relais auf Platine mit Anschlüssen die der
> Arduino ansteuern kann.

Die meisten davon enthalten Optokoppler, die man leicht entlöten kann. 
Aber Relais geht natürlich auch, solange du den Stromverbrauch nicht 
minimieren willst.

> Mit Optokopplern kenne ich mich auch nicht aus.

Ist eigentlich ganz simpel:
Eingangsseitig steckt da eine Led drin, die auf einen Transistor 
leuchtet und diesen damit einschaltet.

[Manuel (Gast)]

Niedriger Stromverbrauch ist immer gut, gerade bei Akkubetrieb. Aber ich 
denke bei einem 600 Wattstunden Akku wird ein Relais nicht so viel 
ausmachen.

Was ich wieder nicht verstehe:
Warum macht man Optokoppler mit Relais zusammen?
Das Relais trennt doch auch schon.
Elektronisch geschaltet ohne Relais, da sehe ich als Vorteil den nicht 
vorhandenen Kontakt Verschleiß.

[Stefan F. (Gast)]

Manuel schrieb:
> Warum macht man Optokoppler mit Relais zusammen?

Das versteht niemand hier. Das musst du den Chinesen fragen, der sich 
das ursprünglich ausgedacht hat. Wir kennen ihn leider nicht.

> Das Relais trennt doch auch schon.
Eben

> Elektronisch geschaltet ohne Relais, da sehe ich als Vorteil den nicht
> vorhandenen Kontakt Verschleiß.

Der Kontakt verschleisst nur nennenswert, wenn er überlastet wird.

[U. M. (oeletronika)]

Hallo,
> Manuel schrieb:
> Die Frage ist nur noch ob ich ein Arduino Relais oder Optokoppler
> brauche
> oder ob der Eingang am Controller GND  Signal  5 V nicht der Arduino
> direkt übernehmen kann. Im Prinzip machen ja die Bremsgriffe mit 3 Kabel
> und Hallsensor das Gleiche. GND und 5 V rein und GND und Signal werden
> verbunden bei Hebel Betätigung.
Da bin ich der Meinung, dass Optokoppler oder Relais eher nicht 
unbedingt nötig sind.
Da solche Schaltung mit GND üblicherweise auf Fahrzeugmasse liegt und 
die Leitungen kurz sind, wird man kaum mit Störungen rechnen müssen, 
welche es sonst sinnvoll machen, eine galvanische Trennung über 
Optokoppler oder Relais zu realisieren.
Allerdings muß man sich darüber auch kler sein, dass Eingänge von uC 
recht empfindlich gegen Überspannungen (ESD Störungen im Bordnetz) sind.
Aus diesem Grund ist es sehr zweckmäßig, uC-Pins von der peripheren 
Schaötungen zu entkoppeln und gegen Überspannung und bei Ausgängen evtl. 
auch gegen Kurzschluss zu schützen.


> Es gibt auch Hebel mit Zwei Leitungen
> und die Verbinden dann Signal und GND direkt ohne 5V.
Das würde heißen, dass das Signal low-aktiv geschaltet werden soll.
Messe mal den Strom mit einem Multimeter, der da fließt, wenn das Signal 
auf GND geklemmt wird. Vermutlich liegt der Strom nur bei 1mA oder 
weniger.

Um das umzusetzen und den uC zu entkopplen eignet sich ein robuster 
npn-Bipolartranssitor sicher gut.
Zwischen uc und Basis gehört ein Basisvorwiderstand.
Da sicher nur ein geringer Strom geschaltet werden muß, kann dieser rel. 
hochohmig sein (z.B. 2,2...10 kOhm).
Am uC läßt sich dann der Eingang leicht mit einer Z.Diode (5,6V) oder 
mit Dioden gegen GND und 5V gut schützen
-> wie Schaltung im Anhang:
* Eingang ist links, nach rechts geht es zum uC.
* links käme in dem Fall die Basis vom Transistor dran (die Pullup-R 
wären dann nicht nötig).

Man kann die Entkopplung auch mit einem Optokoppler machen, allerdings 
sind bei der Dimensionierung auch ein paar Sachen zu beachten.

> Notfalls hätte ich für die Relais Variante noch 5V am Akku zur
> Verfügung.
Ein Relais braucht vergleichsweise viel Strom. Bei der Relaiswicklung 
unbedingt die "Freilaufdiode" vorsehen. Der direkte Betrieb an einem 
uC-Pin ist nicht unbedingt vorteilhaft, da wäre ein 
npn-Treibertransistor auch empfehlenswert. Damit hat man dann aber in 
Summe noch mehr Aufwand.
https://www.mikrocontroller.net/articles/Relais_mit_Logik_ansteuern
Ein Relaiskontakt ist allerdings völlig unempfindlich gegen diverse 
Störungen aus dem Bordnetz.
Diesbezüglich ist aber auch die 5V-Stromversorgung gefährdet.
Wenn diese aus einer vorhandenen Stromversorgung kommt, ist das weniger 
kritisch. Dann sollte man nur aufpassen, dass die interne SV nicht durch 
seinen zusätzlichen Bastelkram überlastet wird. Ein paar mA fallen 
sicher immer ab, aber ein Relais mit paar 10mA könnte schon zu viel 
sein.
Da sollte man sich auch mal ansehen, ob die interne SV evtl. schon sehr 
heiß wird.
Gruß Öletronika

[Stefan F. (Gast)]

Mit dem Transistor hast du ihn jetzt vermutlich überfordert.

Kann man machen, muss man nicht.

[U. M. (oeletronika)]

Stefanus F. schrieb:
> Mit dem Transistor hast du ihn jetzt vermutlich überfordert.
Und mit dem uC hast du ihn nicht überfordert?

> Kann man machen, muss man nicht.

Klar kann man oder auch nicht.
Es gibt wie immer eine Anzahl Lösungsmöglichkeiten.
In dem Link zu der Schaltung mit Freilaufdiode ist ja die Grundschaltung 
schon gegeben. Am Ende braucht es nur 2 Bauelemente (Transistor + 
Basisvorwiderstand)

https://www.mikrocontroller.net/articles/Relais_mit_Logik_ansteuern
Statt des Relais (und Freilaufdiode) muß doch nur noch das Schaltsignal 
zwischen 5V und Kolektor geschaltet werden.

Ich meine, das wird so schon zuverlässig funktionieren.
Der Transistor selbst entkoppelt das Signal vom uC und ist an der Stelle 
sicher ausreichend robust gegen alle zu erwartenden Störungen.
Offenbar ist das zu schaltenden Signal ja auch nur ein Eingang von einem 
uC in der internen Steuerschaltung, also sehr wahrscheinlich ziemlich 
unkritisch bezüglich Störungen.

Als Test kann man das ja mal eben anbauen und ausprobieren
-> Basiswiderstand an GND = Transistor als Schalter offen!
-> Basiswiderstand an +5V = Transistor als Schalter geschlossen!
Wenn das klappt, kann er den Basiswiderstand an das uC-Port klemmen
und fertisch!
Gruß Öletronika

[Stefan F. (Gast)]

Ich empfehle, dem Joachim keine weiteren Tipps mehr zu geben, denn jetzt 
hat er (in Beitrag "elektronischer Stufenschalter") auch noch vor, 
die Leistungssteuerung des Pedelecs zu manipulieren.

[Joachim H. (jochen_hr)]

Lieber Stefan, das ist leider der größte Blödsinn, den Du gerade 
geschrieben hast.
Es geht nicht um Tuning , geschweige denn Leistungssteigerung. Du hast 
mein Anliegen absolut nicht begriffen. Lies bitte im anderen Faden, 
meine nachgeschoben Erläuterung.
Schade, das Du Dich hier so abfällig geäußert hast.

[Stefan F. (Gast)]

Joachim H. schrieb:
> Schade, das Du Dich hier so abfällig geäussert hast.

Das war gar nicht abfällig gemeint.

[Manuel (Gast)]

So sieht das Teil aus, das ich probieren möchte.

[Manuel (Gast)]

Stefanus F. schrieb:
> Der Kontakt verschleisst nur nennenswert, wenn er überlastet wird.

Dann  ist die Lebenserwartung von einem 10 Ampere Relais das mit 10 
Milliampere belastet wird also gut?

[Stefan F. (Gast)]

Manuel schrieb:
> Stefanus F. schrieb:
>> Der Kontakt verschleisst nur nennenswert, wenn er überlastet wird.
>
> Dann  ist die Lebenserwartung von einem 10 Ampere Relais das mit 10
> Milliampere belastet wird also gut?

Jein. Die meisten Schaltkontakte brauchen eine gewisse Mindestlast, 
damit sie langfristig zuverlässig funktionieren. Größzügig 
dimensionieren ist schon sinnvoll, aber man soll es auch nicht 
übertreiben.

10mA bei einem 10A Relais wird in den meisten Fällen gut gehen.
Aber 0,1mA bei einem 10A Relais halte ich für bedenklich.

Leider geben die Datenblätter oft nur die maximale Belastung der 
Relaiskontakte an, nicht die minimale. Das gleiche gilt auch für 
Schalter und Taster.

Damit kommen wir zu einem Punkt, den ich die ganze Zeit verschwiegen 
habe weil ich Dich nicht verwirren wollte: Es ist vorteilhaft, 
zusätzlich zu den internen Pull-Up Widerstanden des Mikrocontrollers 
noch externe hinzuzufügen, weil.

a) Weil Schaltkontakte einen gewissen minimalen Strom brauchen, um 
langfristig zuverlässig zu funktionieren.

b) Weil jede Leitung auch eine Antenne ist, also empfänglich für 
Funkwellen. Je geringer der Widerstand, umso mehr Strom wird abgeleitet, 
as die Schaltung unempfindlicher macht.

Wenn ich keine konkreten Werte habe, lege ich den Pull-Up Widerstand 
immer so aus, dass mindestens 1mA fliessen.

[Manuel (Gast)]

Ich habe noch ein Problem entdeckt.
Und zwar wenn ich es mit extra Relais und extra Stromversorgung mache, 
dann ist das auch extra ein und auszuschalten was nicht so sicher ist, 
weil man es vergessen kann. Ich möchte jetzt nicht fragen wie man das 
auch noch automatisieren kann, weil es ja nicht noch komplizierter 
werden soll. Würde dann eher einen Knoten ins Taschentuch 
machen...lach...

Dann bin ich noch darauf gestoßen, das ja  der Controller insgesamt 5 
Hallsensoren verträgt.
Tretsensor, Gasgriff, Speedsensor und 2 !!! Bremshebel.

Und ich habe nur den Tretsensor an 5 Volt.
Dann müsste doch noch ein Arduino auch noch versorgt werden können?

Aber:

So wie ich das verstanden habe ist es normaler Weise so, das der 
Hallsensor von einem normalen Bremsgriff bei Betätigung Signal und GND 
verbindet.
Der Arduino kann aber nur sein eigenes Signal ausgeben, zB. für eine Led 
oder ein Relais aber kann nix verbinden?

Mir hat einer was von gleichem Potential gesagt wenn beide an gleicher 
Leitung hängen?
Der meinte das geht...
Würde es ja testen, aber habe Angst den Controller zu zerstören.

Bin schon kurz davor, einfach einen Schalter an die Bremsleitung zu 
machen, und per Hand zu schalten.

Sorry, bin Laie auf dem Gebiet

[Stefan F. (Gast)]

Wegen der möglicherweise unterschiedlichen Potentiale hatte ich Dir den 
Optokoppler (Relais ist auch gut) empfohlen. Du hast aber geschrieben, 
dass du die Stromversorgung vom Motor-Controller verwenden wirst, dann 
hast du logischerweise das gleiche Potential und auch kein Problem mit 
getrenntem Aus-Schalten.

Ansonsten gefällt mir gar nicht, dass du hier so viele Annahmen 
beschreibst, Schlüsse daraus ziehst und uns um Bestätigung/Korrektur 
bittest. Das ist die falsche Reihenfolge. Zuerst müssen deine Annahmen 
gesichert werden,

Wir kennen deinen Motorcontroller nicht, also können wir Dir auch nicht 
erklären, wie er funktioniert. Im Gegensatz zu Dir, haben wir ihn auch 
nicht vorliegen, um seine Eigenschaften durch Messungen und Experimente 
zu ermitteln.

Du kannst das hingegen tun, hast aber anscheinend mehr Interesse daran, 
das Pferd von hinten aufzuzäumen indem du zuerst die Steuerung baust um 
dann im Anschluss zu hinterfragen, ob sie überhaupt passt.

> Dann müsste doch noch ein Arduino auch noch versorgt werden können?

Das kann man hoffen, aber wissen tut man es nicht. Du weisst nicht, wie 
viel Strom du extern an den 5V Anschlüssen abgreifen darfst. Und du 
weisst vermutlich auch noch nicht einmal, wie viel Strom deine externe 
Schaltung aufnimmt.

> Würde es ja testen, aber habe Angst den Controller zu zerstören.

Durchaus berechtigt. Wenn man keine Ahnung und keine 
Schaltungsunterlagen hat, besteht dieses Risiko.

Da kann man also nur experimentieren und hoffen, dass nichts kaputt 
geht. Oder so wie ich Dir anfangs empfohlen hatte: Für deine eigene 
Elektronik eine eigene Stromversorgung bauen, eigene Sensoren verwenden 
und nur potentialfrei über Optokoppler/Relais miteinander verbinden. 
Damit bist du auf der sicheren Seite.

> Der Arduino kann aber nur sein eigenes Signal ausgeben,
> zB. für eine Led oder ein Relais aber kann nix verbinden?

Dazu solltest du mal lernen, wie die Ausgänge des Mikrocontrollers (bzw 
CMOS IC's allgemein) aufgebaut sind. Schau Dir zum Beispiel das Bild 
rechts oben auf der Seite https://en.wikipedia.org/wiki/CMOS an. Da 
siehst du, dass der Chip den Ausgang wahlweise mit 5V oder mit GND 
verbinden kann.

[Manuel (Gast)]

Da siehst du, dass der Chip den Ausgang wahlweise mit 5V oder mit GND 
verbinden kann.

Das ist es doch was ich mir überlegt habe!
Wieder einmal Danke!!!
Da grübel ich schon lange drüber.

Dann ist es also so?
Man kann den Ausgang des Arduino  mit 5V verbinden für eine LED oder 
Relais.
Oder mit GND so wie es ein Hallsensor im Bremshebel macht indem er 
Signal und GND verbindet.

Dann müsste es ja tatsächlich direkt gehen.

Habe auch gesehen:
Manche Zubehör Sensoren für die Controller haben auch noch eine 
Kontrolle LED eingebaut. Also etwas Strom muss da schon anliegen für 
Hallsensor+LED.

Nimmt den der Nano alleine
so viel mehr Strom wie eine LED?

[Manuel (Gast)]

Sorry , aber ich habe nur +und- gelernt.

Was ich nicht kapiere:
Bei meinem Testaufbau schaltet der Arduino eine LED ein, wenn ein 
Magnetschalter eine gewisse Frequenz liefert. Es fließt also Strom am 
Ausgang.
Aber der Controller Eingang will ja scheinbar nur verbunden werden?

[Stefan F. (Gast)]

Manuel schrieb:
> Nimmt den der Nano alleine so viel mehr Strom wie eine LED?

Auf jeden Fall hast du in deiner Schaltung mehrere Sachen, die Strom 
aufnehmen:

- Die Power LED
- Der Mikrocontroller (Stromaufnahme hängt von der Takt-Konfiguration ab 
und ob du den Sleep Modus verwendest).
- Der Spannungsregler nimmt auch Strom auf, wenn du "von hinten herum" 
5V anlegst
- Der USB-UART Chip nimmt auch Strom auf, wenn kein USB Kabel 
angeschlossen ist
- Die Rx und Tx LEDs
- ggf. eine Status LED
- ggf. das Relais
- Und alles was du sonst noch so dran baust.

Wie viel Strom ist denn für dich "eine LED"? Da fängt die größte 
Unsicherheit doch schon an!

[Manuel (Gast)]

Im Pedelec Forum meinten gerade die Experten,
der Signaleingang wäre direkt ohne Relais kein Problem aber die 5V 
sollte ich von woanders her nehmen weil die Controller etwas 
schwachbrüstig sind, was die 5V angeht. Nicht das es plötzlich stinkt...

Ok, ich habe ja den Step Down Wandler für meine Lampen der steht auf 5V.

Wenn ich jetzt beide Infos sicherheitshalber berücksichtige läuft es auf 
die externe Stromversorgung mit Relais hinaus.

[Stefan F. (Gast)]

Ja mache das lieber mit Relais (oder Optokoppler). Denn wenn du 
versehentlich 5V an den Motorcontroller sendest während dieser 
ausgeschaltet ist, killst du ihn sonst womöglich.

Immer dran denken: Solange keine spezielle Ausnahme dokumentiert ist, 
darf die Spannung an sämtlichen Pins von allen IC's nicht höher als die 
Versorgungsspannung sein (und die ist in ausgeschaltetem Zustand 0 
Volt).

[Manuel (Gast)]

Dann hatte ich ja Glück das nix passiert ist als ich die LED am Arduino 
an 5V statt an GND hatte. Die glimmte nur dunkler und ging nicht aus.

Dann wünsche ich erst mal einen guten Rutsch!
Ich schaffe dann erst mal Platz für zwei neue Platinen am Rad. Alu kann 
ich besser biegen als Arduinos programmieren.

[Manuel (Gast)]

Ich habe das System jetzt am Rad.
Es funktioniert einwandfrei.
Habe das Programm noch um eine Funktion erweitert.
Eine Kontrolle Leuchte die gegensätzlich zum angezogenen Relais 
leuchtet.
Ein Problem ist mir noch auf dem Prüfstand aufgefallen was im 
Fahrbetrieb vielleicht nicht so oft vorkommt.
Wenn das Rad aus dem mittleren Tempobereich schnell abgebremst wird geht 
das Relais nicht in die Startposition zurück weil dann die Impulse vom 
langsam drehenden Rad fehlen. Vielleicht fällt mir dazu noch was ein...

unsigned long time=0;

#define LED 6
#define SENSOR 7

void setup()
{
    pinMode(LED, OUTPUT);
    pinMode(SENSOR, INPUT_PULLUP);
}

void loop()
{
    // Wenn der Speuchen-Magnet am Sensor ist
    int sensorstatus=digitalRead(SENSOR);
    if (sensorstatus == LOW)
    {
        // Zeit erfassen
        unsigned long diff=millis()-time;
        time=millis();

        // Wenn weniger als 500ms seit dem letzten Impuls
        if ((diff<190)or(diff>800)) // Tempo 8-28 km/h
        {
            digitalWrite(LED, HIGH);
        }
        else
        {
           digitalWrite(LED, LOW);
        }

        // Warte, bis der Magnet wieder weg ist
        do
        {
           delay(5); // Zum Entprellen
        }
        while (digitalRead(SENSOR) == LOW);
    }
}

[Stefan F. (Gast)]

Ich würde da irgendwie einen Timeout verwenden. Wenn soundso lange keine 
Impulse kommen muss es wohl Stillstand sein.

[Manuel (Gast)]

If Drehzahl = 0 than go to Programm Anfang?

Oder

If Drehzahl = 0 than digitalWrite (LED, LOW);?

oder wie?

[Manuel (Gast)]

Hier mein geänderter Sketch:

Relais funktioniert.
Kontroll Lampe funktioniert.
Null Stellung noch nicht getestet.
Ist das so richtig?

// Schubabschaltung Pedelec

unsigned long time=0;
#define RELAIS 12
#define LED 8 // Kontroll Lampe
#define SENSOR 10

void setup()
{
    pinMode(RELAIS, OUTPUT);
    pinMode(SENSOR, INPUT_PULLUP);
    pinMode(6, OUTPUT); // Kontroll Lampe
    pinMode(8, OUTPUT); // Kontroll Lampe
}

void loop()
{
    digitalWrite(6, LOW);  // Kontroll Lampe
    // Wenn der Magnet am Sensor ist
    int sensorstatus=digitalRead(SENSOR);
    if (sensorstatus == HIGH)
    {
        // Zeit erfassen
        unsigned long diff=millis()-time;
        time=millis();

        // Wenn weniger als 500ms seit dem letzten Impuls
        // 190 = 28 KMH - 800 = 6 KMH
        // 200 = 25 KMH - 500 = 12 KMH
        if ((diff<190)or(diff>800))
        if (millis()-time>3000) // Null Stellung
        {
            digitalWrite(RELAIS, LOW);
            digitalWrite(LED, HIGH); // Kontroll Lampe
        }
        else
        {
           digitalWrite(RELAIS, HIGH);
           digitalWrite(LED, LOW); // Kontroll Lampe
        }

        // Warte, bis der Magnet wieder weg ist
        do
        {
           delay(3); // Zum Entprellen
        }
        while (digitalRead(SENSOR) == HIGH);
    }
}

[Stefan F. (Gast)]

Du misst hier die Zeit-Differenz zwischen zwei High Impulsen und 
reagierst dann dementsprechend.

Wenn das Rad plötzlich gestoppt wird, kommt kein Impuls mehr, also auch 
keine Reaktion. Du müsstest außerhalb von

if (sensorstatus == HIGH)
{
   ...
}

den Timeout erkennen. Außerdem könnte er im HIGH Zustand hängen bleiben, 
deswegen muss die while Schleife "Warte, bis der Magnet wieder weg ist" 
auch einen Timeout erkennen.

Vielleicht so:

void loop()
{
    digitalWrite(6, LOW);  // Kontroll Lampe
    
    // Wenn der Magnet am Sensor ist
    int sensorstatus=digitalRead(SENSOR);
    if (sensorstatus == HIGH)
    {
        // Zeit erfassen
        unsigned long diff=millis()-time;
        time=millis();
        ...

        // Warte, bis der Magnet wieder weg ist
        while (digitalRead(SENSOR) == HIGH)
        {
            diff=millis()-time;
            if (diff>3000)
            {
                // Rad wurde angehalten
                auf_timeout_reagieren;
            }
        }
    }

    else // sensorstatus is LOW
    {

        // Kontrolliere, ob das Rad angehalten wurde (lange keine Impulse mehr) 
        unsigned long diff=millis()-time;
        if (diff>3000)
        {
            // Rad wurde angehalten
            auf_timeout_reagieren;
        }
    }
}

Die Timeout-Erkennung ist doppelt, weil je nach Position des Magneten 
der Sensor entweder im HIGH oder im LOW Zustand hängen bleibt.

[Manuel (Gast)]

habe ich alles richtig eingefügt?
Und ist der Wert 3000 ok? Das habe ich von einem Tachoprogamm geborgt.
Dort gab es auch Probleme mit der Nullstellung.
Ich muss immer den Arduino im Keller ausbauen und zwei Etagen rauf 
tragen zum PC. ;-)

// Schubabschaltung Pedelec

unsigned long time=0;
#define RELAIS 12
#define LED 8 // Kontroll Lampe
#define SENSOR 10

void setup()
{
    pinMode(RELAIS, OUTPUT);
    pinMode(SENSOR, INPUT_PULLUP);
    pinMode(6, OUTPUT); // Kontroll Lampe
    pinMode(8, OUTPUT); // Kontroll Lampe
}

void loop()
{
    digitalWrite(6, LOW);  // Kontroll Lampe
    // Wenn der Magnet am Sensor ist
    int sensorstatus=digitalRead(SENSOR);
    if (sensorstatus == HIGH)
        {
        // Zeit erfassen
        unsigned long diff=millis()-time;
        time=millis();
        // Warte, bis der Magnet wieder weg ist
        while (digitalRead(SENSOR) == HIGH)
        {
        diff=millis()-time;
        if (diff>3000)
        {
        // Rad wurde angehalten, auf_timeout_reagieren;
        }
        else // sensorstatus is LOW
        {

        // Kontrolliere, ob das Rad angehalten wurde (lange keine 
Impulse mehr)
        unsigned long diff=millis()-time;
        if (diff>3000)
        {
        // Rad wurde angehalten auf_timeout_reagieren;

        }
        }
        // Wenn weniger als 500ms seit dem letzten Impuls
        // 190 = 28 KMH - 800 = 6 KMH
        // 200 = 25 KMH - 500 = 12 KMH
        if ((diff<190)or(diff>800))

        {
        digitalWrite(RELAIS, LOW);
        digitalWrite(LED, HIGH); // Kontroll Lampe
        }
        else
        {
        digitalWrite(RELAIS, HIGH);
        digitalWrite(LED, LOW); // Kontroll Lampe
        }

        // Warte, bis der Magnet wieder weg ist
        do
        {
        delay(3); // Zum Entprellen
        }
        while (digitalRead(SENSOR) == HIGH);
    }
  }
}

[Stefan F. (Gast)]

> habe ich alles richtig eingefügt?

Das erfährst du durch einen Test.

> Und ist der Wert 3000 ok?

Kommt drauf an, was du willst. 3000 bedeutet: 3 Sekunden Reaktionszeit.

> Ich muss immer den Arduino im Keller ausbauen und zwei Etagen
> rauf tragen zum PC. ;-)

Baue Dir doch ein Modell.

Dein Quelltext ist auf jeden Fall total durcheinander geraten und 
unvollständig. Die entsprechenden Stellen sind sogar entsprechend 
kommentiert.

Kopierst du nur Sachen Zusammen ohne dabei nachzudenken? Ich habe es 
doch schon vorgekaut!

[Manuel (Gast)]

Achja,
auf timeout reagieren fehlt ja noch...

[Stefan F. (Gast)]

Ordentlich Einrücken wäre auch mal eine sinnvolle Massnahme, dann sieht 
man sofort die falsche Verschachtelung der Codeblöcke.

[Manuel (Gast)]

ich glaube jetzt hab ich es.

// Schubabschaltung Pedelec

unsigned long time=0;
#define RELAIS 12
#define LED 8 // Kontroll Lampe
#define SENSOR 10

void setup()
{
    pinMode(RELAIS, OUTPUT);
    pinMode(SENSOR, INPUT_PULLUP);
    pinMode(6, OUTPUT); // Kontroll Lampe
    pinMode(8, OUTPUT); // Kontroll Lampe
}

void loop()
{
    digitalWrite(6, LOW);  // Kontroll Lampe
    // Wenn der Magnet am Sensor ist
    int sensorstatus=digitalRead(SENSOR);
    if (sensorstatus == HIGH)
    {
        // Zeit erfassen
        unsigned long diff=millis()-time;
        time=millis();

        // Wenn weniger als 500ms seit dem letzten Impuls
        // 190 = 28 KMH - 800 = 6 KMH
        // 200 = 25 KMH - 500 = 12 KMH
        if ((diff<190)or(diff>800))
        {
            digitalWrite(RELAIS, LOW);
            digitalWrite(LED, HIGH); // Kontroll Lampe
        }
        else
        {
           digitalWrite(RELAIS, HIGH);
           digitalWrite(LED, LOW); // Kontroll Lampe
        }

        // Warte, bis der Magnet wieder weg ist
        do
        {
           delay(3); // Zum Entprellen
        }
        while (digitalRead(SENSOR) == HIGH);
        {
            diff=millis()-time;
            if (diff>3000)
            {
            // Rad wurde angehalten
            {
            digitalWrite(RELAIS, LOW);
            digitalWrite(LED, HIGH); // Kontroll Lampe
        }
            }
        }
    }

    else // sensorstatus is LOW
    {

        // Kontrolliere, ob das Rad angehalten wurde (lange keine 
Impulse mehr)
        unsigned long diff=millis()-time;
        if (diff>3000)
        {
        // Rad wurde angehalten
        {
            digitalWrite(RELAIS, LOW);
            digitalWrite(LED, HIGH); // Kontroll Lampe
        }
        }
    }
}

[Stefan F. (Gast)]

Die Einrückung ist immer noch furchtbar.
Du hast jetzt schon zig mal die Anleitung gesehen, wie man Quelltexte 
korrekt einfügt. Wende sie an!

[Manuel (Gast)]

Das hat sich wohl beim Kopieren verschoben,
bei mir im Arduino Fenster ist alles eingerückt.

Ein Fehler wird nicht angezeigt.

Aber sind die Befehle jetzt richtig,
damit der Stillstand richtig erkannt wird?

Wenn 3000=3 Sekunden ist.
Dann wäre doch sicher auch 1000 ok?

[Stefan F. (Gast)]

Manuel schrieb:
> Aber sind die Befehle jetzt richtig,
> damit der Stillstand richtig erkannt wird?

Frage nicht so viel, probiere es aus. Das ist dein Job.

> Wenn 3000=3 Sekunden ist.
> Dann wäre doch sicher auch 1000 ok?

Das kannst nur du entscheiden.

[Manuel (Gast)]

habe das jetzt getestet,
aber keine Reaktion bei Stillstand?

[Stefan F. (Gast)]

Anstatt herum zu raten, wäre jetzt ein guter Zeitpunkt, einen Debugger 
anzuschliessen oder wenigstens Debug Meldungen seriell auszugeben.

[Manuel (Gast)]

verstehe ich nicht.
{
            diff=millis()-time;
            if (diff>3000)
            {
            // Rad wurde angehalten
            {
            digitalWrite(RELAIS, LOW);
            digitalWrite(LED, HIGH); // Kontroll Lampe
        }
Da müsste doch was passieren,wenn keine Impulse mehr kommen?

[Stefan F. (Gast)]

Manuel schrieb:
> Da müsste doch was passieren,wenn keine Impulse mehr kommen?

Das sehe ich auch so. Deswegen mein Hinweis zum Debugging. Füge 
Textmeldungen hinzu, die den Wert der wichtigen Variablen ausgeben: time 
und diff. Ich würde auch Meldungen hinzufügen, die anzeigen, ob du in 
dem "if (sensorstatus == HIGH)" Block bist, oder im "else" Block.

[Manuel (Gast)]

Sorry , das ist für mich alles noch viel zu kompliziert.
Kann ich nicht einfach eine Zeile so in der Art da zufügen:

Wenn 3 Sekunden kein High am Eingang dann Ausgang Relais LOW / LED High.

Aber finde nix wie man 3 Sekunden messen und in IF einbinden kann.

Dann habe ich noch was gefunden von millis die nach einer gewissen Zeit 
über laufen. Wird das bei meinem Programm auch passieren wenn es länger 
läuft?

[Stefan F. (Gast)]

Manuel schrieb:
> Kann ich nicht einfach eine Zeile so in der Art da zufügen:
> Wenn 3 Sekunden kein High am Eingang dann Ausgang Relais LOW / LED High.
> Aber finde nix wie man 3 Sekunden messen und in IF einbinden kann.

Genau das hast du bereits gemacht.

Manuel schrieb:
> Dann habe ich noch was gefunden von millis die nach einer gewissen Zeit
> über laufen. Wird das bei meinem Programm auch passieren wenn es länger
> läuft?

Ja, sicher, jeder Zähler läuft irgendwann über. Aber deine Berechnung 
der "diff" Werte berücksichtigt das bereits. Der Trick besteht in der 
Subtraktion. Bei einem Überlauf funktioniert die Subtraktion trotzdem. 
Mit einer Addition käme ein falsches Ergebnis heraus. Um das zu 
verstehen, braucht man schon etwas mehr Erfahrung mit binären 
Zahlensystemen und Assembler.

Was du vielleicht vermisst ist ein Betriebssystem, das ereignisgesteuert 
arbeitet. Wo man für jedes Ereignis eine Reaktion programmieren kann und 
sich nur wenig Gedanken um Nebenläufigkeit, Multitasking, 
Warteschlangen, etc. machen muss. Das kannst du auf diesen kleinen 
Mikrocontrollern aber vergessen.

Dass Arduino eine loop() vorgibt, die immer wieder durchlaufen wird, 
ergibt sich aus den Fähigkeiten der Hardware. Die haben das schon genau 
richtig gemacht, glaube es mir.

Softwareentwickler haben die Fähigkeit, eine Aufgabe mit den gegebenen 
technischen Möglichkeiten umzusetzen. Die gleichen Leute sind oft auch 
gut darin, Dinge aus Legosteinen und Metallbaukästen zu konstruieren. Es 
geht immer darum, grosse Dinge aus kleinen Teilen zusammen zu setzen und 
irgendwie auch klar zu kommen, wenn sie nicht exakt dem Wunsch 
entsprechen.

[Manuel (Gast)]

Eigentlich funktioniert das System ja super, und vielleicht wird im 
Fahrbetrieb auch nicht so schnell auf Null abgebremst wie auf dem 
Prüfstand.
Aber die Funktion Nullstellung wenn das Rad 3 Sekunden steht würde ich 
noch gerne da zufügen.
Was kann ich noch probieren außer:

diff=millis()-time;
if (diff>3000)
{
// Rad wurde angehalten
{
digitalWrite(RELAIS, LOW);
digitalWrite(LED, HIGH); // Kontroll Lampe
}

Vielleicht habe ich es auch nur in einer falschen Schleife eingefügt. Es 
tut sich nix nach 3 Sekunden?
Gar nix. :-(

[Manuel (Gast)]

Kann es eventuell daran liegen das " diff " bei stehendem Rad gar nicht 
errechnet werden kann?
Wenn das Rad dreht geht es einwandfrei.

[Stefan F. (Gast)]

Manuel schrieb:
> Kann es eventuell daran liegen das " diff " bei stehendem Rad gar nicht
> errechnet werden kann?

Nein, denn diff ist die Zeit-Differenz und die Zeit läuft immer weiter.

Irgendwo hängt was, und diese Stelle musst du mit Debug Meldungen 
finden.

[Wolfgang (Gast)]

Manuel schrieb:
> Vielleicht habe ich es auch nur in einer falschen Schleife eingefügt. Es
> tut sich nix nach 3 Sekunden?
> Gar nix. :-(

Dann prüfe, was diff für Werte annimmt. Vielleicht hast du einfach 
irgendwo den falschen Variablentyp gewählt.

[Manuel (Gast)]

Diff muss ja Werte zwischen 190 + 800 annehmen,
sonst könnte ja nicht an diesen Punkten bei Raddrehung geschaltet 
werden.

[Stefan F. (Gast)]

Manuel schrieb:
> Diff muss ja Werte zwischen 190 + 800 annehmen,
> sonst könnte ja nicht an diesen Punkten bei Raddrehung geschaltet
> werden.

Bist du der Joachim, der der extra Code für 3000ms Timeout eingebaut 
hat?

[Manuel (Gast)]

Nein , ich bin der Manuel, der die Schubabschaltung sich ausgedacht hat, 
aber keine Ahnung vom Arduino hat.
Der Joachim wollte nur helfen und hat hier die ersten Fragen gestellt. 
Wir sind beide aus dem Pedelec Forum.
Und der Stefanus ist der Experte, der den fast fertigen Sketch geliefert 
hat. Danke!!!
Der nur an einer kleinen Stelle hakt. Und ich finde immer noch keine 
Lösung.

[Stefan F. (Gast)]

Manuel schrieb:
> Und ich finde immer noch keine Lösung.

Zeige den aktuellen Sketch und die Debug-Ausgaben der Variablen.

Falls du das noch nicht gemacht hast: Dann mach, anstatt herum zu raten.

[Manuel (Gast)]

so viel Ahnung habe ich leider nicht.

Hier noch mal der Sketch, den ich jetzt verwende.
Geht einwandfrei, bis auf die Tatsache das ein schnell stoppendes Rad 
nicht erkannt wird weil dann die langsamen Impulse vom Reedschalter 
nicht mehr zur Verfügung stehen. Beim erneuten anfahren reicht dann eine 
Umdrehung und das Relais schaltet wieder in Startposition.
Aber dann hat der Motor schon kurz Gas gegeben...

// Schubabschaltung Pedelec

unsigned long time=0;
#define RELAIS 12
#define LED 8 // Kontroll Lampe
#define SENSOR 10

void setup()
{
  pinMode(RELAIS, OUTPUT);
  pinMode(SENSOR, INPUT_PULLUP);
  pinMode(6, OUTPUT); // Kontroll Lampe
  pinMode(8, OUTPUT); // Kontroll Lampe
}

void loop()
{
  digitalWrite(6, LOW);  // Kontroll Lampe
  // Wenn der Magnet am Sensor ist
  int sensorstatus=digitalRead(SENSOR);
  if (sensorstatus == HIGH)
  {
    // Zeit erfassen
    unsigned long diff=millis()-time;
    time=millis();

    // Wenn weniger als 500ms seit dem letzten Impuls
    // 190 = 28 KMH - 800 = 6 KMH
    // 200 = 25 KMH - 500 = 12 KMH
    if ((diff<190)or(diff>800))
    {
      digitalWrite(RELAIS, LOW);
      digitalWrite(LED, HIGH); // Kontroll Lampe
    }
    else
    {
      digitalWrite(RELAIS, HIGH);
      digitalWrite(LED, LOW); // Kontroll Lampe
    }

    // Warte, bis der Magnet wieder weg ist
    do
    {
      delay(3); // Zum Entprellen
    }
    while (digitalRead(SENSOR) == HIGH);
  }
}

[Manuel (Gast)]

Für einen Profi fehlt sicher nur ein kleiner Zusatz.
für mich unlösbar...

[Stefan F. (Gast)]

Das fehlt doch jetzt was, was vorher noch drin war!:

        while (digitalRead(SENSOR) == HIGH)
        {
            diff=millis()-time;
            if (diff>3000)
            {
                // Rad wurde angehalten
                digitalWrite(RELAIS, LOW);
                digitalWrite(LED, HIGH);
            }
        }

und:

    else // sensorstatus is LOW
    {
        unsigned long diff=millis()-time;
        if (diff>3000)
        {
            // Rad wurde angehalten
            digitalWrite(RELAIS, LOW);
            digitalWrite(LED, HIGH);
        }
    }

Wie sollen wir hier gemeinsam ein Problem analysieren, wenn du in deinem 
Programm die entscheidenden Teile wieder ausbaust ohne es mitzuteilen?!

Warum hast du genau den Code wieder weg gelöscht, der genau dein Problem 
lösen soll? Ich habe Dir doch sogar erklärt, was ich mir dabei gedacht 
habe. Ich frage mich erneut, ob du wenigstens unsere Antworten liest?

Was denkst du warum wir hier schreiben und auf Anleitungen verweisen? 
Damit die schick aussehen, oder damit sie gelesen werden? Ohne zu lernen 
kann man nichts leisten!

> so viel Ahnung habe ich leider nicht.

Junge Junge, du sollst doch bloss Textmeldungen ausgeben! Das ist in 
fast jeder Programmieranleitung die erste Aufgabe! Du kannst nicht 
einfach diese komplexe Technik nutzen, ohne die Anleitungen durch zu 
arbeiten.

Wie viel wolltest Du mir dafür eigentlich bezahlen? Die ersten 2 Stunden 
sind sicher schon verbraucht - macht 120€.

Du findest diesen Kommentar sicher doof. Aber jetzt wird Dir hoffentlich 
mal klar, das der Spruch "von nichts kommt nichts" richtig ist. Entweder 
lernst du es selbst zu machen, oder du bezahlst andere dafür.

Wir können ja auch tauschen. Kannst du Autos reparieren? Karosserie und 
gebrochene Plastikteile. Oder kannst du Laminat verlegen? Ich hätte hier 
einiges zu tun, was ich nicht gut kann.

Ich weiss, du hättest gerne das gesamte Programm von mir vorgekaut, aber 
das kannst du ohne Gegenleistung vergessen.

[Stefan F. (Gast)]

Noch was: Pass mit den Semikolons auf!

while (digitalRead(SENSOR) == HIGH);
{
   Serial.println("Sensor ist HIGH");
}

Dieser Code wird n icht das tun, was beabsichtigt war, weil das while 
Kommando durch das Semikolon beendet wird. Hier wird gewartet, solange 
der Sensor HIGH liefert. Erst danach, wenn er nicht mehr HIGH liefert, 
wird die serielle Textausgabe gemacht.

Das Semikolon hinter while ist zu viel.

Ich schreibe Dir das, weil es mir gerade an einem Quelltext weiter oben 
zufällig aufgefallen ist. Jetzt bist du aber dran. Lerne und stelle 
fragen zum Lehrstoff. Du bist noch lange nicht weit genug, Steuerungen 
für Fahrzeuge zu entwickeln.

[Manuel (Gast)]

viel Geld habe ich leider nicht.

Aber ich gebe gerne kostenlose handwerkliche Tipps.
Ich bin kein gelernter Handwerker, aber da bringe ich mir alles selber 
bei, das ist mehr mein Hobby.
Im Pedelec Forum helfen wir ahnungslosen Anfängern auch gerne weiter.
Auch wenn die manchmal erst durch den Kakao gezogen werden müssen.

Das mit "diff 3000" habe ich entfernt,
weil es nicht funktioniert hat.
Hatte gehofft das jetzt ein anderer kopierbarer Vorschlag kommt,
der Rad Stillstand erkennt.

xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
Ich kann es nur noch einmal betonen, Deine Hilfe war wirklich super!
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Wenn es zu viel Mühe macht, dann muss es eben so bleiben wie es jetzt 
läuft.

[Manuel (Gast)]

Hier noch mal der Komplette 3000ener Versuch.
Wenn ich das Simikolon weg nehme kommen Klammer Fehler?

// Schubabschaltung Pedelec

unsigned long time=0;
#define RELAIS 12
#define LED 8 // Kontroll Lampe
#define SENSOR 10

void setup()
{
    pinMode(RELAIS, OUTPUT);
    pinMode(SENSOR, INPUT_PULLUP);
    pinMode(6, OUTPUT); // Kontroll Lampe
    pinMode(8, OUTPUT); // Kontroll Lampe
}

void loop()
{
    digitalWrite(6, LOW);  // Kontroll Lampe
    // Wenn der Magnet am Sensor ist
    int sensorstatus=digitalRead(SENSOR);
    if (sensorstatus == HIGH)
        {
        // Zeit erfassen
        unsigned long diff=millis()-time;
        time=millis();

        // Wenn weniger als 500ms seit dem letzten Impuls
        // 190 = 28 KMH - 800 = 6 KMH
        // 200 = 25 KMH - 500 = 12 KMH
        if ((diff<190)or(diff>800))
        {
            digitalWrite(RELAIS, LOW);
            digitalWrite(LED, HIGH); // Kontroll Lampe
        }
        else
        {
           digitalWrite(RELAIS, HIGH);
           digitalWrite(LED, LOW); // Kontroll Lampe
        }

        // Warte, bis der Magnet wieder weg ist
        do
        {
           delay(3); // Zum Entprellen
        }
        while (digitalRead(SENSOR) == HIGH);
            {
            diff=millis()-time;
            if (diff>3000)
            {
            // Rad wurde angehalten
            {
            digitalWrite(RELAIS, LOW);
            digitalWrite(LED, HIGH); // Kontroll Lampe
            }
            }
        }
    }

        else // sensorstatus is LOW
        {

        // Kontrolliere, ob das Rad angehalten wurde (lange keine 
Impulse mehr)
        unsigned long diff=millis()-time;
        if (diff>3000)
        {
        // Rad wurde angehalten
        {
            digitalWrite(RELAIS, LOW);
            digitalWrite(LED, HIGH); // Kontroll Lampe
        }
        }
    }
}

[Stefan F. (Gast)]

Wie war das mit dem Semikolon?

Nochmal die Frage: Liest du unsere Antworten?

Ich möchte noch etwas hinterfragen: Stimmen eigentlich deine Kommentare 
im Quelltext?

    // Wenn der Magnet am Sensor ist
    int sensorstatus=digitalRead(SENSOR);
    if (sensorstatus == HIGH)

Oder liefert der Sensor vielmehr einen LOW Pegel, wenn er vom Magnet 
betätigt ist?

Das sind Kleinigkeiten die unwichtig erscheinen mögen, aber sie sind 
sehr wichtig. Die ganze Programmlogik hängt davon ab.

[Manuel (Gast)]

Der Magnet macht den Reedschalter zu.
( eben gemessen )

[Stefan F. (Gast)]

Manuel schrieb:
> Der Magnet macht den Reedschalter zu. ( eben gemessen )

Ist das HIGH oder LOW? Wie sieht eigentlich dein Schaltplan aus, daraus 
ergibt es sich.

[Manuel (Gast)]

Welcher Schaltplan?
Ich habe einen Reedschalter von einer Alarmanlage genommen. Der 
verbindet die beiden Kontakte wenn der Magnet sich annähert. Ansonsten 
offen. Funktioniert am Tacho. Funktioniert am Arduino. Beim Relais habe 
ich beide Möglichkeiten, angezogen offen oder zu.

[Stefan F. (Gast)]

Wie ist dieser Kontakt mit dem Mikrocontroller verbunden? Zeige den 
Schaltplan, daraus ergibt sich, ob der geschlossene Kontakt einen HIGH 
Pegel oder einen LOW Pegel liefert.

Wenn solche Basics schon unklar sind, dann kann das nichts werden.

Ich frage das nicht ohne Grund, denn in deinem Quelltext steht das:

pinMode(SENSOR, INPUT_PULLUP);

Demnach hast du bei geschlossenem Kontakt mit 90% Warscheinlichkeit 
einen LOW Pegel. Und dann muss in deinem Programm HIGH mit LOW getauscht 
werden.

[Manuel (Gast)]

Der Sensor hängt an GND und Pin10.
Das Relais hängt an GND und Pin 12.

[Manuel (Gast)]

Alle HIGHs und alle LOWs tauschen?
Und was war mit dem Semikolon?
Und warum funktioniert es sonst so weit?
Wenn alles vertauscht ist?

[Manuel (Gast)]

Alle HIGHs und alle LOWs tauschen?

Und was war mit dem Semikolon?
Die serielle Textausgabe ist nicht von meinem Programm.

Und warum funktioniert es sonst so weit?
Wenn alles vertauscht ist?

[Stefan F. (Gast)]

Manuel schrieb:
> Der Sensor hängt an GND und Pin10.

Dann liefert er bei Betätigung einen LOW Pegel. Du musst also beim 
Auswerten des Sensorstatus überall HIGH mit LOW tauschen.

> Und was war mit dem Semikolon?

Was ich oben geschrieben habe.

> Die serielle Textausgabe ist nicht von meinem Programm.

Ich habe Dir damit einen Wink mit dem Zaunpfahl gegeben, wie man Debug 
Meldungen programmiert, weil du schriebst:

> so viel Ahnung habe ich leider nicht.

> Und warum funktioniert es sonst so weit?

Darauf solltest du durch Nachdenken selber kommen. Es ist ein simples 
Logik-Problem.

[Manuel (Gast)]

Es geht !!!!!!!!!!!!!!

Habe nur  HIGH und LOW vor den " == " gewechselt.
Schon Scheiße wenn man völlig im Dunklen tappt...

Danke !!!!!!!!!!!!!

Wahnsinn, dann hat das pendeln zwischen Keller und Computerraum gelohnt. 
Sicher ein paar KG abgenommen.

[Stefan F. (Gast)]

Nächstes mal baust Du Dir bitte zuerst ein Modell und zeichnest einen 
Schaltplan.

[Stefan F. (Gast)]

Hast du das falsche Semikolon gelöscht?
Wenn nicht, wird die Abschaltung bei geschlossenem Magnetkontakt nicht 
funktionieren.

[Manuel (Gast)]

Wenn Du das Semikolon in der while Zeile meinst.
Habe es probiert zu löschen, aber dann wird die geschweifte Klammer 
danach als Fehler angezeigt.

[F. F. (foldi)]

Zunächst würde ich erstmal schauen, ob die vorhandene Elektronik sich 
nicht so programmieren lässt.
Wenn ich das richtig verstanden habe, soll der Motor bei einer gewissen 
Eigenleistung durch den Fahrer (hier 8 Km/h), einfach weggeschaltet 
werden.
Vielleicht einmal den Hersteller der Steuerung anschreiben?

[Stefan F. (Gast)]

Manuel schrieb:
> aber dann wird die geschweifte Klammer
> danach als Fehler angezeigt.

Zeige den Quelltext

[Manuel (Gast)]

Error: expected ';' before '{' token
Kommt wenn ich das Semikolon nach while weg nehme.

[Manuel (Gast)]

// Schubabschaltung Pedelec

unsigned long time=0;
#define RELAIS 12
#define LED 8 // Kontroll Lampe
#define SENSOR 10

void setup()
{
    pinMode(RELAIS, OUTPUT);
    pinMode(SENSOR, INPUT_PULLUP);
    pinMode(6, OUTPUT); // Kontroll Lampe
    pinMode(8, OUTPUT); // Kontroll Lampe
}

void loop()
{
    digitalWrite(6, LOW);  // Kontroll Lampe
    // Wenn der Magnet am Sensor ist
    int sensorstatus=digitalRead(SENSOR);
    if (sensorstatus == LOW)
        {
        // Zeit erfassen
        unsigned long diff=millis()-time;
        time=millis();

        // Wenn weniger als 500ms seit dem letzten Impuls
        // 190 = 28 KMH - 800 = 6 KMH
        // 200 = 25 KMH - 500 = 12 KMH
        if ((diff<190)or(diff>800))
        {
            digitalWrite(RELAIS, LOW);
            digitalWrite(LED, HIGH); // Kontroll Lampe
        }
        else
        {
           digitalWrite(RELAIS, HIGH);
           digitalWrite(LED, LOW); // Kontroll Lampe
        }

        // Warte, bis der Magnet wieder weg ist
        do
        {
           delay(3); // Zum Entprellen
        }
        while (digitalRead(SENSOR) == LOW);
            {
            diff=millis()-time;
            if (diff>1000)
            {
            // Rad wurde angehalten
            {
            digitalWrite(RELAIS, LOW);
            digitalWrite(LED, HIGH); // Kontroll Lampe
            }
            }
        }
    }

        else // sensorstatus is LOW
        {

        // Kontrolliere, ob das Rad angehalten wurde (lange keine 
Impulse mehr)
        unsigned long diff=millis()-time;
        if (diff>1000)
        {
        // Rad wurde angehalten
        {
            digitalWrite(RELAIS, LOW);
            digitalWrite(LED, HIGH); // Kontroll Lampe
        }
        }
    }
}

[pegel (Gast)]

Manuel schrieb:
> while (digitalRead(SENSOR) == LOW);

Ist hier wie bei if.
Semikolon beendet den Befehl.

[F. F. (foldi)]

https://www.arduino.cc/reference/en/language/structure/control-structure/while/

[Manuel (Gast)]

Das Semikolon bekomme ich ohne Fehlermeldung nicht weg. Gerade schickt 
noch eine Pedelec Kollege eine kurze Version der Stillstand Abfrage und 
auch das funktioniert. Auch mit Semikolon. Siehe Sketch...
Das der Magnet genau vor dem Reedkontakt zum stehen kommt und sich 
keinen Millimeter mehr bewegt ist sehr unwahrscheinlich. Und selbst dann 
würde das Rad ja stehen.

unsigned long time=0;
#define RELAIS 12
#define LED 8 // Kontroll Lampe
#define SENSOR 10

void setup()
{
pinMode(RELAIS, OUTPUT);
pinMode(SENSOR, INPUT_PULLUP);
pinMode(6, OUTPUT); // Kontroll Lampe
pinMode(8, OUTPUT); // Kontroll Lampe
}

void loop()
{
digitalWrite(6, LOW); // Kontroll Lampe
// Wenn der Magnet am Sensor ist
int sensorstatus=digitalRead(SENSOR);
if (sensorstatus == LOW)
{
// Zeit erfassen
unsigned long diff=millis()-time;
time=millis();

// Wenn weniger als 500ms seit dem letzten Impuls
// 190 = 28 KMH - 800 = 6 KMH
// 200 = 25 KMH - 500 = 12 KMH
if ((diff<190)or(diff>800))
{
digitalWrite(RELAIS, LOW);
digitalWrite(LED, HIGH); // Kontroll Lampe
}
else
{
digitalWrite(RELAIS, HIGH);
digitalWrite(LED, LOW); // Kontroll Lampe
}

// Warte, bis der Magnet wieder weg ist
do
{
delay(3); // Zum Entprellen
}
while (digitalRead(SENSOR) == LOW);
}

if (millis()-time>800) // Stillstand
{
digitalWrite(RELAIS, LOW);
digitalWrite(LED, HIGH); // Kontroll Lampe
}

}

[Hans (Gast)]

Da kann dein Kollege schicken was er will guck dir endlich mal die 
arduino Befehle an dann siehst du dass das hinter While falsch ist.
Mittlerweile ist es ganz schön frech, wenn man keinen der vielen Tipps 
sich zu Herzen nimmt und wenigstens selbst ein bisschen Mühe reinsteckt

[Manuel (Gast)]

Wer liebt Dich ganz?
Nur der Hans!

[Stefan F. (Gast)]

Bitteschön, gut vorgekaute Kost von einem wirklich genervtem Helfer. Und 
jetzt lass mich damit bitte in Ruhe bis du

a) dazu bereit bist, Anleitungen zu lesen
b) Die Grundlagen der Programmiersprache gelernt hast
c) Quelltexte ordentlich formatierst, und zwar in der Arduino IDE und 
hier im Forum.

// Schubabschaltung Pedelec

#define RELAIS 12 // Bei High geht der Motor an
#define LED 8 // Kontroll Lampe, bei Low leuchtet sie
#define SENSOR 10 // Liefert kurze Low-Impulse

// Zwischen den folgenden beiden Werten wird der Motor eingeschaltet
// 190 = 28 KMH - 800 = 6 KMH
// 200 = 25 KMH - 500 = 12 KMH
#define MIN_TIME 190
#define MAX_TIME 800
#define TIMEOUT 1000

// Zeitpunkt des vorherigen Impulses vom Sensor
unsigned long time = 0;


// Motor ein schalten
void motor_ein()
{
  digitalWrite(RELAIS, HIGH);
  digitalWrite(LED, LOW);
}


// Motor aus schalten
void motor_aus()
{
  digitalWrite(RELAIS, LOW);
  digitalWrite(LED, HIGH);
}

// Schalte den Motor ab, wenn das Rad still steht
void check_timeout()
{
  // Kontrolliere, ob das Rad angehalten wurde (lange keine Impulse mehr)
  unsigned long diff = millis() - time;
  if (diff > TIMEOUT)
  {
    // Rad wurde angehalten
    motor_aus();
  }
}


// I/O Pins initialisieren
void setup()
{
  pinMode(RELAIS, OUTPUT);
  pinMode(SENSOR, INPUT_PULLUP);
  pinMode(LED, OUTPUT);
}


void loop()
{
  digitalWrite(6, LOW);

  // Wenn der Magnet am Sensor ist
  if (digitalRead(SENSOR == LOW))
  {
    // Zeitspanne erfassen
    unsigned long diff = millis() - time;
    time = millis();

    // Schalte den Motor abhängig von der Geschwindigkeit ein oder aus
    if ((diff < MIN_TIME) or (diff > MAX_TIME))
    {
      // zu schnell oder zu langsam
      motor_aus();
    }
    else
    {
      // Im Zeitfenster, wo der Motor mit helfen soll
      motor_ein();
    }

    delay(3); // Zum Entprellen

    // Warte, bis der Magnet wieder weg ist
    while (digitalRead(SENSOR) == LOW)
    {
      check_timeout();
    }
  }

  else // Sensor ist LOW, der Magnet ist nicht am Sensor
  {
    check_timeout();
  }

}

[Manuel (Gast)]

Danke für diese neue aufgeräumte Version.

Wäre ja nicht nötig gewesen weil die ca. 25 Zeilen kürze Version auch 
schon mit Simikolon super läuft.

while (digitalRead(SENSOR) == LOW);
}

if (millis()-time>800) // Stillstand
{
digitalWrite(RELAIS, LOW);
digitalWrite(LED, HIGH); // Kontroll Lampe
}

}

ich werde die Punke a,b und c beherzigen.
Etwas habe ich ja schon gelernt:
HIGH und LOW ist nicht das selbe.

Entschuldigung noch mal für die vielen dummen Fragen.
Als Anfänger war das eben mit den millis und Verknüpfungen
gleich etwas viel für mich.

[Stefan F. (Gast)]

Manuel schrieb:
> Wäre ja nicht nötig gewesen weil die ca. 25 Zeilen kürze Version auch
> schon mit Simikolon super läuft.

Sie funktioniert nicht, wenn der Magnet beim schnellen Anhalten vor dem 
Sensor steht.

Außerdem erzeugt sie unsaubere Signale mit sehr kurzen Impulsen die du 
weder sehen kannst, noch reagiert das Relais darauf. Trotzdem gewöhnen 
sich Softwareentwickler an, auch solche "unwirksamen" Fehler zu 
korrigieren. Denn genau solche Stellen verursachen später bei 
Erweiterungen überraschende Probleme.

[Manuel (Gast)]

Ok, dann nochmal vielen Dank!

Ich war schon froh das jetzt jetzt überhaupt
3 Geschwindigkeiten und Stillstand erkannt werden.

Es ist ja nur eine Zusatzfunktion, wenn die Pedale nicht gedreht werden, 
ist der Motor so wie so aus.

[Manuel (Gast)]

Habe gerade mal Deinen neusten Sketch probeweise hochgeladen.
Aber leider tut sich da gar nix an LED oder Relais.

[Stefan F. (Gast)]

Sorry, da ist auch ein blöder Tippfehler drin. Schade dass der Compiler 
es nicht bemerkt hat:

> if (digitalRead(SENSOR == LOW))

Muss heissen:

> if (digitalRead(SENSOR) == LOW)

[Manuel (Gast)]

Ich hätte jetzt an Deiner Stelle gesagt das war ein Test.
Lach...
Soviel habe ich jetzt nämlich schon gelernt, das auf 2x Klammer auf 2x 
Klammer zu kommen muss.
Aber ich habe es auch nicht gefunden.

Kein Problem, ich werde es testen.

[Manuel (Gast)]

Ach nee ist ja beides Mal 2 x zu.
Nur an falscher Stelle.
Bin auch schon ganz wuschig....

[Stefan F. (Gast)]

Manuel schrieb:
> Ach nee ist ja beides Mal 2 x zu.
> Bin auch schon ganz wuschig....

:-)

Ich sag ja, dass es ein blöder Fehler ist. Dabei hatte ich mich noch 
bemüht, es mit allen Warnungen zu compilieren. Gegen manche Doofheit 
hilft nicht einmal das.

[Manuel (Gast)]

Jetzt ging das Relais wieder aber die Kontroll LED nicht.

Aber Dein Lehrling macht Fortschritte.
Habe Fehler selber gesucht und gefunden.
Der pinMode (6, OUTPUT);
hat gefehlt.
(Ich habe die LED an 6 + 8 statt GND.)
War so eine Idee von mir, weil in der GND Klemme schon zwei Kabel 
stecken.

Jetzt geht alles!
3 Geschwindigkeiten werden erkannt.
Stillstand mit Magnet am Schalter und ohne Magnet.

Super !!!

Dann könnte ich ja noch einen Pieper anbauen,
der bei verschiedenen Drehzahlen sich meldet.

[Stefan F. (Gast)]

Manuel schrieb:
> Ich habe die LED an 6 + 8 statt GND.
> War so eine Idee von mir, weil in der GND Klemme schon zwei Kabel
stecken.

Ich bin davon ausgegangen, dass die LED an Pin 6 angeschlossen ist, denn 
so geht das aus deinem Quelltext hervor.

Merkst du, dass wir immer wieder auf den fehlenden Schaltplan zurück 
kommen?

> Dann könnte ich ja noch einen Pieper anbauen,
> der bei verschiedenen Drehzahlen sich meldet.

Bitte nicht.
Dazu müssen wir (oder ich?) das Programm nämlich nochmal komplett 
umschreiben. Du kannst ja mal 
https://de.wikipedia.org/wiki/Endlicher_Automat und 
https://de.wikipedia.org/wiki/Multitasking lesen. Wenn du diese Artikel 
beide verstanden hast und eine Vorstellung davon hast, wie das auf einem 
Mikrocontroller mit den Mitteln von Arduino umgesetzt werden kann, melde 
dich wieder.
Es geht auf jeden Fall und ich weiss auch wie. Aber ich habe keine Lust, 
es Dir zu erklären, denn das würde eine never-ending Story.

[Manuel (Gast)]

Ich habe ja auch die  Kontroll LED an 6 + 8.
Aber  der pinMode (6, OUTPUT);
Text hat gefehlt beim letzten Sketch.

Dachte man könnte einen Ton einfach so wie die Kontroll LED zuschalten.

Aber wenn das zu große Umstände macht,
muss das ja nicht sein.

Habe ja die sehr helle Kontroll LED und das Relais klickt auch ziemlich 
laut.

[Stefan F. (Gast)]

Manuel schrieb:
> Dachte man könnte einen Ton einfach so wie die Kontroll LED zuschalten.

Nee

[Manuel (Gast)]

Warum nicht?

[Stefan F. (Gast)]

Weil du mit Sicherheit keinen Dauerton haben willst.

[Manuel (Gast)]

Ach Du meinst das ich dann mit delay alles durcheinander bringe?
Habe davon gehört...

[Stefan F. (Gast)]

Manuel schrieb:
> Ach Du meinst das ich dann mit delay alles durcheinander bringe?

Ja

[Manuel (Gast)]

Und wenn ich nur mit noTone arbeite?

[Stefan F. (Gast)]

Das Fass ohne Boden wurde aufgestellt, wer mag es befüllen?

[Manuel (Gast)]

Ok, bevor das in Arbeit ausartet.

Sollte ich vielleicht erstmal das System in der Praxis testen. Aber im 
Moment ist Sau Wetter.

Aber ich denke das läuft super.

[F. F. (foldi)]

Manuel schrieb:
> Dann könnte ich ja noch einen Pieper anbauen,
> der bei verschiedenen Drehzahlen sich meldet.

Also ich möchte so wenig wie nötig von meiner Elektronik sehen, wenn ich 
sie vorher ausgiebig getestet habe.
Natürlich sind manchmal optische und akustische Signale wichtig, aber 
bei dem Rad merkst du doch, ob der Motor aktiv ist. Da braucht es nicht 
einmal eine LED.
Alles muss heute irgendwie ein Display haben.
Wenn das Licht an ist, brauche ich nicht noch ein Display, auf dem 
steht, dass das Licht an ist.
Das Gepiepse wird den Fahrer sehr schnell wahnsinnig machen.
Dann baue lieber eine sinnvolle Überwachung für das Relais mit ein, denn 
da können auch mal die Kontakte kleben oder die Spule kaputt sein.

[Manuel (Gast)]

Das Relais klicken wird reichen als Kontrolle.

Die Kontrolllampe zeigt nicht an ob der Motor läuft,
sondern wann ich im Geschwindigskeitbereich bin das beim treten der 
Motor zugeschaltet werden würde oder eben nicht.

[Manuel (Gast)]

Ein Kumpel aus dem Pedelec Forum meint:

Normalerweise hängt man einen Impulsgeber an einen Interrupt.

Warum haben "Wir" das nicht so gemacht?

Wäre dann ein zusätzlicher Pieper einfacher zu integrieren?

[Stefan F. (Gast)]

Manuel schrieb:
> Normalerweise hängt man einen Impulsgeber an einen Interrupt.

Kann man machen, muss man nicht.

> Warum haben "Wir" das nicht so gemacht?

Weil das Programm dann komplexer geworden wäre.

> Wäre dann ein zusätzlicher Pieper einfacher zu integrieren?

Nein

[Manuel (Gast)]

Noch komplexer wollen wir ja nicht.
;-)

Ich werde vielleicht mal in diesen Sketch versuchen
einen Ton zu integrierten. Kann man ja wieder löschen wenn es nicht 
funktioniert...

[Manuel (Gast)]

Aber ich verstehe langsam,
das es ja nicht einfach ist einen Ton etwas länger laufen zu lassen ohne 
den Programm Ablauf zu bremsen.

[Manuel (Gast)]

Wollte noch mal kurz melden, das System läuft auch im Fahrbetrieb genau 
wie gewünscht.
Super!!!

[Manuel (Gast)]

// Zwischen den folgenden beiden Werten wird der Motor eingeschaltet
// 190 = 28 KMH - 800 = 6 KMH
// 200 = 25 KMH - 500 = 12 KMH

#define MIN_TIME 190
#define MAX_TIME 800

#define MIN_TIME 200
#define MAX_TIME 500

Ich habe mal wieder eine Frage.

Im Moment programiere ich das immer um,
wenn ich mal die Schaltpunkte verändern möchte.
Gerne würde ich das ändern der Werte noch mit einem Schalter oder Taster 
lösen.
Kann ich bei #define mit einer If Abfrage des Tasters dazwischen gehen?

[äxl (Gast)]

Na, bin ich ja mal gespannt.
Ich bau dir was, wenn Du magst. Im Abo: 300€ im Monat. Vierteljährlich 
kündbar.
Im Ernst. Ich finds dreist und unangemessen, wie du die 
Hilfsbereitschaft anderer stapazierst.
Ich hatte den Thread hier eben erst mitbekommen.


Statt die Referenz mal aufzurufen, um eigenes Interesse zu 
manifestieren, schriebst du, es ginge schlieslich bei anderen auch "mit 
semikolon".
das haben dann andere gemacht, ohne dass es Erwähnung fand.
Beitrag "Re: Suche Baustein, der in Abhängigkeit von Zeit (Frequenz) schaltet"
Interesse am eigenen Projekt sollte sich nicht auf das Interesse am 
eigenen Vorteil beschränken...

// Syntax

do {
  // statement block
} while (condition);

// Parameters

// condition: a boolean expression that evaluates to true or false.
// Example Code

int x = 0;
do {
  delay(50);          // wait for sensors to stabilize
  x = readSensors();  // check the sensors
} while (x < 100);

Beitrag "Re: Suche Baustein, der in Abhängigkeit von Zeit (Frequenz) schaltet"

[Manuel (Gast)]

Sorry äxl,

das war kein Jobangebot.
Auch keine suche nach einem Oberlehrer.

Es war einfach eine Frage an Leute die sich auf dem Gebiet besser 
auskennen als ich.

So wie ich auch Anfängern in anderen Foren mit Fragen helfe, wo ich mehr 
Wissen habe,
ohne mir das bezahlen zu lassen.

Ich hoffe Du bist noch sehr jung,
dann wirst Du auch noch lernen,
das man Geld nicht essen kann...