Zeigt her eure geilen Projekte!

Wenn sie was ordentliches gelernt hätten, bräuchten sie ja nicht Politiker zu werden.

E-Mobilität mit Strom aus Kohle, Gas und Öl.

Gruß Tommy

2 Likes

Auf Anraten von @agmue und @wno158 poste ich das hier auch mal rein. Originalpost: Projektvorstellung "Schreibtischbelüftung"

Hallo zusammen,
ich möchte euch hier meine "Schreibtischbelüftung" (kann man das so nennen?) vorstellen.
Unsere beiden Rechner stehen beide unter einem Durchgehenden Schreibtisch in U-Form. Nun staut sich, nach einer gewissen Betriebsdauer unter dem Tisch dermaßen die Hitze, dass es nicht mehr angenehm ist. Deshalb habe ich eine Belüftung gebastelt.
Erst habe ich nur versucht ein Lüftungsgitter in die Tischplatte einzuschneiden. Das brachte allerdings gar keine Abhilfe. Die Lösung: LÜFTER :wink:

Ich habe hierzu 6 8cm Lüfter besorgt und unter dem Lüftungsgitter montiert. Die Lüfter werden mittels PID-Regler per PWM-gesteuert. Da ich feststellen musste, dass sich die Lüfter somit nicht völlig abschalten lassen, schalte ich die 12V Versorgung über den Arduino mit einer Transisitor-MOSFET Schaltung.
Es sind zwei 18b20 Temperatursensoren im Einsatz. Einer über und einer unter den Lüftern. Sobald die Differenz der beiden einen bestimmten Wert übersteigt beginnen die Lüfter zu arbeiten. Beim Start werden die Lüfter für einen bestimmte Zeitraum mit maximaler Drehzahl angesteuert (Start-Boost)
Eine RGB-LED zeigt die aktuelle "Leistung" an grün=Mindestdrehzahl, rot=Maximaldrehzahl. Das Display gibt Auskunft über die aktuellen Temperaturen, Leistung in %, Drehzahl, Betriebsdauer der Lüfter und der gesamten Steuerung sowie min/max Werte der Sensoren.
Beim kurzen Betätigen des Tasters auf der Seite, wird die Anzeige aktiviert und blättert die einzelnen Seiten nacheinander durch. Danach wird das Display wieder abgeschaltet. Wenn man den Taster gedrückt hält, kann man zwischen den Modi Max, Aus und Automatik wählen. Bei Doppeldruck werden die Min/Max Werte zurückgesetzt.
Die Betriebsstunden werden in den EEPROM gesichert und nach dem Speichern noch einmal gelesen und verglichen. Wenn die Werte nicht übereinstimmen, wird davon ausgegangen dass der Bereich des EEPROM defekt ist und der nächste Bereich wird verwendet. Sollten alle Bereiche defekt sein (rechnerisch dauert das allerdings Jahre) blinkt die LED Blau.

Verwendet wurde hier ein Arduino Nano, ein 12V Netzteil, ein DC-DC Step-Down Regler, ein OLED-Display und noch ein paar Kleinigkeiten.

Ist jetzt bestimmt keine Meisterleistung oder eine Schönheit, aber was solls :wink: Falls jemand den Code haben/sehen will, bitte ich um Geduld. Das fehlt noch ein bisschen was und aufräumen muss ich auch noch :wink:







Bin mit meinem PHEV auch ganz zufrieden. Einziges Manko ist der Umstand das ich aller 2 Monate zum Brunnen fahren muss um Dino Brühe rein zu pumpen. :sweat_smile:

Mit dem BEV meiner Holden ist dieser Schlenker unnötig.

Diese kleine Box spielt nach dem Start für 15 Minuten eine zufällige Audiodatei von der SD Karte. Nach Ablauf der 15 Minuten wird die Wiedergabe gestoppt und das nächste Mal an der selben Stelle fortgesetzt. Weiters wird auch der Verstärker abgeschaltet.
Das Lauflicht an der unteren Front signalisiert den Zustand: Lauflicht = Betrieb, Lauflicht stopt = mute, Rotes Pulsieren am linken Rand = Verstärker oder Player Fehler.
Steuern lässt sich das Ganze mit einer Fernbedienung und auch mit dem Drehimpulsgeber an der Front.

