Categorie: Puntlasser

Puntlasser

Ik had een aantal 10mF 6V elco’s liggen waar ik geen nut voor had. Ik heb na ze nog maar eens op een andere plaats te leggen beslist om er een soort puntlas apparaat mee te maken. De inspiratie komt uit een elektuur artikel waar ongeveer hetzelfde wordt gedaan.

 

De bedoeling is dat de hoeveelheid energie dat in de elco’s gestopt wordt instelbaar wordt. Hierdoor is de kortsluitvermogen ook instelbaar. Verder wil ik er een meting insteken zodat de controller weet als de 2 pennen elkaar raken en dan na een instelbare tijd pas de fets naar de uitgang aansturen.

 

Voor het instellen heb ik een display en 3 drukknoppen voorzien. Als display heb ik gekozen voor een HP HDSP 2111 H5, dit display is wat kleiner dan een lcd en past daardoor makkelijker op het frontpaneel. Een nadeel is wel dat het maar 8 karakters kan weergeven.

 

De frontpaneel layout die ik wil gebruiken:

 

De elco print:

 

In de behuizing:

 

Aanstuurprint:

 

De 2 printen komen boven elkaar in de behuizing:

http://image.elektronicastynus.be/82/1352735504.jpg

 

De frontprint moet nog gemaakt worden.

 

Schema’s:

De elco print:

http://image.elektronicastynus.be/82/Schema_Cap_Print.png

 

De aanstuurprint:

http://image.elektronicastynus.be/82/Schema_Stuurprint_1.png

http://image.elektronicastynus.be/82/Schema_Stuurprint_1.png

 

De displayprint:

http://image.elektronicastynus.be/82/Schema_Display_Print.png

Puntlasser

Ik heb dit project van een paar jaar geleden weer opgepakt. Eerst heb ik 5V op de elco print gezet, maar onmiddellijk ging er veel te veel stroom lopen (die ook bleef lopen).  Dit kwam doordat er 1 elco intern kortgesloten was. Met veel moeite heb ik kunnen vinden welke het was en deze vervangen. Hierna de print weer getest, maar er liep tijdens het puntlassen veel te weinig stroom. Zo weinig dat er niet eens een stevige vonk kwam bij het kortsluiten.

Na wat verder experimenteren zat er opeens weer een kortsluiting in de print. Na het vinden van de schuldige elco, weer verder gegaan. En opnieuw een elco kapot. Nu waren mijn reserve elco’s ook op en moest ik nieuwe bestellen. Maar voordat ik dat deed maar even narekenen of er dan wel genoeg energie in de elco’s zit. Dit bleek niet het geval te zijn. Tenzij ik elco’s met veel hogere capaciteit zou kopen, maar die zijn duur.

Toen dacht ik eraan dat ik nog een paar transformatoren uit microgolfovens had liggen. Als ik hier op de hoogspanningswikkelingen verwijder en deze vervang door een aantal wikkelingen met dikke draad (16mm² in dit geval) dan levert deze veel stroom bij een lage spanning.
De primaire kant van deze transformator kan ik schakelen met een solid state relays. Om de timing te doen en alles aan te sturen heb ik een PIC16F1788 microcontroller gebruikt. Hier heb ik een ULN2803 bordje bijgezet om de solid state relays aan te sturen. Voor de bediening heb ik nog een LCD en rotary encoder toegevoegd.

Nu kwam er wel een ander probleem naar boven. Bij het oude schema was het makkelijk te detecteren of de las elektroden kortgesloten werden door het te lassen object. Met de nieuwe setup is het wat lastiger omdat de 16mm² draad die met beide pennen in verbinding staat al zorgt voor een enorm lage weerstand. Dit heb ik opgelost door op de uitgang een 50Khz blokgolf te zetten en te meten hoe ver deze inzakt als de uitgang kortgesloten wordt. De draad door de transformator werkt op deze manier als spoel en is een hogere weerstand voor de 50Khz.
Om het signaal op de draad te zetten, had ik meer power nodig dan dat de pin van de microcontroller kan leveren. Daarom heb ik een RS485 IC (mis)gebruikt  als versterker. Achter de RS485 IC heb ik een 1µF condensator gebruikt om het signaal in te koppelen.

Hier heb ik eerst een simulatie op gedaan met volgend resultaat: (Links op de plot is output open, rechts is gesloten.)

Het “out” signaal is verbonden met de AD converter van een microcontroller. Wanneer het signaal onder een bepaald niveau komt dan gaat het las programma starten. Het programma heb ik zo gemaakt dat het 2 pulsen na elkaar kan geven, dit zou een betere las moeten opleveren. De puls en pauze tijd is allemaal apart aanpasbaar.

