Beiträge von KaiR

KaiR · Gestern, 11:52

KaiR · Montag, 22:10

Machen wir hier noch ein bisschen "Alle meine Entchen..."

C

/*
* Program to generate sounds
*/
#include <Arduino.h>
//////////////////////////////////////////////////
// Functions forward declaration(s)
/////////////////////////////////////////////////
void playNote( int speaker, int theTone, int duration, int bpm );
//////////////////////////////////////////////////
// Definitions
//////////////////////////////////////////////////
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
//////////////////////////////////////////////////
// Global constants and variables
//////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
// Main program
//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
// we define durations as numbers between 1 and 7:
// 1 – whole note - 1 unit
// 2 – half note - 0.5 units
// 3 – quater note - 0.25 units
// 4 - eighth note - 0.125 units
// 5 – sixteenth note - 0.0625 units
// 6 – thirty-second note - 0.03125 units
// 7 – sixty-fourth note - 0.015625 units
//////////////////////////////////////////////////////////////////////////////////////
void setup() {
// notes in the melody:
//const int melody[] = {NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4);
const int melody[] = { NOTE_C3, NOTE_D3, NOTE_E3, NOTE_F3, NOTE_G3,
NOTE_G3, NOTE_A3, NOTE_A3, NOTE_A3, NOTE_A3,
NOTE_G3, NOTE_A3, NOTE_A3, NOTE_A3, NOTE_A3,
NOTE_G3, NOTE_F3, NOTE_F3, NOTE_F3, NOTE_F3,
NOTE_E3, NOTE_E3, NOTE_G3, NOTE_G3, NOTE_G3,
NOTE_G3, NOTE_C3};
// note durations: 3 = quarter note, 4 = eighth note, etc.:
//const int noteDurations[] = { 2, 3, 3, 2, 2, 2, 2, 2 };
const int noteDurations[] = { 3, 3, 3, 3, 2,
2, 3, 3, 3, 3,
1, 3, 3, 3, 3,
1, 3, 3, 3, 3,
2, 2, 3, 3, 3,
3, 1};
const int buzzerPin = 8;
const int bpm = 60;
// iterate over the notes of the melody:
for (int thisNote = 0; thisNote < 27; thisNote++) {
playNote(buzzerPin, melody[thisNote], noteDurations[thisNote], bpm);
}
}
void loop() {
// no need to repeat the melody.
}
void playNote( int speaker, int theTone, int duration, int bpm )
{
// menmotecnic: 120 bpm - - > 1000 milliseconds for half note
// source http://bradthemad.org/guitar/tempo_calculator.php
long time = ( 1000 / bpm * 120 ) / pow( 2, duration );
// assign the note to the speaker
tone( speaker, theTone, time );
delay( time * 1.3);
}

Alles anzeigen

Let the music play

Beschreibung zum tone() Befehl mit weiteren Beispielen:

https://www.arduino.cc/referen…nctions/advanced-io/tone/

https://www.arduino.cc/referen…tions/advanced-io/notone/

KaiR · Montag, 19:03

Hier ist ein Beispiel mit Melodie. Es ist nicht von mir, es ist aus den Beispielen von der Arduino IDE Datei->Beispiele->02 Digital->toneMelody.

Dort sind die Notendefinitionen in einem extra Headerfile. Hier habe ich sie in den C-Codefile kopiert. Also nicht von den vielen Definitionen erschrecken lassen:

C

