meccanicAPP.

Generatori di Tolleranza.

interferenza-gioco-albero Interferenza, Gioco, Incerto? (Albero_base) tolleranze h7 10mm diametro h Tolleranze albero

Generatori di GCODE.

Spianatura

Generatori di avanzamento.

velocita di taglio G94 avanzamento (mm/min) FRESA velocita di taglio G95 avanzamento (mm/giro) TORNIO

Generatori di Velocità.

velocita di taglio G96 velocità di taglio (metri/minuto) TORNIO velocita mandrino giri al minuto G97 velocità mandrino (giri/minuto) FRESA

Generatori di Elettricità (legge OHM).

velocita di taglio VOLT (tensione elettrica) velocita mandrino giri al minuto AMPERE (intensità elettrica) velocita mandrino giri al minuto OHM (resistenza elettrica)
ERRORE, RIPROVA!!!
qualcosa è andato storto, riprova!

Vuoi più informazioni?

⚙️ Open Source Web App for CNC, which include 5+ Mechanical Calculators and some GCODE generators!

- funzionalità (meccanicapp):

website: https://meccanicapp.vercel.app

Github: https://github.com/Laaouatni/meccanicAPP

table of contents

Funzionalità MeccanicAPP

1. Generare GCODE automaticamente

esempio GCODE generato da "meccanicapp"

      G90 // programmazione ASSOLUTA
        G54 // Origine Zero Pezzo
        T10 // Utensile
        M6 // Prendere Utensile
        S1592 M3 // Velocità Fresa (ancora da Sviluppare G96/G97)
        G0 X-12 Y-2 Z0 // Spostamento Rapido
        F637 // Avanzamento Fresa (ancora da Sviluppare G94/G95)
        G1 X22 Y-2 Z0 // Spostamento Lineare
        G1 X22 Y-14 Z0 // Spostamento Lineare
        G1 X-12 Y-14 Z0 // Spostamento Lineare
        G1 X-12 Y-14 Z2 // Distanza di Sicurezza 2MM
        G0 X-12 Y-14 Z20 // Ritornare in posizione con una distanza di sicurezza maggiore
        M30 // Spegnimento Programma

come funziona?

clicca il link per vedere come funziona

2. Trovare le misure delle tolleranze “h”

esempi:

      {
        max: 0,
        min: -0.018
        }
    

      {
        max: 0,
        min: -0.004
        }
    

      {
        max: 0,
        min: -0.250
        }

il risultato è calcolato in diretta:
cioè appena viene modificato un value="" dei <input>, il risultato velocemente in meno di 1 secondo.

3. Tolleranze Albero-Foro -> quale Tipologia? (Calcolatrice)

esempi:

FORO MAX_FORO MIN_FORO
0.021 0.000
ALBERO max_albero min_albero
0.015 0.010
FORO MAX_FORO MIN_FORO
0.021 0.000
ALBERO max_albero min_albero
0.028 0.015
FORO MAX_FORO MIN_FORO
0.020 0.010
ALBERO max_albero min_albero
0.05 0.000

ecc…,

in modo semplice:
1. inserisci i dati
2. clicca buttone “calcola”

4. Generatore di avanzamento


5. velocità rotazione


come funziona?

// salvare i punti precedenti
        function setLastPosVar(x, y, z) {
        previusX = x;
        previusY = y;
        previusZ = z;

        options.previusX = previusX;
        options.previusY = previusY;
        options.previusZ = previusZ;
        }

        function checkSolveXYZ(x, y, z) {
        // se un valore è nullo, verrà scritto 0,
        // altrimenti si scriverà il valore precedente
        x == "" || previusX == "" ? x = 0 : x = previusX;
        y == "" || previusY == "" ? y = 0 : y = previusY;
        z == "" || previusZ == "" ? z = 0 : z = previusZ;

        return { x, y, z };
        }
      
function G0(x, y, z) {
        // risolvere prima i possibili errori nei parametri
        let XYZ = checkSolveXYZ(x, y, z);

        // inserire la linea di codice
        gcode.push(`G0 X${XYZ.x % 1 == 0 ? XYZ.x : XYZ.x.toFixed(1)} Y${XYZ.y % 1 == 0 ? XYZy : XYZ.y.toFixed(1)}
        Z${XYZ.z % 1 == 0 ? XYZ.z : XYZ.z.toFixed(1)}`);

        // salvare l'ultima posizione
        setLastPosVar(XYZ.x, XYZ.y, XYZ.z);
        }
      
