Ayuda para interpretar una cadena de comandos en C

[JCAK]

HOLA AMIGOS....

Lo que me pasaron antes resultó todo perfecto, pero me surgíeron un par de dudas más y quiciera saber si pueden ayudarme. Ahí voy ....

ADCSRA es un registro de 8 bits compuesto de la siguiente manera:
ADEN - ADSC - ADATE - ADIF - ADIE - ADPS2 - ADPS1 - ADPS0

En el codigo C tengo una instrucción que dice asi:

while ( ! (ADCSRA & (1<<ADIF))
{
}

Tengo otroa que no usa el signo ! y dice asi:

while (ADCSRA & (1<<ADSC)
{
}

Y por utlimo otra que dice asi:

ADCSRA &= ~((1<<ADATE) | (1<<ADIE))

En esta creo que es algo asi como hacer ADCSRA = ADCSRA AND 11010111 pero la verdad que no estoy seguro ¿me confirmarían?

Yo entiendo que while es para que se quede en un loop, también entiendo que & es para hacer una operación AND, pero todo junto no entiendo como aplicarlo, en especial porque me da la sensación de estar trabajando con 8 bits y 1 bit y ya me perdí.


Algo estudié y uno de los link que me pasaron vino barbaro, pero Socoooorrroooo..... 
Con la ayuda en ejemplos binarios lo entiendo genial, por favor tirenme una manito más, no digo que sea la ultima ... gracias

Saludos

[jfh900]

Veamos:

while ( ! (ADCSRA & (1<<ADIF))

con esto lo que hacemos es poner un 1 en la posición del bit ADIF y todas las demas posiciones son cero seguidamente hacemos un AND, luego todas las posiciones son cero a excepción de la del bit ADIF que valdra "1" si el registro ADCSRA contien un 1 en esa posición. En definitiva comprobamos si el bit ADIF del registro ADCSRA vale uno o cero. El carácter ! lo que hace es invertir el valor osease si vale uno me devulve cero y si vale cero me devuelve uno. Como se lee entoces toda la instrucción:

ejecutar el bucle mientras el bit ADIF del registro ADCSRA valga cero

while (ADCSRA & (1<<ADSC)

Lo mismo perosin inversión:

ejecutar el bucle mientras el bit ADIF del registro ADCSRA valga uno

ADCSRA &= ~((1<<ADATE) | (1<<ADIE))

Teniendo encuenta:

ADEN - ADSC - ADATE - ADIF - ADIE - ADPS2 - ADPS1 - ADPS0

Esta es un poco mas complicada:

((1<<ADATE) | (1<<ADIE))

Esto devuelve:

ADEN - ADSC - ADATE - ADIF - ADIE - ADPS2 - ADPS1 - ADPS0
0         0           1           0         1        0           0            0

00101000

El carácter ~ hace el complemento (cambia ceros por uno y viceversa):

~00101000 = 11010111

Finalmente hace un and con el registro ADCSRA  y se lo asigna así mismo quedando:

ADCSRA &= ~((1<<ADATE) | (1<<ADIE)) =>

ADCSRA = ADCSRA & 11010111

Esto quiere decir que estamos poniendo a cero los bits 3 y 5 del registro ADCSRA que son:

ADEN - ADSC - ADATE - ADIF - ADIE - ADPS2 - ADPS1 - ADPS0
7         6          5            4        3         2           1            0

ADATE - ADIE

Con lo cual lo que habias deducido estaba bien.

Un saludo.

[djpalas]

Buenas!!

Estoy totalmente deacuerdo con jfh900, ha realizado una buen explicación.

[JCAK]

Hola JFH900

Por favor, solo confirmame si en la segunda linea que pusiste:

ejecutar el bucle mientras el bit ADIF del registro ADCSRA valga uno

Quiciste poner:

ejecutar el bucle mientras el bit ADSC del registro ADCSRA valga uno

Además y aprovechando la ocación, vos que sabes de C te pregunt lo siguiente, el que escribió este código en C para hacer el while, no tenia una manera más facil de lograr tal comparación.
Me refiero a que en BASIC yo pongo algo como While ADCSRA.ADIF = 0 y listo, o sea, no tengo que hacer un AND y luego comparar, ni invertir nada. ¿que opinas?

Gracias a todos nuevamente.

[jfh900]

Pues si tienes razón con las prisas crei que era el mismo bit, pero lo correcto es:

ejecutar el bucle mientras el bit ADSC del registro ADCSRA valga uno

En cuanto a lo segundo, comentarte que eso depende del compilador, si puede trabajar a nivel de bit's individuales o no. Creo por lo que vimos en el enlace que te puse y por lo que hemos estado viendo, que este compilador solo trabaja a nivel de byte y por consiguiente hay que aislar el bit que queramos testear dentro de un byte.

Un saludo.

[JCAK]

Y se va la tercera.....

Me surgió una consulta, si bien leí en alguna ayuda de C, que #PRAGMA sirve para compatibilizar, no entiendo su aplicación práctica al momento de interpretar el código.

por ejemplo tengo una linea que dice asi:

#pragma vector=TIMER0_OVF_vect

Abajo de esto viene todo el resto del código
__interrupt void nombre()
etc.
etc.
etc.


Esto me fijé en la tabla del procesador y está definido en la dirección 0x20 y como descripción dice "Timer/Counter0 Overflow

Alguien me podría explicar de que manera interpreto esto y si alguien sabe de BASIC también, decirme cuál es su analogía.

Saludos, y gracias a todos los del foro que me dan una mano.

 

[jfh900]

El significado de pragma es:

#pragma nombre-de-directiva

La directiva #pragma, permite a los compiladores "C" definir sus directivas particulares (que no corresponden a nada establecido en el estándar ANSI) sin interferir con otros compiladores que soporten este tipo de directivas. Si el compilador no reconoce la etiqueta nombre-de-directiva, la directiva es ignorada sin ningún tipo de mensaje o advertencia.

Hasta donde yo llego a entender de este compilador la directive:

#pragma vector=TIMER0_OVF_vect

Esta declarando un vector "vector" que apunta a la direccion de Overflow del Timer0, o lo que es lo mismo a la direccion de la interrupción del overflow del Timer0.

En cuanto a como implementarlo en basic, creo que tendrias que definir la interrupción para este caso.

Un saludo.

[JCAK]

Hola jfh900

Si, eso que me pasaste es lo que leí por ahí, pero sinceramente sigue sin quedarme claro. Es decir, entiendo que la instrucción quedaría como sigue:

#pragma vector=0x20

o sea, setea un vector en la drirectiva #pragma, con un valor de 8 bits.

Pero de ahí en más, qué función cumple esta declaración al referise a la compatibilidad, no me queda claro, pese a que desde que escribí sigo buscando info que me lo aclare.

Saludos y gracias

[jfh900]

Puedes poner un poco mas de código, para ver el contexto en el cual se encuentra la directiva?. Hay que ver donde se utiliza "vector" y como. Tal vez si pones todo el código lo veamos mas coherente.

Un saludo.

[JCAK]

Ahí voy a la carga... y desde ya mil gracias.

Recordar que los registros a los que hace referencia son de ATMEL. Espero no sea motivo de confución, o en todo caso me preguntan y amplío la info.

TIMER0_OVF_vect tiene un valor 0x20 mientras que TIMER1_COMPA_vect vale 0x16
Así tengo otras partes más que comienzan con la directiva #pragma


#pragma vector=TIMER0_OVF_vect
__interrupt void MotorPWMBottom()
{
  unsigned char temp;

  // Disable ADC auto-triggering. This must be done here to avoid wrong channel being sampled on manual samples later.
  ADCSRA &= ~((1 << ADATE) | (1 << ADIE));

  // Wait for auto-triggered ADC sample to complete.
  while (!(ADCSRA & (1 << ADIF)))
  {

  }
  temp = ADCH;
  if (((zcPolarity == EDGE_RISING) && (temp > ADC_ZC_THRESHOLD)) || ((zcPolarity == EDGE_FALLING) && (temp < ADC_ZC_THRESHOLD)))
  {
    unsigned int timeSinceCommutation;

    // Find time since last commutation
    timeSinceCommutation = TCNT1;
    TCNT1 = COMMUTATION_CORRECTION;

    // Filter the current ZC detection with earlier measurements through an IIR filter.
    filteredTimeSinceCommutation = (COMMUTATION_TIMING_IIR_COEFF_A * timeSinceCommutation
                                + COMMUTATION_TIMING_IIR_COEFF_B * filteredTimeSinceCommutation)
                                / (COMMUTATION_TIMING_IIR_COEFF_A + COMMUTATION_TIMING_IIR_COEFF_B);
    OCR1A = filteredTimeSinceCommutation;

    speedUpdated = TRUE;

    SET_TIMER1_INT_COMMUTATION;
    CLEAR_ALL_TIMER1_INT_FLAGS;

    // Disable Timer/Counter0 overflow ISR.
    DISABLE_ALL_TIMER0_INTS;

    // Read speed reference.

    // Make sure that a sample is not in progress.
    while (ADCSRA & (1 << ADSC))
    {

    }
    // Change channel
    ADMUX = ADMUX_SPEED_REF;

    // Start conversion manually.
    ADCSRA |= (1 << ADSC);

    // Wait for conversion to complete.
    while((ADCSRA & (1 << ADSC)))
    {

    }
    speedReferenceADC = ADCH;

    // Read voltage reference.
    // Change ADC channel.
    ADMUX = ADMUX_REF_VOLTAGE;
    // Start conversion manually.
    ADCSRA |= (1 << ADSC);
    // Wait for conversion to complete.
    while((ADCSRA & (1 << ADSC)))
    {

    }
    referenceVoltageADC = ADCH;

    // Enable current measurements in ADC ISR.
    ADMUX = ADMUX_CURRENT;
    ADCSRA |= (1 << ADATE) | (1 << ADIE) | ADC_PRESCALER;
  }
  else
  {
    unsigned char tempADMUX;

    tempADMUX = ADMUX;
    // Read current

    // Make sure that a sample is not in progress
    while (ADCSRA & (1 << ADSC))
    {

    }

    // Change channel
    ADMUX = ADMUX_CURRENT;

    // Start conversion manually.
    ADCSRA |= (1 << ADSC);
    // Wait for conversion to complete.
    while((ADCSRA & (1 << ADSC)))
    {

    }

    shuntVoltageADC = ADCH;
    currentUpdated = TRUE;

    // Restore ADC channel.
    ADMUX = tempADMUX;
    ADCSRA |= (1 << ADATE) | (1 << ADIE) | ADC_PRESCALER;
  }
}


Esta es otra parte del código:


#pragma vector=TIMER1_COMPA_vect
__interrupt void Commutate()
{
  // Commutate and clear commutation timer.
  DRIVE_PORT = nextDrivePattern;
  TCNT1 = 0;

  zcPolarity = nextCommutationStep & 0x01;

  // Set zero-cross detection holdoff time.
  CLEAR_ALL_TIMER1_INT_FLAGS;
  OCR1B = ZC_DETECTION_HOLDOFF_TIME_US;
  SET_TIMER1_INT_HOLDOFF;

  __watchdog_reset();
}


La verdad que no entiendo si esta directiva #pragma es indispensable para usar en el compilador BASIC al que intento pasarlo.


Gracias por la yuda que puedan acercar.

Saludos

[jfh900]

Desde el desconocimiento que poseo de este compilador, y siempre con elocubraciones, parece que esta directiva asigna la función siguiente al evento interrupcion que deseemos, por ejemplo:

#pragma vector=TIMER0_OVF_vect
__interrupt void MotorPWMBottom()

La subrutina de interrupcion MotorPWMBottom() es asignada al evento TIMER0_OVF_vect, o lo que es lo mismo cuando se produce un desbordamiento del Timer0 se llama a MotorPWMBottom.

Creo que ese será el funcionamiento de esta directiva.

Un saludo.

[JCAK]

De ser asi sería barbaro porque ya entendería como aplicarlo en el BASIC

para un basic sería:

ON TIMER0_OVF_vect MotorPWMBottom

O sea que le dice que en caso de la interrupción valla a la rutina MotorPWMBottom

Alguien más que quiera confirma esto y ya estaríamos por la recta final..

Gracias jfh900

[jfh900]

Te dejo este manual para descargar, donde puedes verificar lo indicado:

http://rapidshare.de/files/24118197/cavr.pdf.html

Un saludo.

[JCAK]

Gracias, gracias, gracias ... jfh900

Por ahora no mas preguntas.

Saludos

[JCAK]

He regresado ..... 

El registro se llama TIFR0 y se me hizo un lio con una instrucción que es la siguiente:

TIFR0 = TIFR0;

Esto me parece haber leido que resetea el registro, pero es asi realmente ?

De antemano, gracias una vez mas....