Prosty skrypt na przeliczanie parametrów + inne

Proste programy do obsługi maszyn CNC, vivery, itp. Programy darmowe, napisane przez użytkowników forum
Awatar użytkownika

Autor tematu
Graphart
Specjalista poziom 1 (min. 100)
Specjalista poziom 1 (min. 100)
Posty w temacie: 3
Posty: 134
Rejestracja: 19 sie 2012, 17:41
Lokalizacja: Wadowicen

Prosty skrypt na przeliczanie parametrów + inne

#1

Post napisał: Graphart » 30 cze 2013, 11:05

Sprzątam na dysku, może komuś się przyda - kiedyś w pracy napisałem sobie z nudów. Po zdefiniowaniu Vc dla wiertła np. HSS w stali (opisana linia) wystarczy wpisać średnicę wiertła aby otrzymać parametry.

Kod: Zaznacz cały

#!/usr/bin/python
#przeliczanie parametrow
wybor = raw_input("Wybierz 'frez' lub 'wiertlo': ") 
if  wybor == "frez": 
    Vc = input (" Vc: ") 
    D = input ("D freza: ") 
    Fz = input ("podaj posuw na zab: ") 
    Z = input ("podaj liczbe zebow: ") 
    Pi = D * 3.14159
    Vc2 = Vc * 1000
    print "obroty: " ,Vc2 / Pi
    Vc3 = Vc2 / Pi
    print "posuw: " ,Vc3 * Z * Fz
if wybor == "wiertlo": 
    wiertloD = input ("wpisz srednice wiertla: ") 
    vcs = 25 #wpisz tu Vc
    wycs = vcs * 1000
    asas = wycs / wiertloD
    print asas / 3.14
  
Ostatnio zmieniony 01 lip 2013, 23:47 przez Graphart, łącznie zmieniany 1 raz.


NX CAM.
Produkcja, dystrybucja, masturbacja.

Tagi:

Awatar użytkownika

Autor tematu
Graphart
Specjalista poziom 1 (min. 100)
Specjalista poziom 1 (min. 100)
Posty w temacie: 3
Posty: 134
Rejestracja: 19 sie 2012, 17:41
Lokalizacja: Wadowicen

#2

Post napisał: Graphart » 01 lip 2013, 20:36

Ostatni raz kodziłem coś 2 lata temu, przypominam sobie Pythona, wrzucam następny "przydatny" kodzik:
Skrypt ma na celu generowanie programu na wiercenie z łamaniem wióra, dodatkowo po wpisaniu średnicy freza, w programie wpisze odpowiednie obroty.

Kod: Zaznacz cały

####cykl_wiercenie_z_lamaniem_wiora########
import math
choose = raw_input ("wpisz 1 aby wybrać wiercenie bez cyklu, lub 2 z cyklem: ") 
deep_drill = input('glebokosc otworu: ') 
Diam = input('srednica wiertla: ') 
backdrill = input ('co ile lamanie: ') 
wspol = input ('wpisz pos. w osi X: ') 
wspol2 = input ('wpisz pos. w osi Y: ') 
vcs = 25 #Vc
wycs = vcs * 1000
asas = wycs / Diam
feed = (asas/3.14) 
feed2 = int(feed) 
back = 500 #Posuw przy szybkim wyjezdzie
if choose == "1": 
    print "\n\n\nG49 G40 G80 G90 G0; \nG54;" 
    print "T1 M6;\nS%s M3;\nG0 Z100;\nG0 X%s Y%s;\nG0 Z3 M8;\nG01 Z0.5 F21;" % (feed2, wspol, wspol2) 
    deep_drill2 = deep_drill + 1
    F_int_1 = 1
    F_int_2 = 0.5
    xoxoxo = F_int_1 - backdrill
    while F_int_1 < deep_drill: 
        print "G01 Z-%s;" % (F_int_1) 
        print "G01 Z-%s;" % (F_int_1 - F_int_2) 
        F_int_1 = F_int_1 + backdrill
    else: 
        print "G01 Z-%s;" % (F_int_1,) 
        print "G01 Z3 F%s;\nG0 Z50 M9;\nG49 G90 G80 G40;\nM30;" % (back) 