Verbaut wurden hier unter anderem:
ein ICEPower50ASX Verstärkermodul
ein LM2596S Step-Down
zwei Arduino Nano (einer für die Steuerung und einer fürs Lauflicht, ich weiß das wäre auch anders gegangen, ich wollte aber nicht extra nur wegen eines PWM ICs eine Bestellung aufgeben, und Nanos hat man ja immer etwas mehr rumliegen ;))
ein DFPlayer Mini Modul
ein STEC11B Drehimpulsgeber mit Taster
ein TSOP4838 IR Empfänger
und eine Seki Slim Fernbedienung.

Hab mich bei der Größe ein Wenig verschätzt, darum leider ein bisschen eng geworden :wink:






1 Like

Metallgehäuse sollten besser mit dem Schutzleiter verbunden werden. Würde bei dir natürlich auch ein anderes 230V Kabel und Buchse bedeuten.
Magst du auch die zwei Sketche zeigen?

Daran hab ich dann auch gedacht :wink: andere Buchse und Kabel kommen mit der nächsten Bestellung :wink:

Sketch Main:

// ######################################
// ############## PRESETUP ##############
// ######################################
// CONSTANCES AND DEFINES
#define DEBUG_SKETCH 0 // Set 1 to show debug infos in serial monitor
#define REMOTE_PWR 0x88
#define REMOTE_CH_UP 0x16
#define REMOTE_CH_DOWN 0x12
#define REMOTE_VOL_UP 0x13
#define REMOTE_VOL_DOWN 0x14
#define REMOTE_MUTE 0x15
const unsigned int maxRuntime = 15; // Time in Minutes after the player should stop

const byte encoderA         = 3;
const byte encoderB         = 2;
const int IRsignal         = 7;
const byte playingOut           = 8;
const byte errorOut         = 12;
const byte encoderButtonPIN = A5;
const byte DFPlayerRX       = A0;
const byte DFPlayerTX       = A1;
const byte ampEnable        = A2;
const byte ampTempError     = A3;
const byte ampOverCurrent   = A4;
const byte muteOut = 5;
// END CONSTANCES AND DEFINES

// GLOBAL VARIABLES
byte          encoderAInt  = digitalPinToInterrupt(encoderA);
byte          encoderBInt  = digitalPinToInterrupt(encoderB);
int           volume       = 10;
bool          firstRun     = true;
bool          isPlaying    = false;
bool isPlayingDelayed=false;
bool          errorPresent = false;
bool sdRemoved;
int lastVolume;
long lastReceive;
bool isMuted = false;
int DFPlayerState;
// END GLOBAL VARIABLES

// INCLUDES
#include <MikeysButton.h>
MikeysButton encoderButton;

#include <MikeysTimer.h>
PulseTimer pulse1sec;

#include <EncoderStepCounter.h>
EncoderStepCounter encoder(encoderA, encoderB, HALF_STEP);

#include <IRremote.hpp>

#include <SoftwareSerial.h>
SoftwareSerial mySoftwareSerial(DFPlayerRX, DFPlayerTX);

#include <DFRobotDFPlayerMini.h>
DFRobotDFPlayerMini myDFPlayer;
// END INCLUDES
// ######################################
// ########### END PRESETUP #############
// ######################################

// ######################################
// ############## SETUP #################
// ######################################
void setup() {
  // SERIAL
  Serial.begin(115200);
  mySoftwareSerial.begin(9600);

  // PIN ASSIGNMENTS
  // Digital Input
  attachInterrupt(encoderAInt, interrupt, CHANGE);
  attachInterrupt(encoderBInt, interrupt, CHANGE);
  pinMode(IRsignal, INPUT);
  pinMode(encoderButtonPIN, INPUT_PULLUP);
  pinMode(ampTempError, INPUT);
  pinMode(ampOverCurrent, INPUT);

  // Analog Input

  // Digital Output
  pinMode(ampEnable, OUTPUT);
  digitalWrite(ampEnable, LOW);
  pinMode(playingOut, OUTPUT);
  digitalWrite(playingOut, LOW);
  pinMode(errorOut, OUTPUT);
  digitalWrite(errorOut, LOW);
  pinMode(muteOut,OUTPUT);
  digitalWrite(muteOut,LOW);
  // END PIN ASSIGNMENTS

  // OBJECT SETUP
  // Encoder Stuff
  encoder.begin();
  encoderButton.attach(encoderButtonPIN);
  encoderButton.invert(true);

  // IR Stuff
  Serial.println("Enabling IRin");
  IrReceiver.begin(IRsignal, ENABLE_LED_FEEDBACK);
  Serial.println("Enabled IRin");

  // DFPLayer Stuff
  DFPlayerInitRun();
  // END OBJECT SETUP

  // LOAD VALUES FROM EEPROM
  // END LOAD VALUES FROM EEPROM

}  // END SETUP
// ######################################
// ########### END SETUP ################
// ######################################