Het hoofd deel van het programma:

 while (1)
    {   
        
        MenuDelay ++;   //For debounce
        if (MenuDelay > 4){
            MenuDelay = 0;
            
            if (WeldState){
                LCD_Print_At(1, 1, "Stat:Weld|T1PaT2"); 
            }else{
                LCD_Print_At(1, 1, "Stat:Open|T1PaT2");                 
            }    
            
            sprintf(GetString,"%4u", WeldTime1 * 20); 
            LCD_Print_At(2, 1, GetString);  
            sprintf(GetString,"%4u", WeldPause * 20); 
            LCD_Print_At(2, 6, GetString);      
            sprintf(GetString,"%4u", WeldTime2 * 20); 
            LCD_Print_At(2, 11, GetString);     
            LCD_Print_At(2, 5,  "|");
            LCD_Print_At(2, 10, "|");    
            LCD_Print_At(2, 15, "mS");  
            
            LCD_Cmd(0xFE);
            LCD_Cmd(0x0E);
            LCD_Cmd(0x0F);
            
            switch (MenuItem){ 
                case 0:     
                    LCD_Goto(4, 2);                      
                    WeldTime1 = RotCountValue;
                    if (!RotaryBtn){
                        DATAEE_WriteByte(1, WeldTime1); 
                        MenuItem ++;
                    }
                    break;  
                case 1:
                    if (RotaryBtn){
                        MenuItem ++;
                        RotCountValue = WeldPause;
                        RotMinValue = 1;
                        RotMaxValue = 100;
                        LCD_Cmd(LCD_CLEAR);   
                    }
                    break; 
                case 2:     
                    LCD_Goto(9, 2);  
                    WeldPause = RotCountValue;    
                    if (!RotaryBtn){
                        DATAEE_WriteByte(2, WeldPause); 
                        MenuItem ++;
                    }
                    break; 
                case 3:
                    if (RotaryBtn){
                        MenuItem ++;
                        RotCountValue = WeldTime2;
                        RotMinValue = 1;
                        RotMaxValue = 100;
                        LCD_Cmd(LCD_CLEAR);   
                    }
                    break;                    
                case 4:     
                    LCD_Goto(14, 2);                     
                    WeldTime2 = RotCountValue;
                    if (!RotaryBtn){
                        DATAEE_WriteByte(3, WeldTime2); 
                        MenuItem ++;
                    }                    
                    break;  
                default:
                    if (RotaryBtn){
                        MenuItem = 0;
                        RotCountValue = WeldTime1;
                        RotMinValue = 1;
                        RotMaxValue = 100;
                    }
                    break;
            }      
        }
        
        SensVoltageBuffer = 0;
        for (uint8_t Counter = 0; Counter < 6; Counter++){ 
            SensVoltage = ADC_GetConversion(0); SensVoltage = SensVoltage >> 6;
            SensVoltageBuffer = SensVoltageBuffer + SensVoltage;      
            __delay_ms(20/6);        
        }
        SensVoltage = SensVoltageBuffer / 6;
        WeldDetect = 200;    
        
        switch (WeldState){
            case 0:
                if (SensVoltage < WeldDetect){
                    WeldState ++;
                }
                break;
            case 1:            
                WeldState ++; 
                WeldTimer = 0;
                break;
            case 2:
                if (SensVoltage < WeldDetect){ 
                    WeldState ++; 
                }else{ 
                    WeldTimer ++; 
                    if (WeldTimer == 250){ 
                       WeldState = 0; 
                    } 
                } 
                break; 
            case 3: 
                LATBbits.LATB4 = 1; //Buzzer 
                WeldState ++; 
                break; 
            case 4: 
                LATBbits.LATB4 = 0; 
                WeldState ++; 
                break; 
            case 5:
                WeldTimer = 0; 
                WeldState ++; 
               break; 
            case 6: 
               LATAbits.LATA3 = 1; 
               LATBbits.LATB5 = 1; 
               if (WeldTimer >= WeldTime1){
                    LATAbits.LATA3 = 0;
                    LATBbits.LATB5 =0;
                    WeldTimer = 0;
                    WeldState ++;
                }else{
                    WeldTimer ++;
                }
                break;
            case 7:
                if (WeldPulses == 1){
                   WeldState = 10; 
                }
                if (WeldTimer >= WeldPause){
                    WeldTimer = 0;
                    WeldState ++;
                }else{
                    WeldTimer ++;
                }
                break;
            case 8:
                LATAbits.LATA3 = 1;
                LATBbits.LATB5 = 1;
                if (WeldTimer >= WeldTime2){
                    LATAbits.LATA3 = 0;
                    LATBbits.LATB5 = 0;
                    WeldTimer = 0;
                    WeldState ++;
                }else{
                    WeldTimer ++;
                }
                break;
            case 9:
                WeldState ++;                
                break;               
            case 10:
                WeldTimer ++;
                if (WeldTimer >= (1000/20)){
                    WeldTimer = 0;
                    WeldState ++;
                }
                break;   
            case 11:     
                 if (SensVoltage > WeldDetect){
                    LATAbits.LATA3 = 0;
                    WeldTimer = 0;
                    WeldState = 0;
                }      
                break;                     
            default:
                WeldState = 0;
                break;                    
        }   
    }