Que programa usar para modelar objetos en 3D


Programas de diseño 3D para principiantes

En este post veremos 2 programas online y sencillos para que se inicie en el diseño 3D sin tener que descargar nada. ¡No tiene excusa!, Pues empecemos por uno de los mas populares quizás por interfaz y porque detrás esta Autodesk

Tinkercad

Uno de los programas más sencillos de diseño 3D.

No se deje engañar por los colores y el aspecto infantil, puede diseñar piezas útiles para su vida diaria en las primeras horas jugueteando con Tinkercad.

Tinkercad es el software que recomendamos a los usuarios que están empezando, si no quiere usar Fusion 360 o OpenScad.

Onshape

Onshape, diseño paramétrico online, sin descargar nada, potente y muy sencillo.

Tiene un plan gratis que le permite hacer sus primeras pruebas con el diseño 3D mecánico online.

Autocad es uno de los programas de CAD, o diseño por ordenador, más populares de todos los tiempos.

Sin embargo, en los últimos años multitud de programas han aparecido para quitarle el trono, proponiendo alternativas al diseño paramétrico tanto en 3D como en 2D.

Puntos clave de Autocad

Para saber cuáles son las mejores alternativas a Autocad primero tendremos que conocer sus puntos clave.

Funcionalidades

Este software, propiedad de la marca Autodesk es una suite muy completa de CAD, tanto 2D como 3D. Posee características únicas creadas a medida para las tareas más comunes de arquitectos e ingenieros como por ejemplo:

  • Diseño de circuitos eléctrico
  • Mapeado topología
  • Rasterizado
  • Diseño de sistemas de ventilación o irrigación
  • Mecánica robótica

Además, es un software pensado para su uso de manera deslocalizada, por lo que muchas de sus funciones están disponibles a través de su versión web para que puedas trabajar desde cualquier sitio.

Precio

En cuanto a su coste, Autocad es un software que sigue el modelo de suscripción que puede ser mensual, anual o trianual. En función de la suscripción escogida el precio varía entre 279€/mes y 168€/mes, por lo que no es un software barato.

Fusion 360: nuestro favorito

Ya hemos tratado en este blog Fusion 360, recalcando cómo y por qué podemos considerar el mejor software para comenzar en el mundo del diseño 3D paramétrico. Pero Fusion no se queda ahí, siendo además de un muy buen programa para iniciarse, una excelente alternativa profesional.

Autocad vs fusion 360

En muchísimos casos podrá llevar a cabo tu proyecto usando tanto Autocad como Fusion 360, o incluso ambos ya que, al ser ambos programas de Autodesk, se pueden compartir archivos de manera sencilla. Las diferencias radican en las funcionalidades y el precio de ambos programas de CAD.

Funcionalidades

Autocad y Fusion 360 comparten muchas funcionalidades, pero hay varias exclusivas de cada uno. Mientras que Autocad tiene muchas funcionalidades orientadas a profesiones como la arquitectura, Fusion 360 está centrado de manera casi exclusiva en el diseño mecánico, por lo que es un programa muy apropiado para ingenieros.

Algunas de las principales diferencias son las siguientes:

Fusion 360 vs Autocad

Como puede ver Fusion 360 supera ampliamente a Autocad en algunos apartados, aunque no es un programa con tanto recorrido en arquitectura.

Precio

Fusion 360 tiene también un modelo de suscripción, aunque es muy posible que pueda obtenerlo de manera gratuita. Aquí dejamos una tabla con los precios para que puedas hacerte una idea:

Sketchup, la alternativa para arquitectos

Sketchup, el programa de google, es uno de esos programas que ha sido muy popular durante mucho tiempo. Actualmente ha quedado un poco desplazado por Fusion 360, pero aún así tiene algunos casos de uso donde es interesante.

Funcionalidades

Sketchup tiene algunas funcionalidades interesantes:

  • Está basado en una aplicación web, por lo que podremos modelar en cualquier sitio y almacenar nuestros modelos en la nube.
  • Las versiones de pago incluyen acceso al repositorio de modelos 3D conocido como 3D Warehouse. En él podremos encontrar un montón de modelos de casi cualquier temática para incorporarlos en nuestros proyectos.
  • Tiene disponible un enorme abanico de plugins en el repositorio conocido como Extension warehouse.

