Ich möchte einen bestehenden Pulsgenerator mit einem Arduino Uno nachbauen und optimieren

Hallo alle zusammen,

ich bevor ich loslege ein paar kurze Informationen zur mir: Ich habe nicht viel Erfahrung mit Arduino und Elektronik. Habe letzte Woche mal einen RBG-Controller gebaut um einfach mal einen Zugang zu diesem Thema zu erhalten. Mein aktuelles Problem ist aber eigentlich Teil eines größeren Projekts. Momentan verwendet ich einen Pulsgenerator welcher von meinem Vorgänger entwickelt wurde, ich habe aber den Code und den Schaltplan des Controllers.
Wie schon gesagt ist mein Wissen auf diesem Themengebiet leider begrenzt, weshalb ich hoffe, hier Hilfe finden zu können.

Nun zum Controller: Dieser erzeugt Pulse in einer Frequenz zwischen 10 Hz und 1000 Hz, wobei ich diese Werte im Code beliebig ändern kann, aktuell ist dieser Bereich jedoch ausreichend. Ich kann dabei Frequenzen in 10er Schritten mithilfe eines Potentiometers am Controller einstellen. Die Pulsbreite ist variabel zwischen 2 µs und 5µs und kann ebenfalls über einen Potentiometer eingestellt werden. Die Intensität der Pulse wird über ein Labornetzteil eingestellt, hier benötige ich jedoch maximal 12V, sehr selten 14-15V.
Mit diesen Pulsen wird ein Tropfengenerator ausgelöst woraufhin in der eingestellten Frequenz Tropfen ausgestoßen werden.
Mein Problem liegt nun darin, dass ich gerne Fotos der Tropfen machen würde. Dabei ist es egal, ob ich nur jeden x-ten Tropfen fotografieren kann, wichtig ist nur der gleichbleibende Abstand zwischen Tropfentrigger und Kameratrigger. Momentan verwende ich den gleichen Puls zum Triggern der Tropfen und der Kamera, was auch funktioniert (delays, Belichtungszeit usw. alles kein Problem, das stelle ich in der Kamerasoftware ein), jedoch ist die Kamera auf maximal 30 FPS / Hz limitiert. Ich kann also keine Tropfen bei einer höheren Frequenz aufnehmen um zu überprüfen, ob sich die Tropfengröße bei steigender ausstoßfrequenz verändert.

Was ich nun gerne machen würde ist, über einen der freien Pins des Arduinos das gleiche Signal fix auf zb. 20 oder 30 Hz, eigentlich egal, dazu zu verwenden, die Kamera zu triggern. Wichtig ist nur, dass der Abstand zwischen beiden Pulsen immer der gleiche ist. Dazu müsste der Kamerapuls immer ein vielfaches des Tropfenpulses sein, richtig?
Leider verstehe ich vom Arduinocode noch nicht genug um zu wissen, was genau ich an neuen Zeilen einfügen muss damit das funktioniert. Außerdem weiß ich auch nicht, ob ich auf meinem Mainboard noch einen weiteren IC für den Kamerapuls brauche, oder ob der Kamerapuls so wie ich ihn brauche direkt vom Arduino ausgegeben werden kann.

Ich habe meinen Code mit den beiden Frequenzen 10 Hz und 20 Hz eingefügt, eigentlich geht das noch weiter bis 1000 Hz und später auch in größeren Schritten, aber ich glaube so ist ja alles wichtige enthalten.

#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

int pulsbreite = A1;

#define OLED_RESET 4 // not used / nicht genutzt bei diesem Display
Adafruit_SSD1306 display(OLED_RESET);

int Signal = 7;                  // Signal zur Tropfenerzeugung
int schalter = 2;
int f1 = A0;
int schalterzustand = 0;


long int frequenz = 0;
int pb1 = 0;
int verzoegerung = 0;             // Potiwert der Verzögerung
int j = 0;
int i = 0;                        // allgemeine Zählervariable für Schleifen
int pb = 0;
int f = 0;                        // Potiwert der Frequenz

int zaehler = 0;

void setup()   {
  Serial.begin(9600);
  pinMode(Signal, OUTPUT);         // Pin "Signal" wird als Ausgang definiert
  pinMode(schalter, INPUT);        // Pin "Schalter" wird als Eingang definiert
  pinMode(pulsbreite, INPUT);      // Pin "pulsbreite" wird als Eingang definiert
  pinMode(f1, INPUT);        // pin "frequenz" wird als Eingang definiert

  // initialize with the I2C addr 0x3C / mit I2C-Adresse 0x3c initialisieren
  display.begin(SSD1306_SWITCHCAPVCC, 0x3C);

  // random start seed / zufälligen Startwert für Random-Funtionen initialisieren
  randomSeed(analogRead(0));
}