function G1(x, y, z) {
        // risolvere prima i possibili errori nei parametri
        let XYZ = checkSolveXYZ(x, y, z);

        // inserire la linea di codice
        gcode.push(`G1 X${XYZ.x % 1 == 0 ? XYZ.x : XYZ.x.toFixed(1)} Y${XYZ.y % 1 == 0 ? XYZy : XYZ.y.toFixed(1)}
        Z${XYZ.z % 1 == 0 ? XYZ.z : XYZ.z.toFixed(1)}`);

        // salvare l'ultima posizione
        setLastPosVar(XYZ.x, XYZ.y, XYZ.z);
        }
      
function spianaturaGenerator(options) {
        let isDestra = false; // iniziare da sinistra

        // calcolare il numero di spianatura necessarie
        let lineeY_totali = Math.floor(options.Y0 / options.diamPercMisura);

        // Altezza da spianare
        let lineeZ_totali = options.Z0;


        for (...) { // cliclo ripetizione Z spianatura
        // G54 punto di origine X (coordinata)
        let startPointX = 0 - (options.D / 2) - 2;
        // G54 punto di origine Y (coordinata)
        let startPointY = (options.D / 2) - options.diamPercMisura;

        previusZ = lineeZ_completed; // numero Z spianture mancanti da eseguire

        G0(startPointX, startPointY, previusZ); // distanza di sicurezza

        for (...) { // cliclo ripetizione Y spianatura
        if (lineeY_completed == 1) {
        // inserimento di F nel programma
        gcode.push(`F${options.feed}`);
        }

        // se utensile è a destra si mouverà a sinistra
        // se utensile è a sinistra si mouverà a destra
        isDestra ? GtoSinistra() : GtoDestra();

        if (lineeY_completed == lineeY_totali) {
        lastGspianatura(options, isDestra);
        }
        }
        }

        // funzione per andare a destra
        function GtoDestra(options) {
        G1(options.X0 + 2, "", ""); // X è uguale a "lunghezza_totale +2mm"
        isDestra = true; // siamo a destra attualmente, dopo lalavorazione G1
        GtoDown(); // andare sotto
        }

        // funzione per andare a sinistra
        function GtoSinistra() {
        G1(0 - 2, "", ""); // 2mm fouri a sinistra (0 = punto origine)
        isDestra = false; // siamo a sinistra attualmente, dopo lalavorazione G1
        GtoDown(); // andare sotto
        }

        // funzione per andare giù del 60%
        function GtoDown() {
        G1("", previusY - diamPercMisura, ""); // andiamo sotto del 60%
        }

        // ultima passata, con sicurezza
        function lastGspianatura(options, isDestra) {
        let formulaDestra = options.X0 + (options.diametro / 2) + 2;
        let formulaSinistra = 0 - (options.diametro / 2) - 2;

        if (isDestra) {
        // VAI A SINISTRA
        G1(formulaSinistra, "", "");
        Zsicurezza();
        isDestra = false;
        } else {
        // VAI A DESTRA
        G1(formulaDestra, "", "");
        Zsicurezza();
        isDestra = true;
        }

        // distanza di sicurezza in Z
        function Zsicurezza(isDestra) {
        G1("", "", previusZ + 2);
        G0("", "", 0 + 20);
        }
        }
        }
// inserire codice sullo schermo
        function displayGcode(options, pezzoGrezzo) {
        document.querySelector("#output-gcode").textContent = "";
        let gcodeArray = createGcodeProgram(options, pezzoGrezzo); // array completo contutti i codici generati

        // animazione per ognuna linea di codice
        gcodeArray.forEach((Gline, index) => {
        setTimeout(() => {
        addLine(Gline, index, gcodeArray) // aggiungere una linea di codice generatada un'array
        }, index * 1000 / 30); // 1 secondo diviso per numero volte che vogliamo
        });
        }
      
function addLine(Gline, index, gcodeArray) {
        ...

        GnumLine.textContent = `N${index + 1}`; // numero linea

        ...
        }