Precio

Sketchup tiene su versión gratuita, la cual está limitada en ciertos aspectos pero sigue siendo bastante funcional. Para usuarios domésticos más avanzados o usuarios profesionales, disponemos de varias alternativas de suscripción, cada una con ventajas añadidas sobre la versión gratuita.

Para usuarios domésticos avanzados tenemos los siguientes planes, que van desde el gratuito hasta el pro, con un coste de 299 dólares al año.

Para los usuarios profesionales tenemos otros planes de precio diferentes además de funcionalidades extra que no están disponibles en ninguno de los planes para usuarios domésticos.

Entre estas funcionalidades se incluyen cosas la capacidad de usar su módulo de «diseño basado en rendimiento», único de Sketchup.

Además también ofrecen planes para estudiantes con precios reducidos pero todas las funcionalidades de los modelos más profesionales.

SolidWorks, la opción más profesional

SolidWorks es un programa muy popular, orientado total y absolutamente al mercado profesional. Tanto sus prestaciones como su precio lo enmarcan claramente en la categoría de software para usuarios profesionales que necesitan diseñar modelos muy complejos y utilizar funciones avanzadas.

Funcionalidades

SolidWorks es un programa enorme, con una cantidad de funcionalidades totalmente inabarcable en un artículo como este. Para que pueda hacerse una idea de por qué elegirlo, vamos a comentar algunas de sus funcionalidades más destacadas y que más valor aportan.

  • Diseño generativo: Una nueva manera de diseñar, muy diferente a la experiencia clásica de diseño paramétrico CAD pero mucho más potente en ciertas circunstancias.
  • Oferta modular: SolidWorks es un software profesional bastante caro. Al estar orientado al mercado del diseño industrial, ofrece diversos módulos para cubrir necesidades concretas de ciertos sectores de este mercado, por lo que podremos adquirir sólo aquellos módulos que nos interesen para ajustar el precio.
  • Diseño de PCB: Este programa ofrece un módulo bastante completo de diseño de equipos electrónicos desde cero, incluyendo la PCB y la electrónica y también todo el resto de partes estructurales.
  • Simulación: SolidWorks ofrece un módulo de simulaciones, donde podremos simular ciertas condiciones en los diseños que hagamos para comprobar su viabilidad.
  • Manejo de modelos 3D importados: Otros programas de diseño CAD como Autocad o Fusion 360 no se llevan muy bien con diseños importados en formatos comunes como STL u OBJ, teniendo muchas dificultades para editarlos e incorporarlos en nuestros modelos. SolidWorks maneja este aspecto bastante mejor, por lo que es una excelente alternativa si vas a trabajar reutilizando modelos 3D.

Precio

SolidWorks es bastante caro !tan caro que hace que Autocad parezca barato!. Es por esto que no es un software pensado para makers, por muy pro que sean. Por el contrario, está pensado para dar un servicio excelente en industrias muy exigentes como la de la mecánica, la automoción o la armamentística.

En cuanto al precio, depende mucho de qué módulos escojamos, pero parte de unos 10.000 euros por una licencia monopuesto, pudiendo elevarse muchísimo en función de los módulos que escojamos.

Otras alternativas a Autocad

Nos hemos dejado unas cuantas opciones en el tintero, ya que no queremos hacerte pesada la lectura de estos artículos y por eso hemos escogido nuestros favoritos.

Algunas opciones adicionales que pueden ser interesantes son las siguientes:

  • Openscad: Un programa para diseñar en 3D utilizando programación, el cual hemos tratado muchísimas ocasiones en este blog. Extremadamente potente para profesionales con habilidades de programación que quieran aproximarse al diseño 3D. Es gratuito y de código libre
  • Freecad: Este programa, totalmente gratuito y de código libre, fue muy popular hace años. Ahora está un poco menos de moda pero sigue siendo una opción muy válida para el diseño mecánico. Permite ejecutar scripts en python para añadir funcionalidades.
  • SolidEdge: Una alternativa por parte de Siemens que incorpora muchas de las funciones de Autocad tanto para diseño 3D como para diseño 2D. Además incluye funcionalidades de softwares mucho más caros como el diseño generativo los módulos de simulación. Su precio parte de los 75 dólares al mes.

