MOSFETEARRRRRR

[Althor]

¿¿¿Alguna noticia sobre el nuevo diseño que incluye control de ráfagas???

Que nuevo diseño, porque hay unos cuantos, xD.
Yo estoy ahora experimentado con un diseño nuevo pero aún está un poco verde. Sigo teniendo el problema de detectar cuando el gear acaba un giro. He conseguido detectar el primero pero una vez que el motor está en marcha la corriente que circula hacia el motor cambia respecto al primer giro y me jode mazo, xD.

[huella]

Ánimo althor con ese diseño, que nos tienes impacientes esperando (me refería al que con una pulsación en posición auto disparaba una ráfaga de 3 bolas y si dejabas pulsado tenías la ráfaga normal).

Lo preguntaba porque esta semana o la que viene, recibiré mi nuevo Jing Gong M4 SR-16 y como voy a tener que abrir el Gearbox para cambiar el muelle, ya de paso voy a ponerle el MOSFET con las dos resistencias.

Si hubiera algún diseño funcionando con control de ráfagas, hasta me animaría a meterme con el y montarlo, siempre y cuando haya una lista de componentes y un manual sencillo de montaje-instalación.

De espacio no tengo problemas, ya que la culata del M4 es la rígida y cabe de todo.

Espero noticias.

Salu2.

[Althor]

