We modernize a solid-state laser without registration and SMS

https://habr.com/ru/post/652519/image

Almost a year ago, I wrote an article about building a homemade solid state laser. In that article, I mentioned that a power supply with a pilot arc is often used to power solid-state laser pump lamps. What it is, how to do it and what advantages the laser will get from this arc will be discussed below.


So, why do you need a standby arc in a laser pumping lamp at all? There are several reasons for this. First, when using an arc, the fraction of ultraviolet in the spectrum of the pump lamp decreases and the output of the lamp increases in the longer wavelength range. And this is very good for garnet and ruby. Secondly, the arc reduces the load on the lamp at the time of the flash. And thirdly, a lamp with an arc is very well suited for the frequency mode of laser operation (up to several tens of flashes per second). Among the shortcomings – a lamp with an arc inside must be cooled. Here it’s just not possible to puff like that without cooling.

To cool the laser, I bought a 24 V pump for aliexpress (my power supply produces 24 V), an expansion tank from the VAZ 2101 and several flexible plumbing hoses (initially I used a garden hose, but it is very flexible and easily crushed). I filled the tank with distilled water from the nearest auto shop. It would be nice to add 0.2% potassium bichromate or chromate to the water to further reduce the proportion of ultraviolet in the lamp spectrum, and so that the water in the laser head does not bloom. However, these compounds are poisonous and carcinogenic, and therefore I have refrained from adding them for the time being.



Cooling pump

The active element is sealed by gluing into the holders with a conventional silicone sealant.

The assembled cooling circuit loves to leak in the most unexpected places. 🙂

There is no radiator in my cooling circuit yet. But in general it is needed. Water during the operation of the laser heats up quite quickly. It is also advised to put a strainer immediately after the pump, so as not to clog the laser head with any dirt, for example, from a suddenly collapsed pump (everything happens, after all).

Now we need to understand what kind of arc is there in the lamps and how it turns out.
If a high-frequency voltage is applied to a xenon lamp, then the discharge in the lamp will look like this:

Very nice, but we need a little more than that. We need a thin arc cord. This means that the arc will require direct current. Such an arc does not look as spectacular as a high-frequency one, but it is also very beautiful (and in a magnetic field it bends and twists in such an interesting way):



DC arc in a laser pump lamp.

Such an arc must first be ignited with an increased voltage, breaking through the discharge gap of the lamp, and then kept at a lower voltage. By pumping the voltage of the capacitor bank into this arc, we will get a lamp flash and, accordingly, a laser pulse. At the same time, it would be very nice if the arc did not go out after the flash ended, otherwise you would have to re-ignite the arc, and this is very inconvenient.
Devices called simmers are used to create and hold an arc. They can be bought, for example, on Avito. But we are not looking for easy ways and save the budget. 🙂 So, the simmer should be made by yourself from what is at hand, and what my current knowledge of electronics allows (and they allow me not to say that much). The arc requires current stabilization. In the circuits of industrial simmers, resonant current stabilizers were used (
here is a possible simmer scheme.), and the currents in the lamps reach 1 A and above. In my simmer, I decided to reduce the arc current with a voltage multiplier. Yes, and light the arc with his own help. And of course, 1 And in the arc I don’t even dream. Actually, in the first version of the simmer, my arc suddenly went out after several tens of laser pulses. I had to increase the voltage and current.



Scheme of the laser power supply with a pilot arc.



Appearance of the power supply unit with a standby arc.



Open power supply