Diseño en 3D de un contenedor para proyectos electrónicos


Para el modelado 3D, Tinkercad debería ayudarnos ante cualquier diseño inicial de una manera  más sencilla con el proceso de modelado 3D, tanto es así, que incluso los modeladores experimentados lo hacen  explorando las formas de Tinkercad,  pues curiosamente, una herramienta “simple” como Tinkercad puede conducir a formas complejas. Lógicamente detrás de Tinkercad y de cualquier otro programa de modelado 3D está el código, de modo que a medida que arrastra y suelta formas, los algoritmos complejos están trabajando para calcular cómo aparecerán los gráficos en la pantalla, asi que  también debería ser posible crear figuras geométricas directamente mediante código.

Para aquellos que tienen curiosidad sobre el código, OpenSCAD es una herramienta gratuita de software para explorar el modelado 3d desde esa perspectiva,  resultando  mucho mas eficiente   y concisa   en el  proceso de diseño que cualquier otra herramienta gráfica como por ejemplo Tinkercad.

A diferencia de Tinkercad, OpenSCAD no es una aplicación basada en la web de  modo que si esta interesado  en la herramienta   tendrá que descargarla ( OpenSCAD se puede descargar gartis en http://www.openscad.org y está disponible para Windows, Mac OS X y Linux)   e instalarla en su PC para usarla.

La interfaz OpenSCAD es sencilla  en comparación con Tinkercad ,constando  de sólo tres ventanas, siendo la ventana de la izquierda un editor de texto utilizado para ingresar el código.

panel

Con OpenSCAD está diseñando código,pero no se preocupe: escribir código con Open SCAD es similar al uso de HTML en una página web, siendo el código para crear objetos  autoexplicativo  (por ejemplo, el comando del cubo crea cubos, el comando de esfera crea esferas y el comando del cilindro crea cilindros, etc).

Probablemente haya alrededor de 60 comandos en OpenSCAD, muchos de los cuales  permitirán manipular la geometría ,  como por ejemplo mover, rotar, escalar y usar operaciones booleanas para combinar objetos, pero no se preocupe porque  para modelar  la mayoría de la piezas solo necesitaran  unos pocos comandos como  son union , difference, translate, cylinder o  cube.

Las secuencias de comandos en el lenguaje de OpenSCAD se utilizan para crear modelos en 2D o 3D, veamos a continuacion un ejemplo del diseño de una caja para albergar proyectos electronicos completamente personliazable, para lo cual usaremos el poderoso comando hull () de OpenSCAD y el simple offset () para crear el cuadro de proyecto más fácil de todos.

 Es de destacar que conseguiremos esquinas redondeadas fáciles (sin restas complicadas), aunque en términos de concepto, esto puede no ser «fácil», es fácil en el sentido de que es conciso y demuestra algunos conceptos eficientes.

Conceptos utilizados:

  • Subsistema 2d
    • cuadrado : sqare()
    • compensar: offset()
  • Sistema 3d
    • cáscara: hull()
    • extrusión_lineal:lineal_extrude ()
    • rotate_extrude: rotate_extrude ()
    • escala: scale()
    • redimensionar : resize()
  • Módulos
  • Comprensión de listas

Empiece con las paredes

Comenzamos haciendo las paredes usando el subsistema 2d. Pero antes de hacer esto, agreguemos algunas variables globales que usaremos a lo largo del tutorial. Añádalos a su ide de OpenSCAD. (Los comentarios son para el personalizador)

BOX_W = 80; // Ancho de caja
BOX_L = 120; // Longitud de la caja
BOX_H = 12; // Altura de la caja
SCREW_SIZE = 3; // Tamaño de tornillo en mm
CORNER_RADIUS = 3; // Radio de las esquinas
WALL_THICKNESS = 2; // Espesor de la pared

Luego agregue un cuadrado () después de las variables usando el Ancho y Largo

sqare ([BOX_W, BOX_L]);

Redondearemos las esquinas con el comando offset (), colocaremos este offset () antes del cuadrado ().

offset (r = CORNER_RADIUS) sqare ([BOX_W, BOX_L]);

A continuación, eliminaremos la parte interior, con diferencia () y otro cuadrado (). Restaremos el grosor de la pared para eliminar todo menos la pared.

difference(){
    offset (r = CORNER_RADIUS) sqare ([BOX_W, BOX_L]);
    square ([BOX_W-WALL_THICKNESS, BOX_L-WALL_THICKNESS]);
}

Hay dos cosas que tendremos que ajustar. Primero, la pared interior no está bien posicionada, así que centremos ambos cuadrados

difference(){
    offset(r=CORNER_RADIUS) square( [BOX_W, BOX_L] );
    square( [BOX_W-WALL_THICKNESS, BOX_L-WALL_THICKNESS] );
}

Ahora usemos offset () para agregar un radio interno. Para calcular el radio interior restaremos el espesor de la pared del radio de la esquina.

difference(){
    offset(r=CORNER_RADIUS) 
        square( [BOX_W, BOX_L], center=true );
    offset( r= CORNER_RADIUS - WALL_THICKNESS )
        square( [BOX_W-WALL_THICKNESS, BOX_L-WALL_THICKNESS], center=true );
}

Por último, para la pared, solo necesitamos darle altura. Podemos usar lienar_extrude para dar la altura de la caja. Agregue un linear_extrude () usando BOX_H para el parámetro, en la línea arriba de la diferencia.

linear_extrude( BOX_H )

Añadiendo la parte inferior.

Queremos un fondo que tenga bordes redondeados. Aquí es donde entra hull () podemos usar hull () con cuatro esferas () para crear un rectángulo con bordes redondeados. Queremos agregar cuatro, usamos la comprensión de listas para no tener interminables traducciones ().

Primero crearemos una lista de coordenadas.

coordinates = [[0,0], [0,120], [80,120], [80,0]];

Luego usaremos la variable de coordenadas en un bucle for para iterar usando un bucle for.

for (i = coordinates)

Cada vez que pasemos por el bucle agregaremos una esfera y la trasladaremos por las coordenadas. Aquí está el código completo para agregar:

coordinates = [ [0,0],[0,BOX_L],[BOX_W,BOX_L],[BOX_W,0] ];
for (i = coordinates)
    translate(i) sphere(CORNER_RADIUS);

Ahora pongamos todo el objeto en un casco () Observe cómo no necesita agregar corchetes {} ya que el bucle for es el hijo directo del casco (). Como resultado, el casco funciona con los resultados de for ()

coordinates = [ [0,0],[0,BOX_L],[BOX_W,BOX_L],[BOX_W,0] ];
hull()
   for (i = coordinates)
      translate(i) sphere(CORNER_RADIUS);

Necesitaremos trasladar el casco resultante para que quede debajo de la pared. Agregue una traducción sobre el casco () usando la mitad del ancho de la caja y la mitad de la longitud de la caja. Anotemos también $ fn = 25; en la parte superior de nuestro código para que podamos ver las cosas un poco mejor.

translate ([-BOX_W / 2, -BOX_L / 2])

Podemos agregar cilindros para tornillos de la misma manera que hicimos las cuatro esferas. Ya tenemos las coordenadas de la parte inferior, así que podemos usarlas. pero necesitamos moverlos en algunos.

for (i = coordinates)
   translate(i) 
      difference(){
          cylinder(h=BOX_H,r=CORNER_RADIUS);
          cylinder(h=BOX_H,r=CORNER_RADIUS - SCREW_SIZE);       
}

Usé rend (f6) para que podamos ver los agujeros.

A continuación, debemos mover las publicaciones para que coincidan con el cuadro. coloque un translate () delante del bucle for (). Esto moverá todo el «conjunto» a su posición.

traslate ([-BOX_W / 2, -BOX_L / 2])

Eso nos da cilindros, pero están demasiado cerca del borde, podríamos crear un segundo conjunto de coordenadas para el segundo bucle, pero se vuelve bastante complicado. Se vería así:

coordinates = [[0 + 10,0 + 10], [0 + 10, BOX_L = -10], [BOX_W-10, BOX_L-10], [BOX_W-10,0 + 10]];

En su lugar, usemos resize () y scale () para hacer lo mismo.

Primero use un resize () para establecer las cuatro publicaciones en su posición final. Los valores serán el ancho y el largo entre el centro de las publicaciones. Agregue resize () delante del bucle for () para los cilindros. Para empezar, usaremos valores fijos.

resize ([75,110,0])

Puede notar que las publicaciones se mueven pero se hacen más pequeñas (es un pequeño cambio). Podemos usar la escala para restablecer las publicaciones a su tamaño original. Agregue el comando de escala justo antes de la diferencia para los cilindros.

scale ([BOX_W / 75, BOX_L / 110])

Ahora las publicaciones tienen el tamaño original.

Aquí hay un antes y un después. Realmente es difícil ver la diferencia, pero está ahí.

Creemos una variable y veamos el bloque de código completo. Agregar POST_OFFSET = 10; al principio de su código. Tendremos que restar eso en resize () y scale () del ancho y alto del cuadro, usaremos intermediarios para que sea más fácil de entender. También necesitamos dividir SCREW_SiZE por 2 para que represente un radio, no el diámetro dado. Veamos el código:

POST_OFFSET=10;

... otro código ...

p_w = BOX_W - POST_OFFSET;
p_l = BOX_L - POST_OFFSET;

resize([p_w,p_l,0]) // Mueve las publicaciones desde el borde
    translate([-BOX_W/2,-BOX_L/2,0])
       for (i = coordinates)
           translate(i)
           scale([BOX_W/p_w,BOX_L/p_l])
               difference(){
                 cylinder(h=BOX_H,r=CORNER_RADIUS);
                 cylinder(h=BOX_H,r=SCREW_SIZE/2);
               }POST_OFFSET = 10;



¡Eso es todo lo que hay! Hay algunas mejoras que podemos hacer, pero esto funcionará bastante bien por ahora. Aquí está el código final completo para jugar. Algunos cambios importantes que necesitaríamos son:

  • Establecer el suelo (inferior) en WALL_THICKNESS
  • Usando un valor o cálculo separado para el cilindro exterior del poste

Pero tendremos que tener una parte dos para eso ya que esta publicación se está alargando.

Super_Project_Box$fn=25;
BOX_W = 80; // Box Width
BOX_L = 120;// Box Length
BOX_H = 12; // Box Height

SCREW_SIZE = 1.5; // Screw size radius.

CORNER_RADIUS = 3; // Radius of corners
WALL_THICKNESS = 2;// Wall Thickness

POST_OFFSET=10;

linear_extrude( BOX_H )
    difference(){
        offset(r=CORNER_RADIUS) 
            square( [BOX_W, BOX_L], center=true );
        
        offset( r= CORNER_RADIUS - WALL_THICKNESS )
            square( [BOX_W-WALL_THICKNESS, BOX_L-WALL_THICKNESS], center=true );
    }


coordinates = [ [0,0],[0,BOX_L],[BOX_W,BOX_L],[BOX_W,0] ];

translate ( [-BOX_W/2, -BOX_L/2] )
    hull()
    for (i = coordinates)
        translate(i) sphere(CORNER_RADIUS);

p_w = BOX_W - POST_OFFSET;
p_l = BOX_L - POST_OFFSET;

resize([p_w,p_l,0]) // Move the posts in from the edge
    translate([-BOX_W/2,-BOX_L/2,0])
       for (i = coordinates)
           translate(i)
           scale([BOX_W/p_w,BOX_L/p_l])
               difference(){
                 cylinder(h=BOX_H,r=CORNER_RADIUS);
                 cylinder(h=BOX_H,r=SCREW_SIZE/2);
               }

Mas información en en http://www.openscad.info

Simulador de Arduino


En el mundo del modelado 3D, Tinkercad se ha establecido como una valiosa introducción al diseño asistido por computadora (CAD) . Es un programa CAD gratuito e intuitivo basado en la web que cualquiera puede usar. De hecho, si desea comenzar con Tinkercad, incluso tenemos un tutorial para principiantes para que pueda comenzar .

Recientemente, Tinkercad ha introducido algo nuevo: una expansión para incluir circuitos en su capacidad de diseño llamada Tinkercad Circuits. Esto aporta un lado completamente nuevo a Tinkercad, que gira en torno a la simulación de circuitos con Arduino.

Arduino es una plataforma de creación de prototipos electrónicos de código abierto que también vende microcontroladores. Tinkercad Circuits permite a cualquiera crear y programar virtualmente proyectos Arduino sin la necesidad de hardware físico.

En este artículo, le mostraremos cómo programar un Arduino básico en Tinkercad, pero primero, echemos un vistazo más de cerca a las nuevas capacidades que ofrece Tinkercad Circuits.

Vamos a utilizar una herramienta de Autodesk gratuita y en la red: Tinkercad , pues en efecto de servir como una herramienta excelente de diseño en 3d también incluye un editor de componentes electrónicos, y lo que es aun mas interesante : un simulador

Una vez que decida crear un circuito, utilizará el nuevo entorno de Tinkercad Circuits. Puede parecer mucho al principio, pero no se deje intimidar: tenemos toda la información que necesita para tener éxito. Verá rápidamente que esta plataforma creativa es una excelente herramienta de creación de prototipos.

Área de construcción

En el lado derecho de la pantalla, verá un grupo de componentes electrónicos de arrastrar y soltar. Además, puede buscar y filtrar a través de una cantidad impresionante de componentes disponibles: hay de todo, desde LED hasta circuitos integrados (IC), e incluso algunas herramientas de instrumentos.

El área de construcción abierta es donde diseñas su creación. La barra de herramientas superior que comienza a la izquierda le brinda las operaciones generales para rotar, eliminar e incluso tomar notas sobre sus diferentes componentes. Una característica interesante es que, además de exportar y compartir su trabajo, puede descargar la lista de componentes. Esto hace que sea más fácil llevar sus creaciones al mundo real.

Para hacer las cosas fáciles vamos a usar un simple arduino al que conectaremos 4 entradas analógicas, y 5 digitales

Las entradas analógicas las conectaremos a 4 potenciómetros cuyo punto central lo enviaremos a los GPIO simulando asi 4 señales analógicas por lo que conectaremos también estos a 4 instrumentos analógicos para que de este modo podamos comprobar el valor de las salidas.

Las entradas digitales las conectaremos a un conmutador DIP y sus salidas conectaremos también a 4 leds con sus correspondientes resistencias con el fin de poder comprobar de este modo el estado de dichos interruptores.

Por ultimo conectaremos un pulsador y un led que no indica que el circuito esta funcionando,

Mas en detalle este es el esquema del montaje:

El diseño lo p uede descargar desde https://www.tinkercad.com/things/5P9LP1tlS9O-panel-osciloscopio-con-arduino-/

Área de programación

Una vez que tenga un componente programable en su diseño, puede abrir el visor de «Código» haciendo clic en el botón en la parte superior derecha de la barra de herramientas. Actualmente, los únicos dos dispositivos disponibles son el Arduino Uno R3 y el ATTiny. (El ATTiny es un Arduino más limitado y miniaturizado).

El área de programación es un entorno de desarrollo integrado (IDE) simplificado que hace que la programación del Arduino sea muy sencilla. El método predeterminado es a través de bloques de código, que veremos más adelante, y también hay una vista dual para aprender cómo los bloques de código se traducen en código real. Para aquellos que ya están familiarizados con la biblioteca Arduino, incluso hay una vista de texto.

En cuanto al código Arduino, simplemente hay que pulsar en el botón «Código» y justo ahí copiaremos el código de mas abajo ( ojo porque debe ser correcto sintácticamente hablando, porque en caso de que cometamos un error nos dará un error)

Este es el código para probar el montaje:

#define Sel1 7 // el potenciometro  P1 LO conectamos al GPIO7
#define Sel2 8 // el potenciometro  P2 LO conectamos al GPIO8
#define Sel3 9 // el potenciometro  P3 LO conectamos al GPIO9  
#define Sel4 10 //el potenciometro  P4 LO conectamos al GPIO10

#define trigger 3 // el pin al que conectamos el pulsador

int val = 0; //val se emplea para almacenar el estado del boton
int state = 0; // 0 se muestrean las señales de los ADC
int old_val = 0; // almacena el antiguo valor de val

int y1;  //Variable donde se guardara el valor leido del pin A0
int y2;  //Variable donde se guardara el valor leido del pin A1
int y3;  //Variable donde se guardara el valor leido del pin A2
int y4;  //Variable donde se guardara el valor leido del pin A3


void setup() {
  
  Serial.begin(115200);
  pinMode(Sel1,INPUT_PULLUP);
  pinMode(Sel2,INPUT_PULLUP);
  pinMode(Sel3,INPUT_PULLUP);
  pinMode(Sel4,INPUT_PULLUP);

  pinMode(trigger,INPUT_PULLUP);
  Serial.println("Empezando la simulacion");
}

void loop() {

   val = digitalRead(trigger); // lee el estado del Boton
    if ((val == HIGH) && (old_val == LOW)) {  //Detectamos flanco de subida
        state = 1 - state;           //Cambiamos el valor de state de 0 a 1 ó de 1 a 0            
        delay(10);               //pausa de 10ms
    }
    old_val = val; // actualizamos el valor del antiguo estado


  if (!state) {  //si la variable state es 0 escribimos en el serial


        if (!digitalRead(Sel1) && !digitalRead(Sel2)&& !digitalRead(Sel3) && !digitalRead(Sel4)) {
            
            y1 = analogRead(A0);  //Leemos el conversor A1 y guardamos la lectura en sensor1
            Serial.print(y1);      //Imprimimos en el serial el valor de sensor1
            Serial.print(",");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms

            y2 = analogRead(A1);  //Leemos el conversor A1 y guardamos la lectura en sensor1
            Serial.print(y2);      //Imprimimos en el serial el valor de sensor1
            Serial.print(",");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms

            y3 = analogRead(A2);  //Leemos el conversor A1 y guardamos la lectura en sensor1
            Serial.print(y3);      //Imprimimos en el serial el valor de sensor1
            Serial.print(",");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms

            y4 = analogRead(A3);  //Leemos el conversor A1 y guardamos la lectura en sensor1
            Serial.println(y4);      //Imprimimos en el serial el valor de sensor1
            //Serial.println(" ");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms
        }

    
          if (digitalRead(Sel1) && !digitalRead(Sel2)&& digitalRead(Sel3) && digitalRead(Sel4)) {
            
           // y1 = analogRead(A0);  //Leemos el conversor A1 y guardamos la lectura en sensor1
           // Serial.print(y1);      //Imprimimos en el serial el valor de sensor1
            Serial.print("");
            Serial.print(",");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms

            y2 = analogRead(A1);  //Leemos el conversor A1 y guardamos la lectura en sensor1
            Serial.print(y2);      //Imprimimos en el serial el valor de sensor1
            Serial.print(",");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms

           // y3 = analogRead(A2);  //Leemos el conversor A1 y guardamos la lectura en sensor1
          //  Serial.print(y3);      //Imprimimos en el serial el valor de sensor1
            Serial.print("");
            Serial.print(",");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms

            //y4 = analogRead(A3);  //Leemos el conversor A1 y guardamos la lectura en sensor1
           // Serial.println(y4);      //Imprimimos en el serial el valor de sensor1
            Serial.println(" ");          //Imprimimos en el serial , 
            delay(10);                 //Pausa de 10ms
        }
        


    }

}

Solución de problemas:  si su programa no se comporta como se esperaba, verifique su cableado y programación. Asegúrese de que todos los pines estén conectados correctamente y de que cada bloque esté escrito correctamente.

Si todo parece funcionar, ¡enhorabuena! Siempre puede seguir jugando con el código y los diferentes componentes para aprender más sobre cómo funciona todo.