if choose == "2": 
    print "\n\n\nG90 G40 G49 G80 G0\nT1 M6;\nG54;\nG0 Z100;\nS%s M3;\nG0 Z3 M8;" % (feed2) 
    print "G73 Z-%s Q%s R3 F21;\nX%s Y%s;" % (deep_drill,backdrill,wspol,wspol2) 
    print "G80;" 
    print "G0 Z50;\nG40 G49 G80 G90 G0;\nM30;" 

Obrazek

[ Dodano: 2013-07-02, 20:23 ]
NX CAM.
Produkcja, dystrybucja, masturbacja.

Awatar użytkownika

Autor tematu
Graphart
Specjalista poziom 1 (min. 100)
Specjalista poziom 1 (min. 100)
Posty w temacie: 3
Posty: 134
Rejestracja: 19 sie 2012, 17:41
Lokalizacja: Wadowicen

#3

Post napisał: Graphart » 02 lip 2013, 20:40

Dopiero za 2 tyg. do pracy, więc w wolnym czasie biorę się za konwertowanie wszystkich cykli heidenhaina na kodowanie ISO'wskie, może komuś przyda się do starych maszyn itd. Dziś obróbka gabarytów + opisane zmienne po polsku, więc jeśli ktoś ma dostęp do Fanuca to może sobie przepisać bezpośrednio na maszynę. Program wyciąga różnicę wynikającą z niepodzielności wysokości w osi Z przez głębokość skrawania i dodaje dodatkowy przejazd. Układ na środku.

edit: dodałem możliwość podania promieni naroża.

Kod: Zaznacz cały

#gabaryt
#dane do wprowadzania
import timeit
dl_x = input('dlugosc scianki w osi X') 
dl_y = input('dlugosc scianki w osi Y') 
dl_z = input ('glebokosc gabarytu w osi Z: ') 
wymiar_gabarytu = input ("wpisz ile odsunac narzedzie od scianki podczas zaglebiania") 
srednica_narzedzia = input ('srednica narzedzia: ') 
glebokosc = input ('glebokosc skrawania: ') 
promien_freza = input ('wpisz o ile obnizyc obrobke w ostatnim przejezdzie: ') 
naddatek = input ("naddatek: ") 
posuw = input ("posuw: ") 
promien_naroza = input ("wpisz promien naroza: ") 
#obliczenie roznicy w ostatnim przejezdzie
resztki = dl_z + (promien_freza) % glebokosc
if wymiar_gabarytu < srednica_narzedzia: 
#ustawienie bazy na srodku detalu
    korekta = dl_y /2 + srednica_narzedzia /2 + naddatek
    korek_y = dl_y /2 + srednica_narzedzia /2 + naddatek
    kore_3 = dl_x /2 + srednica_narzedzia /2  + naddatek
    core_4 = dl_x /2 + srednica_narzedzia /2 + naddatek
    korke = (dl_y /2) + srednica_narzedzia /2 + naddatek
#generowanie poczatku programu
    print "#########START_NC###########" 
    print "\n\nG40 G49 G80 G90 G0;\nT1M6;\nG54;\nG0 Z50 S3000 M3;" 
    print "G0 X0 Y-%s" % (korekta + wymiar_gabarytu) 
    print "G0 Z3 M8;" 
if promien_naroza == 0: 
    glebo = glebokosc
    
#petla przejazdow
    while glebo < dl_z + promien_freza: 

    
        print "G1 Z-%s F%s" % (glebo, posuw*2) 
        print "G1 X0 Y-%s F%s" % (korekta, posuw) 
        print "G1 X-%s" % (core_4) 
        print "G1 Y%s" % (korek_y) 
        print "G1 X%s" % (kore_3) 
        print "G1 Y-%s" %(korek_y) 
        print "G1 X0" 
        print "G1 Y-%s F%s" % (korke + wymiar_gabarytu, posuw*2) 
        glebo = glebo + glebokosc
    else: 
        print "G1 Z-%s F%s" % (resztki, posuw*2) 
        print "G1 X0 Y-%s F%s" % (korekta, posuw) 
        print "G1 X-%s" % (core_4) 
        print "G1 Y%s" % (korek_y) 
        print "G1 X%s" % (kore_3) 
        print "G1 Y-%s" %(korek_y) 
        print "G1 X0" 
        print "G1 Y-%s F%s" % (korke + wymiar_gabarytu, posuw*2) 
        print 'G0 Z50;\nM30;'