In the multiplier circuit, I used 2Ts114B diodes – they are quite low-current (50 mA DC and less than an ampere pulse duration less than 50 μs, according to the handbook – we just have a pulse mode). This multiplier is supplied with high voltage from the coil pumped by the bridge on the IRFP460. Node on IRFP460 i taken from the induction heater circuit, which I once collected, but did not finish collecting. I already had this node ready. I used it in my design. The frequency of the converter should not exceed the allowable for the multiplier diodes (for 2Ts114B, 10 kHz is acceptable, but the lower the better for the diodes). For ignition, the coil has an additional primary winding with a smaller number of turns, which allows you to get an increased voltage for a short time, sufficient to breakdown the INP3-7 / 80A lamp. Since my winding of the secondary is insufficient (there simply wasn’t enough space on the ferrite magnetic circuit for a large coil), my primary primary contains a small number of turns, which means that the current in the primary will be large. Therefore, in series with the primary supply, I put small chokes (not shown in the diagram below) at 90 μH. After another decrease in the number of turns in the primary holding the arc, it turned out that the need to ignite the arc with a separate button occurs infrequently – the arc itself ignites when turned on. And that’s just great.

It is no longer worth charging the capacitor bank from a separate 24V to 1200V inverter. This is too long (tens of seconds) and will not allow you to play with the laser in frequency mode. Therefore, a multiplier was assembled with mains power controlled by a triac. This multiplier charges a 2000 uF battery in 0.6 seconds to 800 V, which is what I need.

The switching of the battery into an arc is carried out by a block of powerful thyristors with inductive galvanic isolation. In the process of setting up the unit, it was found that at the moment of ignition of the arc, the thyristors break through, and the pulse goes to charge the capacitor battery, but the arc does not ignite – the thyristors are only 2 kV, and the igniting pulse is much larger. I had to put a block of powerful diodes in series with the thyristors, which prevents the ignition pulse from going into the battery. Powerful diodes and thyristors are needed, because discharge currents can exceed kiloamperes. In addition, a 130 µH coil (not shown in the diagram) was added between the diodes and the lamp, designed to delay the flash pulse and facilitate lamp operation. Such a coil is necessarily wound without a core with a thick wire, since at such huge currents the core will immediately fly into saturation and will be useless. I wanted to wind the coil with PV-1 wire with a cross section of 4 mm square, but I was greedy for both money and space for the coil, so I had to wind it with a wire with a cross section of 2.5 mm square. And of course, during operation, the coil heats up noticeably. It would be strange otherwise.

In all this design, there is still not enough control unit that will alternate charge-flash pulses. I use this unit as a voltmeter to measure the voltage on a capacitor bank. True, it is very inertial, so I decided to charge the battery not according to its indications, but according to time.



Voltmeter circuit.

This voltmeter has a galvanic isolation between the measurement circuit and the indication circuit (the isolation is there, just in case, you never know – voltages and energies are very dangerous and it is better to play it safe). The project (namely, a voltmeter – it is not there in the flash and charge control software, I will give it below) is posted here. Just in case, I filled the measuring resistors with epoxy – so there is no way to accidentally touch them during setup, modernization or repair.

To use this voltmeter as a flash controller, you need to change the lpv.c file in the atmega8 firmware (WinAVR compiler). At the same time, a toggle switch to GND is connected to the PC3 port to turn on the laser in the flash mode, the PC5 port is used as a signal to the charge circuit (sends a signal to the triac to turn on the charge), and the PB2 port is used as a signal to turn on the pump lamp flash.

lpv.c file for atmega8

//----------------------------------------------------------------------------------------------------
//подключаемые библиотеки
//----------------------------------------------------------------------------------------------------
#include "based.h"
#include "mt16s2d.h"

//----------------------------------------------------------------------------------------------------
//константы
//----------------------------------------------------------------------------------------------------

//----------------------------------------------------------------------------------------------------
//глобальные переменные
//----------------------------------------------------------------------------------------------------
extern char String[STRING_BUFFER_SIZE];//строка
volatile bool FireEnabled=false;//разрешение на вспышку

//****************************************************************************************************
//макроопределения
//****************************************************************************************************

//****************************************************************************************************
//порты обмена данными в режиме ведущего
//****************************************************************************************************

#define MISO_DDR      DDRB
#define MISO_PORT     PORTB
#define MISO_PIN      PINB
#define MISO          4

