Hallo!
Ich habe eine Platine gebaut mit einem Arduino nano drauf.
Ich will mit diesem unter anderm 4 Ledleisten mit PWM ansteuern.
Die Ledleisten hängen über ein MosFet Platine dran.
Habe die Ausgänge 6 [LedPin1], 9 [LedPin2], 10 und 11 dafür auserkoren und definiert.
Nun habe ich das Problem dass ich die Ausgänge 9 und 11 nicht in der Helligkeit steuern kann.
Die beiden anderen Ausgänge 6 und 10 steuere ich zB. mit AnalogWrite(LedPin1, 150); an.
Kein Problem funktioniert. Auch andere Werte funktionieren.
Wenn ich aber den Ausgang 9 mit AnalogWrite(LedPin2, 150); ansteuere bleibt alles dunkel.
Nur wenn ich AnalogWrite(LedPin1, 255); verwende, leuchten die Leds.
Habe es auch schon versucht nur 1 Led ohne den MosFet Board anzusteuern. Gleiches Ergebnis.
Das gleiche ist beim Ausgang 11.
Der Ausgang 10 funktioniert.
Die durchnummerierten Variablen schreien ja förmlich nach Array oder Objektorientierung, aber kläre erst mal Deine Pins.
Und dann lass die Delay verschwinden.
Hatte ursprünglich mal ein ein Array dafür verwendet.
Die Delay waren Millis.
Da ich habe rausfinden wollte woran es liegt habe, ich dies mal geändert.
Wenn es funktioniert, baue ich das in meinen ursprünglichen Sketch wieder ein, bzw. verwende diesen dann wieder.
Hier der Sketch mit Array und millis:
// Test Lichtsteuerung
const int taster = 8; // Pin für das Signal zum Öffnen/Schließen
bool tasterGedruckt = false; // Tasterstatus
// Beleuchtung
const int ledPins[] = { 6, 9, 10, 11 };
const int HellPotPin = A1; // Potentiometer für Helligkeitseinstellung
// LED Zustände
bool ledOn[4] = { false, false, false, false }; // Speichert, ob LED an ist
// Steuerungsvariablen Licht
int brightness = 255; // Helligkeit der LEDs (über Helligkeitssenor gesteuert)
bool buttonPressed = false; // Status des Einschaltknopfes
bool ledsOn = false; // Zustand der LEDs (an/aus)
int zaehl = 0; // Zählvariable
//
// *****************************************************
// ********************** setup **********************
// *****************************************************
void setup() {
Serial.begin(9600);
pinMode(taster, INPUT_PULLUP); // SteuerPin
// LED Pins als Ausgang definieren
for (int i = 0; i < 4; i++) {
pinMode(ledPins[i], OUTPUT);
analogWrite(ledPins[i], 0); // LEDs aus
}
// Zufallszahlengenerator initialisieren
randomSeed(analogRead(A7));
}
//
//
//
// *****************************************************
// ********************** loop **********************
// *****************************************************
void loop() {
unsigned long aktuellMillis = millis();
// Helligkeit über Lichtsensor an A1 steuern
int potValue = analogRead(HellPotPin);
brightness = map(potValue, 0, 1023, 100, 255); // Helligkeit von 0 bis 255
//
// Tasterstatus lesen und erkennen, wenn der Taster gedrückt ist
if (!digitalRead(taster) && !tasterGedruckt) {
tasterGedruckt = true; //Taster wurde gedrückt
Serial.println("Impuls auf Pin 8 eingelangt");
}
// Wenn Taster gedrückt wird und Licht aus, dann schalte Licht ein, ansonsten schalte aus
if (!ledsOn) {
turnOnLeds(); // LEDs starten
} else {
turnOffLeds(); // LEDs ausschalten
}
// Wenn der Taster losgelassen wird, erlauben, dass er wieder gedrückt werden kann
if (digitalRead(taster)) {
tasterGedruckt = false; // Tasterstatus zurücksetzen
}
//
}
//
//
//
// *****************************************************
// ******************* Funktionen *******************
// *****************************************************
//
// Funktion zum Einschalten der LEDs mit Flackern
void turnOnLeds() {
Serial.println("Einschalten der LEDs...");
for (int i = 0; i < 4; i++) {
ledOn[i] = true;
simulateStartupFlicker(i); // Simuliert das Einschaltflackern
}
Serial.println("Alle LEDs sind stabil eingeschaltet.");
}
// Funktion zum Ausschalten der LEDs
void turnOffLeds() {
ledsOn = false;
Serial.println("Ausschalten der LEDs...");
for (int i = 0; i < 4; i++) {
analogWrite(ledPins[i], 0);
ledOn[i] = false;
}
Serial.println("Alle LEDs sind ausgeschaltet.");
}
// Simuliert das Flackern der LEDs beim Einschalten
void simulateStartupFlicker(int ledIndex) {
int flickers = random(2, 7); // Anzahl der Flackerzyklen
for (int i = 0; i < flickers; i++) {
analogWrite(ledPins[ledIndex], random(100, brightness)); // Flackernde Helligkeit
delay(random(100, 500)); // Kurze Pause zwischen Flackern
analogWrite(ledPins[ledIndex], 0); // LED kurz aus
delay(random(100, 500));
}
analogWrite(ledPins[ledIndex], brightness); // LED dauerhaft an
Serial.print("LED ");
Serial.print(ledIndex);
Serial.println(" ist stabil an.");
}
Ich habe so was mal für Bojen gebaut, evtl hilft es Dir.
Da könnte man die Flackerintervalle an/aus vorn eintragen (auch unterschiedlich) und dann Leuchtdauer an und Pause aus.
Danke Tommy!
Werde mir das mal anschauen. Aber zuvor will ich die Ursache des Fehlers finden.
Fehlerursache gefunden: Bibliothek Servo.h
Hatte gestern ja meinen Testcode hochgeladen, dabei ist mir aufgefallen, dass ich in meinem Testcode für die Leds, wie hochgeladen, eine Bibliothek Servo.h eingebunden hatte. Diese Einbindung hatte ich rausgenommen, vor dem Hochladen. Bei meinen Tests war sie aber drinnen.
Habe nun nachgelesen, dass diese Bibliothek die PWM Pins 9 und 10 deaktiviert.
Wenn ich die Bibliothek nicht verwende funktioniert es.
Da ich aber in meinem Hauptcode, wo eben die Lichtsteuerung eingebunden ist, auch ein Servo ansteuere, brauche ich diese Bibliothek.
Gibt es eine andere Möglichkeit das Servo anzusteuern ohne diese servo.h oder gibt es eine andere?
Mit dem MoBaTools bist Du nicht auf die PWM-Pins für den Servo angewiesen.
Den kannst Du auf beliebige Pins legen.
Lies doch einfach mal die sehr gute Dokumentation.
Das gilt für die servo.h genau so. Das Problem ist, dass die servo.h - genau wie auch die MobaTools - den Timer 1 benötigen. Und damit können die PWM-Pins des Timer1 nicht genutzt werden.
Wenn man alle PWM-Pins nutzen will, kann man keine Lib einsetze, die einen Timer benötigt.
Alternative könnte ein (pro) micro sein. Der hat einen Timer mehr.
@oslotter: Wieviel PWM-Pins brauchst Du denn wirklich? Bisher war nur von 4 die Rede. Der Nano hat aber 6.
Im Fertig Ausbau brauche ich 6 PWM Pins.
4 für die 4 Ledstreifen
1 für ein Aussenlicht
1 für eine Servo
Das ganze wird eine Garage mit 2 Tore, die gemeinsam geöffnet werden.
Jede Garage hat 2 Lichtstreifen
Ein Aussenlicht kommt vor die Tore.
Alle Lichtstreifen müssen gedimmt werden, da bei dunkler Umgebung diese nicht alles überstrahlen sollen. Dazu habe an A1 ein lichtempfindlichen Widerstandssensor.
Dazu kommen noch 2 Digitaleingänge für Tor öffnen und anschließend Licht einschalten und einer der einen Licht ausfall simulieren soll. (Ja/nein)
Alle Ledstreifen sollen sich verhalten wie Leuchtstofflampen. Als das unterschiedliche blinken beim Einschalten. Der Ausfall soll so einen Balkenausfall simulieren.
Ich habe derzeit nur von den 4 Balken gesprochen weil ich beim Aufbau des Scripts bin.
Da ich zwischendurch immer wieder mal teste, da ist mir das aufgefallen.
Da ich nun weiß, dass ich die Pins 9 & 10 nicht für PWM Aufgaben bei Servo.h und auch bei den MobaTools verwenden kann werde ich die Pins 9 & 10 zu Eingängen umfunktionieren.
2 normale Digitalpins bekommen dann das Servo und der andere das Aussenlicht.