Alvaro Cassinelli / Mbed 2 deprecated laserUI

Laser Sensing Display for UI interfaces in the real world

Dependencies:   mbed

Fork of skinGames_forktest by Alvaro Cassinelli

hardwareIO/hardwareIO.cpp@22:d87317d7ca91, 2012-06-02 (annotated)

Committer:
mbedalvaro
Date:
Sat Jun 02 06:38:12 2012 +0000
Revision:
22:d87317d7ca91
Parent:
14:0fc33a3a7b4b
Child:
23:bf666fcc61bc
testing the LUT table

Who changed what in which revision?

UserRevisionLine numberNew contents of line
mbedalvaro 0:345b3bc7a0ea 1 #include "hardwareIO.h"
mbedalvaro 0:345b3bc7a0ea 2
mbedalvaro 0:345b3bc7a0ea 3 HardwareIO IO; // preintantiation of cross-file global object IO
mbedalvaro 0:345b3bc7a0ea 4
mbedalvaro 0:345b3bc7a0ea 5 // -------------------------------------- (0) SETUP ALL IO (call this in the setup() function in main program)
mbedalvaro 0:345b3bc7a0ea 6
mbedalvaro 0:345b3bc7a0ea 7 Serial pc(USBTX, USBRX); // tx, rx
mbedalvaro 0:345b3bc7a0ea 8 LocalFileSystem local("local"); // Create the local filesystem under the name "local"
mbedalvaro 0:345b3bc7a0ea 9
mbedalvaro 0:345b3bc7a0ea 10 SPI spiDAC(MOSI_PIN, MISO_PIN, SCK_PIN); // mosi, miso, sclk
mbedalvaro 0:345b3bc7a0ea 11 DigitalOut csDAC(CS_DAC_MIRRORS);
mbedalvaro 0:345b3bc7a0ea 12
mbedalvaro 0:345b3bc7a0ea 13 DigitalOut Laser_Red(LASER_RED_PIN);
mbedalvaro 0:345b3bc7a0ea 14 DigitalOut Laser_Green(LASER_GREEN_PIN);
mbedalvaro 0:345b3bc7a0ea 15 DigitalOut Laser_Blue(LASER_BLUE_PIN);
mbedalvaro 0:345b3bc7a0ea 16
mbedalvaro 0:345b3bc7a0ea 17 void HardwareIO::init(void) {
mbedalvaro 0:345b3bc7a0ea 18 Laser_Red = 1;
mbedalvaro 0:345b3bc7a0ea 19 Laser_Green = 0;
mbedalvaro 0:345b3bc7a0ea 20 Laser_Blue = 0;
mbedalvaro 0:345b3bc7a0ea 21
mbedalvaro 0:345b3bc7a0ea 22 //Serial Communication setup:
mbedalvaro 14:0fc33a3a7b4b 23 pc.baud(115200);//
mbedalvaro 14:0fc33a3a7b4b 24 // pc.baud(921600);//115200);//
mbedalvaro 0:345b3bc7a0ea 25
mbedalvaro 0:345b3bc7a0ea 26 // Setup for lock-in amplifier and pwm references:
mbedalvaro 0:345b3bc7a0ea 27 lockin.init();
mbedalvaro 0:345b3bc7a0ea 28
mbedalvaro 0:345b3bc7a0ea 29 // Setup the spi for 8 bit data, high steady state clock,
mbedalvaro 0:345b3bc7a0ea 30 // second edge capture, with a 10MHz clock rate
mbedalvaro 0:345b3bc7a0ea 31 csDAC = 1;
mbedalvaro 0:345b3bc7a0ea 32 spiDAC.format(16,0);
mbedalvaro 0:345b3bc7a0ea 33 spiDAC.frequency(16000000);
mbedalvaro 0:345b3bc7a0ea 34
mbedalvaro 0:345b3bc7a0ea 35 // default initial mirror position:
mbedalvaro 0:345b3bc7a0ea 36 writeOutX(CENTER_AD_MIRROR_X);
mbedalvaro 0:345b3bc7a0ea 37 writeOutY(CENTER_AD_MIRROR_Y);
mbedalvaro 0:345b3bc7a0ea 38
mbedalvaro 0:345b3bc7a0ea 39 // Load LUT table:
mbedalvaro 0:345b3bc7a0ea 40 setLUT();
mbedalvaro 0:345b3bc7a0ea 41 }
mbedalvaro 0:345b3bc7a0ea 42
mbedalvaro 0:345b3bc7a0ea 43 //write on the first DAC, output A (mirror X)
mbedalvaro 10:6f8e48dca1bd 44 void HardwareIO::writeOutX(unsigned short value){
mbedalvaro 0:345b3bc7a0ea 45 if(value > MAX_AD_MIRRORS) value = MAX_AD_MIRRORS;
mbedalvaro 0:345b3bc7a0ea 46 if(value < MIN_AD_MIRRORS) value = MIN_AD_MIRRORS;
mbedalvaro 0:345b3bc7a0ea 47
mbedalvaro 0:345b3bc7a0ea 48 value |= 0x7000;
mbedalvaro 0:345b3bc7a0ea 49 value &= 0x7FFF;
mbedalvaro 0:345b3bc7a0ea 50
mbedalvaro 0:345b3bc7a0ea 51 csDAC = 0;
mbedalvaro 0:345b3bc7a0ea 52 spiDAC.write(value);
mbedalvaro 0:345b3bc7a0ea 53 csDAC = 1;
mbedalvaro 0:345b3bc7a0ea 54 }
mbedalvaro 0:345b3bc7a0ea 55
mbedalvaro 0:345b3bc7a0ea 56 //write on the first DAC, output B (mirror Y)
mbedalvaro 10:6f8e48dca1bd 57 void HardwareIO::writeOutY(unsigned short value){
mbedalvaro 0:345b3bc7a0ea 58 if(value > MAX_AD_MIRRORS) value = MAX_AD_MIRRORS;
mbedalvaro 0:345b3bc7a0ea 59 if(value < MIN_AD_MIRRORS) value = MIN_AD_MIRRORS;
mbedalvaro 0:345b3bc7a0ea 60
mbedalvaro 0:345b3bc7a0ea 61 value |= 0xF000;
mbedalvaro 0:345b3bc7a0ea 62 value &= 0xFFFF;
mbedalvaro 0:345b3bc7a0ea 63
mbedalvaro 0:345b3bc7a0ea 64 csDAC = 0;
mbedalvaro 0:345b3bc7a0ea 65 spiDAC.write(value);
mbedalvaro 0:345b3bc7a0ea 66 csDAC = 1;
mbedalvaro 0:345b3bc7a0ea 67 }
mbedalvaro 0:345b3bc7a0ea 68
mbedalvaro 0:345b3bc7a0ea 69 void HardwareIO::setRedPower(int powerValue){
mbedalvaro 0:345b3bc7a0ea 70 if(powerValue > 0){
mbedalvaro 0:345b3bc7a0ea 71 lockin.setLaserPower(true);
mbedalvaro 0:345b3bc7a0ea 72 }
mbedalvaro 0:345b3bc7a0ea 73 else{
mbedalvaro 0:345b3bc7a0ea 74 lockin.setLaserPower(false);
mbedalvaro 0:345b3bc7a0ea 75 }
mbedalvaro 0:345b3bc7a0ea 76 }
mbedalvaro 0:345b3bc7a0ea 77 void HardwareIO::setGreenPower(int powerValue){
mbedalvaro 0:345b3bc7a0ea 78 if(powerValue > 0){
mbedalvaro 0:345b3bc7a0ea 79 Laser_Green = 1;
mbedalvaro 0:345b3bc7a0ea 80 }
mbedalvaro 0:345b3bc7a0ea 81 else{
mbedalvaro 0:345b3bc7a0ea 82 Laser_Green = 0;
mbedalvaro 0:345b3bc7a0ea 83 }
mbedalvaro 0:345b3bc7a0ea 84 }
mbedalvaro 0:345b3bc7a0ea 85 void HardwareIO::setBluePower(int powerValue){
mbedalvaro 0:345b3bc7a0ea 86 if(powerValue > 0){
mbedalvaro 0:345b3bc7a0ea 87 Laser_Blue = 1;
mbedalvaro 0:345b3bc7a0ea 88 }
mbedalvaro 0:345b3bc7a0ea 89 else{
mbedalvaro 0:345b3bc7a0ea 90 Laser_Blue = 0;
mbedalvaro 0:345b3bc7a0ea 91 }
mbedalvaro 0:345b3bc7a0ea 92 }
mbedalvaro 0:345b3bc7a0ea 93
mbedalvaro 0:345b3bc7a0ea 94 void HardwareIO::setRGBPower(char color) {
mbedalvaro 0:345b3bc7a0ea 95 lockin.setLaserPower(color&0x04);
mbedalvaro 0:345b3bc7a0ea 96 Laser_Green=(color&0x02)>>1;
mbedalvaro 0:345b3bc7a0ea 97 Laser_Blue =(color&0x01);
mbedalvaro 0:345b3bc7a0ea 98 }
mbedalvaro 0:345b3bc7a0ea 99
mbedalvaro 22:d87317d7ca91 100 void HardwareIO::showLimitsMirrors(int times) {
mbedalvaro 22:d87317d7ca91 101 unsigned short pointsPerLine=100;
mbedalvaro 22:d87317d7ca91 102
mbedalvaro 22:d87317d7ca91 103 for (int repeat=0; repeat<times; repeat++) {
mbedalvaro 22:d87317d7ca91 104
mbedalvaro 22:d87317d7ca91 105 int shiftX = (MAX_AD_MIRRORS - MIN_AD_MIRRORS) / pointsPerLine;
mbedalvaro 22:d87317d7ca91 106 int shiftY = (MAX_AD_MIRRORS - MIN_AD_MIRRORS) / pointsPerLine;
mbedalvaro 22:d87317d7ca91 107
mbedalvaro 22:d87317d7ca91 108 writeOutX(MIN_AD_MIRRORS);writeOutY(MIN_AD_MIRRORS);
mbedalvaro 22:d87317d7ca91 109 for(int j=0; j<pointsPerLine; j++){
mbedalvaro 22:d87317d7ca91 110 wait_us(200);//delay between each points
mbedalvaro 22:d87317d7ca91 111 writeOutY(j*shiftY + MIN_AD_MIRRORS);
mbedalvaro 22:d87317d7ca91 112 }
mbedalvaro 22:d87317d7ca91 113
mbedalvaro 22:d87317d7ca91 114 writeOutX(MIN_AD_MIRRORS);writeOutY(MAX_AD_MIRRORS);
mbedalvaro 22:d87317d7ca91 115 for(int j=0; j<pointsPerLine; j++) {
mbedalvaro 22:d87317d7ca91 116 wait_us(200);//delay between each points
mbedalvaro 22:d87317d7ca91 117 writeOutX(j*shiftX + MAX_AD_MIRRORS);
mbedalvaro 22:d87317d7ca91 118 }
mbedalvaro 22:d87317d7ca91 119
mbedalvaro 22:d87317d7ca91 120 writeOutX(MAX_AD_MIRRORS);writeOutY(MAX_AD_MIRRORS);
mbedalvaro 22:d87317d7ca91 121 for(int j=0; j<pointsPerLine; j++) {
mbedalvaro 22:d87317d7ca91 122 wait_us(200);//delay between each points
mbedalvaro 22:d87317d7ca91 123 writeOutY(-j*shiftX + MAX_AD_MIRRORS);
mbedalvaro 22:d87317d7ca91 124 }
mbedalvaro 22:d87317d7ca91 125
mbedalvaro 22:d87317d7ca91 126 writeOutX(MAX_AD_MIRRORS);writeOutY(MIN_AD_MIRRORS);
mbedalvaro 22:d87317d7ca91 127 for(int j=0; j<pointsPerLine; j++) {
mbedalvaro 22:d87317d7ca91 128 wait_us(200);//delay between each points
mbedalvaro 22:d87317d7ca91 129 writeOutX(-j*shiftX + MAX_AD_MIRRORS);
mbedalvaro 22:d87317d7ca91 130 }
mbedalvaro 22:d87317d7ca91 131
mbedalvaro 22:d87317d7ca91 132 }
mbedalvaro 22:d87317d7ca91 133 }
mbedalvaro 22:d87317d7ca91 134
mbedalvaro 10:6f8e48dca1bd 135 void HardwareIO::scan_serial(unsigned short pointsPerLine){
mbedalvaro 0:345b3bc7a0ea 136 //scan the total surface with a custom resolution
mbedalvaro 0:345b3bc7a0ea 137 //send the lockin value for each point as a byte on the serial port to the PC
mbedalvaro 0:345b3bc7a0ea 138 //use "scanSLP_save" to see the data on processing
mbedalvaro 0:345b3bc7a0ea 139
mbedalvaro 0:345b3bc7a0ea 140
mbedalvaro 0:345b3bc7a0ea 141 int shiftX = (MAX_AD_MIRRORS - MIN_AD_MIRRORS) / pointsPerLine;
mbedalvaro 0:345b3bc7a0ea 142 int shiftY = (MAX_AD_MIRRORS - MIN_AD_MIRRORS) / pointsPerLine;
mbedalvaro 0:345b3bc7a0ea 143
mbedalvaro 0:345b3bc7a0ea 144 for(int j=0; j<pointsPerLine; j++){
mbedalvaro 0:345b3bc7a0ea 145 writeOutX(MIN_AD_MIRRORS);
mbedalvaro 0:345b3bc7a0ea 146 writeOutY(j*shiftY + MIN_AD_MIRRORS);
mbedalvaro 0:345b3bc7a0ea 147
mbedalvaro 0:345b3bc7a0ea 148 wait_us(300);//begining of line delay
mbedalvaro 0:345b3bc7a0ea 149 for(int i=0; i<pointsPerLine; i++){
mbedalvaro 0:345b3bc7a0ea 150 writeOutX(i*shiftX + MIN_AD_MIRRORS);
mbedalvaro 0:345b3bc7a0ea 151
mbedalvaro 14:0fc33a3a7b4b 152 wait_us(200);//delay between each points
mbedalvaro 10:6f8e48dca1bd 153
mbedalvaro 10:6f8e48dca1bd 154 // SEND A VALUE BETWEEN 0 and 255:
mbedalvaro 0:345b3bc7a0ea 155 pc.putc(int(255.0*lockin.getMedianValue()/4095));//printf("%dL",int(valueLockin*255));//pc.putc(int(lockin*255));//
mbedalvaro 0:345b3bc7a0ea 156 }
mbedalvaro 0:345b3bc7a0ea 157 }
mbedalvaro 0:345b3bc7a0ea 158 }
mbedalvaro 0:345b3bc7a0ea 159
mbedalvaro 0:345b3bc7a0ea 160 //load Look-up Table from LUT.TXT file
mbedalvaro 0:345b3bc7a0ea 161 //or create the file with scanLUT() if not existing.
mbedalvaro 0:345b3bc7a0ea 162 void HardwareIO::setLUT(){
mbedalvaro 0:345b3bc7a0ea 163
mbedalvaro 0:345b3bc7a0ea 164 FILE *fp = fopen(LUT_FILENAME, "r"); // Open file on the local file system for writing
mbedalvaro 0:345b3bc7a0ea 165 if(fp){
mbedalvaro 0:345b3bc7a0ea 166 //load the file into the lut table; keep the SAME resolution!
mbedalvaro 0:345b3bc7a0ea 167 fread(lut,sizeof(uint16),LUT_RESOLUTION*LUT_RESOLUTION,fp);
mbedalvaro 0:345b3bc7a0ea 168 fclose(fp);
mbedalvaro 0:345b3bc7a0ea 169 }
mbedalvaro 0:345b3bc7a0ea 170 else{
mbedalvaro 0:345b3bc7a0ea 171 //fclose(fp);
mbedalvaro 0:345b3bc7a0ea 172 //if the file "LUT.TXT" doesn't exist, create one with scanLUT()
mbedalvaro 0:345b3bc7a0ea 173 lockin.setLaserPower(true);
mbedalvaro 0:345b3bc7a0ea 174 scanLUT();
mbedalvaro 0:345b3bc7a0ea 175 }
mbedalvaro 0:345b3bc7a0ea 176
mbedalvaro 0:345b3bc7a0ea 177 }
mbedalvaro 0:345b3bc7a0ea 178
mbedalvaro 0:345b3bc7a0ea 179 //scan the total surface with a fixed 2^x resolution
mbedalvaro 0:345b3bc7a0ea 180 //create the Look-Up Table used to "flatten" the scan according to the position
mbedalvaro 0:345b3bc7a0ea 181 //
mbedalvaro 0:345b3bc7a0ea 182 //To Do: maybe detect high frequency to be sure the area is clean and empty?
mbedalvaro 0:345b3bc7a0ea 183 void HardwareIO::scanLUT(){
mbedalvaro 0:345b3bc7a0ea 184
mbedalvaro 0:345b3bc7a0ea 185 //reset lut table
mbedalvaro 0:345b3bc7a0ea 186 for(int j=0; j<LUT_RESOLUTION; j++){
mbedalvaro 0:345b3bc7a0ea 187 for(int i=0; i<LUT_RESOLUTION; i++){
mbedalvaro 0:345b3bc7a0ea 188 lut[i][j] =0;
mbedalvaro 0:345b3bc7a0ea 189 }
mbedalvaro 0:345b3bc7a0ea 190 }
mbedalvaro 0:345b3bc7a0ea 191
mbedalvaro 0:345b3bc7a0ea 192 int delayScanning = 300; //in us
mbedalvaro 0:345b3bc7a0ea 193
mbedalvaro 0:345b3bc7a0ea 194 //define the distance between each points (from 0 to 4096) and the offset (here 0)
mbedalvaro 0:345b3bc7a0ea 195 float shiftX = 1.0*(MAX_AD_MIRRORS - MIN_AD_MIRRORS) / (LUT_RESOLUTION-1);
mbedalvaro 0:345b3bc7a0ea 196 float shiftY = 1.0*(MAX_AD_MIRRORS - MIN_AD_MIRRORS) / (LUT_RESOLUTION-1);
mbedalvaro 0:345b3bc7a0ea 197 float offsetX = MIN_AD_MIRRORS;
mbedalvaro 0:345b3bc7a0ea 198 float offsetY = MIN_AD_MIRRORS;
mbedalvaro 0:345b3bc7a0ea 199
mbedalvaro 0:345b3bc7a0ea 200 //move the mirrors to the first position
mbedalvaro 0:345b3bc7a0ea 201 writeOutX(MAX_AD_MIRRORS);writeOutY(MIN_AD_MIRRORS);
mbedalvaro 0:345b3bc7a0ea 202 wait_us(500);
mbedalvaro 0:345b3bc7a0ea 203
mbedalvaro 0:345b3bc7a0ea 204 float x, y;
mbedalvaro 0:345b3bc7a0ea 205
mbedalvaro 10:6f8e48dca1bd 206 //scan the surface NB_SCANS times
mbedalvaro 0:345b3bc7a0ea 207 //the total value in lut[i][j] shouldn't exceed uint16 !!!
mbedalvaro 10:6f8e48dca1bd 208 for(int loop=0; loop<NB_SCANS; loop++){
mbedalvaro 0:345b3bc7a0ea 209 for(int j=0; j<LUT_RESOLUTION; j++){
mbedalvaro 0:345b3bc7a0ea 210 y = shiftY*j + offsetY ;
mbedalvaro 0:345b3bc7a0ea 211 writeOutY(int(y));
mbedalvaro 0:345b3bc7a0ea 212 //scan from right to left
mbedalvaro 0:345b3bc7a0ea 213 for(int i=LUT_RESOLUTION-1; i>=0; i--){
mbedalvaro 0:345b3bc7a0ea 214 x = shiftX*i + offsetX;
mbedalvaro 0:345b3bc7a0ea 215 writeOutX(int(x));
mbedalvaro 0:345b3bc7a0ea 216 wait_us(delayScanning);
mbedalvaro 0:345b3bc7a0ea 217 lut[i][j] += lockin_read();
mbedalvaro 0:345b3bc7a0ea 218 }
mbedalvaro 0:345b3bc7a0ea 219 //re-scan from left to right
mbedalvaro 0:345b3bc7a0ea 220 for(int i=0; i<LUT_RESOLUTION; i++){
mbedalvaro 0:345b3bc7a0ea 221 x = shiftX*i + offsetX;
mbedalvaro 0:345b3bc7a0ea 222 writeOutX(int(x));
mbedalvaro 0:345b3bc7a0ea 223 wait_us(delayScanning);
mbedalvaro 0:345b3bc7a0ea 224 lut[i][j] += lockin_read();
mbedalvaro 0:345b3bc7a0ea 225 }
mbedalvaro 0:345b3bc7a0ea 226 }
mbedalvaro 0:345b3bc7a0ea 227 }
mbedalvaro 0:345b3bc7a0ea 228
mbedalvaro 0:345b3bc7a0ea 229
mbedalvaro 0:345b3bc7a0ea 230 //save tab in file
mbedalvaro 0:345b3bc7a0ea 231 FILE *fp;
mbedalvaro 0:345b3bc7a0ea 232 #ifdef LUT_FILENAME
mbedalvaro 0:345b3bc7a0ea 233 fp = fopen(LUT_FILENAME, "w"); // Open file on the local file system for writing
mbedalvaro 0:345b3bc7a0ea 234 fwrite(lut,sizeof(uint16),LUT_RESOLUTION*LUT_RESOLUTION,fp);
mbedalvaro 0:345b3bc7a0ea 235 fclose(fp); //close the file (the mBed will appear connected again)
mbedalvaro 0:345b3bc7a0ea 236 #endif
mbedalvaro 0:345b3bc7a0ea 237
mbedalvaro 0:345b3bc7a0ea 238 #ifdef LUT_H_FILENAME
mbedalvaro 22:d87317d7ca91 239 //save tab in Human readable file (not used by the program, this is just for checking)
mbedalvaro 22:d87317d7ca91 240 // NOTE: we divide the content of the lut table by NB_SCANS, for easy reading (values should be between 0-4095)
mbedalvaro 0:345b3bc7a0ea 241 fp = fopen(LUT_H_FILENAME, "w"); // Open file on the local file system for writing
mbedalvaro 0:345b3bc7a0ea 242 fprintf(fp, "scan resolution: %d x %d\r\n",LUT_RESOLUTION, LUT_RESOLUTION);
mbedalvaro 0:345b3bc7a0ea 243 for(int j=0; j<LUT_RESOLUTION; j++){
mbedalvaro 0:345b3bc7a0ea 244 for(int i=0; i<LUT_RESOLUTION; i++){
mbedalvaro 0:345b3bc7a0ea 245 fprintf(fp, "X=%d,\tY=%d,\tI=%d\t \r\n", int(shiftX*i + offsetX), int(shiftY*j + offsetY), lut[i][j] );
mbedalvaro 0:345b3bc7a0ea 246 }
mbedalvaro 0:345b3bc7a0ea 247 }
mbedalvaro 0:345b3bc7a0ea 248 fclose(fp); //close the file (the mBed will appear connected again)
mbedalvaro 0:345b3bc7a0ea 249 #endif
mbedalvaro 0:345b3bc7a0ea 250
mbedalvaro 0:345b3bc7a0ea 251 }
mbedalvaro 0:345b3bc7a0ea 252
mbedalvaro 0:345b3bc7a0ea 253
mbedalvaro 10:6f8e48dca1bd 254 //Return the lockin value "corrected with the Look-UpTable" - this means a RATIO between two reflectivities (and normally, this is <1).
mbedalvaro 10:6f8e48dca1bd 255 float HardwareIO::lockInCorrectedValue(unsigned short x, unsigned short y){
mbedalvaro 0:345b3bc7a0ea 256 //*******Correction using DIRECT approximation
mbedalvaro 0:345b3bc7a0ea 257 #ifdef LUT_DIRECT
mbedalvaro 10:6f8e48dca1bd 258 return 2.0* NB_SCANS * lockin_read() / (lut[x >> LUT_BITS_SHIFT][y >> LUT_BITS_SHIFT]); // 2 * NB_SCANS is the number of recorded sample added to one position of the LUT (scan is performed twice: left-right and right-left)
mbedalvaro 22:d87317d7ca91 259 #endif
mbedalvaro 22:d87317d7ca91 260
mbedalvaro 0:345b3bc7a0ea 261 //*******Correction using BILINEAR approximation
mbedalvaro 0:345b3bc7a0ea 262 #ifdef LUT_BILINEAR
mbedalvaro 14:0fc33a3a7b4b 263 unsigned short X = x >> LUT_BITS_SHIFT; //mirror "x" is 12bits, LUT "X" needs 4bits when lut is 17x17
mbedalvaro 14:0fc33a3a7b4b 264 unsigned short Y = y >> LUT_BITS_SHIFT; //mirror "y" is 12bits, LUT "Y" needs 4bits when lut is 17x17
mbedalvaro 0:345b3bc7a0ea 265 float dx = 1.0*(x & LUT_BITS_MASK)/(LUT_BITS_MASK+1); //weight to apply on X (mask with 255 and norm)
mbedalvaro 0:345b3bc7a0ea 266 float dy = 1.0*(y & LUT_BITS_MASK)/(LUT_BITS_MASK+1); //weight to apply on Y (mask with 255 and norm)
mbedalvaro 0:345b3bc7a0ea 267
mbedalvaro 0:345b3bc7a0ea 268 //Wheighted mean approximation of the Look-Up Table at the position (x,y):
mbedalvaro 0:345b3bc7a0ea 269 float wmLUT = (1-dy)*( (1-dx)*lut[X][Y] + dx*lut[X+1][Y] ) + dy*( (1-dx)*lut[X][Y+1] + dx*lut[X+1][Y+1] );
mbedalvaro 0:345b3bc7a0ea 270
mbedalvaro 22:d87317d7ca91 271 return 2.0* NB_SCANS * lockin_read() / wmLUT;// 2 * NB_SCANS is the number of recorded sample added to one position of the LUT (scan is performed twice: left-right and right-left)
mbedalvaro 22:d87317d7ca91 272 #endif
mbedalvaro 22:d87317d7ca91 273
mbedalvaro 0:345b3bc7a0ea 274 //*******Correction using LINEAR approximation
mbedalvaro 0:345b3bc7a0ea 275 #ifdef LUT_LINEAR
mbedalvaro 14:0fc33a3a7b4b 276 unsigned short X = x >> LUT_BITS_SHIFT; //mirror "x" is 12bits, LUT "X" needs 4bits when lut is 17x17
mbedalvaro 14:0fc33a3a7b4b 277 unsigned short Y = y >> LUT_BITS_SHIFT; //mirror "y" is 12bits, LUT "Y" needs 4bits when lut is 17x17
mbedalvaro 0:345b3bc7a0ea 278 float dx = 1.0*(x & LUT_BITS_MASK)/(LUT_BITS_MASK+1); //weight to apply on X (mask with 255 and norm)
mbedalvaro 0:345b3bc7a0ea 279 float dy = 1.0*(y & LUT_BITS_MASK)/(LUT_BITS_MASK+1); //weight to apply on Y (mask with 255 and norm)
mbedalvaro 0:345b3bc7a0ea 280 float linearLUT, dzx, dzy;
mbedalvaro 0:345b3bc7a0ea 281
mbedalvaro 0:345b3bc7a0ea 282 if(dx>dy){ //if the position is on the "top-right" triangle
mbedalvaro 0:345b3bc7a0ea 283 dzx = (lut[X+1][Y] - lut[X][Y]) * dx;
mbedalvaro 0:345b3bc7a0ea 284 dzy = (lut[X+1][Y+1] - lut[X+1][Y]) * dy;
mbedalvaro 0:345b3bc7a0ea 285 }
mbedalvaro 0:345b3bc7a0ea 286 else{ //if the position is on the "bottom-left" triangle
mbedalvaro 0:345b3bc7a0ea 287 dzy = (lut[X][Y+1] - lut[X][Y]) * dy;
mbedalvaro 0:345b3bc7a0ea 288 dzx = (lut[X+1][Y+1] - lut[X][Y+1]) * dx;
mbedalvaro 0:345b3bc7a0ea 289 }
mbedalvaro 0:345b3bc7a0ea 290
mbedalvaro 0:345b3bc7a0ea 291 //linear approximation of the Look-Up Table at the position (x,y):
mbedalvaro 0:345b3bc7a0ea 292 linearLUT = lut[X][Y] + dzx + dzy;
mbedalvaro 10:6f8e48dca1bd 293 return 2.0* NB_SCANS * lockin_read() / linearLUT; // 2 * NB_SCANS is the number of recorded sample added to one position of the LUT (scan is performed twice: left-right and right-left)
mbedalvaro 0:345b3bc7a0ea 294
mbedalvaro 22:d87317d7ca91 295 #endif
mbedalvaro 22:d87317d7ca91 296
mbedalvaro 22:d87317d7ca91 297 //*******No corrections, just return the value divided by 4096 (this means we are assuming that the surface is everywhere perfectly reflective - we supposedly get the max value always)
mbedalvaro 22:d87317d7ca91 298 #ifdef NO_LUT
mbedalvaro 10:6f8e48dca1bd 299 return 1.0* lockin_read()/4096;
mbedalvaro 22:d87317d7ca91 300 #endif
mbedalvaro 22:d87317d7ca91 301
mbedalvaro 0:345b3bc7a0ea 302 }