#define MOSI_DDR      DDRB
#define MOSI_PORT     PORTB
#define MOSI_PIN      PINB
#define MOSI          3

#define SCK_DDR      DDRB
#define SCK_PORT     PORTB
#define SCK_PIN      PINB
#define SCK          5

#define RW_DDR      DDRD
#define RW_PORT     PORTD
#define RW_PIN      PIND
#define RW          6

//****************************************************************************************************
//сигнал включения вспышки
//****************************************************************************************************

#define FIRE_DDR      DDRB
#define FIRE_PORT     PORTB
#define FIRE          2

//****************************************************************************************************
//сигнал включения зарядки
//****************************************************************************************************

#define CHARGING_DDR      DDRC
#define CHARGING_PORT     PORTC
#define CHARGING          5

//****************************************************************************************************
//включение лазера
//****************************************************************************************************

#define LASER_ENABLED_DDR      DDRC
#define LASER_ENABLED_PORT     PORTC
#define LASER_ENABLED_PIN      PINC
#define LASER_ENABLED          3


//----------------------------------------------------------------------------------------------------
//прототипы функций
//----------------------------------------------------------------------------------------------------
void InitAVR(void);//инициализация контроллера
uint16_t GetData(void);//считать данные

void MOSI_Hi(void);//выставить высокий уровень на выходе MOSI
void MOSI_Lo(void);//выставить низкий уровень на выходе MOSI
void SCK_Hi(void);//выставить высокий уровень на выходе SCK
void SCK_Lo(void);//выставить низкий уровень на выходе SCK
bool GetMISOState(void);//получить значение уровня на входе MISO
void FireEnable(void);//произвести вспышку
void FireDisable(void);//отключить вспышку
void ChargingEnable(void);//произвести зарядку
void ChargingDisable(void);//отключить зарядку
bool IsLaserEnabled(void);//получить, включён ли лазер

//----------------------------------------------------------------------------------------------------
//основная функция программы
//----------------------------------------------------------------------------------------------------
int main(void)
{ 
 InitAVR();
 _delay_ms(500);
 MT16S2D_Init();
 float fire_u=0; 
 _delay_ms(100);
 MT16S2D_SetTextUpLine("Вольтметр лазера");
 MT16S2D_SetTextDownLine("Ожидаю ответ МК1");
 
 ChargingDisable();
 FireDisable();
 
 while(1)
 {
  uint16_t value=GetData();
  float v=2.56*value/1023;//напряжение на измерительном резисторе
  const float r_measure=13000;//измерительный резистор
  const float r_ballast=10200000;//балластный резистор
  
  const float FIRE_U=800;//напряжение готовности к вспышке
  
  float i=v/r_measure;//ток в цепи
  float u=i*(r_measure+r_ballast);
  //фильтр даёт существенную задержку, поэтому показания для готовности к вспышке фильтруем иначе
  fire_u=0.5*fire_u+0.5*u;
  if (fire_u>FIRE_U)
  {
   cli();  
   FireEnabled=true;
   sei();
  }
  else
  {
   cli();  
   FireEnabled=false;
   sei();
  }
  u=fire_u;
  
  sprintf(String,"U,В:%i",(int)(u));
  MT16S2D_SetTextUpLine(String);
  const float c=2000E-6;//ёмкость батареи конденсаторов
  uint32_t e=(uint32_t)(c*u*u/2);
  sprintf(String,"E,Дж:%i",(int)e);
  MT16S2D_SetTextDownLine(String);
  _delay_ms(50);
 }
 return(0);
}
//****************************************************************************************************
//****************************************************************************************************
//общие функции
//****************************************************************************************************
//****************************************************************************************************