/*
Melody
Plays a melody
circuit:
- 8 ohm speaker on digital pin 8
created 21 Jan 2010
modified 30 Aug 2011
by Tom Igoe
This example code is in the public domain.
http://www.arduino.cc/en/Tutorial/Tone
*/
#include <Arduino.h>
//////////////////////////////////////////////////
// Functions forward declaration(s)
/////////////////////////////////////////////////
//////////////////////////////////////////////////
// Definitions
//////////////////////////////////////////////////
#define NOTE_B0 31
#define NOTE_C1 33
#define NOTE_CS1 35
#define NOTE_D1 37
#define NOTE_DS1 39
#define NOTE_E1 41
#define NOTE_F1 44
#define NOTE_FS1 46
#define NOTE_G1 49
#define NOTE_GS1 52
#define NOTE_A1 55
#define NOTE_AS1 58
#define NOTE_B1 62
#define NOTE_C2 65
#define NOTE_CS2 69
#define NOTE_D2 73
#define NOTE_DS2 78
#define NOTE_E2 82
#define NOTE_F2 87
#define NOTE_FS2 93
#define NOTE_G2 98
#define NOTE_GS2 104
#define NOTE_A2 110
#define NOTE_AS2 117
#define NOTE_B2 123
#define NOTE_C3 131
#define NOTE_CS3 139
#define NOTE_D3 147
#define NOTE_DS3 156
#define NOTE_E3 165
#define NOTE_F3 175
#define NOTE_FS3 185
#define NOTE_G3 196
#define NOTE_GS3 208
#define NOTE_A3 220
#define NOTE_AS3 233
#define NOTE_B3 247
#define NOTE_C4 262
#define NOTE_CS4 277
#define NOTE_D4 294
#define NOTE_DS4 311
#define NOTE_E4 330
#define NOTE_F4 349
#define NOTE_FS4 370
#define NOTE_G4 392
#define NOTE_GS4 415
#define NOTE_A4 440
#define NOTE_AS4 466
#define NOTE_B4 494
#define NOTE_C5 523
#define NOTE_CS5 554
#define NOTE_D5 587
#define NOTE_DS5 622
#define NOTE_E5 659
#define NOTE_F5 698
#define NOTE_FS5 740
#define NOTE_G5 784
#define NOTE_GS5 831
#define NOTE_A5 880
#define NOTE_AS5 932
#define NOTE_B5 988
#define NOTE_C6 1047
#define NOTE_CS6 1109
#define NOTE_D6 1175
#define NOTE_DS6 1245
#define NOTE_E6 1319
#define NOTE_F6 1397
#define NOTE_FS6 1480
#define NOTE_G6 1568
#define NOTE_GS6 1661
#define NOTE_A6 1760
#define NOTE_AS6 1865
#define NOTE_B6 1976
#define NOTE_C7 2093
#define NOTE_CS7 2217
#define NOTE_D7 2349
#define NOTE_DS7 2489
#define NOTE_E7 2637
#define NOTE_F7 2794
#define NOTE_FS7 2960
#define NOTE_G7 3136
#define NOTE_GS7 3322
#define NOTE_A7 3520
#define NOTE_AS7 3729
#define NOTE_B7 3951
#define NOTE_C8 4186
#define NOTE_CS8 4435
#define NOTE_D8 4699
#define NOTE_DS8 4978
//////////////////////////////////////////////////
// Global constants and variables
//////////////////////////////////////////////////
// notes in the melody:
const int melody[] = {NOTE_C4, NOTE_G3, NOTE_G3, NOTE_A3, NOTE_G3, 0, NOTE_B3, NOTE_C4};
// note durations: 4 = quarter note, 8 = eighth note, etc.:
const int noteDurations[] = { 4, 8, 8, 4, 4, 4, 4, 4 };
const int buzzerPin = 8;
//////////////////////////////////////////////////////////////////////////////////////
// Main program
//////////////////////////////////////////////////////////////////////////////////////
void setup() {
// iterate over the notes of the melody:
for (int thisNote = 0; thisNote < 8; thisNote++) {
// to calculate the note duration, take one second divided by the note type.
//e.g. quarter note = 1000 / 4, eighth note = 1000/8, etc.
int noteDuration = 1000 / noteDurations[thisNote];
tone(buzzerPin, melody[thisNote], noteDuration);
// to distinguish the notes, set a minimum time between them.
// the note's duration + 30% seems to work well:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// stop the tone playing:
noTone(buzzerPin);
}
}
void loop() {
// no need to repeat the melody.
}

Alles anzeigen

Das sollte erst mal langen, um Dich zu beschäftigen .

Gruß Kai

KaiR · Montag, 18:41

Also wenn wir mal simpel anfangen, nimmst Du Dir einen Buzzer:

buzzer.jpg

Den Buzzer verbindest Du mit einem Pol mit einem Pin des µControllers und mit dem anderen an GND. Besser ist es, noch einen 100Ω Widerstand in Reihe zu schalten. In dem Bild fehlt er.

Dann schaltest Du den Pin für 1136µs an und für 1136µs aus ... das entspricht einer Periodendauer von 2272µs = 440Hz = dem Ton A.

Und wenn Du das immer wiederholst mit einer Pause dazwischen, dann hast du einen sich wiederholenden Ton.

Im folgenden Beispiel wird der Pin 8 (der Buzzer ist daran angeschlossen) 50mal für die oben genannte Zeitspanne an und ausgeschaltet.

Damit wird für ca. 113ms der Ton A erzeugt. Dann wird eine Sekunde gewartet um anschließend wieder den Ton zu erzeugen.

