Der PE4302 Attentuator / Dämpfungsglied ist vom PC steuerbar über einen Arduino

Das Dämpfungsglied mit dem PE4302 Chip soll seriell einstellbar sein und vom PC aus angesprochen werden können.

Dazu nehme ich die Schaltung vom vorherigen Beitrag und erweitere die Arduino Software für die serielle Steuerung.

Diese seriellen Kommandos können im Seriellen Monitor des Arduino Programms eingegeben werden und werden dann zum Arduino geschickt, der entsprechende Aktionen auslöst.

Die Kommandos sind:
s : set attentuator. Examples: s1.5 | s0 | s 22.5 | s 31 | s 0.0
g : get actual attentuator value
d : device class
w : who
v : version
1 : min. frequency
2 : max. frequency
3 : min. attentuation
4 : max. attentuation
5 : attentuator step width

Diese Auflistung ist auch über das h (help) Kommando aufrufbar. Dann wird die Liste der Kommandos ausgegeben.

Hier die Arduino Software:

// PE4302 Digital Step Attentuator
// 1MHz bis 4GHz Dämpfungsglied 0-31,5dB
// 
// seriell vom PC aus einstellbar
//
// Matthias Busse 10.2017 Version 2.0

int DATA=5;
int CLOCK=6;
int LE=7;
float att=0.0; // Dämpfung und Startwert

void setup() {
  Serial.begin(38400);
  pinMode(DATA, OUTPUT);
  pinMode(CLOCK, OUTPUT);
  pinMode(LE, OUTPUT); 
  setAttenuator(att);
}

void loop() {
  int ser, len;
  char buf[10];
  float attinput;
  
  if (Serial.available() > 0) {
    ser = Serial.read();
    if(ser == 'h') {  
      Serial.println("Help");
      Serial.println(" s: set attentuator. Examples: s1.5 | s0 | s 22.5 | s 31 | s 0.0 ");
      Serial.println(" g: get actual attentuator value");
      Serial.println(" d: device class");
      Serial.println(" w: who");
      Serial.println(" v: version");
      Serial.println(" 1: min. frequency");
      Serial.println(" 2: max. frequency");
      Serial.println(" 3: min. attentuation");
      Serial.println(" 4: max. attentuation");
      Serial.println(" 5: attentuator step width");
    }  
    if(ser == 'd') Serial.println("Attentuator"); // device ?
    if(ser == 'w') Serial.println("PE4302"); // who ?
    if(ser == 'v') Serial.println("1.0"); // version ?
    if(ser == '1') Serial.println("1000000"); // 1MHz fmin
    if(ser == '2') Serial.println("4000000000"); // 4GHz fmax
    if(ser == '3') Serial.println("0.0"); // 0  dB att. min
    if(ser == '4') Serial.println("31.5"); // 31.5dB att. max
    if(ser == '5') Serial.println("0.5"); // att. step
    if(ser == 'g') Serial.println(att); // get attentuation
    if(ser == 's') { // set attentuation s1.5 | s0 | s 22.5 | s 31 | s 0.0
      Serial.setTimeout(15);
      len = Serial.readBytes(buf,10);
      if((len>2) && (len<8)) { // s und was dahinter ?
        attinput = atof (buf);
        attinput = (round(attinput * 2.0)) /2.0; // auf .0 und .5 runden
        if((attinput >= 0.0) && (attinput <= 31.51)) {
          att=attinput;
          setAttenuator(att);
        }
      }
    }
    Serial.setTimeout(500);  
  }
}

void setAttenuator(float attent){
// MSB (C16) ... LSB (C0.5) werden an den PA4302 seriell übergeben 
// max. 25kHz oder alle 0,05 ms aufrufen.
//
// Matthias Busse 10.2017 Version 1.0
  
  int i; // das Datenbit
  int attent2 = (int) attent*2.0;
  
  if ((attent2 < 0) || (attent2 > 63)) // Wert im Bereich ?
    return;
  digitalWrite(LE, LOW); // Daten in das Latch eingeben
  digitalWrite(CLOCK,LOW);
  for (int b = 6; b > 0; b--) { // die 6 Bits
    i=((attent2 << 1) >> b) & 0x01;
    digitalWrite(DATA, i); // ein Bit schreiben
    digitalWrite(CLOCK, HIGH); // und Bit übernehmen
    digitalWrite(CLOCK, LOW); 
  }
  digitalWrite(LE, HIGH); // Serielle Daten an den Chip übergeben
  digitalWrite(LE, LOW);  // Auf neue Daten warten.
}

Verwendet wurden:
Arduino Uno
Arduino Software 1.8.0
Drei Spannungsteiler 5V > 3V aus 2,2k und 3,3kOhm
PE4302 Platine fertig aufgebaut
Aufbau wie in diesem Beitrag.

von Matthias Busse

2 Gedanken zu „Der PE4302 Attentuator / Dämpfungsglied ist vom PC steuerbar über einen Arduino

  1. Pingback: PE4302 Attentuator einstellen vom PC & Rotary Encoder, Ausgabe auf LCD Display | Shelvin – Elektronik ausprobiert und erläutert

  2. Manuel

    Hallo,

    vielen Dank für dieses Beispiel.
    Beim Testen ist uns aufgefallen, dass es einen kleinen Bug im Code gibt. In Zeile 73 wird der int-Cast zuerst ausgeführt und danach wird multipliziert. Dadurch wird eine 0.5 immer verschluckt.
    Korrekt wäre also:
    int attent2 = (int) (attent*2.0);

    Viele Grüße
    Manuel

    Antworten

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Diese Website verwendet Akismet, um Spam zu reduzieren. Erfahre mehr darüber, wie deine Kommentardaten verarbeitet werden.