//----------------------------------------------------------------------------------------------------
//инициализация контроллера
//----------------------------------------------------------------------------------------------------
void InitAVR(void)
{
 cli(); 
 //настраиваем порты
 DDRB=0;
 DDRD=0; 
 DDRC=0;
 
 RW_DDR|=(1<<RW); 
 MOSI_DDR|=(1<<MOSI);
 SCK_DDR|=(1<<SCK);
 MISO_DDR&=0xff^(1<<MISO);
 
 FIRE_DDR|=(1<<FIRE);
 CHARGING_DDR|=(1<<CHARGING);
 LASER_ENABLED_DDR&=0xff^(1<<LASER_ENABLED);

 //задаём состояние портов
 PORTB=0x00;
 PORTD=0x00;
 PORTC=0x00;
 
 RW_PORT&=0xff^(1<<RW); 
 
 LASER_ENABLED_PORT|=(1<<LASER_ENABLED);//подтяжка входа разрешения работы лазера 
 
 //настраиваем таймер T0
 TCCR0=((0<<CS02)|(1<<CS01)|(0<<CS00));//выбран режим деления тактовых импульсов на 8
 TCNT0=0;//начальное значение таймера
 TIMSK=(1<<TOIE0);//прерывание по переполнению таймера (таймер T0 восьмибитный)
 
 
 sei(); 
}
//----------------------------------------------------------------------------------------------------
//считать данные
//----------------------------------------------------------------------------------------------------
uint16_t GetData(void)
{ 
 //отправляем сигнал, пока не получим 32 единицы после ноля
 uint8_t counter=0;
 bool zero=false;
 while(1)
 {
  SCK_Hi();
  _delay_ms(1);
  bool state=GetMISOState();
  SCK_Lo();
  _delay_ms(1); 
  if (zero==false)
  {
   counter=0;  
   if (state==false) zero=true;
   continue;
  } 
  if (state==true) counter++;//считаем единицы
  else//ошибка
  {
   counter=0;
   zero=false;
   continue;
  }
  if (counter==32) break;
 }
 //принимаем данные
 uint16_t mask=(1<<0);
 uint16_t value=0;
 for(int16_t n=0;n<sizeof(uint16_t)*8;n++,mask<<=1)
 {
  SCK_Hi();
  _delay_ms(1);
  bool state=GetMISOState();
  SCK_Lo();
  _delay_ms(1);
  if (state==true) value|=mask; 
 }
 return(value);
}

//----------------------------------------------------------------------------------------------------
//выставить высокий уровень на выходе MOSI
//----------------------------------------------------------------------------------------------------
void MOSI_Hi(void)
{
 MOSI_PORT|=(1<<MOSI);
}
//----------------------------------------------------------------------------------------------------
//выставить низкий уровень на выходе MOSI
//----------------------------------------------------------------------------------------------------
void MOSI_Lo(void)
{
 MOSI_PORT&=0xff^(1<<MOSI);
}

//----------------------------------------------------------------------------------------------------
//выставить высокий уровень на выходе SCK
//----------------------------------------------------------------------------------------------------
void SCK_Hi(void)
{
 SCK_PORT|=(1<<SCK);
}
//----------------------------------------------------------------------------------------------------
//выставить низкий уровень на выходе SCK
//----------------------------------------------------------------------------------------------------
void SCK_Lo(void)
{
 SCK_PORT&=0xff^(1<<SCK);
}