if wymiar_gabarytu >= srednica_narzedzia: 
    print "srednica narzedzia zbyt mala!" 
if promien_naroza != 0: 
    glebo = glebokosc
    while glebo < dl_z + promien_freza: 

    
        print "G1 Z-%s F%s" % (glebo, posuw*2) 
        print "G1 X0 Y-%s F%s" % (korekta, posuw) 
        print "G1 X-%s" % (core_4 - promien_naroza) 
        print "G2 X-%s Y-%s R%s" %(core_4, korekta - promien_naroza, promien_naroza) 
        print "G1 Y%s" % (korek_y - promien_naroza) 
        print "G2 Y%s X-%s R%s" %(korek_y, core_4 - promien_naroza, promien_naroza) 
        print "G1 X%s" % (kore_3 - promien_naroza) 
        print "G2 X%s Y%s R%s" % (kore_3, korekta - promien_naroza, promien_naroza) 
        print "G1 Y-%s" %(korek_y - promien_naroza) 
        print "G2 X%s Y-%s R%s" %(core_4 - promien_naroza, korek_y, promien_naroza ) 
        print "G1 X0" 
        print "G1 Y-%s F%s" % (korke + wymiar_gabarytu, posuw*2) 
        glebo = glebo + glebokosc
    else: 
        print "G1 Z-%s F%s" % (resztki, posuw*2) 
        print "G1 X0 Y-%s F%s" % (korekta, posuw) 
        print "G1 X-%s" % (core_4) 
        print "G1 Y%s" % (korek_y) 
        print "G1 X%s" % (kore_3) 
        print "G1 Y-%s" %(korek_y) 
        print "G1 X0" 
        print "G1 Y-%s F%s" % (korke + wymiar_gabarytu, posuw*2) 
        print 'G0 Z50;\nM30;'
        

foto:
Obrazek
NX CAM.
Produkcja, dystrybucja, masturbacja.


conor87
Nowy użytkownik, używaj wyszukiwarki
Nowy użytkownik, używaj wyszukiwarki
Posty w temacie: 1
Posty: 3
Rejestracja: 17 gru 2012, 18:55
Lokalizacja: Łowicz

#4

Post napisał: conor87 » 06 sie 2013, 17:33

Wstawiam kod na postprocesor. Program wczytuje clfile i tworzy nc. Testowany na PROE i fanuc control. Jeszcze sporo do zrobienia - cykle. Nie mam teraz na to czasu (małe dziecko ma wielką moc pożytkowania tacie czasu).

Kod: Zaznacz cały

#-*- coding: utf-8 -*-

import time

print '''
**********************
Postprocesor dzialajacy na podstawie
pliku CL FILE
**********************
'''

#pliki
zrodlo="seq0005.ncl.1"   #skad pobrac clfile
cel="o0005.nc"			 #plik docelowy



#*****************************************
#zmienne globalne

X_zapis=0.0000001
Y_zapis=0.0000001
Z_zapis=0.0000001
I_zapis=0.0000001
J_zapis=0.0000001
K_zapis=0.0000001
blok=''



czas=time.time() 
nazwa=cel.replace('.nc','') 



#*******************************************************************
#otworzenie pliku w celu sprawdzenia jego dlugosci
linie=open(zrodlo).readlines() 
docel=open(cel,'w') 

naglowek='''(PROGRAM TESTOWY) 
(POSTPROCESOR PYTHON 2.7.0) 
(AUTOR KD) 
(VER1 1.03.2013) 
(FUNKCJE PRZYGOTOWAWCZE) 
G54 G90 G40
(CAM) 
'''


docel.write(nazwa+'\n') 
docel.write(naglowek) 
docel.close() 

#ilosc linii
dlug=len(linie) 
print 'Ilosc linii w pliku CL = %s\n' %dlug

#*******************************************************************

#otworzenie pliku w celu analizy
plik=open(zrodlo).read() 

#Wyswietlenie zawartosci pliku CL
print '''Zawartosc pliku CL: 

 %s
Koniec pliku CL FILE''' %plik

