Fasimetro (secuencia de fases)

[Ruco]

Un saludo mis hermanos del foro TodoPic.

Mi intensión es hacer un fasimetro con pic para conocer la secuencia en una red trifásica. Se que cada una de las fases están desplazadas 120° una de la otra. Ahora como lo plasmó en ccs c para saber cuál fase es primero, cual es segunda y cuál es tercera.

Gracias por su ayuda...

[Robert76]

Hola Amigo, yo armé hace unos años, un protector que incluía la detección de fases con PIC, dame a que busque el programa y lo publico por aquí.

[Ruco]

Robert76, gracias.

Es un tema muy interesante para mi y en la red  no hay mucha información aplicada. Gracias por compartir 

[DominusDRR]

Un saludo mis hermanos del foro TodoPic.

Mi intensión es hacer un fasimetro con pic para conocer la secuencia en una red trifásica. Se que cada una de las fases están desplazadas 120° una de la otra. Ahora como lo plasmó en ccs c para saber cuál fase es primero, cual es segunda y cuál es tercera.

Gracias por su ayuda...

Tal vez este enlace sea de utilidad para ti.

https://microcontrollerslab.com/power-factor-measurement-using-microcontroller/

[Robert76]

Código: [Seleccionar]

  int nta=0,eta=0;

{     
      lecpor=input_a();
      R=lecpor&1;S=lecpor>>1&1;T=lecpor>>2&1;
////////////////////////////////////////Detecta sentido de fases////////////////////////////////////////     
      if(!R&&!S&&eta==3){eta=4,nta=0;}
      if(!R&&S&&eta==2)eta=3;
      if(R&&S&&eta==1)eta=2;
      if(R&&!S&&eta==0)eta=1;
      if(!R&&!S&&nta==3){nta=0,eta=0;}
      if(R&&!S&&nta==2)nta=3;
      if(R&&S&&nta==1)nta=2;
      if(!R&&S&&nta==0)nta=1;
////////////////////////////////////////////////////////////////////////////////////////////////////////
      if(eta==4){actif=0,eta=0,nta=0;}
      else {if(actif<1000)actif++;} 

}


Aqui un ejem. de detección de fases.
Sólo se requiere que éste código esté en el bucle principal, ya que debe estar permanentemente analizando la secuencia.
Además añadí la variable "actif".
Si ésta variable alcanza el valor 1000, sig. que la secuencia NO es correcta.

[DominusDRR]

Código: [Seleccionar]

  int nta=0,eta=0;

{     
      lecpor=input_a();
      R=lecpor&1;S=lecpor>>1&1;T=lecpor>>2&1;
////////////////////////////////////////Detecta sentido de fases////////////////////////////////////////     
      if(!R&&!S&&eta==3){eta=4,nta=0;}
      if(!R&&S&&eta==2)eta=3;
      if(R&&S&&eta==1)eta=2;
      if(R&&!S&&eta==0)eta=1;
      if(!R&&!S&&nta==3){nta=0,eta=0;}
      if(R&&!S&&nta==2)nta=3;
      if(R&&S&&nta==1)nta=2;
      if(!R&&S&&nta==0)nta=1;
////////////////////////////////////////////////////////////////////////////////////////////////////////
      if(eta==4){actif=0,eta=0,nta=0;}
      else {if(actif<1000)actif++;} 

}


Aqui un ejem. de detección de fases.
Sólo se requiere que éste código esté en el bucle principal, ya que debe estar permanentemente analizando la secuencia.
Si la secuencia es correcta, la variable "eta" alcanza el valor 4.
Yo añadí la variable "actif", para que genere un retardo, antes de dar el OK!

Me parece un poco complejo y muy sofisticado ese código. ¿No hay manera de hacerlo al estilo de conocer el sentido de giro similar a un encoder?

[Robert76]

Otra opción es usar interrupciones.
Pero dado que use un PIC de bajos recursos, el código funcionó muy bien.

[DominusDRR]

Hola. Voy a presentar mi idea.

Las 3 señales pueden generar señales cuadradas como se indica en la siguiente Figura denominada "fases", y son solo dos opciones desde el punto de vista de una que denominaré fase A o terminal A (Figura denominada "fases").


