Mindsensors Light Sensor Array

Mindsensors is working on a new NXT sensor, called a Light Sensor Array. It’s similar in form factor to the LineLeader that they have sold previously, but it doesn’t have a PID algorithm built in. Instead, it just gives you access to the individual light sensors, and their binary states. The reason for this, is that the LineLeader was disqualified from many competitions, since it was too much of a “canned” line follower (it did all the necessary calculations on board).

I made a function that you can use to determine where a line is compared to the sensor. It returns a number from 10-80 based on where it “sees” the line. 45 is the middle, so you can compare the position to 45 to determine the offset from being centered on the line. 0 represents no line detected. Use this in conjunction with the LSA library provided by mindsensors.

float ScaleRange(float Value, float ValueMin, float ValueMax, float DesiredMin, float DesiredMax)
{
return (DesiredMax - DesiredMin) * (Value - ValueMin) / (ValueMax - ValueMin) + DesiredMin;
}

float LSA_Get_Average(byte port, byte addr, byte & Bool_LSA_Values, byte & LSA_Array_Values[], byte LSA_Threshold = 40){
Bool_LSA_Values = 0;                                                          // Reset from last state
int bit_index_i = 0;                                                          // The bit it's working on
int averaging_weight_i = 10;                                                  // The weight to add the the Weighted_Position, if the bit is 1
byte total_bits = 0;                                                          // The number of bits that are true. This is needed for the division at the end
bool set_bit;                                                                 // The bit it's working on
char low_bit = 0;                                                             // The bit just below the lowest 1
char high_bit = 7;                                                            // The bit just above the highest 1

LSA_ReadRaw_Calibrated(port, addr, LSA_Array_Values);                         // Fill LL_Array_Values with the calibrated values of the 8 sensors

for (byte i = 0; i<8; i++){                                                   // Build a byte with the bits set to the boolean state of the sensors
Bool_LSA_Values = Bool_LSA_Values | ((LSA_Array_Values[i]<=LSA_Threshold?1:0)<<i);
}

float Weighted_Position = 0;                                                  // The value that will contain the overall weighted avarage
float Weighted_Position_Adder = 0;                                            // The value that will contain the average adder, based on the effected, but not true sensors
float Absolute_Average = 0;

repeat(8){
set_bit = Bool_LSA_Values >> bit_index_i & 0x01;                            // Seperate the bits out of the byte
Weighted_Position += set_bit * averaging_weight_i;                          // Add the 1's to the value
total_bits += set_bit;                                                      // If the bit was 1, add 1 to the counter (divide by the sum at the end).
averaging_weight_i+=10;                                                     // Set the variables for the next round
bit_index_i++;                                                              //                    ''
}

until((Bool_LSA_Values >> high_bit) & 0x01){                                  // Determine the bit just above the highest set bit
high_bit--;
if(high_bit==-1)break;
}
high_bit++;

until((Bool_LSA_Values >> low_bit) & 0x01){                                   // Determine the bit just below the lowest set bit
low_bit++;
if(low_bit==8)break;
}
low_bit--;

if (0 < high_bit && high_bit < 8 && -1 < low_bit && low_bit < 7){             // Both ends can be used
Weighted_Position_Adder = (ScaleRange(LSA_Array_Values[low_bit], LSA_Threshold, 100, 0, 100) - ScaleRange(LSA_Array_Values[high_bit], LSA_Threshold, 100, 0, 100)) / 20;
}
if(high_bit == 8 && low_bit == -1){                                           // According to logic, blacked out totally
return 45;
}
else{
if(high_bit==8){                                                            // Black off the high side, but not totally blacked out
Weighted_Position_Adder = ScaleRange(LSA_Array_Values[low_bit], LSA_Threshold, 100, -2.5, 2.5);//(100/(100-Threshold)*lower/20)-5;
}
if(low_bit==-1){                                                            // Black off the low side, but not totally blacked out
Weighted_Position_Adder = ScaleRange(LSA_Array_Values[high_bit], LSA_Threshold, 100, 5, 0);//((100/(100-Threshold)*higher/20)-5) *(-1);
}
}
if(low_bit==7&&high_bit==0){                                                  // According to logic, whited out completely
if(LSA_Array_Values<LSA_Array_Values){                                // More detection on the low side
Weighted_Position_Adder = ScaleRange(LSA_Array_Values, LSA_Threshold, 100, 10, 5);
}
else{
if (LSA_Array_Values>LSA_Array_Values){                             // More detection on the high side
Weighted_Position_Adder = ScaleRange(LSA_Array_Values, LSA_Threshold, 100, 0, 5) + 82;
}
}
}

//NumOut(54, LCD_LINE5, Weighted_Position_Adder);                             // The average's adder calculated by the closest non-true bytes

if (Weighted_Position/total_bits+Weighted_Position_Adder){ //Not equal to 0
Absolute_Average = ScaleRange(Weighted_Position/total_bits+Weighted_Position_Adder, 5, 86, 10, 80); // Avaragetotal divided by the number of bits high, plus the adder. Then scale this from 0-82 to 0-80 so it is the same as the LL native average.
}
return Absolute_Average;
}