Code

#include <Arduino.h>
//////////////////////////////////////////////////
// Functions forward declaration(s)
/////////////////////////////////////////////////
void toneOnOff(void);
//////////////////////////////////////////////////
// Definitions
//////////////////////////////////////////////////
//////////////////////////////////////////////////
// Global constants and variables
//////////////////////////////////////////////////
const int buzzerPin = 8;
//////////////////////////////////////////////////////////////////////////////////////
// Main program
//////////////////////////////////////////////////////////////////////////////////////
void setup() {
pinMode(buzzerPin,OUTPUT);
}
void loop() {
toneOnOff();
delay(1000);
}
void toneOnOff() {
for (int i=50;i;--i) {
digitalWrite(buzzerPin,HIGH);
delayMicroseconds(1136);
digitalWrite(buzzerPin,LOW);
delayMicroseconds(1136);
}
}

Alles anzeigen

Das lässt sich mit der Arduino "tone()" Funktion noch schön erweitern, bzw. anders gestalten.

Ja --- millis() kommt nicht vor. Es geht hier erst mal nur um das Prinzip. Das C4 hat z.B. eine Frequenz von 261,63Hz. Das lässt sich schlecht teilen, macht aber nix. Es gilt f = 1/p => p = 1/f also 1/261,63Hz = 3827µs Periodendauer. Das ergibt ein Delay von ≈ 2 x 1913µs. Wenn Du diesen Ton erzeugst, wird die Zeitperiode bei 50 Wiederholungen natürlich länger. Logisch... weil die Frequenz niedriger ist.

Gruß Kai

KaiR · Montag, 12:38

In den Artikeln werden doch zwei Funktionen vorgestellt. „writeEEPROM()“ und „readEEPROM()“. Damit kannst du den externen Speicher beschreiben bzw. lesen. Bei der Library musst Du Dir die ino Dateien in Examples mal anschauen.

Gruß Kai

KaiR · Sonntag, 19:04

Uiii.... schön zu gucken.

Es sieht danach aus, als sei der Neodym Stab auch etwa 2cm. Hast du die zwei Magnete zusammengeklebt?!

KaiR · Sonntag, 18:54

Oh ... das guckt sich tatsächlich jemand an .

DanielS: Danke für den Hinweis. Ich habe es korrigiert.

KaiR · Sonntag, 11:56

Hallo Pius,

es ist sicher alles richtig was du schreibst. Mir geht es hier im Speziellen um den Mechanismus, den nische verwendet um das Pendel zu treiben.

Wenn ich das richtig sehe, wird für das Pendel eine Luftspule (Also kein Eisenkern) benutzt. Am Pendel ist ein Metallstab und ein Magnet angebracht. Die Spule sorgt also dafür, dass der Magnet abgestoßen wird, wenn eine Spannung induziert wird. Bei nisches Beitrag sieht es so aus, als sei dort fast eine ganze Rolle verwendet worden (Luftspule -> mehr Wicklungen).

Darum interessiert es mich, um wieviel Wicklungen es sich in etwa handelt.

Gruß Kai

KaiR · Sonntag, 10:28

Alles sehr interessant . Du hattest am Anfang dieses Threads (Beitrag 12) mal auf meine Bitte hin deine Spulenkonstruktion gepostet. Ich habe mit das noch einmal angeschaut. Es sind ja jede Menge Windungen. Wie viele? Oder kommt das nicht so genau. Wie viele sind es ungefähr?

Ich hab zwar einiges über Spulen gelernt... aber das in der Hauptsache nur theoretisch. Ich will mal anfangen in der Richtung praktisch zu experimentieren. Darum frage ich. Um ein Gefühl zu bekommen, wie viel Draht man für so ein Pendel braucht . Auch wenn ich sicher ein paar Nummern kleiner Anfangen würde .

Gruß Kai

KaiR · Sonntag, 08:12

Also wenn Englisch kein Problem ist, kann man hier eigentlich so gut wie alles finden was man braucht:

https://www.hobbytronics.co.uk/arduino-external-eeprom

https://www.hobbytronics.co.uk/eeprom-page-write

Der erste Link verweist auf einen Beitrag der Grundlagen und das Schreiben/Lesen von einzelnen Bytes erklärt. Der zweite erklärt, wie Daten blockweise und schneller schneller geschrieben und gelesen werden können.

Leider ist das ganz nicht so extra simpel. Aber der dort vorgestellte Code ist gut verwendbar.

