WebSVN – MLAB – /Modules/Sensors/IMU01A/SW/PIC16F887/ Rev 2961 and /Modules/Sensors/IMU01A/SW/PIC16F887/ Rev 2962 – Path Comparison

No changes between revisions

 /Modules/Sensors/IMU01A/SW/PIC16F887/MMA8451Q.c
 ,0 → 1,59
+void setAK (void) //nastaveni akcelerometru
+{
+   i2c_start();
+   I2C_Write(AK_W);
+   I2C_write(0x2A);
+   I2C_write(0x01); //nastavi aktivni stav
+   i2c_stop();
+}
+int16 akR (int8 H, int8 L) //vycitani hodnot z akcelerometru
+{
+unsigned int8 XL=0,XH=0;
+signed int16 x;
+   i2c_start();
+   I2C_Write(AK_W);
+   I2C_write(H);
+   i2c_start();
+   I2C_Write(AK_R);
+   XH=i2c_read(0);
+   i2c_stop();
+   i2c_start();
+   I2C_Write(AK_W);
+   I2C_write(L);
+   i2c_start();
+   I2C_Write(AK_R);
+   XL=i2c_read(0);
+   i2c_stop();
+   x = (((unsigned int16) XH << 8) + XL ); //prevod na 16bit hodnotu
+   x=x/4;
+   return x;
+}
+int16 akX (void)
+{
+int16 X;
+X= akR (AK_XH, AK_XL);
+return X;
+}
+int16 akY (void)
+{
+int16 Y;
+Y= akR (AK_YH, AK_YL);
+return Y;
+}
+int16 akZ (void)
+{
+int16 Z;
+Z= akR (AK_ZH, AK_ZL);
+return Z;
+}

 /Modules/Sensors/IMU01A/SW/PIC16F887/MMA8451Q.h
 ,0 → 1,14
+//Adresa obvodu
+#define AK_W  0x38 //adresa akcelerometru zápis
+#define AK_R  0x39 //adresa akcelerometru ètení
+#define AK_XH 0x01 //osa X LSB
+#define AK_XL 0x02 //osa X MSB
+#define AK_YH 0x03 //osa Y LSB
+#define AK_YL 0x04 //osa Y MSB
+#define AK_ZH 0x05 //osa Z LSB
+#define AK_ZL 0x06 //osa Z MSB
+#include "MMA8451Q.c"

 /Modules/Sensors/IMU01A/SW/PIC16F887/main.bak
 ,0 → 1,56
+//Akcelerometr IMU01A
+//(c) MLAB Jan Chroust 2013
+#include <main.h>
+#define PIN_SDA  PIN_C4
+#define PIN_SCL  PIN_C3
+#use i2c(master, sda=PIN_SDA, scl=PIN_SCL) //I2C
+#use rs232(baud=9600,parity=N,xmit=PIN_C7,rcv=PIN_C6,bits=8) //rcv TXD xmit RXD
+#include <math.h>
+#include <MMA8451Q.h>
+//Akcelerometr
+#define AK_W  0x38 //adresa akcelerometru zápis
+#define AK_R  0x39 //adresa akcelerometru ètení
+#define AK_XH 0x01 //osa X LSB
+#define AK_XL 0x02 //osa X MSB
+#define AK_YH 0x03 //osa Y LSB
+#define AK_YL 0x04 //osa Y MSB
+#define AK_ZH 0x05 //osa Z LSB
+#define AK_ZL 0x06 //osa Z MSB
+signed int16 X, Y, Z; //promenne pro akcelerometr
+void main()
+{
+   setup_adc_ports(NO_ANALOGS|VSS_VDD);
+   setup_adc(ADC_CLOCK_DIV_2);
+   setup_spi(SPI_SS_DISABLED);
+   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
+   setup_timer_1(T1_DISABLED);
+   setup_timer_2(T2_DISABLED,0,1);
+   setup_ccp1(CCP_OFF);
+   setup_comparator(NC_NC_NC_NC);
+   setAK(); //nastaveni akcelerometru
+   printf("Akcelerometr IMU01A - MMA8451Q \r\n",);
+   printf("(c) MLAB JACHO 2013  \r\n",);
+  while(TRUE)
+      {
+         X=akX ();
+         Y=akY ();
+         Z=akZ ();
+         printf("Namerene hodnoty: \r\n",);
+         printf("Osa X: %Ld \r\n",X);
+         printf("Osa Y: %Ld \r\n",Y);
+         printf("Osa Z: %Ld \r\n",Z);
+         delay_ms (2000);
+      }
+}

 /Modules/Sensors/IMU01A/SW/PIC16F887/main.c
 ,0 → 1,45
+//Akcelerometr IMU01A
+//(c) MLAB Jan Chroust 2013
+#include <main.h>
+#define PIN_SDA  PIN_C4
+#define PIN_SCL  PIN_C3
+#use i2c(master, sda=PIN_SDA, scl=PIN_SCL) //I2C
+#use rs232(baud=9600,parity=N,xmit=PIN_C7,rcv=PIN_C6,bits=8) //rcv TXD xmit RXD
+#include <math.h>
+#include <MMA8451Q.h>
+signed int16 X, Y, Z; //promenne pro akcelerometr
+void main()
+{
+   setup_adc_ports(NO_ANALOGS|VSS_VDD);
+   setup_adc(ADC_CLOCK_DIV_2);
+   setup_spi(SPI_SS_DISABLED);
+   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
+   setup_timer_1(T1_DISABLED);
+   setup_timer_2(T2_DISABLED,0,1);
+   setup_ccp1(CCP_OFF);
+   setup_comparator(NC_NC_NC_NC);
+   setAK(); //nastaveni akcelerometru
+   printf("Akcelerometr IMU01A - MMA8451Q \r\n",);
+   printf("(c) MLAB JACHO 2013  \r\n",);
+  while(TRUE)
+      {
+         X=akX ();
+         Y=akY ();
+         Z=akZ ();
+         printf("Namerene hodnoty: \r\n",);
+         printf("Osa X: %Ld \r\n",X);
+         printf("Osa Y: %Ld \r\n",Y);
+         printf("Osa Z: %Ld \r\n",Z);
+         delay_ms (2000);
+      }
+}

/Modules/Sensors/IMU01A/SW/PIC16F887/main.cof
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Modules/Sensors/IMU01A/SW/PIC16F887/main.err
0,0 → 1,2
Memory usage: ROM=14% RAM=4% - 7%
0 Errors, 0 Warnings.

 /Modules/Sensors/IMU01A/SW/PIC16F887/main.esym
 ,0 → 1,590