print 'Poczatek analizy oraz generowania nc'
print nazwa
print naglowek
#Funkcja analizujaca pojedyncza linie pliku CL
def analizuj(linie,a): 
	
	global X_zapis
	global Y_zapis
	global Z_zapis
	global I_zapis
	global J_zapis
	global K_zapis
	global blok
	#analiza pliku 
#**************************************************************
	
	#poszukiwanie ruchu szybkiego lub posuwu F (okreslenie G00 lub G01 F) 
	test=linie[a].find('RAPID') 
	global GR
	if test != -1: 
		GR='G00'
		#print 'ruch %s' %GR
	test=linie[a].find('FEDRAT') 
	if test != -1: 
		GR='G01'
		tool=linie[a].split() 			#podzial linii na slowa
		fedrat=tool[2].replace(',','') 		#kasowanie przecinka
		fedrat=float(fedrat) 
		blok='F%.0f\n'%fedrat
		print blok
		
		zapis = open(cel,'a') 
		zapis.write(blok) 
		zapis.close() 
		
		
		return
#*************************************************************
	
	#poszukiwanie interpolacji liniowej
	test=linie[a].find('GOTO') 
	if test != -1: 
		if GR !='G00' and GR !='G01': 
			exit() 
		#wyswietl X
		tool=linie[a].split() 			#podzial linii na slowa
		X=tool[2].replace(',','') 		#kasowanie przecinka
		X=float(X)						#zaokraglanie
		#print 'X%.3f' %X
				
		#wyswietl Y
		Y=tool[3].replace(',','') 
		Y=(float(Y)) 
		#print 'Y%.3f' %Y
		
		#wyswietl Z
		Z=tool[4].replace(',','') 
		Z=(float(Z)) 
		#print 'Z%.3f' %Z
		
		if X_zapis == X: 
			blokX=''
			
		else: 
			X_zapis=X
			blokX = 'X%.3f' %X_zapis
			
		
		if Y_zapis == Y: 
			blokY=''
		else: 
			Y_zapis=Y
			blokY = 'Y%.3f' %Y_zapis
			
		if Z_zapis == Z: 
			blokZ=''
		else: 
			Z_zapis=Z
			blokZ = 'Z%.3f' %Z_zapis
		
		blok = '%s'%GR+blokX+blokY+blokZ+'\n'
		
		#print blok
		
		if blok!='G01\n': 
			print blok
			zapis = open(cel,'a') 
			zapis.write(blok) 
			zapis.close() 
		
			
			
		
		
		return
#****************************************************************
	
	#poszukiwanie interpolacji kolowej
	test=linie[a].find('CIRCLE') 
	if test != -1: 
		tool2=linie[a].split() 
		tool3=linie[a+1].split() 
		tool4=linie[a+2].split() 
		#print tool2, tool3, tool4
		
		X=tool4[2].replace(',','') 
		X=(float(X)) 
		Y=tool4[3].replace(',','') 
		Y=(float(Y)) 
		Z=tool4[4].replace(',','') 
		Z=(float(Z)) 
		I=tool2[2].replace(',','') 
		I=(float(I)) 
		J=tool2[3].replace(',','') 
		J=(float(J)) 
		K=tool2[4].replace(',','') 
		K=(float(K)) 
		if float(tool3[2].replace(',',''))<0: 
			G='G02'
			#print tool3[2] 
		if float(tool3[2].replace(',',''))>0: 
			#print tool3[2] 
			G='G03'		
			
			#*****************
		if X_zapis == X: 
			blokX=''
		else: 
			X_zapis=X
			blokX = 'X%.3f' %X_zapis
		
		if Y_zapis == Y: 
			blokY=''
		else: 
			Y_zapis=Y
			blokY = 'Y%.3f' %Y_zapis
			
		if Z_zapis == Z: 
			blokZ=''
		else: 
			Z_zapis=Z
			blokZ = 'Z%.3f' %Z_zapis
		
		if I_zapis == I: 
			blokI=''
		else: 
			I_zapis=I
			blokI = 'I%.3f' %I_zapis
			
		if J_zapis == J: 
			blokJ=''
		else: 
			J_zapis=J
			blokJ = 'J%.3f' %J_zapis
		
		if K_zapis == K: 
			blokK=''
		else: 
			K_zapis=K
			blokK = 'K%.3f' %K_zapis

			#*****************
			
		blok = '%s'%G+blokX+blokY+blokZ+blokI+blokJ+blokK+'\n'
		print blok
		
		zapis = open(cel,'a') 
		zapis.write(blok) 
		zapis.close() 
		
		
		return
		
