[Snapper]

ist ein normaler NE555P allerdings ohne die beiden 82ohm Widerstände in der Gate
Leitung wie bei deiner Schaltung !? HV habe ich auf 180V eingestellt und als HV
Gleichrichter eine BYT52J verwendet weil ich die gerade noch liegen hatte. Bozo
verwendet einen LM555C, macht das den Unterschied ? 

[kahlo]

Noch was: Die Betriebsspannung von 12V ist harte Arbeit für den Stepup-Wandler. Du könntest es der Schaltung leichter machen, wenn du die Eingangsspannung erhöhst. Schon ein paar Volt können Wunder wirken. Das sollte auch ohne Schaltungsänderung möglich sein.

Vorschlag: Irgendein altes Laptopnetzteil. Ich habe eins mit 16V benutzt, bis 20V sollten keine Probleme auftauchen.
--
Die Diode ist ok.
Keine Widerstände in der Gateleitung ist auch ok, der 555 schafft das.

[Snapper]

Bozo verwendet die gleiche HV Schaltung auch in seinen Nixie Uhren (wohlgemerkt auch mit 12V) die er z.T. auch verkauft.
ich kann mir nicht vorstellen das seine Schaltung die gleichen Probleme macht !? noch irgend eine Idee was bei mir schieflaufen könnte ?

http://www.elektroncso.hu/cikkek.php


  nixi3011_kapcs.pdf (Größe: 275,51 KB / Downloads: 257)


  nix_cpu.pdf (Größe: 255,07 KB / Downloads: 246)

[kahlo]

Man glaubt kaum, was auch gekaufte Sachen an Problemen machen .
Wenn du der Schaltung sonst vertraust: Vielleicht ein Mosfetwechsel? IRF840, IRF 740, IRF730. Sie alle haben einen deutlich geringeren RDSon als der 2SK1808.

Es besteht noch die Möglichkeit, dass der Schaltvorgang zu langsam ist, da entstehen weitere Verluste. Das kann ich aber nicht "einfach so" beurteilen.

[kahlo]

So, ich hab die 555-Schaltung durch den Simulator gejagt. Sie ist gut. Das Problem ist tatsächlich der RDSon des Mosfet. Die 3 Ohm des 2SK1808 limitieren die Effizienz der ganzen Schaltung. Man bekommt geradeso 15mA bei 180V heraus, wobei der Mosfet ordentlich warm wird (1W Verlustleistung).

Mit dem IRF740 werden die 180V spielend und mit Reserven erreicht, wobei er nur unter gleicher Last 100mW verbrennt. Also: Anderen Mosfet einsetzen.

[Snapper]

habe gestern in meinem Bestand noch div. IRF840 gefunden, 0,85Ω sind immer noch besser als 3Ω  
dann frage ich mich nur warum Du in Deinem Projekt damals den 2SK1808 verwendet hast, den habe
ich nämlich daraus übernommen !?

Danke für Deine Unterstützung, werde ich nachher mal ausprobieren  

[kahlo]

Das Projekt ist von 2005. Da war ich 18 Jahre jünger, bedeutend hübscher und unerfahrener. Und ich hatte den Mosfet in der Kramkiste.

[voltwide]

(06.05.2023, 11:31 AM)kahlo schrieb: Das Projekt ist von 2005. Da war ich 18 Jahre jünger, bedeutend hübscher und unerfahrener. Und ich hatte den Mosfet in der Kramkiste.

2005 war ich nicht ganz so hübsch und jung wie Du, aber auch nicht ganz so unerfahren in Elektronik

[kahlo]

(06.05.2023, 04:31 PM)voltwide schrieb: 2005 war ich nicht ganz so hübsch und jung wie Du, aber auch nicht ganz so unerfahren in Elektronik

Das ist hübsch gesagt! 2005 kannte ich dieses Forum noch nicht, hatte also die harte Schule durch die geehrten Mitglieder dieses Clubs noch vor mir     . Und auch Induktivitäten waren nicht unbedingt meine Lieblingsbauteile.