+D G "__PCM__" 0 58 ""4.106""
+D G "__DEVICE__" 0 58 "887"
+D G "__DATE__" 0 58 ""11-5-13""
+D G "__TIME__" 0 58 ""10:50:06"" "Akcelerometr IMU01A"
+d G "PIN_A0" 2 20 "40"
+d G "PIN_A1" 2 21 "41"
+d G "PIN_A2" 2 22 "42"
+d G "PIN_A3" 2 23 "43"
+d G "PIN_A4" 2 24 "44"
+d G "PIN_A5" 2 25 "45"
+d G "PIN_A6" 2 26 "46"
+d G "PIN_A7" 2 27 "47"
+d G "PIN_B0" 2 29 "48"
+d G "PIN_B1" 2 30 "49"
+d G "PIN_B2" 2 31 "50"
+d G "PIN_B3" 2 32 "51"
+d G "PIN_B4" 2 33 "52"
+d G "PIN_B5" 2 34 "53"
+d G "PIN_B6" 2 35 "54"
+d G "PIN_B7" 2 36 "55"
+d G "PIN_C0" 2 38 "56"
+d G "PIN_C1" 2 39 "57"
+d G "PIN_C2" 2 40 "58"
+d G "PIN_C3" 2 41 "59"
+d G "PIN_C4" 2 42 "60"
+d G "PIN_C5" 2 43 "61"
+d G "PIN_C6" 2 44 "62"
+d G "PIN_C7" 2 45 "63"
+d G "PIN_D0" 2 47 "64"
+d G "PIN_D1" 2 48 "65"
+d G "PIN_D2" 2 49 "66"
+d G "PIN_D3" 2 50 "67"
+d G "PIN_D4" 2 51 "68"
+d G "PIN_D5" 2 52 "69"
+d G "PIN_D6" 2 53 "70"
+d G "PIN_D7" 2 54 "71"
+d G "PIN_E0" 2 56 "72"
+d G "PIN_E1" 2 57 "73"
+d G "PIN_E2" 2 58 "74"
+d G "PIN_E3" 2 59 "75"
+d G "FALSE" 2 62 "0"
+d G "TRUE" 2 63 "1"
+d G "BYTE" 2 65 "int8"
+d G "BOOLEAN" 2 66 "int1"
+d G "getc" 2 68 "getch"
+d G "fgetc" 2 69 "getch"
+d G "getchar" 2 70 "getch"
+d G "putc" 2 71 "putchar"
+d G "fputc" 2 72 "putchar"
+d G "fgets" 2 73 "gets"
+d G "fputs" 2 74 "puts"
+d G "WDT_FROM_SLEEP" 2 79 "3"
+d G "WDT_TIMEOUT" 2 80 "11"
+d G "MCLR_FROM_SLEEP" 2 81 "19"
+d G "MCLR_FROM_RUN" 2 82 "27"
+d G "NORMAL_POWER_UP" 2 83 "25"
+d G "BROWNOUT_RESTART" 2 84 "26"
+d G "T0_INTERNAL" 2 91 "0"
+d G "T0_EXT_L_TO_H" 2 92 "32"
+d G "T0_EXT_H_TO_L" 2 93 "48"
+d G "T0_DIV_1" 2 95 "8"
+d G "T0_DIV_2" 2 96 "0"
+d G "T0_DIV_4" 2 97 "1"
+d G "T0_DIV_8" 2 98 "2"
+d G "T0_DIV_16" 2 99 "3"
+d G "T0_DIV_32" 2 100 "4"
+d G "T0_DIV_64" 2 101 "5"
+d G "T0_DIV_128" 2 102 "6"
+d G "T0_DIV_256" 2 103 "7"
+d G "T0_8_BIT" 2 106 "0"
+d G "RTCC_INTERNAL" 2 108 "0" "The following are provided for compatibility"
+d G "RTCC_EXT_L_TO_H" 2 109 "32" "with older compiler versions"
+d G "RTCC_EXT_H_TO_L" 2 110 "48"
+d G "RTCC_DIV_1" 2 111 "8"
+d G "RTCC_DIV_2" 2 112 "0"
+d G "RTCC_DIV_4" 2 113 "1"
+d G "RTCC_DIV_8" 2 114 "2"
+d G "RTCC_DIV_16" 2 115 "3"
+d G "RTCC_DIV_32" 2 116 "4"
+d G "RTCC_DIV_64" 2 117 "5"
+d G "RTCC_DIV_128" 2 118 "6"
+d G "RTCC_DIV_256" 2 119 "7"
+d G "RTCC_8_BIT" 2 120 "0"
+d G "WDT_18MS" 2 132 "8"
+d G "WDT_36MS" 2 133 "9"
+d G "WDT_72MS" 2 134 "10"
+d G "WDT_144MS" 2 135 "11"
+d G "WDT_288MS" 2 136 "12"
+d G "WDT_576MS" 2 137 "13"
+d G "WDT_1152MS" 2 138 "14"
+d G "WDT_2304MS" 2 139 "15"
+d G "WDT_ON" 2 143 "0x4100"
+d G "WDT_OFF" 2 144 "0"
+d G "WDT_DIV_16" 2 145 "0x100"
+d G "WDT_DIV_8" 2 146 "0x300"
+d G "WDT_DIV_4" 2 147 "0x500"
+d G "WDT_DIV_2" 2 148 "0x700"
+d G "WDT_TIMES_1" 2 149 "0x900" "Default"
+d G "WDT_TIMES_2" 2 150 "0xB00"
+d G "WDT_TIMES_4" 2 151 "0xD00"
+d G "WDT_TIMES_8" 2 152 "0xF00"
+d G "WDT_TIMES_16" 2 153 "0x1100"
+d G "WDT_TIMES_32" 2 154 "0x1300"
+d G "WDT_TIMES_64" 2 155 "0x1500"
+d G "WDT_TIMES_128" 2 156 "0x1700"
+d G "T1_DISABLED" 2 162 "0"
+d G "T1_INTERNAL" 2 163 "5"
+d G "T1_EXTERNAL" 2 164 "7"
+d G "T1_EXTERNAL_SYNC" 2 165 "3"
+d G "T1_CLK_OUT" 2 167 "8"
+d G "T1_DIV_BY_1" 2 169 "0"
+d G "T1_DIV_BY_2" 2 170 "0x10"
+d G "T1_DIV_BY_4" 2 171 "0x20"
+d G "T1_DIV_BY_8" 2 172 "0x30"
+d G "T1_GATE" 2 174 "0x40"
+d G "T1_GATE_INVERTED" 2 175 "0xC0"
+d G "T2_DISABLED" 2 180 "0"
+d G "T2_DIV_BY_1" 2 181 "4"
+d G "T2_DIV_BY_4" 2 182 "5"
+d G "T2_DIV_BY_16" 2 183 "6"
+d G "CCP_OFF" 2 189 "0"
+d G "CCP_CAPTURE_FE" 2 190 "4"
+d G "CCP_CAPTURE_RE" 2 191 "5"
+d G "CCP_CAPTURE_DIV_4" 2 192 "6"
+d G "CCP_CAPTURE_DIV_16" 2 193 "7"
+d G "CCP_COMPARE_SET_ON_MATCH" 2 194 "8"
+d G "CCP_COMPARE_CLR_ON_MATCH" 2 195 "9"
+d G "CCP_COMPARE_INT" 2 196 "0xA"
+d G "CCP_COMPARE_RESET_TIMER" 2 197 "0xB"
+d G "CCP_PWM" 2 198 "0xC"
+d G "CCP_PWM_PLUS_1" 2 199 "0x1c"
+d G "CCP_PWM_PLUS_2" 2 200 "0x2c"
+d G "CCP_PWM_PLUS_3" 2 201 "0x3c"
+d G "CCP_PWM_H_H" 2 206 "0x0c"
+d G "CCP_PWM_H_L" 2 207 "0x0d"
+d G "CCP_PWM_L_H" 2 208 "0x0e"
+d G "CCP_PWM_L_L" 2 209 "0x0f"
+d G "CCP_PWM_FULL_BRIDGE" 2 211 "0x40"
+d G "CCP_PWM_FULL_BRIDGE_REV" 2 212 "0xC0"
+d G "CCP_PWM_HALF_BRIDGE" 2 213 "0x80"
+d G "CCP_SHUTDOWN_ON_COMP1" 2 215 "0x100000"
+d G "CCP_SHUTDOWN_ON_COMP2" 2 216 "0x200000"
+d G "CCP_SHUTDOWN_ON_COMP" 2 217 "0x300000"
+d G "CCP_SHUTDOWN_ON_INT0" 2 218 "0x400000"
+d G "CCP_SHUTDOWN_ON_COMP1_INT0" 2 219 "0x500000"
+d G "CCP_SHUTDOWN_ON_COMP2_INT0" 2 220 "0x600000"
+d G "CCP_SHUTDOWN_ON_COMP_INT0" 2 221 "0x700000"
+d G "CCP_SHUTDOWN_AC_L" 2 223 "0x000000"
+d G "CCP_SHUTDOWN_AC_H" 2 224 "0x040000"
+d G "CCP_SHUTDOWN_AC_F" 2 225 "0x080000"
+d G "CCP_SHUTDOWN_BD_L" 2 227 "0x000000"
+d G "CCP_SHUTDOWN_BD_H" 2 228 "0x010000"
+d G "CCP_SHUTDOWN_BD_F" 2 229 "0x020000"
+d G "CCP_SHUTDOWN_RESTART" 2 231 "0x80000000"
+d G "CCP_PULSE_STEERING_A" 2 233 "0x01000000"
+d G "CCP_PULSE_STEERING_B" 2 234 "0x02000000"
+d G "CCP_PULSE_STEERING_C" 2 235 "0x04000000"
+d G "CCP_PULSE_STEERING_D" 2 236 "0x08000000"
+d G "CCP_PULSE_STEERING_SYNC" 2 237 "0x10000000"
+d G "SPI_MASTER" 2 245 "0x20"
+d G "SPI_SLAVE" 2 246 "0x24"
+d G "SPI_L_TO_H" 2 247 "0"
+d G "SPI_H_TO_L" 2 248 "0x10"
+d G "SPI_CLK_DIV_4" 2 249 "0"
+d G "SPI_CLK_DIV_16" 2 250 "1"
+d G "SPI_CLK_DIV_64" 2 251 "2"
+d G "SPI_CLK_T2" 2 252 "3"
+d G "SPI_SS_DISABLED" 2 253 "1"
+d G "SPI_SAMPLE_AT_END" 2 255 "0x8000"
+d G "SPI_XMIT_L_TO_H" 2 256 "0x4000"
+d G "UART_ADDRESS" 2 262 "2"
+d G "UART_DATA" 2 263 "4"
+d G "UART_AUTODETECT" 2 264 "8"
+d G "UART_AUTODETECT_NOWAIT" 2 265 "9"
+d G "UART_WAKEUP_ON_RDA" 2 266 "10"
+d G "UART_SEND_BREAK" 2 267 "13"
+d G "NC_NC_NC_NC" 2 273 "0x00"
+d G "NC_NC" 2 274 "0x00"
+d G "CP1_A0_A3" 2 277 "0x00090080"
+d G "CP1_A1_A3" 2 278 "0x000A0081"
+d G "CP1_B3_A3" 2 279 "0x00880082"
+d G "CP1_B1_A3" 2 280 "0x00280083"
+d G "CP1_A0_VREF" 2 281 "0x00010084"
+d G "CP1_A1_VREF" 2 282 "0x00020085"
+d G "CP1_B3_VREF" 2 283 "0x00800086"
+d G "CP1_B1_VREF" 2 284 "0x00200087"
+d G "CP1_OUT_ON_A4" 2 286 "0x00000020"
+d G "CP1_INVERT" 2 287 "0x00000010"
+d G "CP1_ABSOLUTE_VREF" 2 288 "0x20000000"
+d G "CP2_A0_A2" 2 291 "0x00058000"
+d G "CP2_A1_A2" 2 292 "0x00068100"
+d G "CP2_B3_A2" 2 293 "0x00848200"
+d G "CP2_B1_A2" 2 294 "0x00248300"
+d G "CP2_A0_VREF" 2 295 "0x00018400"
+d G "CP2_A1_VREF" 2 296 "0x00028500"
+d G "CP2_B3_VREF" 2 297 "0x00808600"
+d G "CP2_B1_VREF" 2 298 "0x00208700"
+d G "CP2_OUT_ON_A5" 2 300 "0x00002000"
+d G "CP2_INVERT" 2 301 "0x00001000"
+d G "CP2_ABSOLUTE_VREF" 2 302 "0x10000000"
+d G "CP2_T1_SYNC" 2 305 "0x01000000"
+d G "CP2_T1_GATE" 2 306 "0x02000000"
+d G "VREF_LOW" 2 315 "0xa0"
+d G "VREF_HIGH" 2 316 "0x80"
+d G "OSC_31KHZ" 2 322 "1"
+d G "OSC_125KHZ" 2 323 "0x11"
+d G "OSC_250KHZ" 2 324 "0x21"
+d G "OSC_500KHZ" 2 325 "0x31"
+d G "OSC_1MHZ" 2 326 "0x41"
+d G "OSC_2MHZ" 2 327 "0x51"
+d G "OSC_4MHZ" 2 328 "0x61"
+d G "OSC_8MHZ" 2 329 "0x71"
+d G "OSC_INTRC" 2 330 "1"
+d G "OSC_NORMAL" 2 331 "0"
+d G "OSC_STATE_STABLE" 2 333 "4"
+d G "OSC_31KHZ_STABLE" 2 334 "2"
+d G "ADC_OFF" 2 342 "0" "ADC Off"
+d G "ADC_CLOCK_DIV_2" 2 343 "0x100"
+d G "ADC_CLOCK_DIV_8" 2 344 "0x40"
+d G "ADC_CLOCK_DIV_32" 2 345 "0x80"
+d G "ADC_CLOCK_INTERNAL" 2 346 "0xc0" "Internal 2-6us"
+d G "sAN0" 2 350 "1" "| A0"
+d G "sAN1" 2 351 "2" "| A1"
+d G "sAN2" 2 352 "4" "| A2"
+d G "sAN3" 2 353 "8" "| A3"
+d G "sAN4" 2 354 "16" "| A5"
+d G "sAN5" 2 355 "32" "| E0"
+d G "sAN6" 2 356 "64" "| E1"
+d G "sAN7" 2 357 "128" "| E2"
+d G "sAN8" 2 358 "0x10000" "| B2"
+d G "sAN9" 2 359 "0x20000" "| B3"
+d G "sAN10" 2 360 "0x40000" "| B1"
+d G "sAN11" 2 361 "0x80000" "| B4"
+d G "sAN12" 2 362 "0x100000" "| B0"
+d G "sAN13" 2 363 "0x200000" "| B5"
+d G "NO_ANALOGS" 2 364 "0" "None"
+d G "ALL_ANALOG" 2 365 "0x1F00FF" "A0 A1 A2 A3 A5 E0 E1 E2 B0 B1 B2 B3 B4 B5"
+d G "VSS_VDD" 2 368 "0x0000" "| Range 0-Vdd"
+d G "VSS_VREF" 2 369 "0x1000" "| Range 0-Vref"
+d G "VREF_VREF" 2 370 "0x3000" "| Range Vref-Vref"
+d G "VREF_VDD" 2 371 "0x2000" "| Range Vref-Vdd"
+d G "ADC_START_AND_READ" 2 375 "7" "This is the default if nothing is specified"
+d G "ADC_START_ONLY" 2 376 "1"
+d G "ADC_READ_ONLY" 2 377 "6"
+d G "L_TO_H" 2 389 "0x40"
+d G "H_TO_L" 2 390 "0"
+d G "GLOBAL" 2 392 "0x0BC0"
+d G "INT_RTCC" 2 393 "0x000B20"
+d G "INT_RB" 2 394 "0x01FF0B08"
+d G "INT_EXT_L2H" 2 395 "0x50000B10"
+d G "INT_EXT_H2L" 2 396 "0x60000B10"
+d G "INT_EXT" 2 397 "0x000B10"
+d G "INT_AD" 2 398 "0x008C40"
+d G "INT_TBE" 2 399 "0x008C10"
+d G "INT_RDA" 2 400 "0x008C20"
+d G "INT_TIMER1" 2 401 "0x008C01"
+d G "INT_TIMER2" 2 402 "0x008C02"
+d G "INT_CCP1" 2 403 "0x008C04"
+d G "INT_CCP2" 2 404 "0x008D01"
+d G "INT_SSP" 2 405 "0x008C08"
+d G "INT_BUSCOL" 2 406 "0x008D08"
+d G "INT_EEPROM" 2 407 "0x008D10"
+d G "INT_TIMER0" 2 408 "0x000B20"
+d G "INT_OSC_FAIL" 2 409 "0x008D80"
+d G "INT_COMP" 2 410 "0x008D20"
+d G "INT_COMP2" 2 411 "0x008D40"
+d G "INT_ULPWU" 2 412 "0x008D04"
+d G "INT_RB0" 2 413 "0x0010B08"
+d G "INT_RB1" 2 414 "0x0020B08"
+d G "INT_RB2" 2 415 "0x0040B08"
+d G "INT_RB3" 2 416 "0x0080B08"
+d G "INT_RB4" 2 417 "0x0100B08"
+d G "INT_RB5" 2 418 "0x0200B08"
+d G "INT_RB6" 2 419 "0x0400B08"
+d G "INT_RB7" 2 420 "0x0800B08"
+D G "PIN_SDA" 0 7 "PIN_C4"
+D G "PIN_SCL" 0 8 "PIN_C3"
+D G "MATH_H" 3 21 ""
+D G "PI" 3 26 "3.1415926535897932"
+D G "SQRT2" 3 29 "1.4142135623730950"
+C L "CEIL_FLOOR" 3 2 3 "FUNCTION"
+F G "CEIL_FLOOR" 3 36 "float(float x,int8 n)"
+V L "x" 3 36 "float"
+V L "n" 3 36 "int8"
+V L "y" 3 38 "float"
+V L "res" 3 38 "float"
+V L "l" 3 39 "int16"
+V L "s" 3 40 "int1"
+C L "floor" 3 2 5 "FUNCTION"
+F G "floor" 3 192 "float(float x)"
+V L "x" 3 192 "float"
+C L "ceil" 3 2 5 "FUNCTION"
+F G "ceil" 3 218 "float(float x)"
+V L "x" 3 218 "float"
+D G "fabs" 3 244 "abs"
+C L "fmod" 3 2 6 "FUNCTION"
+F G "fmod" 3 256 "float(float x,float y)"
+V L "x" 3 256 "float"
+V L "y" 3 256 "float"
+V L "i" 3 258 "float"
+D G "LN2" 3 319 "0.6931471805599453"
+V G "pe" 3 321 "float[6]"
+F G "exp" 3 325 "float(float x)"
+V L "x" 3 325 "float"
+V L "y" 3 327 "float"
+V L "res" 3 327 "float"
+V L "r" 3 327 "float"
+V L "n" 3 331 "sint8"
+V L "s" 3 332 "int1"
+C L "exp" 3 2 1 "FUNCTION"
+V G "pl" 3 496 "float[4]"
+V G "ql" 3 497 "float[4]"
+C L "log" 3 2 3 "FUNCTION"
+F G "log" 3 505 "float(float x)"
+V L "x" 3 505 "float"
+V L "y" 3 507 "float"
+V L "res" 3 507 "float"
+V L "r" 3 507 "float"
+V L "y2" 3 507 "float"
+V L "n" 3 511 "sint8"
+C L "log" 3 2 1 "FUNCTION"
+D G "LN10" 3 729 "2.3025850929940456"
+C L "log10" 3 2 3 "FUNCTION"
+F G "log10" 3 737 "float(float x)"
+V L "x" 3 737 "float"
+V L "r" 3 739 "float"
+C L "modf" 3 2 8 "FUNCTION"
+F G "modf" 3 778 "float(float value,*float iptr)"
+V L "value" 3 778 "float"
+V L "iptr" 3 778 "*float"
+C L "pwr" 3 2 6 "FUNCTION"
+F G "pwr" 3 806 "float(float x,float y)"
+V L "x" 3 806 "float"
+V L "y" 3 806 "float"
+C L "pow" 3 2 7 "FUNCTION"
+F G "pow" 3 869 "float(float x,float y)"
+V L "x" 3 869 "float"
+V L "y" 3 869 "float"
+C L "sqrt" 3 2 5 "FUNCTION"
+F G "sqrt" 3 930 "float(float x)"
+V L "x" 3 930 "float"
+V L "y" 3 932 "float"
+V L "res" 3 932 "float"
+V L "p" 3 936 "*int8"
+D G "PI_DIV_BY_TWO" 3 1125 "1.5707963267948966"
+C L "cos" 3 2 3 "FUNCTION"
+F G "cos" 3 1136 "float(float x)"
+V L "x" 3 1136 "float"
+V L "y" 3 1138 "float"
+V L "t" 3 1138 "float"
+V L "t2" 3 1138 "float"
+V L "quad" 3 1139 "int8"
+V L "i" 3 1139 "int8"
+V L "frac" 3 1140 "float"
+V L "p" 3 1141 "float[6]" "by the series definition for cosine"
+C L "cos" 3 2 1 "FUNCTION"
+C L "cos" 3 2 2 "FUNCTION"
+C L "cos" 3 2 1 "FUNCTION"
+C L "cos" 3 2 1 "FUNCTION"
+C L "cos" 3 2 1 "FUNCTION"
+C L "cos" 3 2 1 "FUNCTION"
+C L "cos" 3 2 1 "FUNCTION"
+C L "cos" 3 2 1 "FUNCTION"
+C L "sin" 3 2 5 "FUNCTION"
+F G "sin" 3 1278 "float(float x)"
+V L "x" 3 1278 "float"
+C L "tan" 3 2 5 "FUNCTION"
+F G "tan" 3 1304 "float(float x)"
+V L "x" 3 1304 "float"
+V L "c" 3 1306 "float"
+V L "s" 3 1306 "float"
+V G "pas" 3 1344 "float[3]"
+V G "qas" 3 1345 "float[3]"
+F G "ASIN_COS" 3 1347 "float(float x,int8 n)"
+V L "x" 3 1347 "float"
+V L "n" 3 1347 "int8"
+V L "y" 3 1349 "float"
+V L "res" 3 1349 "float"
+V L "r" 3 1349 "float"
+V L "y2" 3 1349 "float"
+V L "s" 3 1350 "int1"
+C L "ASIN_COS" 3 2 1 "FUNCTION"
+C L "ASIN_COS" 3 2 1 "FUNCTION"
+C L "asin" 3 2 5 "FUNCTION"
+F G "asin" 3 1493 "float(float x)"
+V L "x" 3 1493 "float"
+V L "r" 3 1495 "float"
+C L "acos" 3 2 5 "FUNCTION"
+F G "acos" 3 1527 "float(float x)"
+V L "x" 3 1527 "float"
+V L "r" 3 1529 "float"
+V G "pat" 3 1555 "float[4]"
+V G "qat" 3 1556 "float[4]"
+C L "atan" 3 2 3 "FUNCTION"
+F G "atan" 3 1564 "float(float x)"
+V L "x" 3 1564 "float"
+V L "y" 3 1566 "float"
+V L "res" 3 1566 "float"
+V L "r" 3 1566 "float"
+V L "s" 3 1567 "int1"
+V L "flag" 3 1567 "int1"
+C L "atan" 3 2 1 "FUNCTION"
+C L "atan2" 3 2 7 "FUNCTION"
+F G "atan2" 3 1697 "float(float y,float x)"
+V L "y" 3 1697 "float"
+V L "x" 3 1697 "float"
+V L "z" 3 1699 "float"
+V L "sign" 3 1700 "int1"
+V L "quad" 3 1701 "int8"
+C L "atan2" 3 2 1 "FUNCTION"
+C L "atan2" 3 2 1 "FUNCTION"
+C L "cosh" 3 2 7 "FUNCTION"
+F G "cosh" 3 1919 "float(float x)"
+V L "x" 3 1919 "float"
+C L "sinh" 3 2 6 "FUNCTION"
+F G "sinh" 3 1946 "float(float x)"
+V L "x" 3 1946 "float"
+C L "tanh" 3 2 6 "FUNCTION"
+F G "tanh" 3 1976 "float(float x)"
+V L "x" 3 1976 "float"
+D G "LOG2" 3 2006 ".30102999566398119521"
+F G "frexp" 3 2007 "float(float x,*sint8 exp)"
+V L "x" 3 2007 "float"
+V L "exp" 3 2007 "*sint8"
+V L "res" 3 2009 "float"
+V L "sign" 3 2010 "int1"
+C L "ldexp" 3 2 6 "FUNCTION"
+F G "ldexp" 3 2152 "float(float value,sint8 exp)"
+V L "value" 3 2152 "float"
+V L "exp" 3 2152 "sint8"
+D G "AK_W" 4 2 "0x38" "adresa akcelerometru zápis"
+D G "AK_R" 4 3 "0x39" "adresa akcelerometru ètení"
+D G "AK_XH" 4 6 "0x01" "osa X LSB"
+D G "AK_XL" 4 7 "0x02" "osa X MSB"
+D G "AK_YH" 4 8 "0x03" "osa Y LSB"
+D G "AK_YL" 4 9 "0x04" "osa Y MSB"
+D G "AK_ZH" 4 10 "0x05" "osa Z LSB"
+D G "AK_ZL" 4 11 "0x06" "osa Z MSB"
+F G "setAK" 5 1 "void()" "nastaveni akcelerometru"
+C L "setAK" 5 6 1 "FUNCTION"
+F G "akR" 5 12 "int16(int8 H,int8 l)"
+V L "H" 5 12 "int8"
+V L "l" 5 12 "int8" "vycitani hodnot z akcelerometru"
+V L "XL" 5 14 "int8"
+V L "XH" 5 14 "int8"
+V L "x" 5 15 "sint16"
+C L "akR" 5 6 1 "FUNCTION"
+F G "akX" 5 39 "int16()"
+V L "x" 5 41 "int16"
+F G "akY" 5 46 "int16()"
+V L "y" 5 48 "int16"
+F G "akZ" 5 53 "int16()"
+V L "z" 5 55 "int16"
+V G "x" 0 14 "sint16"
+V G "y" 0 14 "sint16"
+V G "z" 0 14 "sint16" "promenne pro akcelerometr"
+F G "MAIN" 0 16 "void()"
+C L "MAIN" 0 27 1 "FUNCTION"
+F B "reset_cpu" 0 0
+F B "abs" 1 0
+F B "sleep_ulpwu" 1 0
+F B "sleep" 0 0
+F B "delay_cycles" 1 0
+F B "read_bank" 2 0
+F B "write_bank" 3 0
+F B "shift_left" 2 2
+F B "shift_right" 2 2
+F B "rotate_left" 2 0
+F B "rotate_right" 2 0
+F B "_mul" 2 0
+F B "memset" 3 0
+F B "isamoung" 2 0
+F B "isamong" 2 0
+F B "bit_set" 2 0
+F B "bit_clear" 2 0
+F B "bit_test" 2 0
+F B "toupper" 1 0
+F B "tolower" 1 0
+F B "swap" 1 0
+F B "printf" 1 255
+F B "fprintf" 1 255
+F B "sprintf" 1 255
+F B "make8" 2 0
+F B "make16" 2 0
+F B "make32" 1 255
+F B "label_address" 1 1
+F B "goto_address" 1 0
+F B "_va_arg" 1 0
+F B "offsetofbit" 2 2
+F B "enable_interrupts" 1 0
+F B "disable_interrupts" 1 0
+F B "interrupt_active" 1 0
+F B "clear_interrupt" 1 0
+F B "jump_to_isr" 1 0
+F B "ext_int_edge" 1 2
+F B "read_eeprom" 1 0
+F B "write_eeprom" 2 0
+F B "read_program_eeprom" 1 0
+F B "write_program_eeprom" 2 0
+F B "write_program_memory" 4 0
+F B "write_program_memory8" 4 0
+F B "read_program_memory" 4 0
+F B "read_program_memory8" 4 0
+F B "erase_program_eeprom" 1 0
+F B "strcpy" 2 0
+F B "memcpy" 3 0
+F B "strstr100" 2 0
+F B "output_high" 1 0
+F B "output_low" 1 0
+F B "input" 1 0
+F B "input_state" 1 0
+F B "output_float" 1 0
+F B "output_drive" 1 0
+F B "output_bit" 1 1
+F B "output_toggle" 1 0
+F B "output_a" 1 0
+F B "output_b" 1 0
+F B "output_c" 1 0
+F B "output_d" 1 0
+F B "output_e" 1 0
+F B "input_a" 0 0
+F B "input_b" 0 0
+F B "input_c" 0 0
+F B "input_d" 0 0
+F B "input_e" 0 0
+F B "set_tris_a" 1 0
+F B "set_tris_b" 1 0
+F B "set_tris_c" 1 0
+F B "set_tris_d" 1 0
+F B "set_tris_e" 1 0
+F B "get_tris_a" 0 0
+F B "get_tris_b" 0 0
+F B "get_tris_c" 0 0
+F B "get_tris_d" 0 0
+F B "get_tris_e" 0 0
+F B "input_change_a" 0 0
+F B "input_change_b" 0 0
+F B "input_change_c" 0 0
+F B "input_change_d" 0 0
+F B "input_change_e" 0 0
+F B "port_b_pullups" 1 0
+F B "setup_counters" 2 0
+F B "setup_wdt" 1 0
+F B "restart_cause" 0 0
+F B "restart_wdt" 0 0
+F B "get_rtcc" 0 0
+F B "set_rtcc" 1 0
+F B "get_timer0" 0 0
+F B "set_timer0" 1 0
+F B "setup_comparator" 1 0
+F B "setup_port_a" 1 0
+F B "setup_adc_ports" 1 0
+F B "setup_adc" 1 0
+F B "set_adc_channel" 1 0
+F B "read_adc" 0 1
+F B "adc_done" 0 0
+F B "setup_timer_0" 1 0
+F B "setup_vref" 1 0
+F B "setup_timer_1" 1 0
+F B "get_timer1" 0 0
+F B "set_timer1" 1 0
+F B "setup_timer_2" 3 0
+F B "get_timer2" 0 0
+F B "set_timer2" 1 0
+F B "setup_ccp1" 1 2
+F B "set_pwm1_duty" 1 0
+F B "setup_ccp2" 1 0
+F B "set_pwm2_duty" 1 0
+F B "setup_oscillator" 1 2
+F B "setup_spi" 1 0
+F B "spi_read" 0 1
+F B "spi_write" 1 0
+F B "spi_data_is_in" 0 0
+F B "setup_spi2" 1 0
+F B "spi_read2" 0 1
+F B "spi_write2" 1 0
+F B "spi_data_is_in2" 0 0
+F B "brownout_enable" 1 0
+F B "delay_ms" 1 0
+F B "delay_us" 1 0
+F B "i2c_read" 0 2
+F B "i2c_write" 1 2
+F B "i2c_start" 0 2
+F B "i2c_stop" 0 1
+F B "i2c_isr_state" 0 1
+F B "putchar" 1 2
+F B "puts" 1 2
+F B "getch" 0 1
+F B "gets" 1 3
+F B "kbhit" 0 1

 /Modules/Sensors/IMU01A/SW/PIC16F887/main.h
 ,0 → 1,19
