Servo servo_x; // crea el objeto servo Servo servo_y; // crea el objeto servo Servo servo_z; const int pot_x = A0; const int pot_y = A1; const int pot_z = A2; int pos_x; //Variables lectura int pos_y; int pos_z;
const int led = 3;
int paro = 90; //valor paro servo int margen_sup = 55;//valores medios 52,53 int margen_inf = 45; //########################## //SETUP#####################
void setup() { Serial.begin(9600); servo_x.attach(9); // vincula el servo al pin digital 9 servo_y.attach(10); servo_z.attach(11); pinMode(led , OUTPUT); }
void loop() {
pos_x = map(analogRead(pot_x), 0, 1023, 0, 100); // lee entrada analogica y trans a % pos_y = map(analogRead(pot_y), 0, 1023, 0, 100); pos_z = map(analogRead(pot_z), 0, 1023, 0, 100);
Last year I built a DIY
tissue processor based on Arduino
This
device helps to dehydrate samples dipping them into increasing alcoholic
baths. Despite its construction was a rewarding challenge for me and I
am proud of this device, I think it is excessively complex. Due to that
I don't see it like a reliable machine.
So I am going to build a
second version based more in mechanics than in electronics. I will use
mechanisms like the four bar arm linkage, a cams system and a Geneva
wheel.
So I am going to build a second version replacing motors
and sensor for more mechanical systems like a four bar arm linkage, cams
systems and a Geneva wheel. That mechanisms would make this new tissue
processor much more reliable than the previous one because it will need
very few motors and sensors.
Auto apuntes
-(05/12/2018). Los siguientes pasos serían:
Mejorar el diseño de la Rueda de Ginebra, utilizando software CAD y hacer más pruebas en madera contrachapada.
Hacer pruebas de material (metacrilato) y de anclaje de las ruedas a una base.
Redimensionar el diseño para hacerlo los más pequeño posible (tamaño de un libro grande). La idea es que pueda guardarse en una estantería. Este punto es más importante de lo que parece para la utilidad práctica del procesador (de nada servirá si se ha de guardar en un almacén inaccesible)
For this project I use a hard disk motor. This motor is brushless, so it produces little friction and can reach higher speeds than standard motors. Furthermore, it is very easy to recycle one from an old hard disk.
I make the centrifuge enclosure with layers of Wood. I carved out different shapes to make space for the electronic components inside, as shown in the picture.
The centrifuge will be controlled by an Arduino micro controller. I will use an infrared sensor to count how fast the motor spins.
I have an old lab centrifuge which I bought in a second hand market. I put a tachometer, based also on an arduino, into that apparatus. Then, I realized that the centrifuge speed tended to change progressively. Its speed was unstable.
In this mini centrifuge, the arduino will hopefully regulate the engine speed if that differs from the speed set by the arduino. I use a special electronic component: "Electronic Speed Control", or ESC, which is used to control brushless drone or helicopter motors, too. That device allows the arduino to control the motor easily.
Using a little screen and three buttons, it will be possible to program the speed and time of working of the centrifuge.
// Aqui se configuran los pines asignados a la pantalla del PCF8574 LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); //Pines: SCL ->A0, SDA ->A1. Son estandart.
void setup() { Serial.begin(9600); attachInterrupt(0,isr,RISING); //para poner en setup ¿?¿? 0 es pin 2, 1 es pin 3. servoBrazo.write(0);//emieza con motor apagado
lcd.begin(16, 2);// Indica LCD 16x2
pinMode(bot_blue, INPUT); //BOTONES pinMode(bot_up, INPUT); pinMode(bot_down , INPUT); servoBrazo.attach(9);//donde va el motor
for(int i = 0; i< 3; i++)//3 PARPADEOS DE LUZ DE PANTALLA { lcd.backlight(); delay(150); lcd.noBacklight(); delay(150); tone(buzzer, 4800, 80);//frecuencia, milisegundos } lcd.backlight(); delay(400); // Mover el cursor a la primera posición de la pantalla (0, 0) lcd.setCursor ( 0, 0 ); lcd.print("---CENTRIFUGA---"); // Mover el cursor a la segunda linea (1) primera columna lcd.setCursor ( 0, 1 ); // Imprimir otra cadena en esta posicion lcd.print("Pulsa Boton Azul");
int autoajuste = 0; //contador para autoajuste int velo_ini; //Velocidad mapeada de variable revol, preguntada antes int ajuste; //Variable que usara en servo()
velo_ini = map(revol, 0, 10000, 0,9); //mapeo las revoluciones introducidas //iniciamos el motor a una velocidad de servo
switch (velo_ini) //+++pendiente ajuste empirico de valores+++ { case 0: //0-1000 ajuste = 80; servoBrazo.write(ajuste); break;
case 1://1000-2000 ajuste = 90; servoBrazo.write(ajuste); break;
case 2://2000-3000 ajuste = 100; servoBrazo.write(ajuste); break;
case 3://3000-4000 ajuste = 110; servoBrazo.write(ajuste); break;
case 4://4000-5000 ajuste = 120; servoBrazo.write(ajuste); break;
case 5://5000-6000 ajuste = 130; servoBrazo.write(ajuste); break;
case 6://6000-7000 ajuste = 140; servoBrazo.write(ajuste); break;
case 7://7000-8000 ajuste = 150; servoBrazo.write(ajuste); break;
case 8://8000-9000 ajuste = 160; servoBrazo.write(ajuste); break;
case 9://9000-10000 ajuste = 170; servoBrazo.write(ajuste); break; }//fin de switch---------
delay(300); //este tiempo es el que cuenta la interrupcion detachInterrupt(0); //anula la interrupcion timex = millis()-oldtime; rpm2=(rev/timex)*60000; //da las revoluciones por minuto. De milisegundos a minuto
rpm2=rpm2/2.8; //ajuste empirico
oldtime=millis(); //pone tiempo a 0 rev=0; //pone revoluciones a 0
attachInterrupt(0,isr,RISING); //Volvemos a activar la interrupcción
delay(300); //este tiempo es el que cuenta la interrupcion detachInterrupt(0); //anula la interrupcion timex = millis()-oldtime; rpm2=(rev/timex)*60000; //da las revoluciones por minuto. De milisegundos a minuto
rpm2=rpm2/2.8; //ajuste empirico
oldtime=millis(); //pone tiempo a 0 rev=0; //pone revoluciones a 0
attachInterrupt(0,isr,RISING); //Volvemos a activar la interrupcción
//....fin tacometro---<
servoBrazo.write(ajuste);//Envia dato a motor
//--autoajuste--- //Ajusta rpm real con el programado
int histeresis = 50; autoajuste++; if (autoajuste > 4)//se autoajuta cada x bucles { autoajuste=0; if (rpm2 < (revol - histeresis)){ajuste = ajuste + 1;} if (rpm2 > (revol + histeresis)){ajuste = ajuste - 1;} if (ajuste >180){ajuste = 180;} }
//--fin autoajuste--
// VERIFICACIONES ++++++++++ Serial.print("Revol: ");//verificamos dato en serial para ajuste--------- Serial.print(revol); Serial.print(". ajuste mapeado: "); Serial.print(ajuste); Serial.print(". RPM: "); Serial.println(rpm2);
He estado trasteando con un programa de CAD (computer-aided design), tal vez les suene el famoso AUTOCAD. Se trata programas de dibujo industrial o arquitectónico.
Esta es la primera vez que hago algo con uno. He utilizado el LibreCAD para rediseñar el carrusel del procesador de tejidos que tengo entre manos.
En vez de "dibujar" he preferido indicarle al "CAD" los comandos para que fuera más preciso. Sin embargo, tienes que saber los puntos donde le vas a decir que dibuje lo que sea. Ej: círculo con centro en (0,0) y radio 15.
El carrusel tiene 12 agujeros, la única dificultat es la de hallar los centros para los agujeros que no estan sobre los ejes Y o X. Para ello téngase en cuenta la siguiente imagen.
Los agujeros iran a 30º y 60º, por lo que por trigonometria \(radio*sen(alfa)=Y\) y \(radio*cos(alfa)=X\). Para trazar la línea que corta el círculito (para poder taladrar el agujero) se ha procedido encontrando dos puntos alineados con el centro de este, con el mismo método.
Bueno, si esto es raro de entender, es porque esta raro explicado. Solo son apuntes. En el fondo (y en la superficie) lo que quiero es poner el dibujito de mi plano y ya está. Pues eso es todo. Arte, arte... esto si que es arte:
Probar el servo, que ha de ir a un Pin PWM. Hacía cosas raras al iniciarse,
tal vez debiera colocarle un relé.
Terminar el menú que ha de constar de las siguientes secciones:
Preprogramas: Son las rutinas básicas como:
Baños de deshidratación
Deshidratación y xilol
Deshidratación, xilol y parafina
Solo parafina,
Etc.
Programación
Le especificamos que ha de hacer
Utilidades
Permite mover los motores independientes y otras acciones. Para hacer pruebas
sin tener que modificar el software de la máquina.
Hacer la caja. En
principio sería de aluminio y metacrilato. Se compondría de dos partes,
inferior y superior. La parte de arriba se quitaría como una tapa dejando al descubierto
el brazo con el carrusel y los
controles. El brazo y el carrusel serían fácilmente extraíbles de la carcasa.
Perfeccionar el sistema
de “encoder” óptico. Tendría que hacer un optoacoplador especial a partir de
dos de ellos y usar solo un disco de posición en vez de dos. El sensor tendrá
que ser móvil y ajustable con palomilla.
Pruebas con el porta-cables.
Una vez se tenga la caja hay que ver cómo encaja todo.