El inicio del proceso será cuando el terminal o la fase A pase de 0 a 1 lógico (Figura denominada "Inicio Proceso")


Puede ser por interrupción la detección del cambio del terminal FASE A de 0 lógico a 1 lógico.

Si no se desea utilizar interrupciones, el proceso para detectar el cambio de 0 lógico a 1 lógico es el siguiente código:

Código: [Seleccionar]

#define INICIO 0
#define ESPERAR_QUE_A_PASE_A_0 1
#define ESPERAR_QUE_A_PASE_A_1 2
estadoTarea = INICIO;
while(1) // super bucle principal, generalmente esta en main

{
       switch (estadoTarea)
       {
             case INICIO:
             {
                  if (TerminalA == 1) // Si terminal A está en 1 lógico, se debe esperar a que pase a cero lógico
                  {
                         estadoTarea = ESPERAR_QUE_A_PASE_A_0;
                  }
                  else // Si terminal A está en 0 lógico, se debe esperar a que pase a 1 lógico
                  {
                         estadoTarea = ESPERAR_QUE_A_PASE_A_1;
                  }
                   break;
             }
     case ESPERAR_QUE_A_PASE_A_0:
     {
if (TerminalA == 0)
{
estadoTarea = ESPERAR_QUE_A_PASE_A_1;
}
break;
     }
    default:// equivale a ESPERAR_QUE_A_PASE_A_1;
     {
           if (TerminalA == 1)
  {
       proceso();
       estadoTarea = 0; //para que repita el ciclo
}
     }
       }
       
       
}

Una vez que inicia el proceso es determinar si el terminal B o C pasan a 1 lógico. Si B pasa primero, implica que es la opción 1 de la figura denominado "fases", o caso contrario la opción 2.

Proceso sería algo asi:


[/code]

Código: [Seleccionar]

void proceso(void)
{
while(1)
{
if (TerminalB == 1)
{
//opcion 1
break; // para que retorne a al lazo principal
}
if (TerminalC == 1)
{
//opcion 2
break; // para que retorne a al lazo principal
}
}
}


[Robert76]

Más óptimo resulta comparar los estados de dos fases que comparar cuándo una de ellas cambia de estado.

[DominusDRR]

Más óptimo resulta comparar los estados de dos fases que comparar cuándo una de ellas cambia de estado.

Sería de conocer la opinión de don Ruco para determinar cual solución presentada es más entendible para él.

[Ruco]

Saludos a todos.

E visto este código. Aquí lo dejo para ver sus opiniones...

https://www.academia.edu/44267723/3_Phase_secuence_Detector

Código: C#

1. /**************************************************************************
2. * 3_Phase Secuence Detector Version: 1.0
3. * PIC16F88
4. * Octubre, 2020
5. ***************************************************************************/
6. #include <16f88.h>
7. #use delay(clock=4000000)
8. #use fast_io(A)
9. #use fast_io(B)
10. //////// Fuses: LP,XT,HS,EC_IO,NOWDT,WDT,NOPUT,PUT,MCLR,NOMCLR,BROWNOUT
11. //////// Fuses: NOBROWNOUT,LVP,NOLVP,CPD,NOCPD,WRT,NOWRT,DEBUG,NODEBUG,CCPB0
12. //////// Fuses: CCPB3,PROTECT,NOPROTECT,INTRC,INTRC_IO,RC,RC_IO,FCMEN
13. //////// Fuses: NOFCMEN,IESO,NOIESO
14. #fuses XT,PUT,BROWNOUT,NOPROTECT,NOLVP,CCPB3
15. #zero_ram
16. #byte PORTA = 0x05
17. #byte PORTB = 0x06
18. #bit LED1 = PORTB.1 //Rojo Secuencia Incorrecta
19. #bit LED2 = PORTB.2 //Verde Secuencia correcta
20.  
21. #byte ANSEL = 0x9b
22. #byte TMR1L = 0xE /* definitions for Timer1 module */
23. #byte TMR1H = 0xF
24. #define ALL_OUT 0
25. #define ALL_IN 0xff
26. /**************************************************************************
27. * Variables Globales
28. **************************************************************************/
29. int16 t;
30. /************************************************************************
31. * Interrupcion EXT
32. * Usada para detectar flanco de subida de señal R
33. **************************************************************************/
34. #INT_EXT
35. void EX_isr()
36. {
37. set_timer1(0);
38. }
39. /*********************************************************************************
40. * Interrupcion CCP1
41. * Usada para detectar tiempo que ocurre en flanco de subida de señal S
42. * De acuerdo tiempo transcurrida se sabe si la secuencia es correcta o incorecta
43. **********************************************************************************/
44. #INT_CCP1
45. void CCP1_isr()
46. {
47. t=CCP_1;
48. if(t>0 && t<6000) { //Secuencia Correcta (t en us)
49. LED2=1;
50. LED1=0;
51. }
52. if(t>6000 && t<12000) { // Secuencia Incorrecta (t en us)
53. LED2=0;
54. LED1=1;
55. }
56. }
57. /**************************************************************************
58. * Programa Principal
59. **************************************************************************/
60. void main()
61. {
62. setup_timer_1(T1_INTERNAL|T1_DIV_BY_1); // tick= 1useg a 4Mhz
63. setup_ccp1(CCP_CAPTURE_RE);
64. set_tris_b(0x9);
65. LED1=0;
66. LED2=0;
67. enable_interrupts(INT_EXT);
68. ext_int_edge(0,L_TO_H);
69. enable_interrupts(INT_CCP1);
70. enable_interrupts(GLOBAL);
71. while(1);
72. }