+#include <16F887.h>
+#device adc=8
+#FUSES NOWDT                    //No Watch Dog Timer
+#FUSES INTRC                    //Internal RC Osc
+#FUSES NOPUT                    //No Power Up Timer
+#FUSES MCLR                     //Master Clear pin enabled
+#FUSES NOPROTECT                //Code not protected from reading
+#FUSES NOCPD                    //No EE protection
+#FUSES NOBROWNOUT               //No brownout reset
+#FUSES IESO                     //Internal External Switch Over mode enabled
+#FUSES FCMEN                    //Fail-safe clock monitor enabled
+#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
+#FUSES NODEBUG                  //No Debug mode for ICD
+#FUSES NOWRT                    //Program memory not write protected
+#FUSES BORV40                   //Brownout reset at 4.0V
+#use delay(clock=8000000)

 /Modules/Sensors/IMU01A/SW/PIC16F887/main.hex
 ,0 → 1,148
+:1000000003308A00972B0000C135E332EC32F2371F
+:10001000ED327439A024CD2AB01841102D10CD2610
+:10002000411CB41AB128A0060A00A83129104D2697
+:1000300041212025C121C8272019B0183310A0065E
+:100040000A00CE30ED32F232EE3220346F32EE372B
+:10005000F43C3A100D050001CF396110581DA01273
+:100060004C32A0060A00CF396110591DA0124C3243
+:10007000A0060A00CF3961105A1DA0124C32A0060A
+:100080000A000830F80000008711A011200883162C
+:10009000870000008312AF0D0712031C552820169D
+:1000A00020088316870059288312201220088316FF
+:1000B000870000008312A015200883168700831292
+:1000C000871D6028F80B432800008711A011200825
+:1000D00083168700000083122016200883168700ED
+:1000E000000000008312A0152008831687008312E9
+:1000F000871D7828F8010000071A78148711A011CD
+:100100002008831687008312071220122008831606
+:10011000870083120800201620088316870000003D
+:100120008312A0152008831687000000831207128F
+:100130002012200883168700000083128711A01167
+:1001400020088316870038308312AF0041202A3000
+:10015000AF0041200130AF0041202012200883165B
+:10016000870000008312A0152008831687008312E1
+:10017000871DB8280000BC28000020162008831620
+:100180008700000083128A110A12FF2BA013200897
+:1001900083168700831287130830F800CF280000E9
+:1001A000F817E028F813B00C03188717031C8713FF
+:1001B0007817E0287813F80BD328DE28000087177B
+:1001C0003F308400840BE2280000F81BD228781B03
+:1001D000DA280800831603178C170C14000000009F
+:1001E00083120C087F3903192E290313A700031764
+:1001F0000D080313A80003170F080313A90027080D
+:10020000B000C620280803178D0003132908031720
+:100210008F0083168C170C140000000083120C0D45
+:100220000E0D7F3903192E290313A70003170D089C
+:100230000313A80003170F080313A9002708B00031
+:10024000C620280803178D000313290803178F0001
+:100250008D0A03198F0A0313EA28031703130800F2
+:100260000830B0007708B1002016200883168700F8
+:1002700000008312A0152008831687008312871DB3
+:100280003F29071A0314071E0310F80D0000A011E0
+:1002900020088316870083128711B00B342920169B
+:1002A0002008831687000000831207123108031903
+:1002B0005E29201220088316870083120000A015F3
+:1002C0002008831687008312871D64290000871188
+:1002D000A011200883168700000083120712201245
+:1002E00020088316870083120800AB01AC0120169A
+:1002F00020088316870000008312A01520088316AB
+:10030000870000008312071220122008831687003E
+:10031000000083128711A01120088316870038304F
+:100320008312AF0041202908AF0041202016200889
+:100330008316870000008312A0152008831687000B
+:1003400000008312871DA22907122012200883169D
+:100350008700000083128711A011200883168700F0
+:1003600039308312AF004120F70130217808AC000A
+:10037000201220088316870000008312A015200891
+:10038000831687008312871DC3290000C729000038
+:1003900020162008831687000000831220162008EC
+:1003A0008316870000008312A0152008831687009B
+:1003B0000000831207122012200883168700000015
+:1003C00083128711A011200883168700383083120A
+:1003D000AF0041202A08AF004120201620088316D4
+:1003E000870000008312A0152008831687000000F4
+:1003F0008312871DF929071220122008831687000F
+:10040000000083128711A01120088316870039305D
+:100410008312AF004120F70130217808AB00201291
+:1004200020088316870000008312A0152008831679
+:1004300087008312871D1A2A00001E2A000020163A
+:1004400020088316870000008312B0012C08AF003B
+:10045000B000AF012B082F07F8003008FA0003188E
+:10046000FA0A7808AD007A08AE002E08B0002D0810
+:10047000AF00B2010430B100300832068039B40058
+:10048000B01F472AAF09B009AF0A0319B00AB21F5B
+:100490004E2AB109B209B10A0319B20AF801F901E9
+:1004A000F701FA013208031D582A31080319722A8C
+:1004B0001030B3000310AF0DB00DF70DFA0D320878
+:1004C0007A02031D652A31087702031C6E2A31085F
+:1004D000F702031CFA033208FA020314F80DF90DAF
+:1004E000B30B5A2AB41F792AF809F909F80A031933
+:1004F000F90A7908AE007808AD002D08F8002E083A
+:10050000F90008000130A9000230AA00752179081D
+:10051000A8007808A7002708F8002808F9008A1121
+:100520000A120E2C0330A9000430AA0075217908A4
+:10053000A8007808A7002708F8002808F9008A1101
+:100540000A12132C0530A9000630AA00752179087B
+:10055000A8007808A7002708F8002808F9008A11E1
+:100560000A12182C831603178C170C1400000000B5
+:100570000318E12A83120C087F390313A80003171C
+:100580000D080313A90003170F080313AA00280876
+:10059000B000C620290803178D0003132A0803178B
+:1005A0008F0083168C170C140000000083120313B5
+:1005B000A70BDB2ADE2A83160317E12A002B8316FA
+:1005C000031783120C0D0E0D7F390313A8000317B8
+:1005D0000D080313A90003170F080313AA00280826
+:1005E000B000C620290803178D0003132A0803173B
+:1005F0008F008D0A03198F0A03100313A70BB22A69
+:100600000800AF010408AE002F10831B2F14A81F91
+:10061000112BAE172E1EAE0AA709A809A70A0319A7
+:10062000A80A280EF038AA00AA07E23EAB00323E24
+:10063000AD0028080F39AB07AB07AD07E93EAC00AA
+:10064000AC07AC07270E0F39AC07AD07AC0DAD0DED
+:10065000AD09AD0D27080F39AD07AA0D0730A90068
+:100660000A30AD07AC03031C312BAC07AB03031CF2
+:10067000352BAB07AA03031C392BAA07A903031CBC
+:100680003D2B29308400831307302E052E1384035D
+:100690002E05031D522B2E1A840A2E1A522B20309F
+:1006A000F7006F2B84072D30040203192E17000862
+:1006B000F700031D632B2E1B632B2E1A7D2BAE1907
+:1006C000632B20306E2BAE1F6B2B2D30F700840375
+:1006D0002E13AE136F2BAE152E123030F707A80174
+:1006E0000408A7002810831B28147708B000C62030
+:1006F00027088400831328188317840A2E1F532B7E
+:10070000080028308400831300080319942B02305A
+:10071000F800F701F70B8A2BF80B892B9730F700BD
+:10072000F70B902B800B872B8A110A12762C8401F1
+:1007300083131F308305713083168F000F088312D7
+:10074000A0132008831687008312871783160317C8
+:100750000908C039890003131F129F1200300317C4
+:1007600088008312870188018901FF300313A000EC
+:10077000831603170908C039890003131F129F123B
+:10078000003003178800831203131F139F1383166F
+:100790009F1383121F149412A0122008831687003F
+:1007A000831220162008831687008312A0112008C8
+:1007B0008316870001308312940000308316940062
+:1007C0000108C73908388100831290010030F80011
+:1007D00092000030831692008312201520088316A1
+:1007E00087008312970183169B019C0101309D00B5
+:1007F0008312031787018801890103138B280430B2
+:1008000003178D0000308F000313EA201530031703
+:100810008D0000308F000313EA20822A7908A2009D
+:100820007808A100922A7908A4007808A300A22AD7
+:100830007908A6007808A500213003178D00003044
+:100840008F000313EA202C3003178D0000308F0037
+:10085000031007300313A700B222103084002208CF
+:10086000A8002108A70001232030B000C6200D30C9
+:10087000B000C6200A30B000C620333003178D0008
+:1008800000308F00031007300313A700B22210308E
+:1008900084002408A8002308A70001232030B0000A
+:1008A000C6200D30B000C6200A30B000C6203A3055
+:1008B00003178D0000308F00031007300313A700CB
+:1008C000B222103084002608A8002508A7000123C2
+:1008D0002030B000C6200D30B000C6200A30B00075
+:1008E000C6200830A700FA30A800812BA70B732C74
+:0408F0000D2C630068
+:04400E00F52CFF3F4F
+:00000001FF
+;PIC16F887
+;CRC=01BF  CREATED="11-5-13 10:50"

 /Modules/Sensors/IMU01A/SW/PIC16F887/main.lst
 ,0 → 1,3085