Es gibt auch min. eine Library. Z.B. folgende:

I2C_EEPROM von Rob Tillaart

Gruß Kai

KaiR · Sonntag, 01:09

nische: ja, ich werde versuchen den „Drehaufbau“ noch zu realisieren und dabei sicher auf die ein oder andere „Herausforderung“ stoßen. Es kann sich aber noch etwas hinziehen. Die Zeit dafür ist etwas knapp bemessen.

Gruß Kai

KaiR · Samstag, 18:04

Hallo zusammen,

war so lange ruhig hier.

Heute habe ich mich mal wieder mit OP-Amps befasst und einen "Licht-" oder "Sonnenfolger" gebaut. Dabei werden die zwei Op-Amps (LM741) als "Fensterkomparatoren" verwendet. Dieser Begriff leitet sich davon ab, dass zwei Op-Amps das gleiche Ausgangspotential haben, solange eine Eingangsspannung innerhalb eines bestimmten Bereiches (Fenster) liegt. Über- oder unterschreitet die Eingangsspannung jedoch den Fensterbereich, so wird bei einem der beiden Op-Amps die Ausgangsspannung invertiert.

Sonnenfolger.png

In der vorgestellten Schaltung, sind die beiden LM741 mit zwei lichtempfindlichen Widerständen gekoppelt (LDRs). Die Ausgänge der Op-Amps sind wiederum mit einer Brückenschaltung für einen Gleichstrommotor verbunden. Werden zwei LDRs mit gleicher Lichtintensität bestrahlt, so haben sie einen mehr oder weniger gleichen Widerstand und der Motor steht still. Die Eingangsspannung liegt im Fensterbereich. An den Eingängen der beiden LM741 liegt etwa die halbe Betriebsspannung an und die Ausgänge sind negativ.

Je nachdem, wohin das Licht wandert, ändert sich die Lichtintensität pro LDR. Deren Widerstandswerte ändern sich und damit auch die Eingangsspannung der Op-Amps. Ab einem bestimmten Wert "kippt" einer der Op-Amps. Seine Ausgangsspannung wird invertiert und somit positiv. In der Brückenschaltung werden entweder die Transistoren T1 und T4 oder T2 und T3 leitend. Entsprechend dreht sich der Motor in unterschiedliche Richtungen.

Um das etwas mit Zahlen zu verdeutlichen (die Betriebsspannung beträgt 3V):

Ausgänge	Motor Stillstand	Rechtdrehung	Linksdrehung
		unterer LDR dunkel	oberer LDR dunkel
Op-Amp1 (rechts)	-0,729V	-0,69V	+2,24V
Op-Amp2 (links)	-0,728V	+2,23V	-0,69V

Die Angaben oben/unten/links/rechst beziehen sich auf untenstehendes Foto.

An dem 100K Poti erfolgt die Grundeinstellung. Sind beide LDRs gleichmäßig hell beleuchtet, kann die Ruhestellung des Motors darüber eingestellt werden. Mit dem zweiten 10K Poti wird die Empfindlichkeit der Schaltung reguliert.

Auf dem Breadboard sieht die Schaltung wie folgt aus:

370776A3-1070-4E79-B38D-410B9492C058.jpeg

Die LDRs sind hier links auf dem Breadboard untergebracht. Der Motor wird mit seinen beiden Polen in der Brückenschaltung in den gleichen Reihen eingesteckt, in denen sich auch die gelben Steckbrücken und die Dioden befinden. Der besseren Übersicht wegen, habe ich ihn für das Foto aus der Schaltung herausgenommen. Falls sich jemand über die gelbe Steckbrücke am links oberen LDR wundert, ich habe die obere (+) Spannungsschiene des Breadboards für die Verbindung der LDRs mit jeweils einem "invertierenden" und einem "nicht invertieren" Eingang der Op-Amps benutzt. Die untere (+) Spannungsschiene führt die positive Spannung für die gesamte Schaltung . Die negative Spannung für die Op-Amps liegt auf der unteren (-) Reihe. Auf der oberen (-) Reihe liegt das Massepotential an.

Die negative Spannung für die Op-Amps erzeuge ich mit einer, im Bild nicht sichtbaren, "Ladungspumpe":

Neg-Spannung-Schmitt-Trigger.png

Bei einem sinnvollen Aufbau, sollten die LDRs zusammen mit einer Solarzelle auf der Welle des Motors befestigt werden. Die Solarzelle würde dadurch mit der Sonne "mitwandern" und somit eine optimale Lichtausbeute haben. Weil ich die Schaltung aber erst einmal ausprobieren wollte, habe ich nur getestet ob der Motor sich dreht, wenn sich die Lichtverhältnisse ändern und ob er auch mal stehen bleibt, wenn beide LDRs gleich hell beleuchtet werden.

