¿Por qué el ejemplo ATtiny85 codifica ceros de desplazamiento de bits?

Navega tus respuestas
3

El ATtiny85 datasheet proporciona el siguiente ejemplo C, en la página 18. 

1  void EEPROM_write(unsigned char ucAddress, unsigned char ucData)
2  {
3     /* Wait for completion of previous write */
4     while(EECR & (1<<EEPE))
5       ;
6     /* Set Programming mode */
7     EECR = (0<<EEPM1)|(0<<EEPM0);
8     /* Set up address and data registers */
9     EEAR = ucAddress;
10    EEDR = ucData;
11    /* Write logical one to EEMPE */
12    EECR |= (1<<EEMPE);
13    /* Start eeprom write by setting EEPE */
14    EECR |= (1<<EEPE);
15  }

(Agregué números de línea al código anterior.)

En línea 7 , ¿por qué el código de ejemplo no se lee simplemente? 

EECR = 0;

¿Por qué molestarse con todas las operaciones bitwise para algo que finalmente se resuelve en cero?

    
pregunta Blair Fonville

1 respuesta

5

En C hay dos formas sensatas de establecer un bit dado en el valor 1. Cualquiera 

REGISTER |= BITMASK;

o 

REGISTER |= (1<<BITNUMBER);

(El primero es el estilo más utilizado, el segundo es menos común, pero Atmel lo prefiere. Cualquiera de los dos está bien).

Entonces, si necesitamos establecer varios bits en un registro en 1, podemos escribir código como 

REGISTER = (1<<THIS) | (1<<THAT);

Esta es una buena práctica de codificación, ya que está perfectamente claro lo que hace el código (a diferencia del código incorrecto que usa "números mágicos").

El único problema con esto es que la razón por la que algunos bits en el mismo registro se ponen a cero no se muestra explícitamente. Por lo tanto, uno puede escribir un código de auto-documentación, como se hizo en este caso, para demostrar que está escribiendo cero intencionalmente en algunos bits de registro.

Si aún damos un paso más allá, el código podría haberse escrito así: 

EECR = (0<<EEPM1)|(0<<EEPM0) |   // Erase and Write in one operation
       (0<<EERIE) |              // EEPROM Ready interrupt disabled
       (0<<EEMPE) |              // EEPROM Master program disabled
       (0<<EEPE)  |              // EEPROM Program disabled
       (0<<EERE);                // EEPROM Read disabled

Ahora está perfectamente claro no solo lo que significan las máscaras mágicas de bits, sino también lo que hace el código, lo que hace el registro y también que el programador en realidad ha considerado cada bit relevante en el registro.

Compara esto con algo muy mal escrito como EECR = 0x26; . No nos dice Jack, para entenderlo, tendremos que sentarnos con la nariz en el manual. Tampoco tenemos idea de si el programador sabe lo que están haciendo o si están escribiendo cero en algunos bits por accidente.

    
respondido por el Lundin

Lea otras preguntas en las etiquetas

Conceptos básicos del transformador: ¿Por qué no cambian la fase en aproximadamente 90 °? Una pregunta sobre la detección remota del suelo y sus ventajas