[leoloel]

Hello, I am from Ukraine and it is difficult to find PBG-12201 manufacturer VISHAY/DALE.
but we have indicators IN-33 and IN-36. Produced by the USSR plant "Gazotron" in Ukraine.

Will this display work instead of PBG-12201?
       
Thank you

[Snapper]

(05.11.2023, 01:19 PM)leoloel schrieb: Hello, I am from Ukraine and it is difficult to find PBG-12201 manufacturer VISHAY/DALE.
but we have indicators IN-33 and IN-36. Produced by the USSR plant "Gazotron" in Ukraine.
Will this display work instead of PBG-12201? Thank you

https://www.dj9kw.de/dj9kw/projekte/audi...rgraph.htm

[leoloel]

(05.11.2023, 01:56 PM)Snapper schrieb:

(05.11.2023, 01:19 PM)leoloel schrieb: Hello, I am from Ukraine and it is difficult to find PBG-12201 manufacturer VISHAY/DALE.
but we have indicators IN-33 and IN-36. Produced by the USSR plant "Gazotron" in Ukraine.
Will this display work instead of PBG-12201? Thank you

https://www.dj9kw.de/dj9kw/projekte/audi...rgraph.htm

Thank you. but there will be such a question, the circuit uses PIC16F876 but I don’t have one
but there is another PIC16F826A and also PIC16F690
is this useless?

[kahlo]

The IN-33 and IN-36 should work. But you need a datasheet to identify the pins and other basic parameter of the display (see this posting).

[kahlo]

Das Posting von leoloel und auch ein paar PN's haben mir gezeigt, dass die Displaysteuerung mit den Informationen aus diesem Thread nicht "einfach so" nachbaubar ist. Es fehlt irgendwie eine Zusammenfassung aller wichtigen Sachen. Ob das im Posting 155+ des Threads überhaupt was bringt? Aber wohin sonst?  

[christianw.]

Naja, sieh es als intellektuelles Erbe.

Ich freue mich jedenfalls immer über solche "Basteleien".

[kahlo]

(05.05.2023, 12:10 PM)Snapper schrieb: ist ein normaler NE555P allerdings ohne die beiden 82ohm Widerstände in der Gate
Leitung wie bei deiner Schaltung !? HV habe ich auf 180V eingestellt und als HV
Gleichrichter eine BYT52J verwendet weil ich die gerade noch liegen hatte. Bozo
verwendet einen LM555C, macht das den Unterschied ? 

Damals überlesen, aber vielleicht die Ursache für deine Probleme: Das Display braucht nicht 180V, sondern 245V +/-5V.

[kahlo]

So, diese Schaltung sollte allgemein nachbaubar sein.

• Geeignet zur Ansteuerung jeder Plasma-Balkenanzeige (Russisch, amerikanisch, englisch, was auch immer) mit 3 oder 5 Phasen.
  
• 3-phasiger Aufbau. Für 5 Phasen sind die Pins 5 und 6 (3 und 4   ) am Prozessor freigehalten. Dort kann einfach die Schaltung wie für die Phasen 1 bis 3 dupliziert werden.
  