Es hat geklappt . Im folgenden Video kann sich das Prinzip anschauen.

Die Schaltung ist aus dem Buch "Elektronik gar nicht schwer- Experimente mit Operationsverstärkern" von Kurt Diedrich entnommen.

Gruß Kai

KaiR · 22. September 2020

Hallo zusammen,

durch eine Frage einer Forenteilnehmerin bin ich wieder etwas zu dem Infrarot-Thema gekommen. Es ging darum eine IR-LED über einen Transistor anzusteuern. Das kann wie folgt gelöst werden:

IR-LED1.png

V2 stellt in diesem Fall den (Output) Pin eines µControllers z.B. vom Atmega328p (Nano / Uno) dar. Über diesen Pin wird der Transitor mit Hilfe eines 38kHz (phasenkorrekten) PWM Signals angesteuert. Der Transistor ist deshalb vorhanden, weil die IR-LED mit mehr als den Arduino verträglichen 20mA Strom betrieben werden soll.

Das (Beispiel-) Signal womit die IR-LED angesteuert wird, sieht wie folgt aus:

IR_Senden_Empfangen.PNG

Im unteren Bereich des Oszillogramms sind die die Blöcke, die von 0 auf 5V moduliert werden, deutlich zu erkennen. Diese Blöcke bestehen aus dem 38kHz Signal. Keine Blöcke, kein PWM Signal. Die von der IR-Diode "abgestrahlten" Signale habe ich mit einem Empfänger (unten schon erwähnter TSOP31238) wieder "aufgefangen" und an dessen Signal-Pin das Oszi mit einem weiteren Kanal angeschlossen. Das Empfangssignal ist in der oberen Reihe abgebildet.

Es ist deutlich zu erkennen, dass der Empfänger dieses Signal invertiert (Von 5V auf 0V). Sender HIGH wird zu Empfänger LOW und umgekehrt. Die "Breite" der Signale entspricht den PWM Blöcken und den Pausen. Man kann sich also relativ "simpel" durch eine PWM-Signalabfolge sein eigenes IR-Protokoll zusammenbauen. Was es für professionelle Codierungsmethoden gibt, lässt sich hier nachlesen "Mikrocontroller.net IRMP.

Man erkennt auch einen winzigen Versatz zwischen dem Sende- und dem Empfangssignal:

IR_Versatz.PNG

Es handelt sich um etwa 194µs. Das schreibe ich mal der Verarbeitungsdauer des Empfängers zu.

Folgenden Programmcode zum Ausprobieren habe ich verwendet (nur Codeerzeugung, nicht Dekodierung):

C