#****************************************************************
	#poszukiwanie narzedzia
	test=linie[a].find('LOADTL') 
	if test != -1: 
		#print 'narzedzie w linii %s' %(str(a)) 
		tool=linie[a].split() 			#podzial linii na slowa
		T=tool[2].replace(',','') 		#kasowanie przecinka
		T=float(T)						#zaokraglanie
		tool=linie[a] 
		blok='T%0.f M06\nH%0.f\n' %(T,T) 
		print blok
		
		zapis = open(cel,'a') 
		zapis.write(blok) 
		zapis.close() 
		
		
		return
		
#****************************************************************
	#poszukiwanie obrotow
	test=linie[a].find('SPINDL') 
	if test != -1: 
		tool=linie[a].split() 			#podzial linii na slowa
		if tool[2].replace(',','')=='RPM': 
			S=tool[3].replace(',','') 		#kasowanie przecinka
			S=float(S)						#zaokraglanie
			blok='S%0.f M03\n' %S
		if tool[2].replace(',','')=='OFF': 
			blok='M05\n'
		print blok
		
		zapis = open(cel,'a') 
		zapis.write(blok) 
		zapis.close() 
		
		
		return
		
#*********************************************************************
	#poszukiwanie konca
	test=linie[a].find('FINI') 
	if test != -1: 
		blok='M30\n'
		print blok
		
		zapis = open(cel,'a') 
		zapis.write(blok) 
		zapis.close() 
		
		
		return

		blok=''
for i in range(dlug): 
	analizuj(linie,i) 
	


print 'Czas dzialania programu %f %s' %(time.time()-czas, 'sekund') 

Plik clfile:

Kod: Zaznacz cały

$$*          Pro/CLfile  Version Wildfire 5.0 - M050
$$-> MFGNO / POST
PARTNO / POST
$$-> FEATNO / 97
MACHIN / UNCX01, 1
$$-> CUTCOM_GEOMETRY_TYPE / OUTPUT_ON_CENTER
UNITS / MM
LOADTL / 1
$$-> CUTTER / 20.000000
$$-> CSYS / 1.0000000000, 0.0000000000, 0.0000000000, 0.0000000000,  $
            0.0000000000, 1.0000000000, 0.0000000000, 0.0000000000,  $
            0.0000000000, 0.0000000000, 1.0000000000, 0.0000000000
SPINDL / RPM, 8000.000000,  CLW
RAPID 
GOTO / 0.0000000000, 0.0000000000, 200.0000000000
RAPID 
GOTO / 0.0000000000, 0.0000000000, 2.0000000000
FEDRAT / 1000.000000,  MMPM
GOTO / 0.0000000000, 0.0000000000, -200.0000000000
GOTO / -45.0000000000, -60.0000000000, -200.0000000000
CIRCLE / -45.0000000000, -30.0000000000, -200.0000000000,  $
0.0000000000, 0.0000000000, -1.0000000000,  30.0000000000
GOTO / -75.0000000000, -30.0000000000, -200.0000000000
GOTO / 0.0000000000, 0.0000000000, -200.0000000000
GOTO / 0.0000000000, 0.0000000000, 200.0000000000
SPINDL / OFF
$$-> END / 
FINI 
Gotowy plik NC:

Kod: Zaznacz cały

o0005
(PROGRAM TESTOWY) 
(POSTPROCESOR PYTHON 2.7.0) 
(AUTOR KD) 
(VER1 1.03.2013) 
(FUNKCJE PRZYGOTOWAWCZE) 
G54 G90 G40
(CAM) 
T1 M06
H1
S8000 M03
G00X0.000Y0.000Z200.000
G00Z2.000
F1000
G01Z-200.000
G01X-45.000Y-60.000
G02X-75.000Y-30.000I-45.000J-30.000K-200.000
G01X0.000Y0.000
G01Z200.000
M05
M30

ODPOWIEDZ Poprzedni tematNastępny temat

Wróć do „Software”