Tym razem naszło mnie na wykonanie zgrzewarki punktowej. A jako że od dawna w piwnicy poniewierały mi się dwa transformatory od kuchenek mikrofalowych to nie pozostało mi nic innego jak wykorzystać oba z nich.
Zgrzewarka powstała w czasie trzech miesięcy. Może to długi czas ale większość moich prac wykonuje w wolnych chwilach bez nacisku. Maksymalnie kilka godz. dziennie. Czasami przez tydzień projekt leży nie ruszany.
Zgrzewarka jest przeznaczona do zgrzewania stali, aluminium, stali nierdzewnej, miedzi. Oczywiście o ograniczonej grubości. Maksymalna grubość zgrzewanych elementów nie może przekroczyć 2 mm. A dzięki zastosowaniu mikro-kontrolera (atMega 8) jest możliwość ustawienia dokładnego czasu zgrzewania elementów co pozwala na zgrzewanie blach również bardzo cienkich. Czas zgrzewania jest regulowany w zakresie od 10ms do aż 5s. Zgrzewarka posiada również możliwość wyłączenia drugiego transformatora.
Poniżej zamieszczam opis i zdjęcia z postępu pracy nad zgrzewarką:
1. Obudowa (panel czołowy, nóżki)
- podstawa tj. spód to sklejka gr. 10 mm,
- nóżki odzyskane z innego uszkodzonego urządzenia,
- ścianka z prawej strony to element z aluminiowej kratki wentylacyjnej z drzwi łazienkowych (pozostałość po remoncie),
- reszta obudowy wykonana jest z blachy a dokładniej jest to blacha odzyskana z filtra oleju hydraulicznego z koparki, (mam takich blach na pęczki – różnego rodzaju),
- cała obudowa po za panelem czołowym została pomalowana szarym podkładem oraz lakierem bezbarwnym,
- panel tylny oraz przedni to sklejka gr. 6 mm. Na panel przedni nałożone zostały metodą transferu na zimno opisy oraz przyklejony filtr (czerwony) na wyświetlacz,
TRANSFER NA ZIMNO
Transfer na zimno (działa najlepiej nanoszony na drewno lub inną chłonną powierzchnię) polega na:
* wydrukowaniu (drukarka laserowa) na zwykłej kartce lustrzanego odbicia tego co chcemy nanieść,
* przyłożeniu kartki wydrukiem do miejsca na który ma być nałożony rysunek,
* namoczeniu obficie kartki rozpuszczalnikiem (np NITRO lub acetonem),
* dociskaniu wydruku,
Jakość transferu nie jest powalająca ale wystarczająca na szybkie przeniesienie napisu lub grafiki na dowolną powierzchnię. Testowałem przenoszenie tą metodą na aluminium z w miarę dobrym rezultatem. Więcej informacji można uzyskać na poniższym filmie: http://www.spryciarze.pl/zobacz/jak-przeniesc-grafike-na-drewno-cz-1
2. Panel przedni, złącza zgrzewarki, bezpiecznik i wyłącznik główny
- wyłącznik główny umieszczony jest z tyłu urządzenia i pełni on również rolę bezpiecznika – 16A,
- z tyłu obudowy po za wyłącznikiem znajduje się również złącze przewodu zasilania oraz wylot ciepłego powietrza wydmuchiwanego przez wentylator,
- na panelu przednim znajduje się:
- zielona kontrolka załączenia zgrzewarki,
- wyświetlacz LED sygnalizujący ustawiony czas zgrzewania (od 10ms do 5s),
- pokrętło regulacyjne czas zgrzewania,
- kontrolka sygnalizująca załączenie dodatkowego transformatora,
- wyłącznik dodatkowego transformatora,
- złącza wysoko-prądowe zgrzewarki,
- złącze włącznika / uruchamiania procesu zgrzewania,
3. Elektronika (schematy, PCB, połączenia)
Zgrzewarka została wykonana / zbudowana w oparciu o ogólnodostępny projekt z czasopisma Nowy Elektronik o nr. 376-K. (schemat i opis do pobrania na początku strony).
W porównaniu do oryginału zastosowałem mikro-kontroler atMega8, wyświetlacz 7LED z trzema cyframi oraz dodatkowy transformator, który można wyłączać w celu zmniejszenia mocy zgrzewarki.
4. Lista elementów
Poniżej lista elementów elektronicznych. Oczywiście należy do tego dopisać transformatory oraz elementy takie jak obudowa, śruby i inne elementy potrzebne do budowy.
5. Program (kod)
Poniżej zamieszczam kod programu do atMega8. Jest to moja druga konstrukcja urządzenia z wykorzystaniem mikro-kontrolera dlatego kod nie jest powalający. Zapewniam jednak że działa bez zarzutów.
Programowania dopiero się uczę a korzystam przy tym z książek Mirka (http://mirekk36.blogspot.com/), dlatego też w kodzie użyta została jego funkcja do obsługi przycisków oraz lekko zmodyfikowana funkcja do obsługi wyświetlacza 7-mio segmentowego.
Plik c:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 |
/* * main.c * * Created on: 10 sty 2017 * Author: Wujek */ #include <avr/io.h> // dołączenie głównego systemowego pliku nagłówkowego #include <avr/interrupt.h> // dołączenie pl. nagłówkowego potrzebnego do obsł. przerwań #include <avr/pgmspace.h> // dołączenie pl. nagłówkowego potrzebnego do odczytu danych zawartych w pamięci programu FLASH #include <util/delay.h> // dołączenie pl. nagłówkowego potrzebnego do obsł. przerwań #include "main.h" // dołączenie pl. nagłówkowego z informacjami o podlaczonych pinach //Funkcja SuperDebounce do obsługi pojedynczych klawiszy void SuperDebounce(uint8_t * key_state, volatile uint8_t *KPIN, uint8_t key_mask, uint16_t rep_time, uint16_t rep_wait, void (*push_proc)(void), void (*rep_proc)(void) ); //Funkcja do obsługi encodera uint8_t read_gray_code_from_encoder(void ) { uint8_t val=0; if(!bit_is_clear(PINC, PC0)){ val |= (1<<1); } if(!bit_is_clear(PINC, PC1)){ val |= (1<<0); } return val; } void F_ZGRZEW (void); //Funkcja przycisku uruchamiania procesu zgrzewania void F_ZGRZEW_OFF (void); void F_SW_ENCODER (void); int main(void) { //Ustawienie początkowej wartości czasu zgrzewania ustaw_czas_zgrzewu = 250; //2,5 sekundy F_ZGRZEW_OFF ();//Wyłączenie wszystkiego na poczatku //wyjscia DDRB |= DEBUGER | BUZZER; DDRC |= OPTOTRIAK; //wejścia DDRC &= ~(SW_ZGRZEW | SW_ENCODER | ENCODER_A | ENCODER_B); //podciądanie wejśc do VCC PORTC |= SW_ZGRZEW | SW_ENCODER | ENCODER_A | ENCODER_B; LED_DATA_DIR = 0xFF; // wszystkie piny portu C jako WYJŚCIA(katody) LED_DATA = 0xFF; // wygaszenie wszystkich katod – stan wysoki ANODY_DIR |= ZNAK1 | ZNAK2 | ZNAK3; // 4 piny portu A jako WYJŚCIA (anody wyświetlaczy) ANODY_PORT |= ZNAK1 | ZNAK2 | ZNAK3; // wygaszenie wszystkich wyświetlaczy - anody //___Timer programowy – inicjalizacja przerwania co 10ms TCCR2 |= (1<<WGM21); // tryb pracy CTC TCCR2 |= (1<<CS22); // preskaler = 64 OCR2 = 125; // przerwanie porównania co 1000ms TIMSK |= (1<<OCIE2); // Odblokowanie przerwania CompareMatch //___Timer do obsługi wyświetlaczy TCCR1B |= (1<<WGM12); //CTC TCCR1B |= (1<<CS12); //preskaler 256 OCR1A = 180; TIMSK |= (1<<OCIE1A); // przerwanie Compare Match A //___Niezbedne do obslugi encodera val = read_gray_code_from_encoder(); //___Zezwolenie na przerwania sei(); while(1){ //Jeżeli ustawienie enkodera przekracza 5 lub jest poniżej 10 ms to nie pozwól na jego powiększenie if(ustaw_czas_zgrzewu == 500 || ustaw_czas_zgrzewu > 500) ustaw_czas_zgrzewu = 500; if(ustaw_czas_zgrzewu == 1 || ustaw_czas_zgrzewu < 1) ustaw_czas_zgrzewu = 1; //Funkcje obsługujace przyciski SuperDebounce(&k1, &PINC, SW_ZGRZEW, 50, 250, F_ZGRZEW, F_ZGRZEW_OFF ); SuperDebounce(&k2, &PINC, SW_ENCODER, 50, 1000, F_SW_ENCODER, F_SW_ENCODER ); //Jeżeli działa funkcja zgrzewająca to wyświetlaj odliczanie do zakończenia zgrzewu if(flag_SW_ZGRZEW){ setki=czas_zgrzewu/1000; dziesiatki=((czas_zgrzewu % 1000) - (czas_zgrzewu % 100)) / 100; jednosci = czas_zgrzewu % 100; }else{ setki=ustaw_czas_zgrzewu/100; dziesiatki=((ustaw_czas_zgrzewu % 100) - (ustaw_czas_zgrzewu % 10)) / 10; jednosci = ustaw_czas_zgrzewu % 10; } //___Obsługa encodera val_tmp = read_gray_code_from_encoder(); if(val != val_tmp){ if( //(val==2 && val_tmp==3) || //(val==3 && val_tmp==1) || (val==1 && val_tmp==0) //|| //(val==0 && val_tmp==2) ){ustaw_czas_zgrzewu++; czas_buzzera = 2;} else if( //(val==3 && val_tmp==2) || //(val==2 && val_tmp==0) || (val==0 && val_tmp==1) //|| //(val==1 && val_tmp==3) ){ ustaw_czas_zgrzewu--; czas_buzzera = 2;} val = val_tmp; } }//end_while } //Funkcja przycisku uruchamiania procesu zgrzewania void F_ZGRZEW (void){ if(flag_SW_ZGRZEW || flag_czas_przerwy)return; czas_zgrzewu=ustaw_czas_zgrzewu * 10;//mnożone * 10 bo wyświetlamy niższą wartośc OPTOTRIAK_ON; flag_SW_ZGRZEW=1; flag_czas_przerwy = 2000 + czas_zgrzewu; czas_buzzera=czas_zgrzewu; } void F_ZGRZEW_OFF (void){ OPTOTRIAK_OFF; flag_SW_ZGRZEW=0; czas_buzzera=0; } //Funkcja przycisku uruchamiania procesu zgrzewania void F_SW_ENCODER (void){ czas_buzzera = 2; if(ustaw_czas_zgrzewu == 500){ ustaw_czas_zgrzewu -= 500; return;} if(ustaw_czas_zgrzewu > 400){ ustaw_czas_zgrzewu = 500; return;} ustaw_czas_zgrzewu += 100; } /*___Funkcja SuperDebounce do obsługi pojedynczych klawiszy *************** * AUTOR: Mirosław Kardaś * ZALETY: * - nie wprowadza najmniejszego spowalnienia * - posiada funkcję REPEAT (powtarzanie akcji dla dłużej wciśniętego przycisku) * - można przydzielić różne akcje dla trybu REPEAT i pojedynczego kliknięcia * - można przydzielić tylko jedną akcję wtedy w miejsce drugiej przekazujemy 0 (NULL) * * Wymagania: * Timer programowy utworzony w oparciu o Timer sprzętowy (przerwanie 100Hz) * * Parametry wejściowe: * * *key_state - wskaźnik na zmienną w pamięci RAM (1 bajt) - do przechowywania stanu klawisza * *KPIN - nazwa PINx portu na którym umieszczony jest klawisz, np: PINB * key_mask - maska klawisza np: (1<<PB3) * rep_time - czas powtarzania funkcji rep_proc w trybie REPEAT * rep_wait - czas oczekiwania do przejścia do trybu REPEAT * push_proc - wskaźnik do własnej funkcji wywoływanej raz po zwolenieniu przycisku * rep_proc - wskaźnik do własnej funkcji wykonywanej w trybie REPEAT **************************************************************************************/ void SuperDebounce(uint8_t * key_state, volatile uint8_t *KPIN, uint8_t key_mask, uint16_t rep_time, uint16_t rep_wait, void (*push_proc)(void), void (*rep_proc)(void) ) { enum {idle, debounce, go_rep, wait_rep, rep}; if(!rep_time) rep_time=20; if(!rep_wait) rep_wait=150; uint8_t key_press = !(*KPIN & key_mask); if( key_press && !*key_state ) { *key_state = debounce; Timer1 = 15; } else if( *key_state ) { if( key_press && debounce==*key_state && !Timer1 ) { *key_state = 2; Timer1=5; } else if( !key_press && *key_state>1 && *key_state<4 ) { if(push_proc) push_proc(); /* KEY_UP */ *key_state=idle; } else if( key_press && go_rep==*key_state && !Timer1 ) { *key_state = wait_rep; Timer1=rep_wait; } else if( key_press && wait_rep==*key_state && !Timer1 ) { *key_state = rep; } else if( key_press && rep==*key_state && !Timer1 ) { Timer1 = rep_time; if(rep_proc) rep_proc(); /* KEY_REP */ } } if( *key_state>=3 && !key_press ) *key_state = idle; } ISR(TIMER2_COMP_vect) { //___Obsługa funkcji zgrzewania w ustalonym czasie if(czas_zgrzewu){czas_zgrzewu--;}else{OPTOTRIAK_OFF; flag_SW_ZGRZEW=0;} //___Obsługa blokady urzuchomienia zgrzewarki miedzy zgrzewammi if(flag_czas_przerwy){flag_czas_przerwy--;} //___Obsługa czasu trwania dzwięku generowanego przez buzzer if(czas_buzzera > 0) {czas_buzzera--; BUZZER_ON;}else{ BUZZER_OFF; } //___Obsługa debugera - mryga co 1 s. if(SEKUNDA == 1000){ SEKUNDA=0; DEBUGER_TOG; } //___Programowy timer uint16_t n; n = Timer1; /* 100Hz Timer1 */ if (n) Timer1 = --n; SEKUNDA++; } ISR(TIMER1_COMPA_vect) { //___Obsługa wyświetlacza 7-LED static uint8_t licznik=1; // zmienna do przełączania kolejno anod wyrwietlacza ANODY_PORT = (ANODY_PORT | MASKA_ANODY); // if(ustaw_czas_zgrzewu < 100) setki=NIC;//Zgaś zero if(licznik==1){ ANODY_PORT &= ~ZNAK1; //załącz znak 1 / resztę wyłącz ANODY_PORT |= ZNAK2; ANODY_PORT |= ZNAK3; //wyswietl liczbe dla setek LED_DATA = pgm_read_byte( &cyfry[setki] ); LED_DATA &= pgm_read_byte( &cyfry[12] ); } else if(licznik==2){ ANODY_PORT |= ZNAK1; ANODY_PORT &= ~ZNAK2; //załącz znak 2 / resztę wyłącz ANODY_PORT |= ZNAK3; //wyswietl liczbe dla dziesiatek LED_DATA = pgm_read_byte( &cyfry[dziesiatki] ); } else if(licznik==4){ ANODY_PORT |= ZNAK1; ANODY_PORT |= ZNAK2; ANODY_PORT &= ~ZNAK3; //załącz znak 3 / resztę wyłącz //wyswietl liczbe dla jednosci LED_DATA = pgm_read_byte( &cyfry[jednosci] ); if(flag_czas_przerwy) LED_DATA &= pgm_read_byte( &cyfry[12] ); } // operacje cyklicznego przesuwania bitu zapalającego anody w zmiennej licznik licznik <<= 1; // przesunięcie zawartości bitów licznika o 1 w lewo if(licznik>4) licznik = 1; // jeśli licznik większy niż 8 to ustaw na 1 } |
Plik h:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 |
* main.h * * Created on: 10 sty 2017 * Author: Wujek */ #ifndef MAIN_H_ #define MAIN_H_ //___DEFINICJE STAŁYCH - PRZYPISANIE DO PINÓW PORTÓW //DEBUGER #define DEBUGER (1<<PB7) #define DEBUGER_ON PORTB |= DEBUGER //Załączenie - w tym pinie zwarte do VCC #define DEBUGER_OFF PORTB &= ~DEBUGER #define DEBUGER_TOG PORTB ^= DEBUGER //OPTOTRIAK #define OPTOTRIAK (1<<PC5) #define OPTOTRIAK_OFF PORTC |= OPTOTRIAK #define OPTOTRIAK_ON PORTC &= ~OPTOTRIAK //Załączenie - w tym pinie zwarte do GND #define OPTOTRIAK_TOG PORTC ^= OPTOTRIAK //BUZZER #define BUZZER (1<<PB6) #define BUZZER_ON PORTB |= BUZZER //Załączenie - w tym pinie zwarte do VCC #define BUZZER_OFF PORTB &= ~BUZZER #define BUZZER_TOG PORTB ^= BUZZER //Zmienne potrzebne do obsługi timerow programowych volatile uint16_t Timer1, SEKUNDA; //Zmienne do obslugi funkcji zgrzewania w ustalonym czasie volatile uint16_t czas_zgrzewu, ustaw_czas_zgrzewu; //Zmienne do obsługi encodera volatile uint8_t val=0, val_tmp =0; //Zmienna do obsługi buzzera volatile uint16_t czas_buzzera; //czas pracy buzzera w ms //Zmienne potrzebne do działania funkcji SuperDebounce uint8_t k1; // zmienne pomocnicze do przechowywania stanów klawiszy uint8_t k2; //Zmienne przyciskow #define SW_ZGRZEW (1<<PC2) //PRZYCISK - uruchamiania zgrzewania #define SW_ENCODER (1<<PC4) //PRZYCISK - na enkoderze //Flagi przycisków volatile uint8_t flag_SW_ZGRZEW; volatile uint16_t flag_czas_przerwy=0; //Zmienne encodera #define ENCODER_A (1<<PC0) #define ENCODER_B (1<<PC1) //Zmienne do wyświetlacza 7-LED #define LED_DATA PORTD // port z podłączonymi segmentami #define LED_DATA_DIR DDRD // rejestr kierunku portu ANOD wyświetlaczy #define ANODY_PORT PORTB // port z podłączonymi anodami- 4 bity najmłodsze #define ANODY_DIR DDRB // rejestr kierunku portu anod wyświetlaczy #define ZNAK1 (1<<PB1) // ZNAK1 #define ZNAK2 (1<<PB0) // ZNAK2 #define ZNAK3 (1<<PB2) // ZNAK3 #define MASKA_ANODY (ZNAK1|ZNAK2|ZNAK3) // Do wyłaczania znaków jednocześnie /*opis segmętów LED tylko w tym projekcie - zgrzewarce A - PD2 B - PD3 C - PD6 D - PD5 E - PD4 F - PD1 G - PD0 DP - PD7 */ #define SEG_A (1<<2) // Przypisanie portow do segmentow #define SEG_B (1<<3) #define SEG_C (1<<6) // a #define SEG_D (1<<5) // f b #define SEG_E (1<<4) // g #define SEG_F (1<<1) // e c #define SEG_G (1<<0) // d #define SEG_DP (1<<7) #define NIC 10 volatile uint8_t setki; volatile uint8_t dziesiatki; volatile uint8_t jednosci; //___Definicja tablicy zawierającej definicje bitowe cyfr LED - do wyświetlacza 7-LED const uint16_t cyfry[16] PROGMEM = { ~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F), // 0 ~(SEG_B|SEG_C), // 1 ~(SEG_A|SEG_B|SEG_D|SEG_E|SEG_G), // 2 ~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_G), // 3 ~(SEG_B|SEG_C|SEG_F|SEG_G), // 4 ~(SEG_A|SEG_C|SEG_D|SEG_F|SEG_G), // 5 ~(SEG_A|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G), // 6 ~(SEG_A|SEG_B|SEG_C|SEG_F), // 7 ~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G), // 8 ~(SEG_A|SEG_B|SEG_C|SEG_D|SEG_F|SEG_G), // 9 0xFF, // 10 - NIC (puste miejsce) ~(SEG_A|SEG_E|SEG_F|SEG_G), // 11 - Litera "F" ~(SEG_DP) // 12 - kropka }; #endif /* MAIN_H_ */</pre> |
6. Kosztorys
Do kosztów wykonania zgrzewarki należy dopisać transformatory, farby, spreje, śrubki które były użyte, i inne elementy których nie ma w powyższym spisie. Mnie cała zgrzewarka wyniosła około 250 zł. Doliczyć trzeba jeszcze zakup kabli zgrzewających oraz wtyków do zgrzewarki.
7. Instrukcja obsługi
Poniżej znajduje się instrukcja obsługi zgrzewarki. Są to te same informacje które zostały zamieszczone na obudowie.
8. Zdjęcia z postępu pracy