/*
* IR-Sender Example
* V. 1
* Based on https://wolles-elektronikkiste.de/ir-fernbedienungen AND
* IRremote (Copyright 2009 Ken Shirriff)
*
* Created: 22.09.2020
*
* Author : KaiR
*
* A simple example for the generation on IR Signal for an IR-Receiver
*
*/
#include <Arduino.h>
//////////////////////////////////////////////////
// Functions forward declaration(s)
//////////////////////////////////////////////////
void pulseIR(unsigned long microsecs);
void initPwmSignal(uint16_t frequency);
void delay_usec(unsigned long uSecs);
//////////////////////////////////////////////////
// Definitions
//////////////////////////////////////////////////
#define TIMESEGMENT 20
#define IR_SEND_DUTY_CYCLE 30 // 30 saves power
#define TIMER_FREQUENCY_PWM 38000
#define TIMER_ENABLE_PWM (TCCR2A |= _BV(COM2B1))
#define TIMER_DISABLE_PWM (TCCR2A &= ~(_BV(COM2B1)))
#define TIMER_OUTPUT_PIN (DDRD = (1 << PD3))
//////////////////////////////////////////////////
// Global constants and variables
//////////////////////////////////////////////////
const int irSignal[] = {48,42,47,43,92,87,92,43,47,42,47,87,92,43,47,43,47,42,47,43,46,4538,47,43,47,42,93,87,92,42,47,43,47,87,92,42,47,43,47,42,48,42,47};
int irSignalLength;
unsigned long phase;
//////////////////////////////////////////////////////////////////////////////////////
// Main program
//////////////////////////////////////////////////////////////////////////////////////
void setup(void) {
irSignalLength = sizeof(irSignal)/2; // One int = Two bytes
TIMER_OUTPUT_PIN;
initPwmSignal(TIMER_FREQUENCY_PWM);
}
void loop(void) {
int i = 0;
phase = TIMESEGMENT*irSignal[i];
pulseIR(phase);
i++;
do{
phase = TIMESEGMENT*irSignal[i];
delay_usec(phase);
i++;
phase = TIMESEGMENT*irSignal[i];
pulseIR(phase);
i++;
} while(i<irSignalLength);
delay(10000);
}
void pulseIR(unsigned long microsecs) {
TIMER_ENABLE_PWM;
delay_usec(microsecs);
TIMER_DISABLE_PWM;
}
//
// Init Timer Control Register 2, phase correct PWM
// Output is OC2B (PD3 = Arduino D03).
// Taken from IRremote (Copyright 2009 Ken Shirriff)
//
void initPwmSignal(uint16_t frequency) {
const uint16_t pwmval = (F_CPU / 2) / (frequency);
TCCR2A = _BV(WGM20);
TCCR2B = _BV(WGM22) | _BV(CS20);
OCR2A = pwmval;
OCR2B = pwmval * IR_SEND_DUTY_CYCLE / 100;
}
//
// Custom delay function that circumvents Arduino's delayMicroseconds limit
// Taken from IRremote (Copyright 2009 Ken Shirriff)
//
void delay_usec(unsigned long uSecs) {
if (uSecs > 4) {
unsigned long start = micros();
unsigned long endMicros = start + uSecs - 4;
if (endMicros < start) { // Check if overflow
while ( micros() > start ) {} // wait until overflow
}
while ( micros() < endMicros ) {} // normal wait
}
}

Alles anzeigen

Der Programm-Code ist nicht auf meinem Mist gewachsen. Ich habe mich des Codes von der sehr guten Seite Wolles Elektronikkiste und von Codeteilen der unten schon erwähnten IRremote Bibliothek von Rafi Khan bedient, in dessen Bibliothek wiederum Code von Ken Shirriff steckt. Ich habe die Teile bloß aus Neugierde etwas zusammengewürfelt um das Prinzip besser zu verstehen.

Weitere, sehr gute Erklärungen sind, wie schon erwähnt, auf Seite Wolles Elektronikkiste zu finden. Das muss ich ja nicht nochmal aufschreiben.

Viel Spaß beim herumprobieren.

Gruß Kai

KaiR · 18. September 2020

Hallo zusammen,

heute habe ich noch einmal etwas herumprobiert. Ich hatte ja geschrieben, dass man bei einem PNP Transistor möglicherweise eine etwas aufwändigere Schaltung braucht. Deswegen hatte ich mit Pius hinter den Kulissen noch etwas Schriftverkehr. Er sagte nämlich, dass ein Output-PIN der auf HIGH gesetzt ist, diesen Status auch im Sleepmode behält. Somit ist also auch eine einfache PNP Schaltung möglich.

Ich habe es ausprobiert und wie immer hatte Pius recht .

Allerdings hatte ich so meine Zweifel, wenn ich im Schlafmodus permanent einen PIN auf HIGH und somit auf Betriebsspannung halte, ob das nicht vielleicht doch mehr Strom verbraucht, als wenn er auf Massepotential liegt.

Darum habe ich beide Varianten mit einem Arduino-Nano Clone aufgebaut. Das Programm aktiviert das Display, spielt eine Grafikdemo und schaltet anschließend das Display wieder aus, bevor der SleepMode aktiviert wird. Die verwendete Routine (Auszug) sieht wie folgt aus:

Code

void loop() {
Serial.println("Switch Display on");
//digitalWrite(SWITCH,LOW); // PNP
digitalWrite(SWITCH,HIGH); // NPN
delay(100);
demo();
Serial.println("Go into Deep-Sleep");
//digitalWrite(SWITCH,HIGH); // PNP
digitalWrite(SWITCH,LOW); // NPN
delay(5000);
GoingToSleep();
}

Alles anzeigen

SWITCH ist in diesem Fall der Pin D10 des Nano. Dieser ist mit der Basis des jeweiligen Transistors verbunden. Je nach verwendeten Transistor habe ich den PIN gegensätzlich geschaltet. Wie, sieht man an den Kommentaren im Quellcode.