Tu monta el mosfet que al menos mis diseños van siempre orientados a utilizar una instalación típica mosfet, así solo tendrás que cambiar el circuito que pongas tu con el nuevo diseño sin tener que abrir de nuevo el gear.
Yo ahora mismo estoy trabajando con un micro con lo que desactivar el modo ráfaga dejando el gatillo pulsado no es problema. De hecho mi idea es, una vez conectado pulsar el gatillo una vez para ponerlo en modo ráfaga, dos veces para modo normal y tres para modo sniper (este modo dejaría todo en modo semi, limitando un poco el ROF y parando el motor con el muelle comprimido para realizar el tiro más rápido, como el PSG-1). Para entrar en modo normal desde el modo ráfaga o sniper se dejaría el gatillo pulsado por un segundo. Para volver a alguno de los otros modos de momento habría que desconectar la batería y volver a empezar (si tenéis sugerencias para hacerlo desde el gatillo...).
Además será programable, actualizable y personalizable (para aquellos que estén puestos en C o ensamblador).
Por poder se puede hacer como queramos, que ya que usamos un micro.... el problema está en que yo no quiero hacerlo por tiempo, sino que quiero hacerlo por disparos completados, que es lo jodido. De momento estoy probando teniendo en cuenta la corriente en el motor (gracias a Mkvenner de los Recios de Vigo por recordarme que el efecto Hall existe, xD) , a mas compresión, el motor hace mas "esfuerzo" y consume más, en el momento que suelta el muelle, el consumo baja de golpe y es lo que intento aprovechar. El problema es que el consumo no es constante, el primer tiro consume mucho mas que los siguientes :-(
Os mantendré informados, y si alguna vez tengo algo medianamente decente ya pondré toda la documentación en el foro de la ASM.

[breiko]

joder althor, cada vez me pones mas cach....... jejejejejeje ya sabes que tienes un conejillo de indias cuando quieras en sevilla. ese control de disparo al estilo psg1 me pone un huevo para mi m21

[FIJO]

Buenas como soy nuevo en el foro y en esto del airsoft, quisiera saber si entendi, es cambiar, el mosfet por el control de disparo que al tocar el gatillo hace contacto??? es que no se ni pajolera de electronica y solo veo el mosfet y no entiendo como se dispara sin los contactos, un saludo

[Sniper]

Althor, coméntame que pic estás usando, y si puedes me pasas los fuentes en ensamblador o C. Yo pensaría en usar un micro pulsador externo, tipo el que llevan las linternas, o los de circuito impreso, que son pequeños y discretos, y trabajar los modos por interrupciones, para dejar libre de carga a los puertos de entrada y salida. Me imagino que simularás el efecto de un oscilador usando los timers internos de la pic... bueno, hay muchas maneras de trabajar la idéa, y al ser lógica programada, las soluciones serían varias

[Althor]

Estoy usando al 12f675 pero al final solo utilizo el comparador y no el conversor así que el código es valido también para los 12f629.
En cuanto al pulsador la verdad que ya que utilizamos un micro prefiero ahorrarlo (en mi diseño anterior utilizo un microswitch y es un coñazo colocarlo en la réplica de forma que sea fácilmente accesible.
En cuanto a las interrupciones, el problema en con los pics de "gama baja/media" está en que tienen un solo vector de interrupción para todas (vamos que da igual el tipo de interrupción que sea que ejecuta el mismo código), así que para trabajar bien utilizo una posición de eeprom para almacenar el modo en el que está trabajando (utilizo la eeprom para que así, al cambiar de batería, se quede en el modo que estuviese).
La semana que viene recuerdame que postee el código en C porque ahora mismo está todo sin comentarios y no hay quien lo lea  .

De todas formas lo complicado no es eso, como bien dices las soluciones y posibilidades son infinitas, el problema sigue estando en saber cuando el gear realiza un giro completo. Yo estoy experimentando con sensores de corriente de efecto hall pero debido al pico de corriente inicial solo puedo calcular con exactitud el primer giro (sin bajar demasiado el ROF claro).

Bueno, recuerdame la semana que viene y ya te voy a diciendo como lo llevo exactamente.

[huella]

Hay que reavivar este post, que ya han pasado dos semanas, y aún no se ha posteado ningún código, ni esquema, ni manual para gente sencilla..., jejeje.

Cuéntanos noticias Althor.

Salu2.

[Althor]

Bueno, la verdad que la cosa va despacio. De momento he aparcado la idea de utilizar los picos de corrientes por que el resultado no era el esperado (se podía detectar mas o menos bien el primer disparo, después la cosa se ponía chunga debido a la curva de consumo de las AEGs) y he vuelto a hacer pruebas por tiempo. La cosa va mas o menos bien, utilizo un potenciometro para ajustar el tiempo en lugar de programarlo desde el gatillo porque me parece bastante más rápido y práctico.

Si te empeñas te pongo el código que tengo ahora mismo y que no funciona muy bien (me falla la desconexión del modo burst desde el gatillo, luego miro a ver que pasa):

Código: [Seleccionar]

//
//                      _______  _______
//                     |       \/       |
//               Vdd --+ 1            8 +-- Vss (GND)
//                     |                |
//(TO GATE)GP5/T1CKI --+ 2            7 +-- GP0/AN0/CIN+/ICSPDAT (Current sensor Output)
//                     |                |
//GP4/AN3/T1G/CLKOUT --+ 3            6 +-- GP1/AN1/CIN-/VREF/ICSPCLK
//                     |                |
//         !MCLR/GP3 --+ 4            5 +-- GP2/AN2/T0CKI/INT/COUT (Gatillo)
//                     |                |
//                     +----------------+



#include <htc.h>
#include <pic.h>
#include <delay.h>
#include <delay.c>

char flag;


void interrupt trigger_int(void)
{
  unsigned int i;  //Variable para el "conteo".
  unsigned int j;  //Almacenamiento temporal para el valor ADC.
DelayMs(15);    //Retardo para evitar rebotes
if (GPIO2==1)  //
  goto EXIT;  //Si se ha dejado de pulsar sale.
if (flag==2) //Si flag=2 pasa a modo "auto".
goto JUMP2;
GODONE=1; //Activa el ADC para calcular el tiempo de rafaga.
  while(GODONE==1) //Espera mientras el ADC esta convirtiendo.
  asm("nop");
GPIO5=1;   //Activo el motor.
flag=0; //Pongo el flag a cero.
  DelayMs(60);  //Al menos esta activado 60 ms
  j=0;    //Las siguientes operaciones transforman ADRESH Y ADRESL en un numero de 16bits
  j=(j|ADRESH);  //y calculan el tiempo en funcion del pot (30 pasos de 20 ms cada uno entre el maximo
  j=((j<<8)|ADRESL); //del ADC y el minimo.
  j=(j/30);   //Aqui tenemos el nuemro de pasos (j*20=tiempo que se debe activar el motor en ms).
  if(j==0)
{
TMR1ON=1; //Conecto el timer.
goto JUMP1;
}
  for(i=0;i<20;++i) //Rutina que cuenta (20*j)en ms.
  {
if (GPIO2==1&&i==3) //Si se deja de pulsar comprueba que al menos ha dado un disparo
  goto JUMP1;    //¡Esto hace que el más leve toque al gatillo dispare al menos una vez!
  DelayMs(j);
  }
TMR1ON=1; //Conecto el timer.
goto JUMP1;


JUMP1:
GPIO5=0;    //Para de disparar y espero a que el gatillo vuelva a reposo.
if(TMR1IF==1) //Si el timer se desborda.
{
++flag;
TMR1H=0; //Pongo el timer a cero para ver si desactivo modo "burst".
TMR1L=0; //
TMR1IF==0; //Reseteo bit de overflow
TMR1ON=1; //Conecto el timer otra vez.
}
if(flag>=2)
{
goto EXIT;
}
if (GPIO2==0);  //
{
  goto JUMP1;   //
}
  DelayMs(15);    //Retardo para evitar rebotes
goto EXIT;


JUMP2: //Modo "Burst" desactivado, activa el motor normalmente
GPIO5=1;   //Activo el motor.
while (GPIO2==0)
  asm("nop");   //
DelayMs(15);
while (GPIO2==0)
  asm("nop");   //
GPIO5=0;
goto EXIT;


EXIT:
TMR1ON=0; //Paro TMR1
TMR1IF==0; //Reseteo bit de overflow
TMR1H=0; //
TMR1L=0; //
INTF=0; //Borro flag de interrupcion y retorno.
}   

//Funcion principal
void main()
{
__CONFIG(UNPROTECT&MCLRDIS&PWRTDIS&WDTDIS&INTIO);
//Configura E/S, interrupciones, perifericos y duerme el micro cuando no hay disparos
TRISIO = 0b001111;  //GP0, GP1, GP2 y GP3 como entradas, resto como salidas.
GPIO = 0x00; //Todas las salidas a cero.
WPU = 0b00000100; //Pull Up de GP2 activado.
ANSEL = 0b00010011; //GP0 y GP1 configurados como entradas analogicas.
OPTION = 0b00000111; //Interrupcion GP2 por flanco de bajada.
T1CON = 0b00110100; //Configuto timer1 con prescaler 8.
// CMCON = 0b00000010; //Configuro comparador.
ADCON0 = 0b10000101;
// programming();
INTCON = 0b11000000; //Permito interrupciones globales en GP2 por flanco de bajada .
flag=0; //Pongo el flag de modos a cero (modo "Burst").
INTE=1; //Permito interrupcion en GP2 por flanco de bajada.

LOOP:
goto LOOP; //Aqui va a estar casi todo el tiempo
}                  






[huella]

No te preocupes Althor, que va bien la cosa, yo solo pretendía saber como andaba ese diseño, hasta que esté acabado yo no puedo ayudar a nada porque de programación y de electrónica se más o menos como de física nuclear (soy masajista...)

Salu2.

[mowahi]

Y para los vagos, los que no quieren volverse loco con los circuitos esta la versión comercial...

http://extreme-fire.com/SW-COMPUTER.html

sobre todo no os perdáis los vídeos...

[ASM]

muy buena la idea de usar un potenciometro para controlar el tiempo de la rafaga ya que la cadencia varia al disminuir la carga de la bateria

cuando esté el codigo depurado me monto uno, por fin voy a tener un g36k con rafaga de 3 como el de verdad 

[Althor]

Bueno, el código está listo.
Dado que detector de corriente era muy inestable, he pasado de él y he tenido que conformarme con hacerlo por tiempo, me consuelo sabiendo que en un futuro no muy lejano las AEGs llevarán en la GB detectores y el disparo será electrónico (lo que nos permitirá hacer lo que queramos sin ninguna limitación).

En fin, al grano:

- Transparente en modo semi o full auto (vamos, que la AEG tira como toda la vida  )
- Ajuste de tiempo de ráfaga mediante potenciometro (entre 80 y 682 ms).
- Se puede pasar de modo burst a full auto dejando pulsado el gatillo dos segundos (el motor se activará 40ms para indicarlo).

Absolutamente todos los tiempo se pueden modificar por soft.

El programa esta en C, compilado con PICC LITE. Los #include se pueden encontrar en las bibliotecas del compilador.

Código: [Seleccionar]

//
//       PIC12F675 ASN Burst V3
//
//                      _______  _______
//                     |       \/       |
//               Vdd --+ 1            8 +-- Vss (GND)
//                     |                |
//   (GATE)GP5/T1CKI --+ 2            7 +-- GP0/AN0/CIN+/ICSPDAT
//                     |                |
//GP4/AN3/T1G/CLKOUT --+ 3            6 +-- GP1/AN1 (Potenciometro)
//                     |                |
//         !MCLR/GP3 --+ 4            5 +-- GP2/AN2/T0CKI/INT/COUT (Gatillo)
//                     |                |
//                     +----------------+



#include <htc.h>
#include <pic.h>
#include <delay.h>
#include <delay.c>
char flag;

void interrupt trigger_int(void)
{
unsigned int i;  //Variable para el "conteo".
  unsigned int j;  //Almacenamiento temporal para el valor ADC.
DelayMs(15);    //Retardo para evitar rebotes
if (GPIO2==1)  //Comprueba el gatillo.
{
  goto EXIT;   
}

if (flag!=0) //Comprueba si esta en modo BURST o FULL_AUTO.
{
goto FULL_A;
}
GODONE=1;
  while(GODONE==1) //Espera la conversión de ADC.
{
  asm("nop");
}
GPIO5=1;    //Activa el motor.
  DelayMs(80);  //Al menos esta activado 80 ms (+/- un disparo completo).
  j=0;    //Las siguientes operaciones meten ADRESH Y ADRESL en una variable de 16bits
  j=(j|ADRESH);  //y calculan el tiempo en funcion del potenciometro (30 pasos de 20 ms cada uno entre el maximo
  j=((j<<8)|ADRESL); //del ADC y el minimo).
  j=(j/30);    // j= "tiempo (en MS) por vuelta. Tiempo total = j*20".
  if(j==0)
{
TMR1ON=1; //Conecto el timer.
goto CHECK_T;
}
  for(i=0;i<20;++i)
  {
if (GPIO2==1&&i==3)  //Si se deja de pulsar el gatillo y al menos ha realizado 3 pasadas (+/- 1 disparo),
{ //comprueba que realmente se ha dejado de pulsar y retorna.
DelayMs(7);
if (GPIO2==1) //Si sigue pulsado continua con la rafaga hasta el final.
goto EXIT;   
}
  DelayMs(j);
  }
TMR1ON=1; //Conecto el timer.
goto CHECK_T;


CHECK_T: //Si el gatillo es pulsado durante 2 sg, se pasa a modo FULL_AUTO
GPIO5=0;    //Para de disparar y espero a que el gatillo vuelva a reposo.
if(TMR1IF==1) //Overflow del TMR1
{
++flag;
TMR1H=0; //Pongo el timer a cero.
TMR1L=0; //
TMR1IF=0; //Reseteo bit de overflow
TMR1ON=1; //Conecto el timer otra vez.
}
if(flag==4) //Comprueba que han pasado 2sg
{
GPIO5=1; //Activa el motor 40ms para indicar que el ha pasado a modo FULL_AUTO.
DelayMs(40);
GPIO5=0;
goto EXIT;
}
if (GPIO2==0)  //Comprueba dos veces que el gatillo siga pulsado
{
DelayUs(100);
if (GPIO2==0)
  goto CHECK_T;   //Comprueba que el gatillo siga pulsado.
}
  DelayMs(7);    //Retardo para evitar rebotes.
flag=0; //Pongo el flag a cero.
goto EXIT;


FULL_A: //Modo "Burst" desactivado, activa el motor normalmente
GPIO5=1;    //Activo el motor.
while (GPIO2==0) //Doble comprobación del gatillo.
  asm("nop");   
DelayMs(7);
while (GPIO2==0)
  asm("nop");   
goto EXIT;


EXIT:
DelayMs(7); //Evita posibles rebotes.
GPIO5=0; //Paro el motor.
TMR1ON=0; //Paro TMR1 .
TMR1IF==0; //Reseteo bit de overflow y TMR1.
TMR1H=0; //
TMR1L=0; //
INTF=0; //Borro flag de interrupcion y retorno.
}   


//Funcion principal
void main()
{
__CONFIG(UNPROTECT&MCLRDIS&PWRTDIS&WDTDIS&INTIO);
//Configura E/S, interrupciones, perifericos y duerme el micro cuando no hay disparos
TRISIO = 0b001111;  //GP0, GP1, GP2 y GP3 como entradas, resto como salidas.
GPIO = 0x00; //Todas las salidas a cero.
WPU = 0b00000100; //Pull Up de GP2 activado.
ANSEL = 0b00010011; //GP0 y GP1 configurados como entradas analogicas.
OPTION = 0b00000111; //Interrupcion GP2 por flanco de bajada.
T1CON = 0b00110100; //Configuto timer1 con prescaler 8.
ADCON0 = 0b10000101; //Configuro ADC.
INTCON = 0b11000000; //Permito interrupciones globales en GP2 por flanco de bajada .
flag=0; //Pongo el flag de modos a cero (modo "Burst").
INTE=1; //Permito interrupcion en GP2 por flanco de bajada.

LOOP:
goto LOOP; //Aqui va a estar casi todo el tiempo esperando pulsación del gatillo.
}                  



[Sniper]

timers de 16 bits supongo, verdad?... menuda sencillez. Yo me las tenía que ver con emsamblador de Intel para las familias 81 y 87 en 8 bits...

[Althor]

Pues como todos pero no voy a estar perdiendo el tiempo escribiendo el programa en assembler cuando me sobra espacio a patadas. Y esta claro que teniendo un timer de 16 bits no voy a usar el de 8 solo para complicar más las cosas.
En programación (ya con lenguajes de alto o bajo nivel), la sencillez manda.