[DominusDRR]

Saludos a todos.

E visto este código. Aquí lo dejo para ver sus opiniones...

https://www.academia.edu/44267723/3_Phase_secuence_Detector

Código: C++

1. #include <16f88.h> #use delay(clock=4000000) #use fast_io(A) #use fast_io(B) //////// Fuses: LP,XT,HS,EC_IO,NOWDT,WDT,NOPUT,PUT,MCLR,NOMCLR,BROWNOUT //////// Fuses: NOBROWNOUT,LVP,NOLVP,CPD,NOCPD,WRT,NOWRT,DEBUG,NODEBUG,CCPB0 //////// Fuses: CCPB3,PROTECT,NOPROTECT,INTRC,INTRC_IO,RC,RC_IO,FCMEN //////// Fuses: NOFCMEN,IESO,NOIESO #fuses XT,PUT,BROWNOUT,NOPROTECT,NOLVP,CCPB3 #zero_ram #byte PORTA = 0x05 #byte PORTB = 0x06 #bit LED1  = PORTB.1   //Rojo Secuencia Incorrecta #bit LED2  = PORTB.2   //Verde Secuencia correcta
2.  
3.  
4.  #byte ANSEL = 0x9b #byte TMR1L = 0xE   /* definitions for Timer1 module */ #byte TMR1H = 0xF  #define ALL_OUT 0 #define ALL_IN 0xff  /************************************************************************** * Variables Globales **************************************************************************/ int16 t; /************************************************************************ * Interrupcion EXT * Usada para detectar flanco de subida de señal R  **************************************************************************/ #INT_EXT  void EX_isr() {  set_timer1(0);     } /********************************************************************************* * Interrupcion CCP1 * Usada para detectar tiempo que ocurre en flanco de subida de señal S * De acuerdo tiempo transcurrida se sabe si la secuencia es correcta o incorecta       **********************************************************************************/ #INT_CCP1   void CCP1_isr() {    t=CCP_1;     if(t>0 && t<6000) {   //Secuencia Correcta (t en us)              LED2=1;              LED1=0;     }      if(t>6000 && t<12000) {   // Secuencia Incorrecta (t en us)              LED2=0;              LED1=1;      }                  }   /************************************************************************** * Programa Principal **************************************************************************/ void main() {     setup_timer_1(T1_INTERNAL|T1_DIV_BY_1); // tick= 1useg a 4Mhz    setup_ccp1(CCP_CAPTURE_RE);    set_tris_b(0x9);          LED1=0;      LED2=0;          enable_interrupts(INT_EXT);      ext_int_edge(0,L_TO_H);      enable_interrupts(INT_CCP1);      enable_interrupts(GLOBAL);           while(1);         }

Cual es su opinión de esto, se puede mejorar en algo.

Deberías darle un formato más legible.

[Ruco]

Ahí esta nuevamente. El código hace ver fácil la tarea, en realidad no se como lo vean. Creo que el código solo verifica 2 de las 3 fases y esto lo hace por comparación de tiempos en el cruce por cero.

Como lo ven amigos.

Como se podría mejorar o monitorear la tercera fase?.

Aquí el PDF del mismo.

[DominusDRR]

Saludos a todos.

E visto este código. Aquí lo dejo para ver sus opiniones...

https://www.academia.edu/44267723/3_Phase_secuence_Detector

Código: C++

1. #include <16f88.h> #use delay(clock=4000000) #use fast_io(A) #use fast_io(B) //////// Fuses: LP,XT,HS,EC_IO,NOWDT,WDT,NOPUT,PUT,MCLR,NOMCLR,BROWNOUT //////// Fuses: NOBROWNOUT,LVP,NOLVP,CPD,NOCPD,WRT,NOWRT,DEBUG,NODEBUG,CCPB0 //////// Fuses: CCPB3,PROTECT,NOPROTECT,INTRC,INTRC_IO,RC,RC_IO,FCMEN //////// Fuses: NOFCMEN,IESO,NOIESO #fuses XT,PUT,BROWNOUT,NOPROTECT,NOLVP,CCPB3 #zero_ram #byte PORTA = 0x05 #byte PORTB = 0x06 #bit LED1  = PORTB.1   //Rojo Secuencia Incorrecta #bit LED2  = PORTB.2   //Verde Secuencia correcta
2.  
3.  
4.  #byte ANSEL = 0x9b #byte TMR1L = 0xE   /* definitions for Timer1 module */ #byte TMR1H = 0xF  #define ALL_OUT 0 #define ALL_IN 0xff  /************************************************************************** * Variables Globales **************************************************************************/ int16 t; /************************************************************************ * Interrupcion EXT * Usada para detectar flanco de subida de señal R  **************************************************************************/ #INT_EXT  void EX_isr() {  set_timer1(0);     } /********************************************************************************* * Interrupcion CCP1 * Usada para detectar tiempo que ocurre en flanco de subida de señal S * De acuerdo tiempo transcurrida se sabe si la secuencia es correcta o incorecta       **********************************************************************************/ #INT_CCP1   void CCP1_isr() {    t=CCP_1;     if(t>0 && t<6000) {   //Secuencia Correcta (t en us)              LED2=1;              LED1=0;     }      if(t>6000 && t<12000) {   // Secuencia Incorrecta (t en us)              LED2=0;              LED1=1;      }                  }   /************************************************************************** * Programa Principal **************************************************************************/ void main() {     setup_timer_1(T1_INTERNAL|T1_DIV_BY_1); // tick= 1useg a 4Mhz    setup_ccp1(CCP_CAPTURE_RE);    set_tris_b(0x9);          LED1=0;      LED2=0;          enable_interrupts(INT_EXT);      ext_int_edge(0,L_TO_H);      enable_interrupts(INT_CCP1);      enable_interrupts(GLOBAL);           while(1);         }

Cual es su opinión de esto, se puede mejorar en algo.

Deberías darle un formato más legible.

He observado el código en el enlace que adjuntaste.

Lo que veo es que utiliza los módulos de comparación y captura. ¿Tiene tu microcontrolador dichos módulos?

El proceso consiste en medir tiempos entre las señales para decidir si es un sentido u el otro.

Si deseas copiar y pegar el código de alguien más y funcione como una caja negra, es posible, pero debes ajustar tu hardware al del ejemplo y si desconoces algunas partes, del sistema podría no funcionar.

Mucho mejor es que tu vayas creando tu propio código, realizando poco a poco varias partes, hasta que funcione como tu deseas.

El método que te propuse no mide tiempos, sino detecta una señal cuando pase de 0 a 1 lógico y luego espera a las otras 2. En función de cual primero se active, se determina que sentido es.

[Ruco]

DominusDRR

Como hacer el hardware para detectar los cambios de las fases?. Con cruce por cero?.