Mit einem Taster an einem Input-Pin wurde der Controller (per Interrupt) wieder aufgeweckt. Die Prozedur habe ich pro Schaltungsvariante fünf mal wiederholt und dabei den Maximalstrom und den Strom im Sleepmode gemessen. Wirklich interessant ist eigentlich nur der Stromverbrauch im Sleepmode. Das Maximum hängt stark von der Art der Displayausgabe ab. Ich führe es der Vollständigkeit halber aber mal mit auf:

PNP	Sleepmode / mA	Max / mA
1	12,636	47,273
2	13,050	51,518
3	13,044	51,447
4	13,046	51,517
5	13,043	51,410

NPN	Sleepmode / mA	Max / mA
1	12,724	51,427
2	12,722	51,403
3	12,720	51,415
4	12,720	51,521
5	12,720	51,416

Der Minimalstrom ist beim Beginn des Sleep-Modes etwas geringer als in der Tabelle angegeben, steigt aber mit der Zeit ein kleines bisschen an, bis er sich einpendelt. Der Unterschied ist nicht sehr groß aber es ist ein leichter Vorteil bei der NPN-Schaltung zu erkennen. Bei den Werten handelt es sich um den Gesamtverbrauch der Schaltung.

Warum die erste Messung beim PNP so aus der Reihe fällt kann ich nicht mit Gewissheit sagen, wahrscheinlich habe ich mich da mit der MIN/MAX Taste meines Multimeters etwas vertüddelt und es ist ein Messfehler.

Wer sich jetzt fragt, warum der Nano im Sleep Mode noch so viel Strom verbraucht, dem sei gesagt, es brennt auch im Schlafmodus die Power-LED. Wenn man das nicht will, muss man sie auslöten. Außerdem haben diese "MCUs" nicht den sparsamsten Spannungswandler. Der verbrät einiges an Ruhestrom. Es ist auch sicher noch das ein oder andere am Schlafmodus optimierbar (z.B. AD-Wandler abschalten usw.). Ich denke aber, am Prinzip würde auch das nichts ändern.

Wer es selber ausprobieren möchte, kann das Programm hier herunter laden: arduino-io.cpp.

Für die Arduino IDE, muss die Datei von .cpp in .ino umbenannt werden.

Gruß Kai

KaiR · 16. September 2020

Nicole:

Ja... das mit R4 habe ich geschrieben und da hat sich auch nichts dran geändert. Der Plan ist aus einer Simulation entstanden. Deshalb ist das Display auch kein Display, sondern eine LED-Bar mit Vorwiderstand. Da meine Schulversion kein Spice Modell für OLEDs hat, habe ich mir so beholfen, um die grundsätzliche Funktionalität zu ermitteln. Darum ist R4 da noch drin.

Ob die zweite Schaltung wirklich sparsamer ist, habe ich nicht ausprobiert. Kannst Du ja mal versuchen. Aber vielleicht fängst du erst mal mit dem NPN an und probierst, ob da alles reibungslos läuft.

Gruß Kai

KaiR · 16. September 2020

Hallo zusammen,

ich habe zumindest für die „Transistorengeschichte“ die Schaltungen noch einmal etwas „schön“ gemacht.

Folgendes Bild zeigt beide Schaltungen, einmal mit einem NPN und einmal mit einem PNP-Transistor.

Es ist jeweils noch ein 100kΩ Widerstand hinzugekommen. Bei der NPN Schaltung ist es ein Pull-Down Widerstand, der dafür sorgt, dass auf der Leitung vom, nennen wir ihn mal „SteuerPIN“ des μControllers, immer ein definierter Zustand herrscht (entweder LOW oder HIGH aber nix dazwischen, z.b. beim Start des Arduino).

53994781-AC47-4B6F-A912-D2BC281D129A.png

Bei der PNP Schaltung ist er als Pull-Up Widerstand eingesetzt. Simpel ausgedrückt, arbeitet die PNP Schaltung genau umgekehrt wie die NPN Schaltung. Und damit kommen wir zum kniffeligen. So wie im obigen Schaltplan angeschlossen, wird das Display angeschaltet, wenn der SteuerPIN des μControllers auf LOW geschaltet ist. Also arbeitet das Display auch, wenn der μController ausgeschaltet ist. Das ist aber nicht gewollt. Und damit komme ich zu Pius‘ Hinweis auf seine Würfelschaltung in Beitrag #17 dieses Threads.

Bitte @Pius korrigiere mich, wenn ich hier jetzt falsche Schlüsse verbreite.