//----------------------------------------------------------------------------------------------------
//получить значение уровня на входе MISO
//----------------------------------------------------------------------------------------------------
bool GetMISOState(void)
{
 if (MISO_PIN&(1<<MISO)) return(true);
 return(false);
}
//----------------------------------------------------------------------------------------------------
//включить вспышку
//----------------------------------------------------------------------------------------------------
void FireEnable(void)
{
 FIRE_PORT|=(1<<FIRE);
}
//----------------------------------------------------------------------------------------------------
//отключить вспышку
//----------------------------------------------------------------------------------------------------
void FireDisable(void)
{
 FIRE_PORT&=0xff^(1<<FIRE);
}
//----------------------------------------------------------------------------------------------------
//произвести зарядку
//----------------------------------------------------------------------------------------------------
void ChargingEnable(void)
{
 CHARGING_PORT|=(1<<CHARGING);
}
//----------------------------------------------------------------------------------------------------
//отключить зарядку
//----------------------------------------------------------------------------------------------------
void ChargingDisable(void)
{
 CHARGING_PORT&=0xff^(1<<CHARGING);
}
//----------------------------------------------------------------------------------------------------
//получить, включён ли лазер
//----------------------------------------------------------------------------------------------------
bool IsLaserEnabled(void)
{
 if (LASER_ENABLED_PIN&(1<<LASER_ENABLED)) return(false);
 return(true);
}
//----------------------------------------------------------------------------------------------------
//обработчик вектора прерывания таймера T0 (8-ми разрядный таймер) по переполнению
//----------------------------------------------------------------------------------------------------
ISR(TIMER0_OVF_vect)
{
 //частота таймера 488 Гц (период 0,002048 секунды).

 TCNT0=0;
 static uint16_t counter=0; 
 
 if (counter>0)
 {
  counter--;
  return;
 }
 
 typedef enum 
 {
  MODE_WAIT,
  MODE_CHARGING, 
  MODE_FIRE,
  MODE_WAIT_FIRE
 } MODE; 
 
 static MODE mode=MODE_WAIT; 
 
 if (mode==MODE_WAIT)
 {
  FireDisable();
  if (IsLaserEnabled()==true) 
  {
   mode=MODE_CHARGING; 
   ChargingEnable();
   counter=300;//для напряжения 800 В нужно поставить 300
   //125 =550 В
   //250 =730 В
   //350 =860 В
   
   //U=1240*(1-exp(-t/295)), где t- время в тактах таймера
   return;
  }
 }
 
 if (mode==MODE_CHARGING)
 { 
  //if (FireEnabled==true)
  {
   ChargingDisable();
   mode=MODE_FIRE;
   counter=5;
   return;
  }
 }
 
 if (mode==MODE_FIRE)
 {
  FireEnable();
  counter=10;
  mode=MODE_WAIT_FIRE;
  return;
 } 
 
 if (mode==MODE_WAIT_FIRE)
 {
  FireDisable();
  if (FireEnabled==false)
  {
   mode=MODE_WAIT; 
   counter=5;
   return;
  }
  counter=10;
  mode=MODE_FIRE;
  return;
 } 
}

With this power supply, I have so far managed to achieve a frequency of 1.5 Hz for 800 V on a 2000 uF capacitor bank. In the video below, I mistakenly indicated a frequency of 2-3 Hz, because I forgot that I set the charge time in the program in timer cycles, and not in milliseconds. The block of charge of the condenser battery limits me in frequency. You can increase the frequency by increasing the capacitance of the capacitors of the multiplier of the charge unit, but so far I have not done this – and so the wiring wires are already heating up. 🙂 Kvant-12, for example, eats as much as 12 kW from a three-phase network. This will be overkill for me.

Well, now the results of the operation of the neodymium laser in the K-107 laser head in the frequency mode.



Sparks from a steel bar.

Unfortunately, I cannot yet run a ruby ​​laser in the frequency mode, since my ruby ​​crystal is rather short (8.5 cm) and in the K-107 laser head it corny barely protrudes from the reflector. This protrusion is sufficient to install the ends into the crystal holders, but at the same time, the access of water to the ruby ​​crystal is completely blocked. And this means that it is not so easy to start it with cooling. But maybe in the future I will do it.

PS Some are interested in what will happen if you shoot such a laser in your hand. 🙂 I did not conduct such an experiment, but it seems like in Quant’e getting a hand into the focus area does not give anything bad. As I was recently informed, hitting a ruby ​​laser beam (with a large AE and a pump of about 5 kJ) feels like a little heat and nothing else. The focused radiation of the same ruby ​​laser creates a small dot on the skin and is almost not felt.

And finally, do not forget about safety!

Similar Posts

Leave a Reply