• Geeignet ist jeder Arduino oder jedes kompatible Bord. Theoretisch auch jeder µC mit genug Beinen, der mit der Arduino-IDE programmiert werden kann. Falls ein Arduino mit 3,3V Betriebsspannung verwendet werden soll, muss die Spannungsversorgung angepasst werden und die beiden Analogeingänge auf 3,3V geklammert werden (siehe den Hinweis für die LED's).
  
• Der Step-Up-Wandler wurde von Bozo übernommen (billig, gut, einfach nachzubauen).
  
• Die LED's sind so zu selektieren, dass die Spannung nicht nennenswert über 5V steigen kann. Sie dienen als Inputbegrenzer an den Analogpins des Arduino.
  
• D4, D8 und U3 dürfen NICHT gegen "irgendwas anderes" getauscht werden.
  

   

Der Vollständigkeit halber noch einmal der Code (Arduino):

Code:

// Bargraph @ Teensy 2.0
// Version 0.1beta
#include <FlexiTimer2.h>
#include <math.h>

const byte Frequency = 67;   // Zielfrequenz des Displays in Hz
const byte Segments = 201;   // Anzahl der Segmente des Displays
const byte Phases = 3;       // Anzahl der Phasen des Displays (maximal 5)
const byte ResetPin = 5;     // Resetanschluss
const byte InputPin_1 = 21;  // Eingangspins
const byte InputPin_2 = 20;  // Eingangspins
const byte InputPin_3 = 19;  // Eingangspins
const byte InputPin_4 = 18;  // Eingangspins
const byte LinLogPin = 23;   // Lin-Log-Umschalt-Pin
const byte AnodePin_1 = 6;   // Anodenpins
const byte AnodePin_2 = 7;   // Anodenpins
const byte AnodePin_3 = 8;   // Anodenpins
const byte AnodePin_4 = 9;   // Anodenpins
const byte Umax = 5;         // Maximalspannung am Analog-Input
const float Ustep = 0.004888;// Spannung zwischen 2 ADC-Werten

volatile int Actual_Phase;        // Zähler für die Phasensteuerung
volatile int Old_Phase;           // Zähler für die Phasensteuerung
volatile int Actual_Segment = 1;  // Zähler für die Phasensteuerung

int Input_1 = 0;  // Analogspeichervariable
int Input_2 = 0;  // Analogspeichervariable
int Input_3 = 0;  // Analogspeichervariable
int Input_4 = 0;  // Analogspeichervariable
int InputScaler;  // Faktor zur Skalierung der ADC-Werte auf die Segmentzahl (lineare Anzeige)
int Balken_1 = 0; // Variable für die aktuelle Balkenlänge
int Balken_2 = 0; // Variable für die aktuelle Balkenlänge
int Balken_3 = 0; // Variable für die aktuelle Balkenlänge
int Balken_4 = 0; // Variable für die aktuelle Balkenlänge
double dBV;        // dBV log
int LogTab[1024]; // LogTabelle ADC-Werte - Segmente

void flush() {                                      // Interrupt service routine zur Phasensteuerung
 switch (Actual_Segment) {
   case Segments:                                    // Das letzte Segment erreicht?
     digitalWrite(Actual_Phase, LOW);                  // Das letzte Segment abschalten
     digitalWrite(ResetPin, HIGH);                     // Reset des Displays
     Actual_Segment = 1;                               // Rücksetzen der Zähler
     Actual_Phase = Phases;                            // Rücksetzen der Zähler
     digitalWrite(AnodePin_1, LOW);                   // Anoden wieder einschalten
     digitalWrite(AnodePin_2, LOW);                   // Anoden wieder einschalten
     digitalWrite(AnodePin_3, LOW);                   // Anoden wieder einschalten
     digitalWrite(AnodePin_4, LOW);                   // Anoden wieder einschalten
     break;
   default:                                          // Kern der Displaysteuerung
     Actual_Segment++;                                             // Zeiger auf das aktuelle Segment erhöhen
     if (Balken_1 < Actual_Segment) digitalWrite(AnodePin_1, HIGH); // Bei Solllänge des Balkens wird die Anode abgeschaltet
     if (Balken_2 < Actual_Segment) digitalWrite(AnodePin_2, HIGH); // Bei Solllänge des Balkens wird die Anode abgeschaltet
     if (Balken_3 < Actual_Segment) digitalWrite(AnodePin_3, HIGH); // Bei Solllänge des Balkens wird die Anode abgeschaltet
     if (Balken_4 < Actual_Segment) digitalWrite(AnodePin_4, HIGH); // Bei Solllänge des Balkens wird die Anode abgeschaltet
     Old_Phase = Actual_Phase++;                                   // Zeiger auf die aktuelle Phase erhöhen und den alten Wert sichern
     if (Actual_Phase > Phases - 1) Actual_Phase = 0;              // Phase overflow auf Null
     digitalWrite(Actual_Phase, HIGH);                             // Das nächste Segment anschalten
     digitalWrite(Old_Phase, LOW);                                 // Das alte Segment ausschalten
     digitalWrite(ResetPin, LOW);                                  // Reset deaktivieren, falls aktiv
     break;
 }
}

void setup() {
 pinMode(0, OUTPUT); // Die Pins für maximal 5 Phasen werden als Output-Pins definiert
 pinMode(1, OUTPUT);
 pinMode(2, OUTPUT);
 pinMode(3, OUTPUT);
 pinMode(4, OUTPUT);
 pinMode(ResetPin, OUTPUT); // Resetpin wird als Output-Pin definiert
 pinMode(LinLogPin, INPUT_PULLUP); // Pin offen: linear, Pin mit GROUND verbunden: logarithmisch
 pinMode(AnodePin_1, OUTPUT);
 pinMode(AnodePin_2, OUTPUT);
 pinMode(AnodePin_3, OUTPUT);
 pinMode(AnodePin_4, OUTPUT);

 Actual_Phase = Phases;
 InputScaler = 1024/Segments;   // Faktor zur Skalierung der ADC-Werte auf die Segmentzahl (lineare Anzeige)

 // Logtabelle schreiben

 LogTab[0] = 1; // Fade out  unter -45dBV, relativ zum Maximalpegel
 LogTab[1] = 2;
 LogTab[2] = 3;
 LogTab[3] = 3;
 LogTab[4] = 4;
 LogTab[5] = 4;
 for(int x = 6; x < 1024; x++) { // Berechnung der Log-Tabelle
   dBV = 20.0 * log10(x * Ustep / Umax);
   LogTab[x] = 4.4 * dBV + Segments;
 }

 digitalWrite(ResetPin, HIGH);                         // Reset des Displays  
 FlexiTimer2::set(1, 1.0/(Frequency*Segments), flush); // Definition des Timerinterrupts
 FlexiTimer2::start();                                 // Aktivierung des Interrupts
}

void loop() {   // Hauptprogramm
 Input_1 = analogRead(InputPin_1); // ADC
 Input_2 = analogRead(InputPin_2);
 Input_3 = analogRead(InputPin_3);
 Input_4 = analogRead(InputPin_4);

 switch (digitalRead(LinLogPin)) {
   case HIGH:  // Default linear, interner Pullup-Widerstand ist aktiviert
     Balken_1 = Input_1/InputScaler; // lineare Skalierung der ADC-Werte auf die Segmentzahl
     Balken_2 = Input_2/InputScaler; // lineare Skalierung der ADC-Werte auf die Segmentzahl
     Balken_3 = Input_3/InputScaler; // lineare Skalierung der ADC-Werte auf die Segmentzahl
     Balken_4 = Input_4/InputScaler; // lineare Skalierung der ADC-Werte auf die Segmentzahl
     break;
   case LOW: // Logarithmisch
     Balken_1 = LogTab[Input_1]; // Lesen der Log-Tabelle
     Balken_2 = LogTab[Input_2];
     Balken_3 = LogTab[Input_3];
     Balken_4 = LogTab[Input_4];
   break;
 }

}

[christianw.]

Sehr gut.

[scalesr1]

(10.11.2023, 04:18 PM)kahlo schrieb: So, this circuit should be generally reproducible.

• Suitable for controlling any plasma bar display (Russian, American, English, whatever) with 3 or 5 phases.
  
• 3-phase configuration. For 5 phases, pins 5 and 6 (3 and 4   ) on the processor are reserved. The circuit can be easily duplicated there as for phases 1 to 3.
  
• Any Arduino or compatible board is suitable. Theoretically, any microcontroller with enough pins that can be programmed with the Arduino IDE will do. If you want to use an Arduino with a 3.3V operating voltage, you'll need to adjust the power supply and clamp the two analog inputs to 3.3V (see the note for the LEDs).
  
• The step-up converter was taken from Bozo (cheap, good, easy to replicate).
  
• The LEDs must be selected so that the voltage cannot significantly exceed 5V. They serve as input limiters on the Arduino's analog pins.
  
• D4, D8 and U3 may NOT be exchanged for "anything else".
  

For the sake of completeness, here is the code again (Arduino):

Code:

// Bargraph @ Teensy 2.0
// Version 0.1beta
#include <FlexiTimer2.h>
#include <math.h>

const byte Frequency = 67; // Target frequency of the display in Hz
const byte Segments = 201; // Number of segments of the display
const byte Phases = 3; // Number of phases of the display (maximum 5)
const byte ResetPin = 5; // Reset connection
const byte InputPin_1 = 21; // Input pins
const byte InputPin_2 = 20; // Input pins
const byte InputPin_3 = 19; // Input pins
const byte InputPin_4 = 18; // Input pins
const byte LinLogPin = 23; // Lin-Log toggle pin
const byte AnodePin_1 = 6; // anode pins
const byte AnodePin_2 = 7; // anode pins
const byte AnodePin_3 = 8; // anode pins
const byte AnodePin_4 = 9; // anode pins
const byte Umax = 5; // Maximum voltage at the analog input
const float Ustep = 0.004888;// Voltage between 2 ADC values

volatile int Actual_Phase; // Counter for the phase control
volatile int Old_Phase; // Counter for phase control
volatile int Actual_Segment = 1; // Counter for phase control

int Input_1 = 0; // Analog memory variable
int Input_2 = 0; // Analog memory variable
int Input_3 = 0; // Analog memory variable
int Input_4 = 0; // Analog memory variable
int InputScaler; // Factor for scaling the ADC values to the number of segments (linear display)
int Balken_1 = 0; // Variable for the current bar length
int Balken_2 = 0; // Variable for the current bar length
int Balken_3 = 0; // Variable for the current bar length
int Balken_4 = 0; // Variable for the current bar length
double dBV; // dBV log
int LogTab[1024]; // LogTable ADC values - segments

void flush() { // Interrupt service routine for phase control
 switch (Actual_Segment) {
   case Segments: // Last segment reached?
     digitalWrite(Actual_Phase, LOW); // Turn off the last segment
     digitalWrite(ResetPin, HIGH); // Reset the display
     Actual_Segment = 1; // Reset the counters
     Actual_Phase = Phases; // Reset the counters
     digitalWrite(AnodePin_1, LOW); // Turn the anodes back on
     digitalWrite(AnodePin_2, LOW); // Turn the anodes back on
     digitalWrite(AnodePin_3, LOW); // Turn the anodes back on
     digitalWrite(AnodePin_4, LOW); // Turn the anodes back on
     break;
   default: // Core of the display control
     Actual_Segment++; // Increment pointer to the current segment
     if (Bar_1 < Actual_Segment) digitalWrite(AnodePin_1, HIGH); // When the bar reaches the desired length, the anode is switched off
     if (Bar_2 < Actual_Segment) digitalWrite(AnodePin_2, HIGH); // When the bar reaches the desired length, the anode is switched off
     if (Bar_3 < Actual_Segment) digitalWrite(AnodePin_3, HIGH); // When the bar reaches the desired length, the anode is switched off
     if (Bar_4 < Actual_Segment) digitalWrite(AnodePin_4, HIGH); // When the bar reaches the desired length, the anode is switched off
     Old_Phase = Actual_Phase++; // Increase pointer to the current phase and save the old value
     if (Actual_Phase > Phases - 1) Actual_Phase = 0; // Phase overflow to zero
     digitalWrite(Actual_Phase, HIGH); // Switch on the next segment
     digitalWrite(Old_Phase, LOW); // Turn off the old segment
     digitalWrite(ResetPin, LOW); // Disable reset if active
     break;
 }
}

void setup() {
 pinMode(0, OUTPUT); // The pins for a maximum of 5 phases are defined as output pins
 pinMode(1, OUTPUT);
 pinMode(2, OUTPUT);
 pinMode(3, OUTPUT);
 pinMode(4, OUTPUT);
 pinMode(ResetPin, OUTPUT); // Reset pin is defined as output pin
 pinMode(LinLogPin, INPUT_PULLUP); // Pin open: linear, pin connected to GROUND: logarithmic
 pinMode(AnodePin_1, OUTPUT);
 pinMode(AnodePin_2, OUTPUT);
 pinMode(AnodePin_3, OUTPUT);
 pinMode(AnodePin_4, OUTPUT);

 Actual_Phase = Phases;
 InputScaler = 1024/Segments; // Factor for scaling the ADC values to the number of segments (linear display)

 // Write log table

 LogTab[0] = 1; // Fade out below -45dBV, relative to the maximum level
 LogTab[1] = 2;
 LogTab[2] = 3;
 LogTab[3] = 3;
 LogTab[4] = 4;
 LogTab[5] = 4;
 for(int x = 6; x < 1024; x++) { // Calculate the log table
   dBV = 20.0 * log10(x * Ustep / Umax);
   LogTab[x] = 4.4 * dBV + Segments;
 }

 digitalWrite(ResetPin, HIGH); // Reset the display  
 FlexiTimer2::set(1, 1.0/(Frequency*Segments), flush); // Definition of the timer interrupt
 FlexiTimer2::start(); // Activation of the interrupt
}

void loop() { // main program
 Input_1 = analogRead(InputPin_1); //ADC
 Input_2 = analogRead(InputPin_2);
 Input_3 = analogRead(InputPin_3);
 Input_4 = analogRead(InputPin_4);

 switch (digitalRead(LinLogPin)) {
   case HIGH: // Default linear, internal pull-up resistor is enabled
     Bar_1 = Input_1/InputScaler; // linear scaling of the ADC values to the number of segments
     Bar_2 = Input_2/InputScaler; // linear scaling of the ADC values to the number of segments
     Bar_3 = Input_3/InputScaler; // linear scaling of the ADC values to the number of segments
     Bar_4 = Input_4/InputScaler; // linear scaling of the ADC values to the number of segments
     break;
   case LOW: // Logarithmic
     Balken_1 = LogTab[Input_1]; // Read the log table
     Bar_2 = LogTab[Input_2];
     Bar_3 = LogTab[Input_3];
     Bar_4 = LogTab[Input_4];
   break;
 }

}

Greetings,

I just built this - I could not get any action with an Arduino Nano but the Teensy worked right away - I think I may have some confusion over my Nano GPIO numbering - regardless. I note that the 33K resistor on the Zener is getting mighty warm - I used a 1206 sized smd part but I am guessing that the current must be greater as multiple 'phases' could be active at any one time - am I even close?
My plan is to use this as a seconds indicator on an clock so I have not used the Audio input part of the design, I also utilised an available HV module for the 245volts.
I tried working out the current requirements using the data sheet for the display (I am using the ones with 5 x phase connections) but failed miserably.
Could you point me in the right direction?
Thank you
Richard

[kahlo]

Hi Richard,

The current through the display is limited by the resistors R7, R8, R17, R18. These resistors need to be able to handle some heat. They should be rated at least with 2W, better 5W. Please have a look to the photo below - the big light green Resistors are 5W-Pieces:



The 33k resistor (R2) needs to be rated 1W. I have here two 0.6W resistors in parallel.