Die Schaltung mit einem PNP-Transistor wird etwas komplizierter, weil die Basis des PNP über einen NPN- Transistor gesteuert werden muss. Dadurch wird das Display, wie gewünscht, ausgeschaltet, wenn der μController im Schlafmodus und damit auch der SteuerPIN auf LOW geschaltet ist. Das sähe dann so aus:

CCB6617D-E445-42F1-998F-BD5777612FA7.png

Bei dieser Schaltung wird der NPN-Transistor durchgeschaltet wenn der SteuerPIN auf HIGH geschaltet ist. Dadurch wird die Basis des PNP-Transistors auf Massepotential gebracht und er schaltet durch. Im umgekehrten Fall schließt der PNP-Transistor. Wir haben wieder das gewünschte Verhalten.

Gruß Kai

KaiR · 15. September 2020

Ich habe mal ein Projekt hier vorgestellt, bei dem MQTT zum Einsatz kommt. Allerdings habe ich einen eigenen Server auf einem Raspberry Pi installiert.

Auf dem Pi werden die Sensordaten von Garten und Wohnung per Funk empfangen. Ein ESP8266 holt sich die Daten ab und zeigt sie auf einem ePaperdisplay an.

Gruß Kai

KaiR · 15. September 2020

Ich habe meinen Test mit einem NPN BC547B gemacht. Mein Multimeter hat mir einen Ruhestrom (Display aus) von -0,002mA = -2µA angezeigt. Das ist so ein kleiner Wert, da weiß ich gar nicht so recht, wie ernst der zu nehmen ist. Das (-) hat mich etwas irritiert. Ich werde das bei Gelegenheit nochmal genauer untersuchen und mit Pius' Variante vergleichen.

Und ja .. so wie Pius es beschrieben hat, ist auch geschaltet.

Gruß Kai

KaiR · 15. September 2020

Eine Frage die sich gar nicht so einfach beantworten lässt. Ich weiß nicht in wie weit Micropython MQTT unterstützt. Wenn es eine Unterstützung für dieses Protokoll gibt, ist es vielleicht erst mal ein einfachsten eine public MQTT Broker zu verwenden und bestimmte Teile auf die eigene HP verlinken. Beispiel HiveMQ. Oder wenn Du auf dem Server beim Hoster selber Software installieren darfst ... nen eigenen Broker wie z.B. Mosquitto installieren, dann ist aber noch nichts visualisiert. Evtl. gibt es Plugins für das CMS das du nutzt, falls Du eine nutzt (Wordpress, Joomla oder sowas?).

Ich weiß es nicht ... sind nur so Ideen.

Gruß Kai

KaiR · 15. September 2020

Danke Pius für Dein geballtes Wissen . Auf jeden Fall würde ich, nach neueren Erkenntnissen, NICHT empfehlen das Display direkt an eine digitalen Pin des Arduino anzuschließen!!!!

Ich bin gerade am Messen und hatte einen Maximalwert von 26,299 mA Stromverbrauch. Meistens liegt der Verbrauch unter 11mA aber eben nur meistens... je nach Grafikoperation geht es offenbar ganz schön nach oben (z.B. wenn die Display-Ausgabe invertiert wird -> weißer Hintergrund) und liegt damit weit über der Angabe, die in diversen Datenblättern zu finden ist.

DABE407D-024D-4237-9564-D936944ECE64.jpeg

Ergänzung:

Nach nun recht vielen Versuchen kann ich keinen bemerkenswerten Unterschied mehr im Stromverbrauch feststellen. Egal ob nun 820Ω Widerstand oder ein 39kΩ Widerstand verwendet wird. Also Nicole ... mach keinen Heckmeck... nimm nen kΩ und gut is . Dann ist auf jeden Fall ist dann genug Saft auf der Leitung.

Gruß Kai

Beiträge von KaiR

millis() mit Lautsprecher

millis() mit Lautsprecher

millis() mit Lautsprecher

millis() mit Lautsprecher

Wie programmiere ich einen externen EEPROM??

Pendeluhr

ANALOG

Pendeluhr

Pendeluhr

Wie programmiere ich einen externen EEPROM??

ANALOG

ANALOG

Steuerung mit Infrarot

Oled Display und Batterie Betrieb ?

Oled Display und Batterie Betrieb ?

Oled Display und Batterie Betrieb ?

Daten vom BME280 via ESP32 via RS232 auf PC mit Python 3.8.X visualisieren

Oled Display und Batterie Betrieb ?

Daten vom BME280 via ESP32 via RS232 auf PC mit Python 3.8.X visualisieren

Oled Display und Batterie Betrieb ?