// ######################################
// ############### LOOP  ################
// ######################################
void loop() {
  pulse1sec.set(1000);
  encoderButton.update();

  encoderDecode();

  if (pulse1sec.pulse) {
    DFPlayerState = myDFPlayer.readState();
  }

  remoteControl();
  encoderControl();

  switch (DFPlayerState) {
    case 1: // Playing
      isPlaying = true;
      break;
    case 2: // Stop
      isPlaying = false;
      break;
    default:
      isPlaying = false;
      break;
  }

  static int shutoffDelay;
  if (isPlaying) {
    shutoffDelay = 0;
    isPlayingDelayed = true;
  } else {
    if (pulse1sec.pulse && isPlayingDelayed) shutoffDelay++;
    if (shutoffDelay > 5) {
      isPlayingDelayed = false;
    }
  }

  if (isPlayingDelayed) {
    pinMode(ampEnable, INPUT);
  } else {
    pinMode(ampEnable, OUTPUT);
    digitalWrite(ampEnable, LOW);
  }

  autoStop();
  errorPresent = (!digitalRead(ampTempError) || !digitalRead(ampOverCurrent));
  LEDControl();
  volumeControl();

  if (myDFPlayer.available()) {
    printDetail(myDFPlayer.readType(), myDFPlayer.read());  // Print the detail message from DFPlayer to handle different errors and states.
  }
// ######################################
// ############## END LOOP ##############
// ######################################

// ######################################
// ############# FUNCTIONS ##############
// ######################################
void interrupt() {
  encoder.tick();
}

void encoderDecode() {
  signed char pos = encoder.getPosition();
  if (pos != 0) {
    volume += pos;
    encoder.reset();
#if DEBUG_SKETCH
    Serial.println(volume);
#endif
  }
}

void remoteControl() {
  if (IrReceiver.decode()) {
#if DEBUG_SKETCH
    IrReceiver.printIRResultShort(&Serial);
    Serial.println(IrReceiver.decodedIRData.command, HEX);
#endif
    switch (IrReceiver.decodedIRData.command) {
      case REMOTE_PWR:  // Power Button
        switch (DFPlayerState) {
          case 1:  // Status 1 = playing
            myDFPlayer.pause();
            break;
          case 2:  // Status 2 = paused
            if (firstRun == true) {
              myDFPlayer.randomAll();
              firstRun = false;
            } else {
              myDFPlayer.start();
            }
            break;
        }
        break;

      case REMOTE_CH_UP:  // Ch+
        myDFPlayer.next();
        lastReceive = IrReceiver.decodedIRData.command;
        break;
      case REMOTE_CH_DOWN:  // Ch-
        myDFPlayer.previous();
        lastReceive = IrReceiver.decodedIRData.command;
        break;

      case REMOTE_VOL_UP:  // Vol+
        volume++;
        lastReceive = IrReceiver.decodedIRData.command;
        break;

      case REMOTE_VOL_DOWN:  // Vol-
        volume--;
        lastReceive = IrReceiver.decodedIRData.command;
        break;

      case REMOTE_MUTE:  // Mute
        if (isMuted) {
          volume = lastVolume;
          isMuted = false;
          lastReceive = IrReceiver.decodedIRData.command;
        } else {
          lastVolume = volume;
          volume = 0;
          isMuted = true;
          lastReceive = IrReceiver.decodedIRData.command;
        }
        break;

      case 0x0: // Button Held
        if (IrReceiver.decodedIRData.flags == 0x01) {
          switch (lastReceive) {
            case REMOTE_VOL_UP:
              volume++;
              break;

            case REMOTE_VOL_DOWN:
              volume--;
              break;
          }
        }
        break;
    }
    IrReceiver.decodedIRData.command = 0x000000;
    IrReceiver.decodedIRData.flags = 0x00;
  }
  IrReceiver.resume(); // Continue receiving
  digitalWrite(muteOut, isMuted);
} // END REMOTE CONTROL

void encoderControl() {
  static bool buttonHeld;
  if (encoderButton.heldEdge()) {
    switch (DFPlayerState) {
      case 1:  // Status 1 = playing
        myDFPlayer.pause();
        break;
      case 2:  // Status 2 = paused
        if (firstRun == true) {
          myDFPlayer.randomAll();
          firstRun = false;
        } else {
          myDFPlayer.start();
        }
    }
    DFPlayerState = myDFPlayer.readState();
    buttonHeld = true;
  } else if (encoderButton.fallingEdge() && isPlayingDelayed && !buttonHeld) {
    myDFPlayer.next();
  }

  if (!encoderButton.pressed()) {
    buttonHeld = false;
  }
}

void autoStop() {
  static unsigned int runtimeSecs;
  if (isPlayingDelayed) {
    if (pulse1sec.pulse) {
      runtimeSecs++;
    }
    if (runtimeSecs > (maxRuntime * 60)) {
      myDFPlayer.pause();
    }
  } else {
    runtimeSecs = 0;
  }
}

void LEDControl() {
  if (isPlayingDelayed && !errorPresent) {
    digitalWrite(playingOut, HIGH);
    digitalWrite(errorOut, LOW);
  } else if ((isPlayingDelayed && errorPresent) || sdRemoved) {
    digitalWrite(playingOut, HIGH);
    digitalWrite(errorOut, HIGH);
  } else {
    digitalWrite(playingOut, LOW);
    digitalWrite(errorOut, LOW);
  }
}

void volumeControl() {
  static int volumeLast;
  if (volume > 30) volume = 30;
  if (volume < 0) volume = 0;

  if (volume != volumeLast) {
    myDFPlayer.volume(volume);
    volumeLast = volume;
  }
}

void DFPlayerInitRun() {
  Serial.println();
  Serial.println(F("DFRobot DFPlayer Mini Demo"));
  Serial.println(F("Initializing DFPlayer ... (May take 3~5 seconds)"));

  delay(1000);

  if (!myDFPlayer.begin(mySoftwareSerial)) {  // Use softwareSerial to communicate with mp3.
    Serial.println(F("Unable to begin:"));
    Serial.println(F("1.Please recheck the connection!"));
    Serial.println(F("2.Please insert the SD card!"));
    while (true)
      ;
  }
  Serial.println(F("DFPlayer Mini online."));

  myDFPlayer.setTimeOut(500);  // Set serial communictaion time out 500ms

  //----Set volume----
  myDFPlayer.volume(volume);    // Set volume value (0~30).
  myDFPlayer.volumeUp();    // Volume Up
  myDFPlayer.volumeDown();  // Volume Down

  //----Set different EQ----
  myDFPlayer.EQ(DFPLAYER_EQ_NORMAL);
  //  myDFPlayer.EQ(DFPLAYER_EQ_POP);
  //  myDFPlayer.EQ(DFPLAYER_EQ_ROCK);
  //  myDFPlayer.EQ(DFPLAYER_EQ_JAZZ);
  //  myDFPlayer.EQ(DFPLAYER_EQ_CLASSIC);
  //  myDFPlayer.EQ(DFPLAYER_EQ_BASS);

  //----Set device we use SD as default----
  //  myDFPlayer.outputDevice(DFPLAYER_DEVICE_U_DISK);
  myDFPlayer.outputDevice(DFPLAYER_DEVICE_SD);
  //  myDFPlayer.outputDevice(DFPLAYER_DEVICE_AUX);
  //  myDFPlayer.outputDevice(DFPLAYER_DEVICE_SLEEP);
  //  myDFPlayer.outputDevice(DFPLAYER_DEVICE_FLASH);

  //----Mp3 control----
  //  myDFPlayer.sleep();     //sleep
  //  myDFPlayer.reset();     //Reset the module
  myDFPlayer.enableDAC();  //Enable On-chip DAC
  //myDFPlayer.disableDAC();  //Disable On-chip DAC
  //myDFPlayer.outputSetting(false, 0); //output setting, enable the output and set the gain to 15

  //----Mp3 play----
  // myDFPlayer.next();  // Play next mp3
  // myDFPlayer.previous();  // Play previous mp3
  // myDFPlayer.play(1);  // Play the first mp3
  // myDFPlayer.loop(1);  // Loop the first mp3
  // myDFPlayer.pause();  // pause the mp3
  // myDFPlayer.start();  // start the mp3 from the pause
  // myDFPlayer.playFolder(15, 4);  // play specific mp3 in SD:/15/004.mp3; Folder Name(1~99); File Name(1~255)
  // myDFPlayer.enableLoopAll();  // loop all mp3 files.
  // myDFPlayer.disableLoopAll();  // stop loop all mp3 files.
  // myDFPlayer.playMp3Folder(4);  // play specific mp3 in SD:/MP3/0004.mp3; File Name(0~65535)
  // myDFPlayer.advertise(3);  // advertise specific mp3 in SD:/ADVERT/0003.mp3; File Name(0~65535)
  // myDFPlayer.stopAdvertise();  // stop advertise
  // myDFPlayer.playLargeFolder(2, 999);  // play specific mp3 in SD:/02/004.mp3; Folder Name(1~10); File Name(1~1000)
  // myDFPlayer.loopFolder(5);  // loop all mp3 files in folder SD:/05.
  // myDFPlayer.randomAll();  // Random play all the mp3.
  // myDFPlayer.enableLoop();  // enable loop.
  // myDFPlayer.disableLoop();  // disable loop.

  //----Read imformation----
  Serial.println(myDFPlayer.readState());                // read mp3 state
  Serial.println(myDFPlayer.readVolume());               // read current volume
  Serial.println(myDFPlayer.readEQ());                   // read EQ setting
  Serial.println(myDFPlayer.readFileCounts());           // read all file counts in SD card
  Serial.println(myDFPlayer.readCurrentFileNumber());    // read current play file number
  Serial.println(myDFPlayer.readFileCountsInFolder(3));  // read file counts in folder SD:/03
} // END DFPLAYER INIT RUN

void printDetail(uint8_t type, int value) {
  switch (type) {
    case TimeOut:
      Serial.println(F("Time Out!"));
      break;
    case WrongStack:
      Serial.println(F("Stack Wrong!"));
      break;
    case DFPlayerCardInserted:
      Serial.println(F("Card Inserted!"));
      break;
    case DFPlayerCardRemoved:
      Serial.println(F("Card Removed!"));
      isPlaying = false;
      sdRemoved = true;
      firstRun = true;
      break;
    case DFPlayerCardOnline:
      Serial.println(F("Card Online!"));
      sdRemoved = false;
      myDFPlayer.volume(volume);
      break;
    case DFPlayerUSBInserted:
      Serial.println("USB Inserted!");
      break;
    case DFPlayerUSBRemoved:
      Serial.println("USB Removed!");
      break;
    case DFPlayerPlayFinished:
      Serial.print(F("Number:"));
      Serial.print(value);
      Serial.println(F(" Play Finished!"));
      break;
    case DFPlayerError:
      Serial.print(F("DFPlayerError:"));
      switch (value) {
        case Busy:
          Serial.println(F("Card not found"));
          break;
        case Sleeping:
          Serial.println(F("Sleeping"));
          break;
        case SerialWrongStack:
          Serial.println(F("Get Wrong Stack"));
          break;
        case CheckSumNotMatch:
          Serial.println(F("Check Sum Not Match"));
          break;
        case FileIndexOut:
          Serial.println(F("File Index Out of Bound"));
          break;
        case FileMismatch:
          Serial.println(F("Cannot Find File"));
          break;
        case Advertise:
          Serial.println(F("In Advertise"));
          break;
        default:
          break;
      }
      break;
    default:
      break;
  }
}
// ######################################
// ########### END FUNCTIONS ############
// ######################################

Sketch LED:

const byte maxPWM = 255;
const float transitionSpeed = 0.5;
const float valueGap = 750;

const byte playIn = 2;
const byte errorIn = 4;
const byte muteIn = 7;
const byte blue1 = 3;
const byte blue2 = 5;
const byte blue3 = 6;
const byte blue4 = 9;
const byte blue5 = 10;
const byte blue6 = 11;
const byte blue7 = A1;
const byte blue8 = A2;
const byte blue9 = A3;
const byte red = A4;
float value = 0.0;

#include <SoftPWM.h>

#include <MikeysTimer.h>
PulseTimer redBlink;

void setup() {
  Serial.begin(115200);

  pinMode(playIn, INPUT);
  pinMode(errorIn, INPUT);
  pinMode(muteIn, INPUT);
  pinMode(blue1, OUTPUT);
  pinMode(blue2, OUTPUT);
  pinMode(blue3, OUTPUT);
  pinMode(blue4, OUTPUT);
  pinMode(blue5, OUTPUT);
  pinMode(blue6, OUTPUT);
  pinMode(blue7, OUTPUT);
  pinMode(blue8, OUTPUT);
  pinMode(blue9, OUTPUT);
  pinMode(red, OUTPUT);
  digitalWrite(blue1, LOW);
  digitalWrite(blue2, LOW);
  digitalWrite(blue3, LOW);
  digitalWrite(blue4, LOW);
  digitalWrite(blue5, LOW);
  digitalWrite(blue6, LOW);
  digitalWrite(blue7, LOW);
  digitalWrite(blue8, LOW);
  digitalWrite(blue9, LOW);
  digitalWrite(red, LOW);

  SoftPWMBegin();
  SoftPWMSet(blue1, 0);
  SoftPWMSet(blue2, 0);
  SoftPWMSet(blue3, 0);
  SoftPWMSet(blue4, 0);
  SoftPWMSet(blue5, 0);
  SoftPWMSet(blue6, 0);
  SoftPWMSet(blue7, 0);
  SoftPWMSet(blue8, 0);
  SoftPWMSet(blue9, 0);
  SoftPWMSet(red, 0);
  SoftPWMSetFadeTime(red, 500, 500);
}

void loop() {
  redBlink.set(500);

  if (digitalRead(playIn) == true && digitalRead(muteIn) == false)  {
    value = value + transitionSpeed;
  } else if (digitalRead(playIn) == 0 && digitalRead(muteIn) == true) {
    ;;
  }

  if (digitalRead(playIn) == true) {
    writePWM(value, 0, blue1);
    writePWM(value, 1, blue2);
    writePWM(value, 2, blue3);
    writePWM(value, 3, blue4);
    writePWM(value, 4, blue5);
    writePWM(value, 5, blue6);
    writePWM(value, 6, blue7);
    writePWM(value, 7, blue8);
    writePWM(value, 8, blue9);
  } else {
    SoftPWMSet(blue1, 0);
    SoftPWMSet(blue2, 0);
    SoftPWMSet(blue3, 0);
    SoftPWMSet(blue4, 0);
    SoftPWMSet(blue5, 0);
    SoftPWMSet(blue6, 0);
    SoftPWMSet(blue7, 0);
    SoftPWMSet(blue8, 0);
    SoftPWMSet(blue9, 0);
  }
  if (value > valueGap * 10)value = 0;

static bool redIsOn;
  if (digitalRead(errorIn) == true) {
    if (redBlink.pulse && !redIsOn) {
      SoftPWMSet(red, 255);
      redIsOn = true;
    } else if (redBlink.pulse && redIsOn) {
      SoftPWMSet(red, 0);
      redIsOn = false;
    }
  } else {
    SoftPWMSet(red, 0);
  }
}

void writePWM(float value, int offset, int pin) {
  if ((value >= valueGap * (offset + 1)) && (value < valueGap * (offset + 2))) {
    SoftPWMSet(pin, map(value, valueGap * (1 + offset), valueGap * (2 + offset), maxPWM, 0));
  } else if ((value >= valueGap * (offset)) && (value < valueGap * (offset + 1))) {
    SoftPWMSet(pin, map(value, valueGap * offset, valueGap * (1 + offset), 0, maxPWM));
  } else {
    SoftPWMSet(pin, 0);
  }
}

"Kleines" Update:

  • ein anderes Gehäuse
  • Kaltgerätekabel als Anschluss
  • Zwei dedizierte Spannungsversorgungen für Arduino und DFPlayer (MW EPS-15-5 und EPS-15-3,3)
  • Endstufe wird jetzt mittels Relais eingeschaltet (erzeugte zuviel Abwärme im Leerlauf)
  • Der "Sleeptimer" lässt sich jetzt per Fernbedienung aktivieren

Bei den Netzteilen habe ich allerdings ein kleines Problem, die surren/pfeifen. Vor allem das 5V Teil. Ich habe mal versucht das Geräusch aufzuzeichnen. Das "Rauschen" im Hintergrund ist ein Lüfter. Ich weiß, es klingt nicht sehr deutlich und ist ziemlich leise, aber ich hoffe ihr könnt es trotzdem einigermaßen hören.

Ich könnte die Frequenz und die Lautstärke des Geräuschs etwas minimieren indem ich die Ausgangsspannung so weit wie möglich runtergeschraubt habe. Probeweise habe ich am Ausgang eine Diode eingebaut (hilfts net, schads net, dacht ich mir :wink: ) auch das hat das Geräusch etwas minimiert. Habt ihr Tipps wie ich das noch weiter reduzieren bzw. ganz weg bekommen kann?

Ich danke euch schon mal :wink:




Ich höre da gar nichts.

Für mich sieht es aus, als ob du zwischen dem DFplayer und dem Verstärker kein abgeschirmtes Kabel verwendes.
Und sorry, aber deine Verdrahtung läuf kreuz und quer, da muss es Störungen im Audioteil geben. das solltest du besser aufräumen.

Dieses Thema war für Projektvorstellungen gedacht. Wenn Du Fragen hast, dann öffne bitte Dein eigenes Thema. Danke!

Da würde ich mal aufpassen, dass "Sprengersteuerung" nicht die NSA alarmiert :wink:

Auch die Leute aus Pullach könnten interessiert sein :wink:

Gruß Tommy

Die werden dann bestimmt im Rahmen der internationalen Amtshilfe informiert...
(Wahrscheinlich kommt es im Ergebnis auch noch darauf an, ob die Erkennung über eine natürliche oder eine künstliche Intelligenz erfolgt ...)

Aber erst später :wink:

Gruß Tommy

Freunde, geht es hier nicht um: Zeigt her eure geilen Projekte !
Zerredet das doch nicht.

2 Likes

Hier Darstellungen von ein paar meiner Projekte:

ESP32 überwacht die Telefonie-Led des DSL-Modems/Routers, da dieser im Schnitt alle vier bis sechs Wochen nach der nächtlichen Zwangstrennung zwar das Internet, aber nicht die Telefonie wieder aktivierte:

Telefonwächter-1

Teilgehäuse aus Sperrholz, "Frontplattenbeschriftung" gedruckt, laminiert und aufgeklebt
Der ESP

  • wählt sich ins WLAN
  • holt per NTP Zeit/Datum
  • prüft per LDR die Telefonie-LED am Modem ("heavily debounced", da die Led beim Telefonieren langsam vor sich hin blinkt
  • sendet einmal pro Tag eine Statusmeldung per Email
  • sendet bei Ausfall der Telefonie sofort und dann jeweils zur vollen Stunde eine Störmeldung (an mich, könnte aber auch an den Provider gehen :wink: )

Das Problem scheint inzwischen durch einen Modem-Tausch verflogen zu sein ... Mal sehen.

Deshalb habe ich das bereits entworfene und gedruckte Gehäuse noch nicht "aktiviert".
Oberteil:

Gehäuse-Oberteil

Unterteil mit Einschub für gedruckte/laminierte Frontbeschriftung und Aufnahmen zum Befestigen einer Platine mit ESP32-"Fassung"

Gehäuse-Unterteil

Hier ein Foto (schwarze Gehäuse geben leider nicht so viel her):

Gehäuse-Komplett-Druck

Dann noch ein Testaufbau für ein HB10401 Display:

HB10401-1

Geeignete Steckverbinder für das Rastermaß 1.27 decken eine Pinreihe ab; das Anlöten der Kabel ist ... nicht ganz einfach :wink: