Analyzer of Quality Electrical Energy, with RTOS ( ARM , Driver ADC, lwip , GPRS , Processing data , FFT , Handle of Thread , Real-Time, Socket )

Analyzer of Quality Electrical Energy
This desing and develop is constructed whit RTOS (eCos), consists of a ADC of 16NBits with two channels one to capture Current and another
one of Voltege, captures the data with a sampling frequency of 7680Hz to acquire 128 samples of the two you wave, are captured with thread, another thdreas for communication with GPRS, other to process the data by means of the FFT, disturbing the waves in its harmonic components to determine as they are his compoenetes and thus to analyze its harmonic Distortion (THD), sends by means of Sockets the data of the waves with interface of network PPP to be stored remotely in real- time.
//********** Analizer Quality Electrical Energy ********* //********** Desing and Develop By Jhoberg Quevedo Ruiz //****************jrquevedor //**********email: snipped-for-privacy@gmail.com*******************
//********** FSAMPLE: 7680Hz //********** NSAMPLE: 128 //********** CH0 : Current //********** CH1 : Voltege //********** NetWork Interface PPP //Capute Voltege and Current, FFT, Socket to Transmit Wave in REAL- TIME //Handle Thread cuminucations, Capture, Sample and Processing in REAL- TIME //RTOS for ARM
#include <pkgconf/io_serial.h> #include <pkgconf/libc.h> #include <cyg/io/io.h> #include <cyg/hal/hal_io.h> #include <cyg/hal/hal_intr.h> #include <cyg/io/serial.h> #include <string.h> #include <stdio.h> #include <math.h> #include <float.h> #include <stdlib.h> #include "lwip/sys.h" #define LWIP_COMPAT_SOCKETS 2 #include "lwip/sockets.h"
//***********Definicion variables eCos
#define STACK_SIZE 0x750 cyg_alarm_t test_timer1; //variables ecos hilos static cyg_thread thread_s[1]; static char stack[1][STACK_SIZE]; cyg_thread_entry_t AD7654_program,samples_program; cyg_handle_t AD7654_threadA,samples_thread; cyg_mutex_t cliblock,adcblock;
//Interrupcion cyg_handle_t handle_ADC_ISR0; cyg_interrupt intrADC; //semaforo cyg_sem_t semaforo_ADC,semaforo_nsamples;
//handle_I cyg_io_handle_t handle_IO;
int aux=0;
#define MAX_BUFFRX 512 #define TOPTCP 2048 #define MAX_BUFFTX 2048 char buffrx[MAX_BUFFRX]; char bufftx[MAX_BUFFTX];
//************fin Definicion variables eCos
#define LED_1    (1<<16) #define LED_2    (1<<17) #define LED_3    (1<<18)
int axgnd=0; int axmin=0; int axmax=0; float *iaux; float *toppw; volatile float posicion=0;
float jh=0; float jh2=0; float jh3=0; float axjh=0; float TOPDESPLAZAMIENTO=0.1; float POSMAX=0; float POSMIN=0;
//**********definicion de la clase ADC ANALOG DEVICE en #define NMUESTRAS 128 #define FSIGNAL 16 #define FSAMPLE 24 #define FNOISE 60 #define NSAMPLES 128
/////////// float dataImgI[NMUESTRAS]; float dataImgV[NMUESTRAS]; float vsignal[NMUESTRAS]; float vsignalax[NMUESTRAS]; float w[NMUESTRAS/2]; float f[NMUESTRAS/2]; float potenciaI[NMUESTRAS]; float potenciaV[NMUESTRAS] float img1[NMUESTRAS]; float real1[NMUESTRAS]; float dataRealI[NMUESTRAS]; float dataRealV[NMUESTRAS]; ///////////
cyg_uint32 ADRMEMORYK=0x297;
int Mapear(void); bool ConvertionStart(void); bool ReadAdc(unsigned short *,cyg_uint32 *); bool setChanel(int);
int Mapear(void) { //Current HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_PDR ,AT91_PIO_PSR_NCS3); HAL_WRITE_UINT32(AT91_EBI + AT91_EBI_MCR,AT91_EBI_MCR_ALE_8M| (0<<4) ); HAL_WRITE_UINT32(AT91_EBI + AT91_EBI_CSR1, AT91_EBI_CSR_DBW_16 | AT91_EBI_CSR_NWS_8 | AT91_EBI_CSR_WSE          | AT91_EBI_CSR_PAGES_1M | AT91_EBI_CSR_TDF_1 | AT91_EBI_CSR_CSEN | (ADRMEMORYK<<20) ); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_PER , AT91_PIO_PSR_TIOA1| AT91_PIO_PSR_P23|AT91_PIO_PSR_P24 ); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_OER, AT91_PIO_PSR_TIOA1| AT91_PIO_PSR_P23|AT91_PIO_PSR_P24 ); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_SODR, AT91_PIO_PSR_TIOA1);
HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_SODR, AT91_PIO_PSR_P23); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_CODR, AT91_PIO_PSR_P24); return 1; }
int Mapeara2(void) { //Voltage HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_PDR ,AT91_EBI_CSR1); HAL_WRITE_UINT32(AT91_EBI + AT91_EBI_MCR,AT91_EBI_MCR_ALE_8M| (0<<4) ); HAL_WRITE_UINT32(AT91_EBI + AT91_EBI_CSR1, AT91_EBI_CSR_DBW_16 | AT91_EBI_CSR_NWS_8 | AT91_EBI_CSR_WSE          | AT91_EBI_CSR_PAGES_1M | AT91_EBI_CSR_TDF_1 | AT91_EBI_CSR_CSEN | (ADRMEMORYK<<20) ); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_PER , AT91_PIO_PSR_TIOA1| AT91_PIO_PSR_P23|AT91_PIO_PSR_P24 ); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_OER, AT91_PIO_PSR_TIOA1| AT91_PIO_PSR_P23|AT91_PIO_PSR_P24 ); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_SODR, AT91_PIO_PSR_TIOA1);
HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_SODR, AT91_PIO_PSR_P23); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_CODR, AT91_PIO_PSR_P24); return 1; }
bool ConvertionStart(void) { HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_CODR, AT91_PIO_PSR_TIOA1); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_SODR, AT91_PIO_PSR_TIOA1); return 1; } bool ReadAdc(cyg_uint16 *Datoax, cyg_uint32 *address) { HAL_READ_UINT16((*address<<20) ,*Datoax ); return 1; } bool setChanel(int chop) { switch(chop) { case 0:{ HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_CODR, AT91_PIO_PSR_P23); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_CODR, AT91_PIO_PSR_P24);      //Voltaje      break;} case 1:{ HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_CODR, AT91_PIO_PSR_P23); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_SODR, AT91_PIO_PSR_P24);      break;} case 2:{ HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_SODR, AT91_PIO_PSR_P23); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_CODR, AT91_PIO_PSR_P24);      //Current      break;} case 3:{ HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_SODR, AT91_PIO_PSR_P23); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_SODR, AT91_PIO_PSR_P24);      break;} } return 1; }
typedef struct adc_7654 { const cyg_uint32 ADRMEMORY; volatile cyg_uint16 Dato; int SamplesI[NMUESTRAS]; int SamplesV[NMUESTRAS]; char *cDato; int topsamples; int numsample;
unsigned long powersample; float powertop; float *PowerDato; int ratepower; int MaxV; int MinV; volatile unsigned int *MaxI; volatile unsigned int *MinI;
volatile float instantVol; volatile float instantCur; int Comdato; int Comando;
int ntfpv; int ntfpi; float fp;
int (* apMapear)(void); bool (* apConvertionStart)(void); bool (* apReadAdc)(cyg_uint16 *,cyg_uint32 *); bool (* apsetChanel)(int);
}; struct adc_7654 adc,axadc;
//** function fft // i : 1 transformada inversa, :-1 trasnformada // j : NMUESTRAS // real : argumento real // img: argumento imaginario bool fft(int i, int j, float real[], float img[]) {
float f = sqrt(1.0F / (float)j); int i1; int k; for( k = i1 = 0; k < j; k++)
{
     if(i1 >= k) {      float f1 = (real[i1]) * f; float f2 = (img[i1]) * f; real[i1] = (real[k]) * f; img[i1] = (img[k]) * f; real[k] = f1; img[k] = f2; }
     int k1; for(k1 = j / 2; k1 >= 1 && i1 >= k1; k1 /= 2)      i1 -= k1;
i1 += k1; }
int l1 = 1; int i2;
for( i2 = 2 * l1; l1 < j; i2 = 2 * l1) {
float f3 = ((float)i * 3.141593F) / (float)l1; int j2; for( j2 = 0; j2 < l1; j2++)     {      float f4 = (float)j2 * f3;      float f5 = (float)cos(f4);      float f6 = (float)sin(f4);      int l;      for( l = j2; l < j; l += i2)      {      int j1 = l + l1;      float f7 = f5 * (real[j1]) - f6 * (img[j1]);      float f8 = f5 * (img[j1]) + f6 * (real[j1]); real[j1] = real[l] - f7; img[j1] = img[l] - f8; real[l] += f7; img[l] += f8;      }
    }
l1 = i2; l1 = i2;
}
return 1; } //**********end FFT **************
void levelCurrent(float al,float am,float aM) { al=(2*(al-am)/(aM-am))-1; al=al*9770; }
void levelVoltage(float al,float am,float aM) { al=(2*(al-am)/(aM-am))-1; al=al*9870; }
cyg_uint32 fun_isr0 (cyg_vector_t vector, cyg_addrword_t data ) { cyg_uint32 resultPIO; HAL_READ_UINT32(AT91_PIO + AT91_PIO_ISR, resultPIO); cyg_interrupt_mask(vector); cyg_interrupt_acknowledge(vector); return (CYG_ISR_HANDLED | CYG_ISR_CALL_DSR);
}
void fun_dsr0(cyg_vector_t vector, cyg_ucount32 count, cyg_addrword_t data){ cyg_interrupt_unmask(vector); }
static void socket_thread(void *arg) {
    int idsock,idsockecho;     int lentx,i,lenrx,len; int cliente_len;     int vartop,varmem,var;     int transmisiones=0;     int sizebuf=0;     unsigned long ciclosamples=0;     char comando [40]="Desconectado";     float axsock=0;     struct sockaddr_in cliente_addr,rem;     strcpy(bufftx,"info");     volatile char *cadenainfo;     volatile char *apcomando;     cadenainfo=malloc(sizeof(char [400]));     apcomando=malloc(sizeof(char [20]));     do {      cliente_len=sizeof(cliente_addr);      cliente_addr.sin_family = AF_INET;      cliente_addr.sin_port = htons(777);      inet_aton("192.168.2.2",&cliente_addr.sin_addr);      if( (idsock = socket(AF_INET,SOCK_STREAM,0)) < 0)      {      cyg_thread_delay(100);
     }      else      {
        lentx=strlen(bufftx);         lenrx ;         connect(idsock,(struct sockaddr *)&cliente_addr,sizeof(cliente_addr));
        for(i=0; ( ( ((lenrx=recv(idsock,buffrx,20,MSG_DONTWAIT) ) > 0) && buffrx[i]!=NULL) ||          (send(idsock,bufftx,lentx,MSG_DONTWAIT) )>0) ;i++ )          {
         strcpy(bufftx,"info");          len=strlen(bufftx);          sizebuf+=len;          if(sizebuf>TOPTCP){          sizebuf=0;          close(idsock);          pbuf_free(idsock);
         }          else send(idsock,bufftx,len,MSG_DONTWAIT);
         cyg_scheduler_lock();          cyg_mutex_lock(&adcblock);          axadc.Comando=1;          cyg_mutex_unlock(&adcblock);          cyg_scheduler_unlock();
         if(lenrx>0){
            if(strncmp(buffrx,"apagar",6)==0){
            HAL_WRITE_UINT32( AT91_PIO + AT91_PIO_CODR ,LED_1 );
            cyg_scheduler_lock();             cyg_mutex_unlock(&adcblock);             sprintf(comando,"Carga Apagada [Ok], Energia [%f]KW*h \n",*toppw);             cyg_mutex_unlock(&adcblock);             cyg_scheduler_unlock();             len=strlen(comando);             send(idsock,comando,len,MSG_DONTWAIT);
            }
         }
         sprintf(comando," %f %f %f %f %lu %d %d \n",*axadc.PowerDato,axadc.instantCur,axadc.instantVol,posicion,axadc.powersample,axadc.ntfpv,axadc.ntfpi);          len=strlen(comando);          sizebuf+=len;          if(sizebuf>TOPTCP){          sizebuf=0;          close(idsock);          pbuf_free(idsock);          }          else send(idsock,comando,len,MSG_DONTWAIT);          varmem=0;          vartop=0;          strcpy(apcomando,"@");          len=strlen(apcomando);          sizebuf+=len;          if(sizebuf>TOPTCP){          sizebuf=0;          close(idsock);          pbuf_free(idsock);
         }          else send(idsock,apcomando,len,MSG_DONTWAIT);
         if(transmisiones==0) {             strcpy(apcomando,"V");             len=strlen(apcomando);          } else{          strcpy(apcomando,"I");          len=strlen(apcomando);          }          sizebuf+=len;          if(sizebuf>TOPTCP){          sizebuf=0;          close(idsock);          pbuf_free(idsock);
         }          else send(idsock,apcomando,len,MSG_DONTWAIT);             for(var=0;var<NSAMPLES;var++)              {              if(transmisiones==0)              sprintf(apcomando,"%d, \n",axadc.SamplesI[var]);
             else              sprintf(apcomando,"%d, \n",axadc.SamplesV[var]);
             varmem=0;              while((varmem<6)&&((char *)apcomando)[varmem]!=' ')              {                 ((char *)cadenainfo+vartop)[varmem]=(char *)apcomando[varmem];                 varmem++;              }              vartop=vartop+varmem;
             }
        len=strlen(cadenainfo);         sizebuf+=len;         if(sizebuf>TOPTCP){          sizebuf=0;          close(idsock);          pbuf_free(idsock);
        }else     send(idsock,cadenainfo,len,MSG_DONTWAIT);
         if(*axadc.PowerDato>216E6)          {             cyg_mutex_lock(&adcblock);
            HAL_WRITE_UINT32( AT91_PIO + AT91_PIO_CODR ,LED_1 );             *adc.PowerDato=0;             *toppw=0;             cyg_mutex_unlock(&adcblock);             sprintf(comando,"allenergy \n");             len=strlen(comando);             send(idsock,comando,len,MSG_DONTWAIT);
         }
         cyg_scheduler_lock();          cyg_mutex_lock(&adcblock);          ciclosamples=axadc.powersample;          axadc.Comando=0;          cyg_mutex_unlock(&adcblock);          cyg_scheduler_unlock();
         if(sizebuf>TOPTCP){          sizebuf=0;          close(idsock);          pbuf_free(idsock);
         }          transmisiones++;          if(transmisiones>2){          transmisiones=0;          }          }      close(idsock);      cyg_thread_delay(7000);      }
    }while(1);
}
void tmain() { cyg_io_handle_t handle_ser1; Cyg_ErrNo err; const char comando_modem [] = "ATE0\r\n"; const char comando0_modem[] = "ATD*99#\r\n"; const char comando1_modem[] = "ATZ \r"; char respuesta_modem [20]; int len = strlen(comando_modem); int cadenatx_len = strlen(comando1_modem); int cadenarx_len,j; char buferr[20];
err = cyg_io_lookup( "/dev/ser1", &handle_ser1 ); cyg_io_set_config(handle_ser1,1,&buferr,&len); err = cyg_io_write( handle_ser1, comando_modem , &len ); cyg_thread_delay(100); len= strlen(comando0_modem); err = cyg_io_write( handle_ser1, comando0_modem , &len ); cyg_io_set_config(handle_ser1,0,&buferr,&len); cyg_thread_delay(100); lwip_init(); sys_thread_new(socket_thread, (void*)"socket",5);
}
void cyg_user_start ( void ) { HAL_WRITE_UINT32( AT91_PIO + AT91_PIO_PDR , AT91_PIO_PSR_TXD0 | AT91_PIO_PSR_RXD0); HAL_WRITE_UINT32( AT91_PIO + AT91_PIO_PDR , AT91_PIO_PSR_TXD1 | AT91_PIO_PSR_RXD1 );
adc.topsamples=NMUESTRAS; adc.numsample=0; adc.powersample=0; adc.powertop!6E6; adc.cDato=(char *)malloc(sizeof(char [4])); adc.apMapear=Mapear; adc.apConvertionStart=ConvertionStart; adc.apReadAdc=ReadAdc; adc.apsetChanel=setChanel; adc.ADRMEMORY=&ADRMEMORYK; adc.apMapear(); adc.Comdato=0; adc.PowerDato=malloc(sizeof(float ));; adc.ratepower; adc.MaxI=malloc(sizeof(int )); adc.MinI=malloc(sizeof(int )); *adc.MaxI=0; *adc.MinI=0xFFFF; adc.instantVol=0; adc.instantCur=0; adc.ntfpi=0; adc.ntfpv=0; adc.fp=1; adc.Comando=0; iaux=malloc(sizeof(float )); *iaux=0; toppw=malloc(sizeof(float )); *toppw=0;
HAL_WRITE_UINT32( AT91_PIO + AT91_PIO_PDR ,AT91_PIO_PSR_IRQ2); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_IDR, 0xFFFFFFFF); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_PER, AT91_PIO_PSR_IRQ2); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_ODR, AT91_PIO_PSR_IRQ2); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_IER, AT91_PIO_PSR_IRQ2); HAL_WRITE_UINT32(AT91_PIO + AT91_PIO_SODR, AT91_PIO_PSR_IRQ2); cyg_interrupt_create(CYGNUM_HAL_INTERRUPT_EXT2,0 , 1,&fun_isr0,&fun_dsr0,&handle_ADC_ISR0,&intrADC); hal_interrupt_set_level(CYGNUM_HAL_INTERRUPT_EXT2,AT91_AIC_SMR_EDGE_NEG); cyg_interrupt_attach(handle_ADC_ISR0); cyg_interrupt_unmask(CYGNUM_HAL_INTERRUPT_EXT2);
cyg_mutex_init(&cliblock); cyg_mutex_init(&adcblock); cyg_semaphore_init(&semaforo_nsamples,0); cyg_semaphore_init(&semaforo_ADC,0);
cyg_thread_create(10, samples_program, (cyg_addrword_t) 0,          "Hilo para AD7654 de ANALOG", (void *) stack[0],STACK_SIZE,          &samples_thread,&thread_s[0]);
cyg_thread_create(7,AD7654_program, (cyg_addrword_t) 0,          "Hilo que contien el LWIP", (void *) stack[1],STACK_SIZE,          &AD7654_threadA, &thread_s[1]);
cyg_thread_resume(samples_thread); cyg_thread_resume(AD7654_threadA);
HAL_WRITE_UINT32( AT91_PIO + AT91_PIO_CODR ,LED_2 ); HAL_WRITE_UINT32( AT91_PIO + AT91_PIO_CODR ,LED_3 );
}
void AD7654_program(cyg_addrword_t data) { int var,len,k; char outstring; char buferr[10]; float promedioI,promedioV,M,prompos;
for(k = 0; k < NMUESTRAS/2; k++) f[k] = k*FSAMPLE/(NMUESTRAS/2); for(k = 0 ;k< NMUESTRAS/2; k++) w[k] = 2*3.1416*f[k];
do{ cyg_semaphore_wait(&semaforo_nsamples); axadc.Comando=1;
k=0; promedioI=0; promedioV=0; while( k<NMUESTRAS) {      levelCurrent( axadc.SamplesI[k],19616,44491);      datosRealI[k] =axadc.SamplesI[k], promedioI += axadc.SamplesI[k] ;
     levelVoltage( axadc.SamplesV[k],19616,44491);      dataRealV[k] =axadc.SamplesV[k], promedioV += axadc.SamplesV[k] ;
     k++; } M=k;
promedioI /= M; for(k = 0; k<M; k++){ datosRealI[k] -= promedioI; dataRealV[k] -= promedioV; } //FFT Current fft(-1,NMUESTRAS/2,dataRealI,dataImgI);
//FFT Voltage fft(-1,NMUESTRAS/2,dataRealV,dataImgV);
for(k=0; k < NMUESTRAS/2; k++) { potenciaI[k] = dataRealI[k]*dataRealI[k] + dataImgI[k]*dataImgI[k];      potenciaV[k] = dataRealV[k]*dataRealV[k] + dataImgV[k]*dataImgV[k]; } axadc.Comando=0;
}while(1); }
// funcion de muestreo, con frecuencia variable
void bitAdc_alarm_func(cyg_handle_t alarmH, cyg_addrword_t data) {
cyg_scheduler_lock(); cyg_mutex_lock(&adcblock); *iaux=0; axmax=0; axmin=0; axgnd=0; jh=0; jh2=0; jh3=0;
if(adc.numsample>adc.topsamples) { if(axadc.Comando==0) axadc=(struct adc_7654)adc;
cyg_semaphore_post(&semaforo_nsamples);
    if((*adc.PowerDato)<adc.powertop)      {      axmaxc.MaxV;      axminc.MinV;      axgnd=axmin+(((axmax)-(axmin))/2 );      jh2=(axmax-axgnd);      if(jh2>0)      adc.instantVol=jh2*1E3/65535E0;      else      adc.instantVol0E0;
     axmax=(*adc.MaxI);      axmin=(*adc.MinI);      axgnd=axmin+(((axmax)-(axmin))/2 );      //para calcuar con dcgnd variable      jh2=( axmax - axgnd);
     jhE65E-6;      if( jh2 > 0)      jh3=jh2*jh;      else      jh3=0;
     if(jh3>0)      {         adc.instantCur=jh3;         jh=(adc.instantVol*(jh3));         *toppw+=jh;         *adc.PowerDato=*toppw;
     }      else{      adc.instantCur0;      adc.instantVol0E0;
     }      adc.MaxV=0;      *adc.MinI=0xFFFF;      *adc.MaxI=0;      adc.MinV=0xFFFF;      adc.numsample=0;      adc.powersample++;      }else{      adc.Comdato=1;      }
}else {
    //Current     adc.apsetChanel(1);     adc.apConvertionStart();     adc.apReadAdc(&adc.Dato,adc.ADRMEMORY);     adc.SamplesI[adc.numsample]c.Dato;     if(*adc.MaxI<adc.SamplesI[adc.numsample])      {      *adc.MaxIc.SamplesI[adc.numsample];      adc.ntfpic.numsample;
     }     if(*adc.MinI>adc.SamplesI[adc.numsample])      *adc.MinI=(unsigned int)adc.SamplesI[adc.numsample];
//Voltege     adc.apsetChanel(0);     adc.apConvertionStart();     adc.apReadAdc(&adc.Dato,adc.ADRMEMORY);     adc.SamplesV[adc.numsample]c.Dato;     if(adc.MaxV<adc.SamplesV[adc.numsample])      {      adc.MaxVc.SamplesV[adc.numsample];      adc.ntfpic.numsample;      }     if(adc.MinV>adc.SamplesV[adc.numsample])      {      adc.MinVc.SamplesV[adc.numsample];      adc.ntfpvc.numsample;      }     adc.numsample++; } cyg_mutex_unlock(&adcblock); cyg_scheduler_unlock();
}
void samples_program(cyg_addrword_t data) { int message = (int) data; int delay; int n,x; char output; cyg_handle_t test_counterH, system_clockH, test_alarmH; cyg_tick_count_t ticks; cyg_alarm test_alarm; cyg_handle_t tiempo_real; unsigned how_many_alarms = 0, prev_alarms = 0, tmp_how_many; system_clockH = cyg_real_time_clock(); cyg_clock_to_counter(system_clockH, &test_counterH); cyg_alarm_create(test_counterH, bitAdc_alarm_func,          (cyg_addrword_t) &how_many_alarms ,          &test_alarmH, &test_alarm);
cyg_alarm_initialize(test_alarmH, cyg_current_time()+1, 160); tmain(); for (;;) {
} }
// fin frecuencia de muestreo
//******* Analizer Quality Electrical Energy ***********
Add pictures here
<% if( /^image/.test(type) ){ %>
<% } %>
<%-name%>
Add image file
Upload

Polytechforum.com is a website by engineers for engineers. It is not affiliated with any of manufacturers or vendors discussed here. All logos and trade names are the property of their respective owners.