+CCS PCM C Compiler, Version 4.106, 47914               11-5-13 10:50
+               Filename: D:\Honza\MLAB\Modules\Sensors\IMU01A\SW\PIC16F887\main.lst
+               ROM used: 1146 words (14%)
+                         Largest free fragment is 2048
+               RAM used: 13 (4%) at main() level
+(7%) worst case
+               Stack:    3 locations
+*
+:  MOVLW  03
+:  MOVWF  0A
+:  GOTO   397
+:  NOP
+.................... //Akcelerometr IMU01A
+.................... //(c) MLAB Jan Chroust 2013
+....................
+....................
+.................... #include <main.h>
+.................... #include <16F887.h>
+.................... //////// Standard Header file for the PIC16F887 device ////////////////
+.................... #device PIC16F887
+.................... #list
+....................
+.................... #device adc=8
+....................
+.................... #FUSES NOWDT                       //No Watch Dog Timer
+.................... #FUSES INTRC                       //Internal RC Osc
+.................... #FUSES NOPUT                       //No Power Up Timer
+.................... #FUSES MCLR                        //Master Clear pin enabled
+.................... #FUSES NOPROTECT                   //Code not protected from reading
+.................... #FUSES NOCPD                       //No EE protection
+.................... #FUSES NOBROWNOUT                  //No brownout reset
+.................... #FUSES IESO                        //Internal External Switch Over mode enabled
+.................... #FUSES FCMEN                       //Fail-safe clock monitor enabled
+.................... #FUSES NOLVP                       //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
+.................... #FUSES NODEBUG                     //No Debug mode for ICD
+.................... #FUSES NOWRT                       //Program memory not write protected
+.................... #FUSES BORV40                      //Brownout reset at 4.0V
+....................
+.................... #use delay(clock=8000000)
+*
+:  MOVLW  28
+:  MOVWF  04
+:  BCF    03.7
+:  MOVF   00,W
+:  BTFSC  03.2
+:  GOTO   394
+:  MOVLW  02
+:  MOVWF  78
+:  CLRF   77
+A:  DECFSZ 77,F
+B:  GOTO   38A
+C:  DECFSZ 78,F
+D:  GOTO   389
+E:  MOVLW  97
+F:  MOVWF  77
+:  DECFSZ 77,F
+:  GOTO   390
+:  DECFSZ 00,F
+:  GOTO   387
+:  BCF    0A.3
+:  BCF    0A.4
+:  GOTO   476 (RETURN)
+....................
+....................
+....................
+.................... #define PIN_SDA  PIN_C4
+.................... #define PIN_SCL  PIN_C3
+.................... #use i2c(master, sda=PIN_SDA, scl=PIN_SCL) //I2C
+*
+:  MOVLW  08
+:  MOVWF  78
+:  NOP
+:  BCF    07.3
+:  BCF    20.3
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  NOP
+A:  BCF    03.5
+B:  RLF    2F,F
+C:  BCF    07.4
+D:  BTFSS  03.0
+E:  GOTO   055
+F:  BSF    20.4
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  GOTO   059
+:  BCF    03.5
+:  BCF    20.4
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  NOP
+A:  BCF    03.5
+B:  BSF    20.3
+C:  MOVF   20,W
+D:  BSF    03.5
+E:  MOVWF  07
+F:  BCF    03.5
+:  BTFSS  07.3
+:  GOTO   060
+:  DECFSZ 78,F
+:  GOTO   043
+:  NOP
+:  BCF    07.3
+:  BCF    20.3
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+A:  NOP
+B:  BCF    03.5
+C:  BSF    20.4
+D:  MOVF   20,W
+E:  BSF    03.5
+F:  MOVWF  07
+:  NOP
+:  NOP
+:  BCF    03.5
+:  BSF    20.3
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  BCF    03.5
+:  BTFSS  07.3
+:  GOTO   078
+A:  CLRF   78
+B:  NOP
+C:  BTFSC  07.4
+D:  BSF    78.0
+E:  BCF    07.3
+F:  BCF    20.3
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  BCF    03.5
+:  BCF    07.4
+:  BCF    20.4
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  BCF    03.5
+A:  RETURN
+*
+:  MOVLW  08
+:  MOVWF  30
+:  MOVF   77,W
+:  MOVWF  31
+:  BSF    20.4
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  NOP
+:  BCF    03.5
+A:  BSF    20.3
+B:  MOVF   20,W
+C:  BSF    03.5
+D:  MOVWF  07
+E:  BCF    03.5
+F:  BTFSS  07.3
+:  GOTO   13F
+:  BTFSC  07.4
+:  BSF    03.0
+:  BTFSS  07.4
+:  BCF    03.0
+:  RLF    78,F
+:  NOP
+:  BCF    20.3
+:  MOVF   20,W
+:  BSF    03.5
+A:  MOVWF  07
+B:  BCF    03.5
+C:  BCF    07.3
+D:  DECFSZ 30,F
+E:  GOTO   134
+F:  BSF    20.4
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  NOP
+:  BCF    03.5
+:  BCF    07.4
+:  MOVF   31,W
+:  BTFSC  03.2
+:  GOTO   15E
+:  BCF    20.4
+A:  MOVF   20,W
+B:  BSF    03.5
+C:  MOVWF  07
+D:  BCF    03.5
+E:  NOP
+F:  BSF    20.3
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  BCF    03.5
+:  BTFSS  07.3
+:  GOTO   164
+:  NOP
+:  BCF    07.3
+:  BCF    20.3
+:  MOVF   20,W
+A:  BSF    03.5
+B:  MOVWF  07
+C:  NOP
+D:  BCF    03.5
+E:  BCF    07.4
+F:  BCF    20.4
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  BCF    03.5
+:  RETURN
+.................... #use rs232(baud=9600,parity=N,xmit=PIN_C7,rcv=PIN_C6,bits=8) //rcv TXD xmit RXD
+*
+C6:  BCF    20.7
+C7:  MOVF   20,W
+C8:  BSF    03.5
+C9:  MOVWF  07
+CA:  BCF    03.5
+CB:  BCF    07.7
+CC:  MOVLW  08
+CD:  MOVWF  78
+CE:  GOTO   0CF
+CF:  NOP
+D0:  BSF    78.7
+D1:  GOTO   0E0
+D2:  BCF    78.7
+D3:  RRF    30,F
+D4:  BTFSC  03.0
+D5:  BSF    07.7
+D6:  BTFSS  03.0
+D7:  BCF    07.7
+D8:  BSF    78.6
+D9:  GOTO   0E0
+DA:  BCF    78.6
+DB:  DECFSZ 78,F
+DC:  GOTO   0D3
+DD:  GOTO   0DE
+DE:  NOP
+DF:  BSF    07.7
+E0:  MOVLW  3F
+E1:  MOVWF  04
+E2:  DECFSZ 04,F
+E3:  GOTO   0E2
+E4:  NOP
+E5:  BTFSC  78.7
+E6:  GOTO   0D2
+E7:  BTFSC  78.6
+E8:  GOTO   0DA
+E9:  RETURN
+.................... #include <math.h>
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... ////        (C) Copyright 1996,2008 Custom Computer Services            ////
+.................... //// This source code may only be used by licensed users of the CCS C   ////
+.................... //// compiler.  This source code may only be distributed to other       ////
+.................... //// licensed users of the CCS C compiler.  No other use, reproduction  ////
+.................... //// or distribution is permitted without written permission.           ////
+.................... //// Derivative programs created using this software in object code     ////
+.................... //// form are not restricted in any way.                                ////
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... ////                                                                    ////
+.................... //// History:                                                           ////
+.................... ////  * 9/20/2001 :  Improvments are made to sin/cos code.              ////
+.................... ////                 The code now is small, much faster,                ////
+.................... ////                 and more accurate.                                 ////
+.................... ////  * 2/21/2007 :  Compiler handles & operator differently and does
+.................... ////                 not return generic (int8 *) so type cast is done   ////
+.................... ////                                                                    ////
+.................... ////////////////////////////////////////////////////////////////////////////
+....................
+.................... #ifndef MATH_H
+.................... #define MATH_H
+....................
+.................... #ifdef PI
+.................... #undef  PI
+.................... #endif
+.................... #define PI     3.1415926535897932
+....................
+....................
+.................... #define SQRT2  1.4142135623730950
+....................
+.................... //float const ps[4] = {5.9304945, 21.125224, 8.9403076, 0.29730279};
+.................... //float const qs[4] = {1.0000000, 15.035723, 17.764134, 2.4934718};
+....................
+.................... ///////////////////////////// Round Functions //////////////////////////////
+....................
+.................... float32 CEIL_FLOOR(float32 x, unsigned int8 n)
+.................... {
+....................    float32 y, res;
+....................    unsigned int16 l;
+....................    int1 s;
+....................
+....................    s = 0;
+....................    y = x;
+....................
+....................    if (x < 0)
+....................    {
+....................       s = 1;
+....................       y = -y;
+....................    }
+....................
+....................    if (y <= 32768.0)
+....................   res = (float32)(unsigned int16)y;
+....................
+....................  else if (y < 10000000.0)
+....................    {
+....................   l = (unsigned int16)(y/32768.0);
+....................       y = 32768.0*(y/32768.0 - (float32)l);
+....................   res = 32768.0*(float32)l;
+....................   res += (float32)(unsigned int16)y;
+....................  }
+....................
+....................  else
+....................   res = y;
+....................
+....................  y = y - (float32)(unsigned int16)y;
+....................
+....................  if (s)
+....................   res = -res;
+....................
+....................  if (y != 0)
+....................  {
+....................   if (s == 1 && n == 0)
+....................    res -= 1.0;
+....................
+....................   if (s == 0 && n == 1)
+....................    res += 1.0;
+....................  }
+....................  if (x == 0)
+....................     res = 0;
+....................
+....................  return (res);
+.................... }
+....................
+.................... // Overloaded Functions to take care for new Data types in PCD
+.................... // Overloaded function CEIL_FLOOR() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 CEIL_FLOOR(float48 x, unsigned int8 n)
+.................... {
+....................    float48 y, res;
+....................    unsigned int16 l;
+....................    int1 s;
+....................
+....................    s = 0;
+....................    y = x;
+....................
+....................    if (x < 0)
+....................    {
+....................       s = 1;
+....................       y = -y;
+....................    }
+....................
+....................    if (y <= 32768.0)
+....................   res = (float48)(unsigned int16)y;
+....................
+....................  else if (y < 10000000.0)
+....................    {
+....................   l = (unsigned int16)(y/32768.0);
+....................       y = 32768.0*(y/32768.0 - (float48)l);
+....................   res = 32768.0*(float32)l;
+....................   res += (float48)(unsigned int16)y;
+....................  }
+....................
+....................  else
+....................   res = y;
+....................
+....................  y = y - (float48)(unsigned int16)y;
+....................
+....................  if (s)
+....................   res = -res;
+....................
+....................  if (y != 0)
+....................  {
+....................   if (s == 1 && n == 0)
+....................    res -= 1.0;
+....................
+....................   if (s == 0 && n == 1)
+....................    res += 1.0;
+....................  }
+....................  if (x == 0)
+....................     res = 0;
+....................
+....................  return (res);
+.................... }
+....................
+....................
+.................... // Overloaded function CEIL_FLOOR() for data type - Float64
+.................... float64 CEIL_FLOOR(float64 x, unsigned int8 n)
+.................... {
+....................    float64 y, res;
+....................    unsigned int16 l;
+....................    int1 s;
+....................
+....................    s = 0;
+....................    y = x;
+....................
+....................    if (x < 0)
+....................    {
+....................       s = 1;
+....................       y = -y;
+....................    }
+....................
+....................    if (y <= 32768.0)
+....................   res = (float64)(unsigned int16)y;
+....................
+....................  else if (y < 10000000.0)
+....................    {
+....................   l = (unsigned int16)(y/32768.0);
+....................       y = 32768.0*(y/32768.0 - (float64)l);
+....................   res = 32768.0*(float64)l;
+....................   res += (float64)(unsigned int16)y;
+....................  }
+....................
+....................  else
+....................   res = y;
+....................
+....................  y = y - (float64)(unsigned int16)y;
+....................
+....................  if (s)
+....................   res = -res;
+....................
+....................  if (y != 0)
+....................  {
+....................   if (s == 1 && n == 0)
+....................    res -= 1.0;
+....................
+....................   if (s == 0 && n == 1)
+....................    res += 1.0;
+....................  }
+....................  if (x == 0)
+....................     res = 0;
+....................
+....................  return (res);
+.................... }
+.................... #endif
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float floor(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : rounds down the number x.
+.................... // Date : N/A
+.................... //
+.................... float32 floor(float32 x)
+.................... {
+....................    return CEIL_FLOOR(x, 0);
+.................... }
+.................... // Following 2 functions are overloaded functions of floor() for PCD
+.................... // Overloaded function floor() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 floor(float48 x)
+.................... {
+....................    return CEIL_FLOOR(x, 0);
+.................... }
+....................
+.................... // Overloaded function floor() for data type - Float64
+.................... float64 floor(float64 x)
+.................... {
+....................    return CEIL_FLOOR(x, 0);
+.................... }
+.................... #endif
+....................
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float ceil(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : rounds up the number x.
+.................... // Date : N/A
+.................... //
+.................... float32 ceil(float32 x)
+.................... {
+....................    return CEIL_FLOOR(x, 1);
+.................... }
+.................... // Following 2 functions are overloaded functions of ceil() for PCD
+.................... // Overloaded function ceil() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 ceil(float48 x)
+.................... {
+....................    return CEIL_FLOOR(x, 1);
+.................... }
+....................
+.................... // Overloaded function ceil() for data type - Float64
+.................... float64 ceil(float64 x)
+.................... {
+....................    return CEIL_FLOOR(x, 1);
+.................... }
+.................... #endif
+....................
+....................  ////////////////////////////////////////////////////////////////////////////
+.................... //   float fabs(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : Computes the absolute value of floating point number x
+.................... // Returns : returns the absolute value of x
+.................... // Date : N/A
+.................... //
+.................... #define fabs abs
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float fmod(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : Computes the floating point remainder of x/y
+.................... // Returns : returns the value of x= i*y, for some integer i such that, if y
+.................... // is non zero, the result has the same isgn of x na dmagnitude less than the
+.................... // magnitude of y. If y is zero then a domain error occurs.
+.................... // Date : N/A
+.................... //
+....................
+.................... float fmod(float32 x,float32 y)
+.................... {
+....................    float32 i;
+....................    if (y!=0.0)
+....................    {
+....................       i=(x/y < 0.0)? ceil(x/y): floor(x/y);
+....................       return(x-(i*y));
+....................    }
+....................    else
+....................    {
+....................    #ifdef _ERRNO
+....................    {
+....................       errno=EDOM;
+....................    }
+....................    #endif
+....................    }
+.................... }
+.................... //Overloaded function for fmod() for PCD
+.................... // Overloaded function fmod() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 fmod(float48 x,float48 y)
+.................... {
+....................    float48 i;
+....................    if (y!=0.0)
+....................    {
+....................       i=(x/y < 0.0)? ceil(x/y): floor(x/y);
+....................       return(x-(i*y));
+....................    }
+....................    else
+....................    {
+....................    #ifdef _ERRNO
+....................    {
+....................       errno=EDOM;
+....................    }
+....................    #endif
+....................    }
+.................... }
+.................... // Overloaded function fmod() for data type - Float64
+.................... float64 fmod(float64 x,float64 y)
+.................... {
+....................    float64 i;
+....................    if (y!=0.0)
+....................    {
+....................       i=(x/y < 0.0)? ceil(x/y): floor(x/y);
+....................       return(x-(i*y));
+....................    }
+....................    else
+....................    {
+....................    #ifdef _ERRNO
+....................    {
+....................       errno=EDOM;
+....................    }
+....................    #endif
+....................    }
+.................... }
+.................... #endif
+.................... //////////////////// Exponential and logarithmic functions ////////////////////
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float exp(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : returns the value (e^x)
+.................... // Date : N/A
+.................... //
+.................... #define LN2 0.6931471805599453
+....................
+.................... float const pe[6] = {0.000207455774, 0.00127100575, 0.00965065093,
+....................                      0.0554965651,  0.240227138,  0.693147172};
+....................
+....................
+.................... float32 exp(float32 x)
+.................... {
+....................    float32 y, res, r;
+....................    #if defined(__PCD__)
+....................    int8 data1;
+....................    #endif
+....................    signed int8 n;
+....................    int1 s;
+....................    #ifdef _ERRNO
+....................    if(x > 88.722838)
+....................    {
+....................       errno=ERANGE;
+....................       return(0);
+....................    }
+....................    #endif
+....................    n = (signed int16)(x/LN2);
+....................    s = 0;
+....................    y = x;
+....................
+....................    if (x < 0)
+....................    {
+....................       s = 1;
+....................       n = -n;
+....................       y = -y;
+....................    }
+....................
+....................    res = 0.0;
+.................... #if !defined(__PCD__)
+....................    *((unsigned int8 *)(&res)) = n + 0x7F;
+.................... #endif
+....................
+.................... #if defined(__PCD__)  // Takes care of IEEE format for PCD
+....................    data1 = n+0x7F;
+....................    if(bit_test(data1,0))
+....................    bit_set(*(((unsigned int8 *)(&res)+2)),7);
+....................    rotate_right(&data1,1);
+....................    bit_clear(data1,7);
+....................    *(((unsigned int8 *)(&res)+3)) = data1;
+.................... #endif
+....................
+....................    y = y/LN2 - (float32)n;
+....................
+....................    r = pe[0]*y + pe[1];
+....................    r = r*y + pe[2];
+....................    r = r*y + pe[3];
+....................    r = r*y + pe[4];
+....................    r = r*y + pe[5];
+....................
+....................    res = res*(1.0 + y*r);
+....................
+....................    if (s)
+....................       res = 1.0/res;
+....................    return(res);
+.................... }
+....................
+....................
+.................... //Overloaded function for exp() for PCD
+.................... // Overloaded function exp() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 exp(float48 x)
+.................... {
+....................    float48 y, res, r;
+....................    int8 data1;
+....................    signed int8 n;
+....................    int1 s;
+....................    #ifdef _ERRNO
+....................    if(x > 88.722838)
+....................    {
+....................       errno=ERANGE;
+....................       return(0);
+....................    }
+....................    #endif
+....................    n = (signed int16)(x/LN2);
+....................    s = 0;
+....................    y = x;
+....................
+....................    if (x < 0)
+....................    {
+....................       s = 1;
+....................       n = -n;
+....................       y = -y;
+....................    }
+....................
+....................    res = 0.0;
+....................
+....................    data1 = n+0x7F;
+....................    if(bit_test(data1,0))
+....................    bit_set(*(((unsigned int8 *)(&res)+4)),7);
+....................    rotate_right(&data1,1);
+....................    bit_clear(data1,7);
+....................    *(((unsigned int8 *)(&res)+5)) = data1;
+....................
+....................    y = y/LN2 - (float48)n;
+....................
+....................    r = pe[0]*y + pe[1];
+....................    r = r*y + pe[2];
+....................    r = r*y + pe[3];
+....................    r = r*y + pe[4];
+....................    r = r*y + pe[5];
+....................
+....................    res = res*(1.0 + y*r);
+....................
+....................    if (s)
+....................       res = 1.0/res;
+....................    return(res);
+.................... }
+....................
+.................... // Overloaded function exp() for data type - Float64
+.................... float64 exp(float64 x)
+.................... {
+....................    float64 y, res, r;
+....................    unsigned int16 data1, data2;
+....................    unsigned int16 *p;
+....................    signed int16 n;
+....................    int1 s;
+....................    #ifdef _ERRNO
+....................    if(x > 709.7827128)
+....................    {
+....................       errno=ERANGE;
+....................       return(0);
+....................    }
+....................    #endif
+....................    n = (signed int16)(x/LN2);
+....................    s = 0;
+....................    y = x;
+....................
+....................    if (x < 0)
+....................    {
+....................       s = 1;
+....................       n = -n;
+....................       y = -y;
+....................    }
+....................
+....................    res = 0.0;
+....................
+.................... #if !defined(__PCD__)
+....................    *((unsigned int16 *)(&res)) = n + 0x7F;
+.................... #endif
+....................    p= (((unsigned int16 *)(&res))+3);
+....................    data1 = *p;
+....................    data2 = *p;
+....................    data1 = n + 0x3FF;
+....................    data1 = data1 <<4;
+....................    if(bit_test(data2,15))
+....................    bit_set(data1,15);
+....................    data2 = data2 & 0x000F;
+....................    data1 ^= data2;
+....................
+....................    *(((unsigned int16 *)(&res)+3)) = data1;
+....................
+....................
+....................    y = y/LN2 - (float64)n;
+....................
+....................    r = pe[0]*y + pe[1];
+....................    r = r*y + pe[2];
+....................    r = r*y + pe[3];
+....................    r = r*y + pe[4];
+....................    r = r*y + pe[5];
+....................
+....................    res = res*(1.0 + y*r);
+....................
+....................    if (s)
+....................       res = 1.0/res;
+....................    return(res);
+.................... }
+....................
+.................... #ENDIF
+....................
+....................
+.................... /************************************************************/
+....................
+.................... float32 const pl[4] = {0.45145214, -9.0558803, 26.940971, -19.860189};
+.................... float32 const ql[4] = {1.0000000,  -8.1354259, 16.780517, -9.9300943};
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float log(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : returns the the natural log of x
+.................... // Date : N/A
+.................... //
+.................... float32 log(float32 x)
+.................... {
+....................    float32 y, res, r, y2;
+....................    #if defined(__PCD__)
+....................    unsigned int8  data1,data2;
+....................    #endif
+....................    signed int8 n;
+....................    #ifdef _ERRNO
+....................    if(x <0)
+....................    {
+....................       errno=EDOM;
+....................    }
+....................    if(x ==0)
+....................    {
+....................       errno=ERANGE;
+....................       return(0);
+....................    }
+....................    #endif
+....................    y = x;
+....................
+....................    if (y != 1.0)
+....................    {
+.................... #if !defined(__PCD__)
+....................     *((unsigned int8 *)(&y)) = 0x7E;
+.................... #endif
+....................
+.................... #if defined(__PCD__) // Takes care of IEEE format
+....................    data2 = *(((unsigned int8 *)(&y))+3);
+....................    *(((unsigned int8 *)(&y))+3) = 0x3F;
+....................    data1 = *(((unsigned int8 *)(&y))+2);
+....................    bit_clear(data1,7);
+....................    *(((unsigned int8 *)(&y))+2) = data1;
+....................    if(bit_test(data2,7))
+....................    bit_set(*(((unsigned int8 *)(&y))+3),7);
+.................... #endif
+....................
+....................       y = (y - 1.0)/(y + 1.0);
+....................
+....................       y2=y*y;
+....................
+....................       res = pl[0]*y2 + pl[1];
+....................       res = res*y2 + pl[2];
+....................       res = res*y2 + pl[3];
+....................
+....................       r = ql[0]*y2 + ql[1];
+....................       r = r*y2 + ql[2];
+....................       r = r*y2 + ql[3];
+....................
+....................       res = y*res/r;
+.................... #if !defined(__PCD__)
+....................       n = *((unsigned int8 *)(&x)) - 0x7E;
+.................... #endif
+.................... #if defined(__PCD__)
+....................     data1 = *(((unsigned int8 *)(&x)+3));
+....................     rotate_left(&data1,1);
+....................     data2 = *(((unsigned int8 *)(&x)+2));
+....................     if(bit_test (data2,7))
+....................       bit_set(data1,0);
+....................     n = data1 - 0x7E;
+.................... #endif
+....................
+....................       if (n<0)
+....................          r = -(float32)-n;
+....................       else
+....................          r = (float32)n;
+....................
+....................       res += r*LN2;
+....................    }
+....................
+....................    else
+....................       res = 0.0;
+....................
+....................    return(res);
+.................... }
+....................
+.................... //Overloaded function for log() for PCD
+.................... // Overloaded function log() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 log(float48 x)
+.................... {
+....................    float48 y, res, r, y2;
+....................    unsigned int8  data1,data2;
+....................    signed int8 n;
+....................    #ifdef _ERRNO
+....................    if(x <0)
+....................    {
+....................       errno=EDOM;
+....................    }
+....................    if(x ==0)
+....................    {
+....................       errno=ERANGE;
+....................       return(0);
+....................    }
+....................    #endif
+....................    y = x;
+....................
+....................    if (y != 1.0)
+....................    {
+....................
+....................    #if !defined(__PCD__)
+....................        *((unsigned int8 *)(&y)) = 0x7E;
+....................    #endif
+....................       data2 = *(((unsigned int8 *)(&y))+5);
+....................       *(((unsigned int8 *)(&y))+5) = 0x3F;
+....................       data1 = *(((unsigned int8 *)(&y))+4);
+....................       bit_clear(data1,7);
+....................       *(((unsigned int8 *)(&y))+4) = data1;
+....................
+....................       if(bit_test(data2,7))
+....................          bit_set(*(((unsigned int8 *)(&y))+4),7);
+....................       y = (y - 1.0)/(y + 1.0);
+....................
+....................       y2=y*y;
+....................
+....................       res = pl[0]*y2 + pl[1];
+....................       res = res*y2 + pl[2];
+....................       res = res*y2 + pl[3];
+....................
+....................       r = ql[0]*y2 + ql[1];
+....................       r = r*y2 + ql[2];
+....................       r = r*y2 + ql[3];
+....................
+....................       res = y*res/r;
+....................
+....................     data1 = *(((unsigned int8 *)(&x)+5));
+....................     rotate_left(&data1,1);
+....................     data2 = *(((unsigned int8 *)(&x)+4));
+....................     if(bit_test (data2,7))
+....................        bit_set(data1,0);
+....................
+....................     n = data1 - 0x7E;
+....................
+....................       if (n<0)
+....................          r = -(float48)-n;
+....................       else
+....................          r = (float48)n;
+....................
+....................       res += r*LN2;
+....................    }
+....................
+....................    else
+....................       res = 0.0;
+....................
+....................    return(res);
+.................... }
+....................
+.................... // Overloaded function log() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float32 const pl_64[4] = {0.45145214, -9.0558803, 26.940971, -19.860189};
+.................... float32 const ql_64[4] = {1.0000000,  -8.1354259, 16.780517, -9.9300943};
+.................... #endif
+.................... float64 log(float64 x)
+.................... {
+....................    float64 y, res, r, y2;
+....................    unsigned int16  data1,data2;
+....................    unsigned int16 *p;
+....................    signed int16 n;
+....................    #ifdef _ERRNO
+....................    if(x <0)
+....................    {
+....................       errno=EDOM;
+....................    }
+....................    if(x ==0)
+....................    {
+....................       errno=ERANGE;
+....................       return(0);
+....................    }
+....................    #endif
+....................    y = x;
+....................
+....................    if (y != 1.0)
+....................    {
+....................    #if !defined(__PCD__)
+....................        *((unsigned int8 *)(&y)) = 0x7E;
+....................    #endif
+....................       p= (((unsigned int16 *)(&y))+3);
+....................       data1 = *p;
+....................       data2 = *p;
+....................       data1 = 0x3FE;
+....................       data1 = data1 <<4;
+....................       if(bit_test (data2,15))
+....................       bit_set(data1,15);
+....................       data2 = data2 & 0x000F;
+....................       data1 ^=data2;
+....................
+....................       *p = data1;
+....................
+....................       y = (y - 1.0)/(y + 1.0);
+....................
+....................       y2=y*y;
+....................
+....................       res = pl_64[0]*y2 + pl_64[1];
+....................       res = res*y2 + pl_64[2];
+....................       res = res*y2 + pl_64[3];
+....................
+....................       r = ql_64[0]*y2 + ql_64[1];
+....................       r = r*y2 + ql_64[2];
+....................       r = r*y2 + ql_64[3];
+....................
+....................       res = y*res/r;
+....................
+....................       p= (((unsigned int16 *)(&x))+3);
+....................       data1 = *p;
+....................       bit_clear(data1,15);
+....................       data1 = data1 >>4;
+....................       n = data1 - 0x3FE;
+....................
+....................
+....................       if (n<0)
+....................          r = -(float64)-n;
+....................       else
+....................          r = (float64)n;
+....................
+....................       res += r*LN2;
+....................    }
+....................
+....................    else
+....................       res = 0.0;
+....................
+....................    return(res);
+.................... }
+.................... #endif
+....................
+....................
+.................... #define LN10 2.3025850929940456
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float log10(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : returns the the log base 10 of x
+.................... // Date : N/A
+.................... //
+.................... float32 log10(float32 x)
+.................... {
+....................    float32 r;
+....................
+....................    r = log(x);
+....................    r = r/LN10;
+....................    return(r);
+.................... }
+....................
+.................... //Overloaded functions for log10() for PCD
+.................... // Overloaded function log10() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 log10(float48 x)
+.................... {
+....................    float48 r;
+....................
+....................    r = log(x);
+....................    r = r/LN10;
+....................    return(r);
+.................... }
+....................
+.................... // Overloaded function log10() for data type - Float64
+.................... float64 log10(float64 x)
+.................... {
+....................    float64 r;
+....................
+....................    r = log(x);
+....................    r = r/LN10;
+....................    return(r);
+.................... }
+.................... #endif
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float modf(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description :breaks the argument value int integral and fractional parts,
+.................... // ach of which have the same sign as the argument.  It stores the integral part
+.................... // as a float in the object pointed to by the iptr
+.................... // Returns : returns the signed fractional part of value.
+.................... // Date : N/A
+.................... //
+....................
+.................... float32 modf(float32 value,float32 *iptr)
+.................... {
+....................    *iptr=(value < 0.0)? ceil(value): floor(value);
+....................    return(value - *iptr);
+.................... }
+.................... //Overloaded functions for modf() for PCD
+.................... // Overloaded function modf() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 modf(float48 value,float48 *iptr)
+.................... {
+....................    *iptr=(value < 0.0)? ceil(value): floor(value);
+....................    return(value - *iptr);
+.................... }
+.................... // Overloaded function modf() for data type - Float64
+.................... float64 modf(float64 value,float64 *iptr)
+.................... {
+....................    *iptr=(value < 0.0)? ceil(value): floor(value);
+....................    return(value - *iptr);
+.................... }
+.................... #endif
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float pwr(float x,float y)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : returns the value (x^y)
+.................... // Date : N/A
+.................... // Note : 0 is returned when the function will generate an imaginary number
+.................... //
+.................... float32 pwr(float32 x,float32 y)
+.................... {
+....................    if(0 > x && fmod(y, 1) == 0) {
+....................       if(fmod(y, 2) == 0) {
+....................          return (exp(log(-x) * y));
+....................       } else {
+....................          return (-exp(log(-x) * y));
+....................       }
+....................    } else if(0 > x && fmod(y, 1) != 0) {
+....................       return 0;
+....................    } else {
+....................       if(x != 0 || 0 >= y) {
+....................          return (exp(log(x) * y));
+....................       }
+....................    }
+.................... }
+.................... //Overloaded functions for pwr() for PCD
+.................... // Overloaded function pwr() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 pwr(float48 x,float48 y)
+.................... {
+....................    if(0 > x && fmod(y, 1) == 0) {
+....................       if(fmod(y, 2) == 0) {
+....................          return (exp(log(-x) * y));
+....................       } else {
+....................          return (-exp(log(-x) * y));
+....................       }
+....................    } else if(0 > x && fmod(y, 1) != 0) {
+....................       return 0;
+....................    } else {
+....................       if(x != 0 || 0 >= y) {
+....................          return (exp(log(x) * y));
+....................       }
+....................    }
+.................... }
+.................... // Overloaded function pwr() for data type - Float64
+.................... float64 pwr(float64 x,float64 y)
+.................... {
+....................    if(0 > x && fmod(y, 1) == 0) {
+....................       if(fmod(y, 2) == 0) {
+....................          return (exp(log(-x) * y));
+....................       } else {
+....................          return (-exp(log(-x) * y));
+....................       }
+....................    } else if(0 > x && fmod(y, 1) != 0) {
+....................       return 0;
+....................    } else {
+....................       if(x != 0 || 0 >= y) {
+....................          return (exp(log(x) * y));
+....................       }
+....................    }
+.................... }
+.................... #endif
+....................
+.................... //////////////////// Power functions ////////////////////
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float pow(float x,float y)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : returns the value (x^y)
+.................... // Date : N/A
+.................... // Note : 0 is returned when the function will generate an imaginary number
+.................... //
+.................... float32 pow(float32 x,float32 y)
+.................... {
+....................    if(0 > x && fmod(y, 1) == 0) {
+....................       if(fmod(y, 2) == 0) {
+....................          return (exp(log(-x) * y));
+....................       } else {
+....................          return (-exp(log(-x) * y));
+....................       }
+....................    } else if(0 > x && fmod(y, 1) != 0) {
+....................       return 0;
+....................    } else {
+....................       if(x != 0 || 0 >= y) {
+....................          return (exp(log(x) * y));
+....................       }
+....................    }
+.................... }
+.................... //Overloaded functions for pow() for PCD
+.................... // Overloaded function for pow() data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 pow(float48 x,float48 y)
+.................... {
+....................    if(0 > x && fmod(y, 1) == 0) {
+....................       if(fmod(y, 2) == 0) {
+....................          return (exp(log(-x) * y));
+....................       } else {
+....................          return (-exp(log(-x) * y));
+....................       }
+....................    } else if(0 > x && fmod(y, 1) != 0) {
+....................       return 0;
+....................    } else {
+....................       if(x != 0 || 0 >= y) {
+....................          return (exp(log(x) * y));
+....................       }
+....................    }
+.................... }
+....................
+.................... // Overloaded function pow() for data type - Float64
+.................... float64 pow(float64 x,float64 y)
+.................... {
+....................    if(0 > x && fmod(y, 1) == 0) {
+....................       if(fmod(y, 2) == 0) {
+....................          return (exp(log(-x) * y));
+....................       } else {
+....................          return (-exp(log(-x) * y));
+....................       }
+....................    } else if(0 > x && fmod(y, 1) != 0) {
+....................       return 0;
+....................    } else {
+....................       if(x != 0 || 0 >= y) {
+....................          return (exp(log(x) * y));
+....................       }
+....................    }
+.................... }
+.................... #endif
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float sqrt(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : returns the square root of x
+.................... // Date : N/A
+.................... //
+.................... float32 sqrt(float32 x)
+.................... {
+....................    float32 y, res;
+....................    #if defined(__PCD__)
+....................    unsigned int16 data1,data2;
+....................    #endif
+....................    BYTE *p;
+....................
+....................    #ifdef _ERRNO
+....................    if(x < 0)
+....................    {
+....................       errno=EDOM;
+....................    }
+....................    #endif
+....................
+....................    if( x<=0.0)
+....................       return(0.0);
+....................
+....................    y=x;
+....................
+....................    #if !defined(__PCD__)
+....................     p=&y;
+....................    (*p)=(BYTE)((((unsigned int16)(*p)) + 127) >> 1);
+....................    #endif
+....................
+....................    #if defined(__PCD__)
+....................     p = (((unsigned int8 *)(&y))+3);
+....................     data1 = *(((unsigned int8 *)(&y))+3);
+....................     data2 = *(((unsigned int8 *)(&y))+2);
+....................     rotate_left(&data1,1);
+....................     if(bit_test(data2,7))
+....................     bit_set(data1,0);
+....................     data1 = ((data1+127) >>1);
+....................     bit_clear(data2,7);
+....................     if(bit_test(data1,0))
+....................     bit_set(data2,7);
+....................     data1 = data1 >>1;
+....................     *(((unsigned int8 *)(&y))+3) = data1;
+....................     *(((unsigned int8 *)(&y))+2) = data2;
+....................
+....................   #endif
+....................
+....................    do {
+....................       res=y;
+....................       y+=(x/y);
+....................
+....................       #if !defined(__PCD__)
+....................      (*p)--;
+....................    #endif
+....................
+....................    #if defined(__PCD__)
+....................     data1 = *(((unsigned int8 *)(&y))+3);
+....................     data2 = *(((unsigned int8 *)(&y))+2);
+....................     rotate_left(&data1,1);
+....................     if(bit_test(data2,7))
+....................     bit_set(data1,0);
+....................     data1--;
+....................     bit_clear(data2,7);
+....................     if(bit_test(data1,0))
+....................     bit_set(data2,7);
+....................     data1 = data1 >>1;
+....................     *(((unsigned int8 *)(&y))+3) = data1;
+....................     *(((unsigned int8 *)(&y))+2) = data2;
+....................
+....................   #endif
+....................    } while(res != y);
+....................
+....................    return(res);
+.................... }
+.................... //Overloaded functions for sqrt() for PCD
+.................... // Overloaded function sqrt() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 sqrt(float48 x)
+.................... {
+....................    float48 y, res;
+....................    unsigned int16 data1,data2;
+....................    BYTE *p;
+....................
+....................    #ifdef _ERRNO
+....................    if(x < 0)
+....................    {
+....................       errno=EDOM;
+....................    }
+....................    #endif
+....................
+....................    if( x<=0.0)
+....................       return(0.0);
+....................
+....................    y=x;
+....................
+....................    #if !defined(__PCD__)
+....................     p=&y;
+....................    (*p)=(BYTE)((((unsigned int16)(*p)) + 127) >> 1);
+....................    #endif
+....................
+....................    #if defined(__PCD__)
+....................     p = (((unsigned int8 *)(&y))+5);
+....................     data1 = *(((unsigned int8 *)(&y))+5);
+....................     data2 = *(((unsigned int8 *)(&y))+4);
+....................     rotate_left(&data1,1);
+....................     if(bit_test(data2,7))
+....................     bit_set(data1,0);
+....................     data1 = ((data1+127) >>1);
+....................     bit_clear(data2,7);
+....................     if(bit_test(data1,0))
+....................     bit_set(data2,7);
+....................     data1 = data1 >>1;
+....................     *(((unsigned int8 *)(&y))+5) = data1;
+....................     *(((unsigned int8 *)(&y))+4) = data2;
+....................
+....................   #endif
+....................
+....................    do {
+....................       res=y;
+....................       y+=(x/y);
+....................
+....................       #if !defined(__PCD__)
+....................      (*p)--;
+....................    #endif
+....................
+....................     data1 = *(((unsigned int8 *)(&y))+5);
+....................     data2 = *(((unsigned int8 *)(&y))+4);
+....................     rotate_left(&data1,1);
+....................     if(bit_test(data2,7))
+....................     bit_set(data1,0);
+....................     data1--;
+....................     bit_clear(data2,7);
+....................     if(bit_test(data1,0))
+....................     bit_set(data2,7);
+....................     data1 = data1 >>1;
+....................     *(((unsigned int8 *)(&y))+5) = data1;
+....................     *(((unsigned int8 *)(&y))+4) = data2;
+....................
+....................    } while(res != y);
+....................
+....................    return(res);
+.................... }
+....................
+.................... // Overloaded function sqrt() for data type - Float64
+.................... float64 sqrt(float64 x)
+.................... {
+....................    float64 y, res;
+....................    unsigned int16 *p;
+....................    unsigned int16 temp1,temp2;
+....................
+....................    #ifdef _ERRNO
+....................    if(x < 0)
+....................    {
+....................       errno=EDOM;
+....................    }
+....................    #endif
+....................
+....................    if( x<=0.0)
+....................       return(0.0);
+....................
+....................    y=x;
+....................    p= (((unsigned int16 *)(&y))+3);
+....................    temp1 = *p;
+....................    temp2 = *p;
+....................    bit_clear(temp1,15);
+....................    temp1 = (temp1>>4)+1023;
+....................    temp1 = temp1 >> 1;
+....................    temp1 = (temp1<<4) & 0xFFF0;
+....................    if(bit_test(temp2,15))
+....................    bit_set(temp1,15);
+....................    temp2 = temp2 & 0x000F;
+....................    temp1 ^= temp2;
+....................
+....................    (*p) = temp1;
+....................
+....................    do {
+....................       res=y;
+....................       y+=(x/y);
+....................      temp1 = *p;
+....................      temp2 = *p;
+....................      bit_clear(temp1,15);
+....................      temp1 = (temp1>>4);
+....................      temp1--;
+....................      temp1 = (temp1<<4) & 0xFFF0;
+....................      if(bit_test(temp2,15))
+....................      bit_set(temp1,15);
+....................      temp2 = temp2 & 0x000F;
+....................      temp1 ^= temp2;
+....................      (*p) = temp1;
+....................
+....................    } while(res != y);
+....................
+....................    return(res);
+.................... }
+.................... #endif
+....................
+.................... ////////////////////////////// Trig Functions //////////////////////////////
+.................... #ifdef PI_DIV_BY_TWO
+.................... #undef PI_DIV_BY_TWO
+.................... #endif
+.................... #define PI_DIV_BY_TWO   1.5707963267948966
+.................... #ifdef TWOBYPI
+.................... #undef TWOBYPI
+.................... #define TWOBYPI          0.6366197723675813
+.................... #endif
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float cos(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : returns the cosine value of the angle x, which is in radian
+.................... // Date : 9/20/2001
+.................... //
+.................... float32 cos(float32 x)
+.................... {
+....................    float32 y, t, t2 = 1.0;
+....................    unsigned int8 quad, i;
+....................    float32 frac;
+....................    float32 p[6] = {                    //by the series definition for cosine
+....................       -0.5,                            // sum ( ( (-1)^n * x^2n )/(2n)! )
+....................        0.04166666666667,
+....................       -0.00138888888889,
+....................        0.00002480158730,
+....................       -0.00000027557319,
+....................        0.00000000208767,
+....................       //-0.00000000001147,
+....................       // 0.00000000000005
+....................    };
+....................
+....................    if (x < 0) x = -x;                  // absolute value of input
+....................
+....................    quad = (unsigned int8)(x / PI_DIV_BY_TWO);    // quadrant
+....................    frac = (x / PI_DIV_BY_TWO) - quad;  // fractional part of input
+....................    quad = quad % 4;                    // quadrant (0 to 3)
+....................
+....................    if (quad == 0 || quad == 2)
+....................       t = frac * PI_DIV_BY_TWO;
+....................    else if (quad == 1)
+....................       t = (1-frac) * PI_DIV_BY_TWO;
+....................    else // should be 3
+....................       t = (frac-1) * PI_DIV_BY_TWO;
+....................
+....................    y = 1.0;
+....................    t = t * t;
+....................    for (i = 0; i <= 5; i++)
+....................    {
+....................       t2 = t2 * t;
+....................       y = y + p[i] * t2;
+....................    }
+....................
+....................    if (quad == 2 || quad == 1)
+....................       y = -y;  // correct sign
+....................
+....................    return (y);
+.................... }
+....................
+....................
+.................... //Overloaded functions for cos() for PCD
+.................... // Overloaded function cos() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 cos(float48 x)
+.................... {
+....................    float48 y, t, t2 = 1.0;
+....................    unsigned int8 quad, i;
+....................    float48 frac;
+....................    float48 p[6] = {                    //by the series definition for cosine
+....................       -0.5,                            // sum ( ( (-1)^n * x^2n )/(2n)! )
+....................        0.04166666666667,
+....................       -0.00138888888889,
+....................        0.00002480158730,
+....................       -0.00000027557319,
+....................        0.00000000208767,
+....................       //-0.00000000001147,
+....................       // 0.00000000000005
+....................    };
+....................
+....................    if (x < 0) x = -x;                  // absolute value of input
+....................
+....................    quad = (unsigned int8)(x / PI_DIV_BY_TWO);    // quadrant
+....................    frac = (x / PI_DIV_BY_TWO) - quad;  // fractional part of input
+....................    quad = quad % 4;                    // quadrant (0 to 3)
+....................
+....................    if (quad == 0 || quad == 2)
+....................       t = frac * PI_DIV_BY_TWO;
+....................    else if (quad == 1)
+....................       t = (1-frac) * PI_DIV_BY_TWO;
+....................    else // should be 3
+....................       t = (frac-1) * PI_DIV_BY_TWO;
+....................
+....................    y = 0.999999999781;
+....................    t = t * t;
+....................    for (i = 0; i <= 5; i++)
+....................    {
+....................       t2 = t2 * t;
+....................       y = y + p[i] * t2;
+....................    }
+....................
+....................    if (quad == 2 || quad == 1)
+....................       y = -y;  // correct sign
+....................
+....................    return (y);
+.................... }
+....................
+.................... // Overloaded function cos() for data type - Float48
+.................... float64 cos(float64 x)
+.................... {
+....................    float64 y, t, t2 = 1.0;
+....................    unsigned int8 quad, i;
+....................    float64 frac;
+....................    float64 p[6] = {                    //by the series definition for cosine
+....................       -0.5,                            // sum ( ( (-1)^n * x^2n )/(2n)! )
+....................        0.04166666666667,
+....................       -0.00138888888889,
+....................        0.00002480158730,
+....................       -0.00000027557319,
+....................        0.00000000208767,
+....................       //-0.00000000001147,
+....................       // 0.00000000000005
+....................    };
+....................
+....................    if (x < 0) x = -x;                  // absolute value of input
+....................
+....................    quad = (unsigned int8)(x / PI_DIV_BY_TWO);    // quadrant
+....................    frac = (x / PI_DIV_BY_TWO) - quad;  // fractional part of input
+....................    quad = quad % 4;                    // quadrant (0 to 3)
+....................
+....................    if (quad == 0 || quad == 2)
+....................       t = frac * PI_DIV_BY_TWO;
+....................    else if (quad == 1)
+....................       t = (1-frac) * PI_DIV_BY_TWO;
+....................    else // should be 3
+....................       t = (frac-1) * PI_DIV_BY_TWO;
+....................
+....................    y = 0.999999999781;
+....................    t = t * t;
+....................    for (i = 0; i <= 5; i++)
+....................    {
+....................       t2 = t2 * t;
+....................       y = y + p[i] * t2;
+....................    }
+....................
+....................    if (quad == 2 || quad == 1)
+....................       y = -y;  // correct sign
+....................
+....................    return (y);
+.................... }
+....................
+.................... #endif
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float sin(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : returns the sine value of the angle x, which is in radian
+.................... // Date : 9/20/2001
+.................... //
+.................... float32 sin(float32 x)
+.................... {
+....................    return cos(x - PI_DIV_BY_TWO);
+.................... }
+....................
+.................... //Overloaded functions for sin() for PCD
+.................... // Overloaded function sin() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 sin(float48 x)
+.................... {
+....................    return cos(x - PI_DIV_BY_TWO);
+.................... }
+....................
+.................... // Overloaded function sin() for data type - Float48
+.................... float64 sin(float64 x)
+.................... {
+....................    return cos(x - PI_DIV_BY_TWO);
+.................... }
+.................... #endif
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float tan(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : returns the tangent value of the angle x, which is in radian
+.................... // Date : 9/20/2001
+.................... //
+.................... float32 tan(float32 x)
+.................... {
+....................    float32 c, s;
+....................
+....................    c = cos(x);
+....................    if (c == 0.0)
+....................       return (1.0e+36);
+....................
+....................    s = sin(x);
+....................    return(s/c);
+.................... }
+.................... //Overloaded functions for tan() for PCD
+.................... // Overloaded function tan() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 tan(float48 x)
+.................... {
+....................    float48 c, s;
+....................
+....................    c = cos(x);
+....................    if (c == 0.0)
+....................       return (1.0e+36);
+....................
+....................    s = sin(x);
+....................    return(s/c);
+.................... }
+....................
+.................... // Overloaded function tan() for data type - Float48
+.................... float64 tan(float64 x)
+.................... {
+....................    float64 c, s;
+....................
+....................    c = cos(x);
+....................    if (c == 0.0)
+....................       return (1.0e+36);
+....................
+....................    s = sin(x);
+....................    return(s/c);
+.................... }
+.................... #endif
+....................
+.................... float32 const pas[3] = {0.49559947, -4.6145309, 5.6036290};
+.................... float32 const qas[3] = {1.0000000,  -5.5484666, 5.6036290};
+....................
+.................... float32 ASIN_COS(float32 x, unsigned int8 n)
+.................... {
+....................    float32 y, res, r, y2;
+....................    int1 s;
+....................    #ifdef _ERRNO
+....................    if(x <-1 || x > 1)
+....................    {
+....................       errno=EDOM;
+....................    }
+....................    #endif
+....................    s = 0;
+....................    y = x;
+....................
+....................    if (x < 0)
+....................    {
+....................       s = 1;
+....................       y = -y;
+....................    }
+....................
+....................    if (y > 0.5)
+....................    {
+....................       y = sqrt((1.0 - y)/2.0);
+....................       n += 2;
+....................    }
+....................
+....................    y2=y*y;
+....................
+....................    res = pas[0]*y2 + pas[1];
+....................    res = res*y2 + pas[2];
+....................
+....................    r = qas[0]*y2 + qas[1];
+....................    r = r*y2 + qas[2];
+....................
+....................    res = y*res/r;
+....................
+....................    if (n & 2)     // |x| > 0.5
+....................       res = PI_DIV_BY_TWO - 2.0*res;
+....................    if (s)
+....................       res = -res;
+....................    if (n & 1)           // take arccos
+....................       res = PI_DIV_BY_TWO - res;
+....................
+....................    return(res);
+.................... }
+....................
+.................... //Overloaded functions for ASIN_COS() for PCD
+.................... // Overloaded function ASIN_COS() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 ASIN_COS(float48 x, unsigned int8 n)
+.................... {
+....................    float48 y, res, r, y2;
+....................    int1 s;
+....................    #ifdef _ERRNO
+....................    if(x <-1 || x > 1)
+....................    {
+....................       errno=EDOM;
+....................    }
+....................    #endif
+....................    s = 0;
+....................    y = x;
+....................
+....................    if (x < 0)
+....................    {
+....................       s = 1;
+....................       y = -y;
+....................    }
+....................
+....................    if (y > 0.5)
+....................    {
+....................       y = sqrt((1.0 - y)/2.0);
+....................       n += 2;
+....................    }
+....................
+....................    y2=y*y;
+....................
+....................    res = pas[0]*y2 + pas[1];
+....................    res = res*y2 + pas[2];
+....................
+....................    r = qas[0]*y2 + qas[1];
+....................    r = r*y2 + qas[2];
+....................
+....................    res = y*res/r;
+....................
+....................    if (n & 2)     // |x| > 0.5
+....................       res = PI_DIV_BY_TWO - 2.0*res;
+....................    if (s)
+....................       res = -res;
+....................    if (n & 1)           // take arccos
+....................       res = PI_DIV_BY_TWO - res;
+....................
+....................    return(res);
+.................... }
+....................
+.................... // Overloaded function ASIN_COS() for data type - Float64
+.................... float64 ASIN_COS(float64 x, unsigned int8 n)
+.................... {
+....................    float64 y, res, r, y2;
+....................    int1 s;
+....................    #ifdef _ERRNO
+....................    if(x <-1 || x > 1)
+....................    {
+....................       errno=EDOM;
+....................    }
+....................    #endif
+....................    s = 0;
+....................    y = x;
+....................
+....................    if (x < 0)
+....................    {
+....................       s = 1;
+....................       y = -y;
+....................    }
+....................
+....................    if (y > 0.5)
+....................    {
+....................       y = sqrt((1.0 - y)/2.0);
+....................       n += 2;
+....................    }
+....................
+....................    y2=y*y;
+....................
+....................    res = pas[0]*y2 + pas[1];
+....................    res = res*y2 + pas[2];
+....................
+....................    r = qas[0]*y2 + qas[1];
+....................    r = r*y2 + qas[2];
+....................
+....................    res = y*res/r;
+....................
+....................    if (n & 2)     // |x| > 0.5
+....................       res = PI_DIV_BY_TWO - 2.0*res;
+....................    if (s)
+....................       res = -res;
+....................    if (n & 1)           // take arccos
+....................       res = PI_DIV_BY_TWO - res;
+....................
+....................    return(res);
+.................... }
+.................... #endif
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float asin(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : returns the arcsine value of the value x.
+.................... // Date : N/A
+.................... //
+.................... float32 asin(float32 x)
+.................... {
+....................    float32 r;
+....................
+....................    r = ASIN_COS(x, 0);
+....................    return(r);
+.................... }
+.................... //Overloaded functions for asin() for PCD
+.................... // Overloaded function asin() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 asin(float48 x)
+.................... {
+....................    float48 r;
+....................
+....................    r = ASIN_COS(x, 0);
+....................    return(r);
+.................... }
+....................
+.................... // Overloaded function asin() for data type - Float64
+.................... float64 asin(float64 x)
+.................... {
+....................    float64 r;
+....................
+....................    r = ASIN_COS(x, 0);
+....................    return(r);
+.................... }
+.................... #endif
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float acos(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : returns the arccosine value of the value x.
+.................... // Date : N/A
+.................... //
+.................... float32 acos(float32 x)
+.................... {
+....................    float32 r;
+....................
+....................    r = ASIN_COS(x, 1);
+....................    return(r);
+.................... }
+.................... //Overloaded functions for acos() for PCD
+.................... // Overloaded function acos() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 acos(float48 x)
+.................... {
+....................    float48 r;
+....................
+....................    r = ASIN_COS(x, 1);
+....................    return(r);
+.................... }
+....................
+.................... // Overloaded function acos() for data type - Float64
+.................... float64 acos(float64 x)
+.................... {
+....................    float64 r;
+....................
+....................    r = ASIN_COS(x, 1);
+....................    return(r);
+.................... }
+.................... #endif
+....................
+.................... float32 const pat[4] = {0.17630401, 5.6710795, 22.376096, 19.818457};
+.................... float32 const qat[4] = {1.0000000,  11.368190, 28.982246, 19.818457};
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float atan(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : returns the arctangent value of the value x.
+.................... // Date : N/A
+.................... //
+.................... float32 atan(float32 x)
+.................... {
+....................    float32 y, res, r;
+....................    int1 s, flag;
+....................
+....................    s = 0;
+....................    flag = 0;
+....................    y = x;
+....................
+....................    if (x < 0)
+....................    {
+....................       s = 1;
+....................       y = -y;
+....................    }
+....................
+....................    if (y > 1.0)
+....................    {
+....................       y = 1.0/y;
+....................       flag = 1;
+....................    }
+....................
+....................    res = pat[0]*y*y + pat[1];
+....................    res = res*y*y + pat[2];
+....................    res = res*y*y + pat[3];
+....................
+....................    r = qat[0]*y*y + qat[1];
+....................    r = r*y*y + qat[2];
+....................    r = r*y*y + qat[3];
+....................
+....................    res = y*res/r;
+....................
+....................
+....................    if (flag)                              // for |x| > 1
+....................       res = PI_DIV_BY_TWO - res;
+....................    if (s)
+....................       res = -res;
+....................
+....................    return(res);
+.................... }
+.................... //Overloaded functions for atan() for PCD
+.................... // Overloaded function atan() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 atan(float48 x)
+.................... {
+....................    float48 y, res, r;
+....................    int1 s, flag;
+....................
+....................    s = 0;
+....................    flag = 0;
+....................    y = x;
+....................
+....................    if (x < 0)
+....................    {
+....................       s = 1;
+....................       y = -y;
+....................    }
+....................
+....................    if (y > 1.0)
+....................    {
+....................       y = 1.0/y;
+....................       flag = 1;
+....................    }
+....................
+....................    res = pat[0]*y*y + pat[1];
+....................    res = res*y*y + pat[2];
+....................    res = res*y*y + pat[3];
+....................
+....................    r = qat[0]*y*y + qat[1];
+....................    r = r*y*y + qat[2];
+....................    r = r*y*y + qat[3];
+....................
+....................    res = y*res/r;
+....................
+....................
+....................    if (flag)                              // for |x| > 1
+....................       res = PI_DIV_BY_TWO - res;
+....................    if (s)
+....................       res = -res;
+....................
+....................    return(res);
+.................... }
+....................
+.................... // Overloaded function atan() for data type - Float64
+.................... float64 atan(float64 x)
+.................... {
+....................    float64 y, res, r;
+....................    int1 s, flag;
+....................
+....................    s = 0;
+....................    flag = 0;
+....................    y = x;
+....................
+....................    if (x < 0)
+....................    {
+....................       s = 1;
+....................       y = -y;
+....................    }
+....................
+....................    if (y > 1.0)
+....................    {
+....................       y = 1.0/y;
+....................       flag = 1;
+....................    }
+....................
+....................    res = pat[0]*y*y + pat[1];
+....................    res = res*y*y + pat[2];
+....................    res = res*y*y + pat[3];
+....................
+....................    r = qat[0]*y*y + qat[1];
+....................    r = r*y*y + qat[2];
+....................    r = r*y*y + qat[3];
+....................
+....................    res = y*res/r;
+....................
+....................
+....................    if (flag)                              // for |x| > 1
+....................       res = PI_DIV_BY_TWO - res;
+....................    if (s)
+....................       res = -res;
+....................
+....................    return(res);
+.................... }
+.................... #endif
+....................
+.................... /////////////////////////////////////////////////////////////////////////////
+.................... //   float atan2(float y, float x)
+.................... /////////////////////////////////////////////////////////////////////////////
+.................... // Description :computes the principal value of arc tangent of y/x, using the
+.................... // signs of both the arguments to determine the quadrant of the return value
+.................... // Returns : returns the arc tangent of y/x.
+.................... // Date : N/A
+.................... //
+....................
+.................... float32 atan2(float32 y,float32 x)
+.................... {
+....................    float32 z;
+....................    int1 sign;
+....................    unsigned int8 quad;
+....................    sign=0;
+....................    quad=0; //quadrant
+....................    quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1));
+....................    if(y<0.0)
+....................    {
+....................       sign=1;
+....................       y=-y;
+....................    }
+....................    if(x<0.0)
+....................    {
+....................       x=-x;
+....................    }
+....................    if (x==0.0)
+....................    {
+....................       if(y==0.0)
+....................       {
+....................       #ifdef _ERRNO
+....................       {
+....................          errno=EDOM;
+....................       }
+....................       #endif
+....................       }
+....................       else
+....................       {
+....................          if(sign)
+....................          {
+....................          return (-(PI_DIV_BY_TWO));
+....................          }
+....................          else
+....................          {
+....................          return (PI_DIV_BY_TWO);
+....................          }
+....................       }
+....................    }
+....................    else
+....................    {
+....................       z=y/x;
+....................       switch(quad)
+....................       {
+....................          case 1:
+....................          {
+....................             return atan(z);
+....................             break;
+....................          }
+....................          case 2:
+....................          {
+.................... //            return (atan(z)+PI_DIV_BY_TWO);  //2L3122
+....................             return (PI-atan(z));
+....................             break;
+....................          }
+....................          case 3:
+....................          {
+....................             return (atan(z)-PI);
+....................             break;
+....................          }
+....................          case 4:
+....................          {
+....................             return (-atan(z));
+....................             break;
+....................          }
+....................       }
+....................    }
+.................... }
+....................
+.................... //Overloaded functions for atan2() for PCD
+.................... // Overloaded function atan2() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 atan2(float48 y,float48 x)
+.................... {
+....................    float48 z;
+....................    int1 sign;
+....................    unsigned int8 quad;
+....................    sign=0;
+....................    quad=0; //quadrant
+....................    quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1));
+....................    if(y<0.0)
+....................    {
+....................       sign=1;
+....................       y=-y;
+....................    }
+....................    if(x<0.0)
+....................    {
+....................       x=-x;
+....................    }
+....................    if (x==0.0)
+....................    {
+....................       if(y==0.0)
+....................       {
+....................       #ifdef _ERRNO
+....................       {
+....................          errno=EDOM;
+....................       }
+....................       #endif
+....................       }
+....................       else
+....................       {
+....................          if(sign)
+....................          {
+....................          return (-(PI_DIV_BY_TWO));
+....................          }
+....................          else
+....................          {
+....................          return (PI_DIV_BY_TWO);
+....................          }
+....................       }
+....................    }
+....................    else
+....................    {
+....................       z=y/x;
+....................       switch(quad)
+....................       {
+....................          case 1:
+....................          {
+....................             return atan(z);
+....................             break;
+....................          }
+....................          case 2:
+....................          {
+.................... //            return (atan(z)+PI_DIV_BY_TWO);  //2L3122
+....................             return (PI-atan(z));
+....................             break;
+....................          }
+....................          case 3:
+....................          {
+....................             return (atan(z)-PI);
+....................             break;
+....................          }
+....................          case 4:
+....................          {
+....................             return (-atan(z));
+....................             break;
+....................          }
+....................       }
+....................    }
+.................... }
+....................
+.................... // Overloaded function atan2() for data type - Float64
+.................... float64 atan2(float64 y,float64 x)
+.................... {
+....................    float64 z;
+....................    int1 sign;
+....................    unsigned int8 quad;
+....................    sign=0;
+....................    quad=0; //quadrant
+....................    quad=((y<=0.0)?((x<=0.0)?3:4):((x<0.0)?2:1));
+....................    if(y<0.0)
+....................    {
+....................       sign=1;
+....................       y=-y;
+....................    }
+....................    if(x<0.0)
+....................    {
+....................       x=-x;
+....................    }
+....................    if (x==0.0)
+....................    {
+....................       if(y==0.0)
+....................       {
+....................       #ifdef _ERRNO
+....................       {
+....................          errno=EDOM;
+....................       }
+....................       #endif
+....................       }
+....................       else
+....................       {
+....................          if(sign)
+....................          {
+....................          return (-(PI_DIV_BY_TWO));
+....................          }
+....................          else
+....................          {
+....................          return (PI_DIV_BY_TWO);
+....................          }
+....................       }
+....................    }
+....................    else
+....................    {
+....................       z=y/x;
+....................       switch(quad)
+....................       {
+....................          case 1:
+....................          {
+....................             return atan(z);
+....................             break;
+....................          }
+....................          case 2:
+....................          {
+.................... //            return (atan(z)+PI_DIV_BY_TWO);  //2L3122
+....................             return (PI-atan(z));
+....................             break;
+....................          }
+....................          case 3:
+....................          {
+....................             return (atan(z)-PI);
+....................             break;
+....................          }
+....................          case 4:
+....................          {
+....................             return (-atan(z));
+....................             break;
+....................          }
+....................       }
+....................    }
+.................... }
+.................... #endif
+....................
+.................... //////////////////// Hyperbolic functions ////////////////////
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float cosh(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : Computes the hyperbolic cosine value of x
+.................... // Returns : returns the hyperbolic cosine value of x
+.................... // Date : N/A
+.................... //
+....................
+.................... float32 cosh(float32 x)
+.................... {
+....................    return ((exp(x)+exp(-x))/2);
+.................... }
+.................... //Overloaded functions for cosh() for PCD
+.................... // Overloaded function cosh() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 cosh(float48 x)
+.................... {
+....................    return ((exp(x)+exp(-x))/2);
+.................... }
+....................
+.................... // Overloaded function cosh() for data type - Float64
+.................... float64 cosh(float64 x)
+.................... {
+....................    return ((exp(x)+exp(-x))/2);
+.................... }
+.................... #endif
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float sinh(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : Computes the hyperbolic sine value of x
+.................... // Returns : returns the hyperbolic sine value of x
+.................... // Date : N/A
+.................... //
+....................
+.................... float32 sinh(float32 x)
+.................... {
+....................
+....................    return ((exp(x) - exp(-x))/2);
+.................... }
+.................... //Overloaded functions for sinh() for PCD
+.................... // Overloaded function sinh() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 sinh(float48 x)
+.................... {
+....................
+....................    return ((exp(x) - exp(-x))/2);
+.................... }
+....................
+.................... // Overloaded function sinh() for data type - Float48
+.................... float64 sinh(float64 x)
+.................... {
+....................
+....................    return ((exp(x) - exp(-x))/2);
+.................... }
+.................... #endif
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float tanh(float x)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : Computes the hyperbolic tangent value of x
+.................... // Returns : returns the hyperbolic tangent value of x
+.................... // Date : N/A
+.................... //
+....................
+.................... float32 tanh(float32 x)
+.................... {
+....................    return(sinh(x)/cosh(x));
+.................... }
+.................... //Overloaded functions for tanh() for PCD
+.................... // Overloaded function tanh() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 tanh(float48 x)
+.................... {
+....................    return(sinh(x)/cosh(x));
+.................... }
+....................
+.................... // Overloaded function tanh() for data type - Float64
+.................... float64 tanh(float64 x)
+.................... {
+....................    return(sinh(x)/cosh(x));
+.................... }
+.................... #endif
+....................
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... //   float frexp(float x, signed int *exp)
+.................... ////////////////////////////////////////////////////////////////////////////
+.................... // Description : breaks a floating point number into a normalized fraction and an integral
+.................... // power of 2. It stores the integer in the signed int object pointed to by exp.
+.................... // Returns : returns the value x, such that x is a double with magnitude in the interval
+.................... // [1/2,1) or zero, and value equals x times 2 raised to the power *exp.If value is zero,
+.................... // both parts of the result are zero.
+.................... // Date : N/A
+.................... //
+....................
+.................... #define LOG2 .30102999566398119521
+.................... float32 frexp(float32 x, signed int8 *exp)
+.................... {
+....................    float32 res;
+....................    int1 sign = 0;
+....................    if(x == 0.0)
+....................    {
+....................       *exp=0;
+....................       return (0.0);
+....................    }
+....................    if(x < 0.0)
+....................    {
+....................      x=-x;
+....................      sign=1;
+....................    }
+....................    if (x > 1.0)
+....................    {
+....................       *exp=(ceil(log10(x)/LOG2));
+....................       res=x/(pow(2, *exp));
+....................       if (res == 1)
+....................       {
+....................          *exp=*exp+1;
+....................           res=.5;
+....................       }
+....................    }
+....................    else
+....................    {
+....................       if(x < 0.5)
+....................       {
+....................          *exp=-1;
+....................          res=x*2;
+....................       }
+....................       else
+....................       {
+....................          *exp=0;
+....................           res=x;
+....................       }
+....................    }
+....................    if(sign)
+....................    {
+....................       res=-res;
+....................    }
+....................    return res;
+.................... }
+....................
+.................... //Overloaded functions for frexp() for PCD
+.................... // Overloaded function frexp() for data type - Float48
+.................... #if defined(__PCD__)
+.................... float48 frexp(float48 x, signed int8 *exp)
+.................... {
+....................    float48 res;
+....................    int1 sign = 0;
+....................    if(x == 0.0)
+....................    {
+....................       *exp=0;
+....................       return (0.0);
+....................    }
+....................    if(x < 0.0)
+....................    {
+....................      x=-x;
+....................      sign=1;
+....................    }
+....................    if (x > 1.0)
+....................    {
+....................       *exp=(ceil(log10(x)/LOG2));
+....................       res=x/(pow(2, *exp));
+....................       if (res == 1)
+....................       {
+....................          *exp=*exp+1;
+....................           res=.5;
+....................       }
+....................    }
+....................    else
+....................    {
+....................       if(x < 0.5)
+....................       {
+....................          *exp=-1;
+....................          res=x*2;
+....................       }
+....................       else
+....................       {
+....................          *exp=0;
+....................           res=x;
+....................       }
+....................    }
+....................    if(sign)
+....................    {
+....................       res=-res;
+....................    }
+....................    return res;
+.................... }
+....................
+.................... // Overloaded function frexp() for data type - Float64
+.................... float64 frexp(float64 x, signed int8 *exp)
+.................... {
+....................    float64 res;
+....................    int1 sign = 0;
+....................    if(x == 0.0)
+....................    {
+....................       *exp=0;
+....................       return (0.0);
+....................    }
+....................    if(x < 0.0)
+....................    {
+....................      x=-x;
+....................      sign=1;
+....................    }
+....................    if (x > 1.0)
+....................    {
+....................       *exp=(ceil(log10(x)/LOG2));
+....................       res=x/(pow(2, *exp));
+....................       if (res == 1)
+....................       {
+....................          *exp=*exp+1;
+....................           res=.5;
+....................       }
+....................    }
+....................    else
+....................    {
+....................       if(x < 0.5)
+....................       {
+....................          *exp=-1;
+....................          res=x*2;
+....................       }
+....................       else
+....................       {
+....................          *exp=0;
+....................           res=x;
+....................       }
+....................    }
+....................    if(sign)
+....................    {
+....................       res=-res;
+....................    }
+....................    return res;
+.................... }
+.................... #endif
+....................
+.................... //////////////////////////////////////////////////////////////////////////////
+.................... //   float ldexp(float x, signed int *exp)
+.................... //////////////////////////////////////////////////////////////////////////////
+.................... // Description : multiplies a floating point number by an integral power of 2.
+.................... // Returns : returns the value of x times 2 raised to the power exp.
+.................... // Date : N/A
+.................... //
+....................
+.................... float32 ldexp(float32 value, signed int8 exp)
+.................... {
+....................    return (value * pow(2,exp));
+.................... }
+.................... //Overloaded functions for ldexp() for PCD
+.................... // Overloaded function ldexp() for data type - Float48
+....................
+.................... #if defined(__PCD__)
+.................... float48 ldexp(float48 value, signed int8 exp)
+.................... {
+....................    return (value * pow(2,exp));
+.................... }
+.................... // Overloaded function ldexp() for data type - Float64
+.................... float64 ldexp(float64 value, signed int8 exp)
+.................... {
+....................    return (value * pow(2,exp));
+.................... }
+.................... #endif
+....................
+.................... #endif
+....................
+.................... #include <MMA8451Q.h>
+.................... //Adresa obvodu
+.................... #define AK_W  0x38 //adresa akcelerometru zápis
+.................... #define AK_R  0x39 //adresa akcelerometru ètení
+....................
+....................
+.................... #define AK_XH 0x01 //osa X LSB
+.................... #define AK_XL 0x02 //osa X MSB
+.................... #define AK_YH 0x03 //osa Y LSB
+.................... #define AK_YL 0x04 //osa Y MSB
+.................... #define AK_ZH 0x05 //osa Z LSB
+.................... #define AK_ZL 0x06 //osa Z MSB
+....................
+....................
+.................... #include "MMA8451Q.c"
+.................... void setAK (void) //nastaveni akcelerometru
+.................... {
+....................    i2c_start();
+*
+B:  BSF    20.4
+C:  MOVF   20,W
+D:  BSF    03.5
+E:  MOVWF  07
+F:  NOP
+:  BCF    03.5
+:  BSF    20.3
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  NOP
+:  BCF    03.5
+:  BCF    07.4
+:  BCF    20.4
+:  MOVF   20,W
+A:  BSF    03.5
+B:  MOVWF  07
+C:  NOP
+D:  BCF    03.5
+E:  BCF    07.3
+F:  BCF    20.3
+A0:  MOVF   20,W
+A1:  BSF    03.5
+A2:  MOVWF  07
+....................    I2C_Write(AK_W);
+A3:  MOVLW  38
+A4:  BCF    03.5
+A5:  MOVWF  2F
+A6:  CALL   041
+....................    I2C_write(0x2A);
+A7:  MOVLW  2A
+A8:  MOVWF  2F
+A9:  CALL   041
+....................    I2C_write(0x01); //nastavi aktivni stav
+AA:  MOVLW  01
+AB:  MOVWF  2F
+AC:  CALL   041
+....................
+....................    i2c_stop();
+AD:  BCF    20.4
+AE:  MOVF   20,W
+AF:  BSF    03.5
+B0:  MOVWF  07
+B1:  NOP
+B2:  BCF    03.5
+B3:  BSF    20.3
+B4:  MOVF   20,W
+B5:  BSF    03.5
+B6:  MOVWF  07
+B7:  BCF    03.5
+B8:  BTFSS  07.3
+B9:  GOTO   0B8
+BA:  NOP
+BB:  GOTO   0BC
+BC:  NOP
+BD:  BSF    20.4
+BE:  MOVF   20,W
+BF:  BSF    03.5
+C0:  MOVWF  07
+C1:  NOP
+.................... }
+C2:  BCF    03.5
+C3:  BCF    0A.3
+C4:  BCF    0A.4
+C5:  GOTO   3FF (RETURN)
+....................
+....................
+.................... int16 akR (int8 H, int8 L) //vycitani hodnot z akcelerometru
+.................... {
+*
+:  CLRF   2B
+:  CLRF   2C
+.................... unsigned int8 XL=0,XH=0;
+.................... signed int16 x;
+....................
+....................    i2c_start();
+:  BSF    20.4
+:  MOVF   20,W
+:  BSF    03.5
+A:  MOVWF  07
+B:  NOP
+C:  BCF    03.5
+D:  BSF    20.3
+E:  MOVF   20,W
+F:  BSF    03.5
+:  MOVWF  07
+:  NOP
+:  BCF    03.5
+:  BCF    07.4
+:  BCF    20.4
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  NOP
+:  BCF    03.5
+A:  BCF    07.3
+B:  BCF    20.3
+C:  MOVF   20,W
+D:  BSF    03.5
+E:  MOVWF  07
+....................    I2C_Write(AK_W);
+F:  MOVLW  38
+:  BCF    03.5
+:  MOVWF  2F
+:  CALL   041
+....................    I2C_write(H);
+:  MOVF   29,W
+:  MOVWF  2F
+:  CALL   041
+....................    i2c_start();
+:  BSF    20.4
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+A:  NOP
+B:  BCF    03.5
+C:  BSF    20.3
+D:  MOVF   20,W
+E:  BSF    03.5
+F:  MOVWF  07
+A0:  NOP
+A1:  BCF    03.5
+A2:  BTFSS  07.3
+A3:  GOTO   1A2
+A4:  BCF    07.4
+A5:  BCF    20.4
+A6:  MOVF   20,W
+A7:  BSF    03.5
+A8:  MOVWF  07
+A9:  NOP
+AA:  BCF    03.5
+AB:  BCF    07.3
+AC:  BCF    20.3
+AD:  MOVF   20,W
+AE:  BSF    03.5
+AF:  MOVWF  07
+....................    I2C_Write(AK_R);
+B0:  MOVLW  39
+B1:  BCF    03.5
+B2:  MOVWF  2F
+B3:  CALL   041
+....................    XH=i2c_read(0);
+B4:  CLRF   77
+B5:  CALL   130
+B6:  MOVF   78,W
+B7:  MOVWF  2C
+....................    i2c_stop();
+B8:  BCF    20.4
+B9:  MOVF   20,W
+BA:  BSF    03.5
+BB:  MOVWF  07
+BC:  NOP
+BD:  BCF    03.5
+BE:  BSF    20.3
+BF:  MOVF   20,W
+C0:  BSF    03.5
+C1:  MOVWF  07
+C2:  BCF    03.5
+C3:  BTFSS  07.3
+C4:  GOTO   1C3
+C5:  NOP
+C6:  GOTO   1C7
+C7:  NOP
+C8:  BSF    20.4
+C9:  MOVF   20,W
+CA:  BSF    03.5
+CB:  MOVWF  07
+CC:  NOP
+....................
+....................    i2c_start();
+CD:  BCF    03.5
+CE:  BSF    20.4
+CF:  MOVF   20,W
+D0:  BSF    03.5
+D1:  MOVWF  07
+D2:  NOP
+D3:  BCF    03.5
+D4:  BSF    20.3
+D5:  MOVF   20,W
+D6:  BSF    03.5
+D7:  MOVWF  07
+D8:  NOP
+D9:  BCF    03.5
+DA:  BCF    07.4
+DB:  BCF    20.4
+DC:  MOVF   20,W
+DD:  BSF    03.5
+DE:  MOVWF  07
+DF:  NOP
+E0:  BCF    03.5
+E1:  BCF    07.3
+E2:  BCF    20.3
+E3:  MOVF   20,W
+E4:  BSF    03.5
+E5:  MOVWF  07
+....................    I2C_Write(AK_W);
+E6:  MOVLW  38
+E7:  BCF    03.5
+E8:  MOVWF  2F
+E9:  CALL   041
+....................    I2C_write(L);
+EA:  MOVF   2A,W
+EB:  MOVWF  2F
+EC:  CALL   041
+....................    i2c_start();
+ED:  BSF    20.4
+EE:  MOVF   20,W
+EF:  BSF    03.5
+F0:  MOVWF  07
+F1:  NOP
+F2:  BCF    03.5
+F3:  BSF    20.3
+F4:  MOVF   20,W
+F5:  BSF    03.5
+F6:  MOVWF  07
+F7:  NOP
+F8:  BCF    03.5
+F9:  BTFSS  07.3
+FA:  GOTO   1F9
+FB:  BCF    07.4
+FC:  BCF    20.4
+FD:  MOVF   20,W
+FE:  BSF    03.5
+FF:  MOVWF  07
+:  NOP
+:  BCF    03.5
+:  BCF    07.3
+:  BCF    20.3
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+....................    I2C_Write(AK_R);
+:  MOVLW  39
+:  BCF    03.5
+:  MOVWF  2F
+A:  CALL   041
+....................    XL=i2c_read(0);
+B:  CLRF   77
+C:  CALL   130
+D:  MOVF   78,W
+E:  MOVWF  2B
+....................    i2c_stop();
+F:  BCF    20.4
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  NOP
+:  BCF    03.5
+:  BSF    20.3
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  BCF    03.5
+A:  BTFSS  07.3
+B:  GOTO   21A
+C:  NOP
+D:  GOTO   21E
+E:  NOP
+F:  BSF    20.4
+:  MOVF   20,W
+:  BSF    03.5
+:  MOVWF  07
+:  NOP
+....................
+....................    x = (((unsigned int16) XH << 8) + XL ); //prevod na 16bit hodnotu
+:  BCF    03.5
+:  CLRF   30
+:  MOVF   2C,W
+:  MOVWF  2F
+:  MOVWF  30
+:  CLRF   2F
+A:  MOVF   2B,W
+B:  ADDWF  2F,W
+C:  MOVWF  78
+D:  MOVF   30,W
+E:  MOVWF  7A
+F:  BTFSC  03.0
+:  INCF   7A,F
+:  MOVF   78,W
+:  MOVWF  2D
+:  MOVF   7A,W
+:  MOVWF  2E
+....................    x=x/4;
+:  MOVF   2E,W
+:  MOVWF  30
+:  MOVF   2D,W
+:  MOVWF  2F
+:  CLRF   32
+A:  MOVLW  04
+B:  MOVWF  31
+*
+:  MOVF   79,W
+A:  MOVWF  2E
+B:  MOVF   78,W
+C:  MOVWF  2D
+....................
+....................    return x;
+D:  MOVF   2D,W
+E:  MOVWF  78
+F:  MOVF   2E,W
+:  MOVWF  79
+.................... }
+:  RETURN
+....................
+.................... int16 akX (void)
+.................... {
+.................... int16 X;
+.................... X= akR (AK_XH, AK_XL);
+:  MOVLW  01
+:  MOVWF  29
+:  MOVLW  02
+:  MOVWF  2A
+:  CALL   175
+:  MOVF   79,W
+:  MOVWF  28
+:  MOVF   78,W
+A:  MOVWF  27
+.................... return X;
+B:  MOVF   27,W
+C:  MOVWF  78
+D:  MOVF   28,W
+E:  MOVWF  79
+.................... }
+F:  BCF    0A.3
+:  BCF    0A.4
+:  GOTO   40E (RETURN)
+....................
+.................... int16 akY (void)
+.................... {
+.................... int16 Y;
+.................... Y= akR (AK_YH, AK_YL);
+:  MOVLW  03
+:  MOVWF  29
+:  MOVLW  04
+:  MOVWF  2A
+:  CALL   175
+:  MOVF   79,W
+:  MOVWF  28
+:  MOVF   78,W
+A:  MOVWF  27
+.................... return Y;
+B:  MOVF   27,W
+C:  MOVWF  78
+D:  MOVF   28,W
+E:  MOVWF  79
+.................... }
+F:  BCF    0A.3
+A0:  BCF    0A.4
+A1:  GOTO   413 (RETURN)
+....................
+.................... int16 akZ (void)
+.................... {
+.................... int16 Z;
+.................... Z= akR (AK_ZH, AK_ZL);
+A2:  MOVLW  05
+A3:  MOVWF  29
+A4:  MOVLW  06
+A5:  MOVWF  2A
+A6:  CALL   175
+A7:  MOVF   79,W
+A8:  MOVWF  28
+A9:  MOVF   78,W
+AA:  MOVWF  27
+.................... return Z;
+AB:  MOVF   27,W
+AC:  MOVWF  78
+AD:  MOVF   28,W
+AE:  MOVWF  79
+.................... }
+AF:  BCF    0A.3
+B0:  BCF    0A.4
+B1:  GOTO   418 (RETURN)
+....................
+....................
+....................
+....................
+....................
+.................... signed int16 X, Y, Z; //promenne pro akcelerometr
+....................
+.................... void main()
+.................... {
+*
+:  CLRF   04
+:  BCF    03.7
+:  MOVLW  1F
+A:  ANDWF  03,F
+B:  MOVLW  71
+C:  BSF    03.5
+D:  MOVWF  0F
+E:  MOVF   0F,W
+F:  BCF    03.5
+A0:  BCF    20.7
+A1:  MOVF   20,W
+A2:  BSF    03.5
+A3:  MOVWF  07
+A4:  BCF    03.5
+A5:  BSF    07.7
+A6:  BSF    03.5
+A7:  BSF    03.6
+A8:  MOVF   09,W
+A9:  ANDLW  C0
+AA:  MOVWF  09
+AB:  BCF    03.6
+AC:  BCF    1F.4
+AD:  BCF    1F.5
+AE:  MOVLW  00
+AF:  BSF    03.6
+B0:  MOVWF  08
+B1:  BCF    03.5
+B2:  CLRF   07
+B3:  CLRF   08
+B4:  CLRF   09
+....................    setup_adc_ports(NO_ANALOGS|VSS_VDD);
+*
+B8:  BSF    03.5
+B9:  BSF    03.6
+BA:  MOVF   09,W
+BB:  ANDLW  C0
+BC:  MOVWF  09
+BD:  BCF    03.6
+BE:  BCF    1F.4
+BF:  BCF    1F.5
+C0:  MOVLW  00
+C1:  BSF    03.6
+C2:  MOVWF  08
+....................    setup_adc(ADC_CLOCK_DIV_2);
+C3:  BCF    03.5
+C4:  BCF    03.6
+C5:  BCF    1F.6
+C6:  BCF    1F.7
+C7:  BSF    03.5
+C8:  BCF    1F.7
+C9:  BCF    03.5
+CA:  BSF    1F.0
+....................    setup_spi(SPI_SS_DISABLED);
+CB:  BCF    14.5
+CC:  BCF    20.5
+CD:  MOVF   20,W
+CE:  BSF    03.5
+CF:  MOVWF  07
+D0:  BCF    03.5
+D1:  BSF    20.4
+D2:  MOVF   20,W
+D3:  BSF    03.5
+D4:  MOVWF  07
+D5:  BCF    03.5
+D6:  BCF    20.3
+D7:  MOVF   20,W
+D8:  BSF    03.5
+D9:  MOVWF  07
+DA:  MOVLW  01
+DB:  BCF    03.5
+DC:  MOVWF  14
+DD:  MOVLW  00
+DE:  BSF    03.5
+DF:  MOVWF  14
+....................    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
+E0:  MOVF   01,W
+E1:  ANDLW  C7
+E2:  IORLW  08
+E3:  MOVWF  01
+....................    setup_timer_1(T1_DISABLED);
+E4:  BCF    03.5
+E5:  CLRF   10
+....................    setup_timer_2(T2_DISABLED,0,1);
+E6:  MOVLW  00
+E7:  MOVWF  78
+E8:  MOVWF  12
+E9:  MOVLW  00
+EA:  BSF    03.5
+EB:  MOVWF  12
+....................    setup_ccp1(CCP_OFF);
+EC:  BCF    03.5
+ED:  BSF    20.2
+EE:  MOVF   20,W
+EF:  BSF    03.5
+F0:  MOVWF  07
+F1:  BCF    03.5
+F2:  CLRF   17
+F3:  BSF    03.5
+F4:  CLRF   1B
+F5:  CLRF   1C
+F6:  MOVLW  01
+F7:  MOVWF  1D
+....................    setup_comparator(NC_NC_NC_NC);
+F8:  BCF    03.5
+F9:  BSF    03.6
+FA:  CLRF   07
+FB:  CLRF   08
+FC:  CLRF   09
+....................
+....................    setAK(); //nastaveni akcelerometru
+FD:  BCF    03.6
+FE:  GOTO   08B
+....................
+....................    printf("Akcelerometr IMU01A - MMA8451Q \r\n",);
+FF:  MOVLW  04
+:  BSF    03.6
+:  MOVWF  0D
+:  MOVLW  00
+:  MOVWF  0F
+:  BCF    03.6
+:  CALL   0EA
+....................    printf("(c) MLAB JACHO 2013  \r\n",);
+:  MOVLW  15
+:  BSF    03.6
+:  MOVWF  0D
+:  MOVLW  00
+A:  MOVWF  0F
+B:  BCF    03.6
+C:  CALL   0EA
+....................
+....................   while(TRUE)
+....................       {
+....................          X=akX ();
+D:  GOTO   282
+E:  MOVF   79,W
+F:  MOVWF  22
+:  MOVF   78,W
+:  MOVWF  21
+....................          Y=akY ();
+:  GOTO   292
+:  MOVF   79,W
+:  MOVWF  24
+:  MOVF   78,W
+:  MOVWF  23
+....................          Z=akZ ();
+:  GOTO   2A2
+:  MOVF   79,W
+:  MOVWF  26
+A:  MOVF   78,W
+B:  MOVWF  25
+....................          printf("Namerene hodnoty: \r\n",);
+C:  MOVLW  21
+D:  BSF    03.6
+E:  MOVWF  0D
+F:  MOVLW  00
+:  MOVWF  0F
+:  BCF    03.6
+:  CALL   0EA
+....................          printf("Osa X: %Ld \r\n",X);
+:  MOVLW  2C
+:  BSF    03.6
+:  MOVWF  0D
+:  MOVLW  00
+:  MOVWF  0F
+:  BCF    03.0
+:  MOVLW  07
+A:  BCF    03.6
+B:  MOVWF  27
+C:  CALL   2B2
+D:  MOVLW  10
+E:  MOVWF  04
+F:  MOVF   22,W
+:  MOVWF  28
+:  MOVF   21,W
+:  MOVWF  27
+:  CALL   301
+:  MOVLW  20
+:  MOVWF  30
+:  CALL   0C6
+:  MOVLW  0D
+:  MOVWF  30
+:  CALL   0C6
+A:  MOVLW  0A
+B:  MOVWF  30
+C:  CALL   0C6
+....................          printf("Osa Y: %Ld \r\n",Y);
+D:  MOVLW  33
+E:  BSF    03.6
+F:  MOVWF  0D
+:  MOVLW  00
+:  MOVWF  0F
+:  BCF    03.0
+:  MOVLW  07
+:  BCF    03.6
+:  MOVWF  27
+:  CALL   2B2
+:  MOVLW  10
+:  MOVWF  04
+:  MOVF   24,W
+A:  MOVWF  28
+B:  MOVF   23,W
+C:  MOVWF  27
+D:  CALL   301
+E:  MOVLW  20
+F:  MOVWF  30
+:  CALL   0C6
+:  MOVLW  0D
+:  MOVWF  30
+:  CALL   0C6
+:  MOVLW  0A
+:  MOVWF  30
+:  CALL   0C6
+....................          printf("Osa Z: %Ld \r\n",Z);
+:  MOVLW  3A
+:  BSF    03.6
+:  MOVWF  0D
+A:  MOVLW  00
+B:  MOVWF  0F
+C:  BCF    03.0
+D:  MOVLW  07
+E:  BCF    03.6
+F:  MOVWF  27
+:  CALL   2B2
+:  MOVLW  10
+:  MOVWF  04
+:  MOVF   26,W
+:  MOVWF  28
+:  MOVF   25,W
+:  MOVWF  27
+:  CALL   301
+:  MOVLW  20
+:  MOVWF  30
+A:  CALL   0C6
+B:  MOVLW  0D
+C:  MOVWF  30
+D:  CALL   0C6
+E:  MOVLW  0A
+F:  MOVWF  30
+:  CALL   0C6
+....................          delay_ms (2000);
+:  MOVLW  08
+:  MOVWF  27
+:  MOVLW  FA
+:  MOVWF  28
+:  GOTO   381
+:  DECFSZ 27,F
+:  GOTO   473
+....................
+....................       }
+:  GOTO   40D
+.................... }
+....................
+:  SLEEP
+Configuration Fuses:
+   Word  1: 2CF5   INTRC NOWDT NOPUT MCLR NOPROTECT NOCPD NOBROWNOUT IESO FCMEN NOLVP NODEBUG
+   Word  2: 3FFF   NOWRT BORV40

 /Modules/Sensors/IMU01A/SW/PIC16F887/main.pjt
 ,0 → 1,24
+[PROJECT]
+Target=D:\Honza\MLAB\Modules\Sensors\IMU01A\SW\PIC16F887\main.hex
+Development_Mode=
+Processor_Text=PIC16F887
+ToolSuite=CCS
+Processor=0x887F
+[D:\Honza\MLAB\Modules\Sensors\IMU01A\SW\PIC16F887\main]
+Type=4
+Path=
+FileList=
+BuildTool=
+OptionString=
+AdditionalOptionString=
+[mru-list]
+=D:\Honza\MLAB\Modules\Sensors\IMU01A\SW\PIC16F887\main.c
+[Windows]
+=0000 %S 0 0 796 451 3 0
+[Units]
+Link=0
+Count=1
+=D:\Honza\MLAB\Modules\Sensors\IMU01A\SW\PIC16F887\main
+[Opened Files]
+=main.c
+=

 /Modules/Sensors/IMU01A/SW/PIC16F887/main.sta
 ,0 → 1,68
+ROM used: 1146 (14%)
+(14%) including unused fragments
+Average locations per line
+Average locations per statement
+RAM used: 13 (4%) at main() level
+(7%) worst case
+Stack used: 3 worst case (out of 8 total available)
+Lines Stmts  %   Files
+----- ----- ---  -----
+21   7  main.c
+0   0  main.h
+0   0  C:\Program Files (x86)\PICC\devices\16F887.h
+260  84  C:\Program Files (x86)\PICC\drivers\math.h
+0   0  MMA8451Q.h
+28   9  MMA8451Q.c
+----- -----
+309 Total
+Page ROM  %  RAM   Vol Diff  Functions:
+---- --- --- ---   --- ----  ----------
+22   2   1             @delay_ms1
+69   6   3             @I2C_READ_1
+74   6   1             @I2C_WRITE_1
+36   3   1             @PUTCHAR_1_
+59   5   0    80  1.2  setAK
+269  23   8   558  4.7  akR
+ Inline        6   272  5.5  @DIVS1616
+16   1   2    68  2.4  akX
+16   1   2    68  2.4  akY
+16   1   2    68  2.4  akZ
+227  20   1   584  3.3  MAIN
+17   1   0   343  8.6  @const232
+70   6   3   367  7.0  @PSTRINGC7_69
+12   1   0   264  6.8  @const234
+11   1   0   153  4.7  @const235
+7   1   0   315  6.5  @const236
+79   7   4   288  6.0  @PSTRINGCN7_69
+128  11   9   209  5.2  @PRINTF_LD_69
+7   1   0   346  7.5  @const241
+7   1   0   318  6.5  @const242
+Program metrics:
+    Functions               16
+    Statements              309
+    Comments                351
+    Volume (V)              7495
+    Difficilty (D)          80.2
+    Effort to implement (E) 600964
+    Time to implement (T)   9 hours, 16 minutes
+    Est Delivered Bugs (B)  2
+    Cyclomatic Complexity   25
+    Maintainability (MI)    132
+ Segment     Used  Free
+-----------  ----  ----
+-00003     4  0
+-007FF  1142  902
+-00FFF     0  2048
+-017FF     0  2048
+-01FFF     0  2048

 /Modules/Sensors/IMU01A/SW/PIC16F887/main.sym
 ,0 → 1,119
+-005 @READ_PROGRAM_MEMORY8.P1
+@WRITE_PROGRAM_MEMORY8.P2
+CCP_1_LOW
+CCP_1
+CCP_1_HIGH
+B     CCP_2_LOW
+B     CCP_2
+C     CCP_2_HIGH
+@TRIS_C
+-022 x
+-024 y
+-026 z
+-028 akX.x
+@PSTRINGCN7_69.P1
+-028 @PRINTF_LD_69.P2
+-028 akZ.z
+-028 akY.y
+MAIN.@SCRATCH1
+@PSTRINGC7_69.@SCRATCH1
+@delay_ms1.P1
+@PSTRINGC7_69.@SCRATCH2
+@PSTRINGCN7_69.@SCRATCH1
+akR.H
+@PSTRINGC7_69.@SCRATCH3
+@PSTRINGCN7_69.@SCRATCH2
+@PRINTF_LD_69.@SCRATCH1
+A     akR.l
+A     @PSTRINGCN7_69.@SCRATCH3
+A     @PRINTF_LD_69.@SCRATCH2
+B     akR.XL
+B     @PRINTF_LD_69.@SCRATCH3
+C     akR.XH
+C     @PRINTF_LD_69.@SCRATCH4
+D-02E akR.x
+D     @PRINTF_LD_69.@SCRATCH5
+E     @PRINTF_LD_69.@SCRATCH6
+F-030 @DIVS1616.P1
+F     @I2C_READ_1.P2
+F     @I2C_WRITE_1.P3
+F     akR.@SCRATCH1
+F     @PRINTF_LD_69.@SCRATCH7
+@PUTCHAR_1_.P1
+@I2C_READ_1.@SCRATCH1
+akR.@SCRATCH2
+-032 @DIVS1616.P1
+@I2C_READ_1.@SCRATCH2
+@DIVS1616.@SCRATCH1
+@DIVS1616.@SCRATCH2
+@SCRATCH
+@SCRATCH
+_RETURN_
+@SCRATCH
+A     @SCRATCH
+.6   C1OUT
+.6   C2OUT
+D-10E @WRITE_PROGRAM_MEMORY8.P1
+D-10E @READ_PROGRAM_MEMORY8.P2
+ROM Allocation:
+@delay_ms1
+@I2C_READ_1
+@I2C_WRITE_1
+C6  @PUTCHAR_1_
+@ADDFF
+B  setAK
+akR
+C  @DIVS1616
+akX
+akY
+A2  akZ
+MAIN
+@const232
+EA  @PSTRINGC7_69
+@const234
+@const235
+C  @const236
+B2  @PSTRINGCN7_69
+@PRINTF_LD_69
+@const241
+A  @const242
+@cinit
+User Memory space:
+User Memory space:
+Project Directory:
+    D:\Honza\MLAB\Modules\Sensors\IMU01A\SW\PIC16F887\
+Project Files:
+    main.c
+    main.h
+    C:\Program Files (x86)\PICC\devices\16F887.h
+    C:\Program Files (x86)\PICC\drivers\math.h
+    MMA8451Q.h
+    MMA8451Q.c
+Units:
+    D:\Honza\MLAB\Modules\Sensors\IMU01A\SW\PIC16F887\main (main)
+Compiler Settings:
+    Processor:      PIC16F887
+    Pointer Size:   16
+    ADC Range:      0-255
+    Opt Level:      9
+    Short,Int,Long: UNSIGNED: 1,8,16
+    Float,Double:   32,32
+Output Files:
+    Errors:      main.err
+    Ext Symbols: main.esym
+    INHX8:       main.hex
+    Symbols:     main.sym
+    List:        main.lst
+    Debug/COFF:  main.cof
+    Project:     main.PJT
+    Call Tree:   main.tre
+    Statistics:  main.sta

 /Modules/Sensors/IMU01A/SW/PIC16F887/main.tre
 ,0 → 1,74
+ÀÄmain
+   ÀÄMAIN  0/227  Ram=1
+      ÃÄ??0??
+      ÃÄsetAK  0/59  Ram=0
+      ³  ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³  ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³  ÀÄ@I2C_WRITE_1  0/74  Ram=1
+      ÃÄ@PSTRINGC7_69  0/70  Ram=3
+      ³  ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ³  ÀÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PSTRINGC7_69  0/70  Ram=3
+      ³  ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ³  ÀÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄakX  0/16  Ram=2
+      ³  ÀÄakR  0/269  Ram=8
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_READ_1  0/69  Ram=3
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_READ_1  0/69  Ram=3
+      ³     ÀÄ@DIVS1616  (Inline)  Ram=6
+      ÃÄakY  0/16  Ram=2
+      ³  ÀÄakR  0/269  Ram=8
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_READ_1  0/69  Ram=3
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_READ_1  0/69  Ram=3
+      ³     ÀÄ@DIVS1616  (Inline)  Ram=6
+      ÃÄakZ  0/16  Ram=2
+      ³  ÀÄakR  0/269  Ram=8
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_READ_1  0/69  Ram=3
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_WRITE_1  0/74  Ram=1
+      ³     ÃÄ@I2C_READ_1  0/69  Ram=3
+      ³     ÀÄ@DIVS1616  (Inline)  Ram=6
+      ÃÄ@PSTRINGC7_69  0/70  Ram=3
+      ³  ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ³  ÀÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PSTRINGCN7_69  0/79  Ram=4
+      ³  ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ³  ÀÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PRINTF_LD_69  0/128  Ram=9
+      ³  ÀÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PSTRINGCN7_69  0/79  Ram=4
+      ³  ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ³  ÀÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PRINTF_LD_69  0/128  Ram=9
+      ³  ÀÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PSTRINGCN7_69  0/79  Ram=4
+      ³  ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ³  ÀÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PRINTF_LD_69  0/128  Ram=9
+      ³  ÀÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ÃÄ@PUTCHAR_1_  0/36  Ram=1
+      ÀÄ@delay_ms1  0/22  Ram=1

Subversion Repositories – MLAB

/Modules/Sensors/IMU01A/SW/PIC16F887/ @ 2961 → /Modules/Sensors/IMU01A/SW/PIC16F887/ @ 2962

Compare Path:	Rev
With Path:	Rev