Pues, tras varios intentos, creo que he conseguido lo que queria. Ahora, para comparar resultados, tengo 3 códigos:
1- "no rápido: analogRead()
2- "rápido: ADLAR=1 Byte ADCH"
Estos códigos anteriores ya están puestos anteriormente
3- "rápido: ADLAR=0 byte ADCL"
Éste último código es:
// *********************************
// datos rápidos ADLAR=0 byte ADCL
// *********************************
#define mysize 40
unsigned long tStart;
unsigned long tEnd;
byte mydata[mysize];
unsigned int bytes_datos[mysize];
void setup()
{
Serial.begin(115200);
delay(200);
//Prescaler
//ADPS2 - ADPS1 - ADPS0 - Division Factor
//0 0 0 ->2
//0 0 1 ->2
//0 1 0 ->4
//0 1 1 ->8
//1 0 0 ->16
//1 0 1 ->32
//1 1 0 ->64
//1 1 1 ->128
//Configure to Prescaler=32
bitWrite(ADCSRA,ADPS2,1); // sbi(ADCSRA, ADPS2);
bitWrite(ADCSRA,ADPS1,0); // cbi(ADCSRA, ADPS1);
bitWrite(ADCSRA,ADPS0,1); // sbi(ADCSRA, ADPS0);
// Input Channel Selections
// MUX3210 Single Ended Input
// 0000 ADC0
// 0001 ADC1
// 0010 ADC2
// 0011 ADC3
// 0100 ADC4
// 0101 ADC5
// 0110 ADC6
// 0111 ADC7
// 1000 ACD8
// Entrada A4
ADMUX=(0<<REFS1)|(1<<REFS0)|(0<<MUX3)|(1<<MUX2)|(0<<MUX1)|(0<<MUX0);//(1<<ADLAR)|
}
void loop()
{
Serial.println("espero corte:");
mydata[0] =analogReadFast();
while (analogReadFast()>mydata[0]-10){};
tStart=micros();
for (int i=1; i<mysize;i++)
{
mydata[i]=analogReadFast();
}
tEnd=micros();
for (int i=0; i<mysize;i++)
{
Serial.print(mydata[i],DEC); Serial.print(" ");
}
Serial.println("");
Serial.println("NEW ACQUISITION");
Serial.print("tStart=");
Serial.println(tStart);
Serial.print("tEnd=");
Serial.println(tEnd);
Serial.print("Tiempo: ");
Serial.println(tEnd-tStart);
Serial.print("nPoints=");
Serial.println(mysize);
}
int analogReadFast()
{
ADCSRA|=(1<<ADSC); // sbi(ADCSRA, ADSC);
// ADSC is cleared when the conversion finishes
while (bit_is_set(ADCSRA, ADSC));
byte BAJO=ADCL;
byte ALTO=ADCH;
return BAJO;
}
La modificaciónes aplicadas son:
-
la línea que define el registro ADMUX, en la que he suprimido la parte que asigna 1 al byte ADLAR, por lo que ahora ADLAR = 0. Ésto es necesario para hacer un desplazamiento de 2 bits hacia la derecha
-
la función analogReadFast(), en la que, después de leer el byte bajo y el alto, envio solo el byte bajo(ADCL). por lo que siempre que el valor del sensor sea < 255 la transmisión de datos será real y la rapidez mucho mayor como puede verse a continuación:
DATOS NO RAPIDOS
esperando corte...
196 181 173 166 158 147 130 108 89 74 61 50 40 34 32 33 35 40 44 52 60 67 77 93 113 134 150 162 174 185 192 195 196 195 196 196 196 195 196 195
NEW ACQUISITION
tStart=1601608
tEnd=1605976
Tiempo: 4368
nPoints=40
esperando corte...
Los resultado son correctos, pero la duración es grande debido a que la transmisión de cada dato ocupa 2 bytes.
DATOS RAPIDOS(ADLAR=1; ADCH)
espero corte:
49 39 38 38 37 37 36 35 35 34 33 32 31 30 29 28 27 26 25 24 23 22 22 21 20 19 18 18 17 16 16 15 14 14 13 12 12 11 11 10
NEW ACQUISITION
tStart=2872060
tEnd=2873156
Tiempo: 1096
nPoints=40
espero corte:
Los resultados tienen corta duración, pues cada dato ocupa 1 sólo byte, pero a consta de hacer un desplazamiento de 2 bytes a la izquierda, por que el valor es menor y hay una ligera disminución de la precisión
DATOS RAPIDOS(ADLAR=0; ADCL)
espero corte:
195 183 179 177 174 170 168 165 161 158 154 150 145 142 138 133 129 124 119 113 109 104 100 96 92 88 85 81 79 76 73 71 68 66 63 61 59 57 56 53
NEW ACQUISITION
tStart=2254152
tEnd=2255248
Tiempo: 1096
nPoints=40
espero corte:
Los datos se transmiten igual de rápidos que en el caso anterior, pues siguen ocupando 1 byte. Ahora hay un desplazamienos de 2 bits a la derecha, y el valor es real(no se reduce su tamaño), coincidiendo con los de los primeros datos, siempre que no se supere el límite de ese byte, que es 255.
Gracias Igor R, ha sido un placer.