void loop() {
  schalterzustand = digitalRead(schalter);                      // Auslesen des Pins "Schalter" und Schaltzustand in Variable "Schaltzustand" speichern

  if (schalterzustand == LOW)                                   // Wenn Variable "Schaltzustand" = LOW führe ... aus / Tropfenerzeugung mit fester Frequenz
  {

    Serial.println("StartXXXXXXXXXXXXXXXXXXXX");

    pb = analogRead(pulsbreite);
    pb = pb / 50;
    pb1 = pb + 2;
    pb1 = pb1 * 500;

    frequenz = analogRead(f1);

    frequenz = frequenz / 10;
    //  frequenz = 77; // Testwert
    f = frequenz;
    if (frequenz <= 10)
    {
      f = f * 10;
    }
    if (frequenz > 10 && frequenz <= 46)
    {
      f = 100 + ((f - 10) * 25);
      Serial.println(f);
    }
    if (frequenz > 46 && frequenz <= 66)
    {
      f = 1000 + ((f - 46) * 50);
      Serial.println(f);
    }
    if (frequenz > 66 && frequenz <= 76)
    {
      f = 2000 + ((f - 66) * 100);
      Serial.println(f);
    }
    if (frequenz > 76 && frequenz <= 84)
    {
      f = 3000 + ((f - 76) * 250);
      Serial.println(f);
    }
    if (frequenz > 84 && frequenz <= 94)
    {
      f = 5000 + ((f - 84) * 500);
      Serial.println(f);
    }
    if (frequenz > 94)
    {
      f = 10000 + ((f - 94) * 1000);
      Serial.println(f);
    }
    frequenz = f;
    display.clearDisplay();
    // set text color / Textfarbe setzen
    display.setTextColor(WHITE);
    // set text size / Textgroesse setzen
    display.setTextSize(1);
    // set text cursor position / Textstartposition einstellen
    display.setCursor(1, 0);
    // show text / Text anzeigen
    display.println("Frequenz:");
    display.print(frequenz);
    display.println(" Hz");
    display.setCursor(1, 17);
    display.println("Pulsbreite:");
    display.print(pb1);
    display.print(" Nanosekunden");

    display.display();
    // delay(8000);
    display.clearDisplay();
    switch (frequenz) //Abfrage welcher proschritt
    {


      // Frequenzen 10 bis 100 in Zehnerschritten


      case 10:
        noInterrupts();
        PORTD |= _BV(Signal);
        for (i = 0; i < pb; i++)                          // Schleife die durchlaufen wird bis die Bedingung i<pb nicht mehr erfüllt ist. Ein Durchgang = 500 ns und i steigt um 1 (i++ == i+1)
        {
          __asm__("nop\n\t");                              // 1 Taktzyklus nichts machen
        }
        PORTD &= ~_BV(Signal);
        _delay_ms(99.997);
        interrupts();
        break;

      case 20:
        noInterrupts();
        PORTD |= _BV(Signal);
        for (i = 0; i < pb; i++)                          // Schleife die durchlaufen wird bis die Bedingung i<pb nicht mehr erfüllt ist. Ein Durchgang = 500 ns und i steigt um 1 (i++ == i+1)
        {
          __asm__("nop\n\t");                              // 1 Taktzyklus nichts machen
        }
        PORTD &= ~_BV(Signal);
        _delay_ms(49.997);
        interrupts();
        break;


    }
}

Hier ist der Schaltplan, leider kann ich nur ein Bild einfügen. Falls benötigt kann ich in einem Kommentar die beiden anderen Module hinzufügen.

Ich wäre dankbar für jede Hilfe! Liebe Grüße

Die Kamera soll also synchron zu den Impulsen laufen, aber mit einem minimalen Abstand zwischen den Aufnahmen. Das ist machbar.

Dein Schaltplan ist wenig hilfreich, aber wenn er funktioniert, dann weißt Du hoffentlich, wo der Arduino den Impuls für die Tropfen und für die Kamera draufgeben soll.

Ja die Kamera soll synchron zu den Pulsen laufen, aber in niedrigerer, fester Frequenz (max. 30 Hz). Ob oder wie groß der Abstand zwischen Tropfenpuls und Kamerapuls ist ist egal, verzögern kann ich das Auslösen der Kamera beliebig in der Software.

Was meinst du mit deinem zweiten Abschnitt? Ich weiß zumindest wo ich die Kabel anschließen muss um meine Tropfen zu erzeugen. Falls ich dann einen weiteren Puls erzeugen kann welcher die Kamera triggert muss ich noch Kabel dafür anlöten.