Main Page | Modules | File List | Globals

hemisson.c File Reference


Detailed Description

The Os functions, all functions are called through an interrupt.

Definition in file hemisson.c.

Go to the source code of this file.

Functions

char chartohex (char valuetoconvert)
void __hemisson_init (void)
void __hemisson_refresh_sensors (int zone)
void __TV_Remote_Control (void)
void __TV_Remote_Interrupt (void)
void Scheduler_Interrupt (void)
void RC5_Decoding_Interrupt (void)
void Serial_Interrupt (void)


Function Documentation

void __hemisson_init void   ) 
 

Definition at line 52 of file hemisson.c.

References __Enable_RS232_Control, __IR_Light, __IR_Proximity, __PwmMotLeft, __PwmMotRight, __Switchs, ADC_CLOCK_INTERNAL, ALL_ANALOG, CCP_OFF, GLOBAL, HEMIOS_REVISION, HEMIOS_VERSION, INIT_PORTA, INIT_PORTB, INIT_PORTD, INIT_PORTE, INIT_TRISA, INIT_TRISB, INIT_TRISD, INIT_TRISE, INT_RB, INT_RDA, INT_TIMER0, PSP_DISABLED, RTCC_DIV_2, RTCC_DIV_4, RTCC_INTERNAL, T1_DISABLED, and T2_DISABLED.

Referenced by hemisson_init().

00053 {
00054    __PwmMotLeft = 0;
00055    __PwmMotRight = 0;
00056 
00057    __IR_Light[ 0 ] = 0;
00058    __IR_Light[ 1 ] = 0;
00059    __IR_Light[ 2 ] = 0;
00060    __IR_Light[ 3 ] = 0;
00061    __IR_Light[ 4 ] = 0;
00062    __IR_Light[ 5 ] = 0;
00063    __IR_Light[ 6 ] = 0;
00064    __IR_Light[ 7 ] = 0;
00065    __IR_Proximity[ 0 ] = 0;
00066    __IR_Proximity[ 1 ] = 0;
00067    __IR_Proximity[ 2 ] = 0;
00068    __IR_Proximity[ 3 ] = 0;
00069    __IR_Proximity[ 4 ] = 0;
00070    __IR_Proximity[ 5 ] = 0;
00071    __IR_Proximity[ 6 ] = 0;
00072    __IR_Proximity[ 7 ] = 0;
00073 
00074    __Switchs[ 0 ] = 0;
00075    __Switchs[ 1 ] = 0;
00076    __Switchs[ 2 ] = 0;
00077    __Switchs[ 3 ] = 0;
00078 
00079    // Analog Port
00080    setup_adc_ports(ALL_ANALOG);
00081    setup_adc(ADC_CLOCK_INTERNAL);
00082 
00083    //setup_spi(FALSE);
00084    setup_psp(PSP_DISABLED);
00085    setup_counters(RTCC_INTERNAL,RTCC_DIV_2);
00086    setup_timer_1(T1_DISABLED);
00087    setup_timer_2(T2_DISABLED,0,1);
00088    setup_ccp1(CCP_OFF);
00089    setup_ccp2(CCP_OFF);
00090 
00091    // I/O's
00092    set_tris_a(INIT_TRISA);
00093    set_tris_b(INIT_TRISB);
00094    //set_tris_c(INIT_TRISC);
00095    set_tris_d(INIT_TRISD);
00096    set_tris_e(INIT_TRISE);
00097    output_a(INIT_PORTA);
00098    output_b(INIT_PORTB);
00099    //output_c(INIT_PORTC);
00100    output_d(INIT_PORTD);
00101    output_e(INIT_PORTE);
00102 
00103    port_b_pullups(false);
00104 
00105    // Timer 2 for TV Remote RC5 Decode
00106    setup_timer_2(T2_DISABLED,0xBB,3);
00107    set_timer2(0);
00108 
00109    // Timer 0 for Scheduler
00110    setup_timer_0 (RTCC_DIV_4);
00111    set_timer0(0);
00112 
00113    // Welcome Message
00114    printf("HemiOS V%d.%d , K-Team S.A. ( Alexandre Colot )  " , HEMIOS_VERSION , HEMIOS_REVISION);
00115    printf(__DATE__);
00116    printf(" @ ");
00117    printf(__TIME__);
00118    printf("\r\n");
00119    printf("E-Mail : info@hemisson.com\r\n\r\n");
00120 
00121    // Interrupts
00122    enable_interrupts(INT_TIMER0);
00123    enable_interrupts(INT_RB);
00124    if( __Enable_RS232_Control == 1 )
00125    {
00126       enable_interrupts(INT_RDA);
00127    }
00128    enable_interrupts(GLOBAL);
00129 }

void __hemisson_refresh_sensors int  zone  ) 
 

Definition at line 133 of file hemisson.c.

References __IR_Light, __IR_Proximity, PIN_B1, PIN_B2, and PIN_B3.

Referenced by hemisson_manual_refresh_sensors().

00134 {
00135    switch( zone )
00136    {
00137    case FrontZone :
00138       set_adc_channel( FrontLeft );
00139       delay_us( 12 );
00140       __IR_Light[ FrontLeft ] = read_adc();
00141       set_adc_channel( FrontRight );
00142       delay_us( 12 );
00143       __IR_Light[ FrontRight ] = read_adc();
00144       set_adc_channel( Front );
00145       delay_us( 12 );
00146       __IR_Light[ Front ] = read_adc();
00147       output_high( PIN_B2 );
00148       delay_us( 300 );
00149       __IR_Proximity[ Front ] = __IR_Light[ Front ] - read_adc();
00150       set_adc_channel( FrontLeft );
00151       delay_us( 12 );
00152       __IR_Proximity[ FrontLeft ] = __IR_Light[ FrontLeft ] - read_adc();
00153       set_adc_channel( FrontRight );
00154       delay_us( 12 );
00155       __IR_Proximity[ FrontRight ] = __IR_Light[ FrontRight ] - read_adc();
00156       output_low( PIN_B2 );
00157       break;
00158    case RearZone :
00159       set_adc_channel(Left);
00160       delay_us(12);
00161       __IR_Light[Left]=read_adc();
00162       set_adc_channel(Right);
00163       delay_us(12);
00164       __IR_Light[Right]= read_adc();
00165       set_adc_channel(Rear);
00166       delay_us(12);
00167       __IR_Light[Rear]= read_adc();
00168       output_high(PIN_B3);
00169       delay_us(300);
00170       __IR_Proximity[Rear]=__IR_Light[Rear]- read_adc();
00171       set_adc_channel(Left);
00172       delay_us(12);
00173       __IR_Proximity[Left]=__IR_Light[Left]- read_adc();
00174       set_adc_channel(Right);
00175       delay_us(12);
00176       __IR_Proximity[Right]=__IR_Light[Right]- read_adc();
00177       output_low(PIN_B3);
00178       break;
00179    case GroundZone :
00180       set_adc_channel( GroundLeft );
00181       delay_us( 12 );
00182       __IR_Light[ GroundLeft ] = read_adc();
00183       set_adc_channel( GroundRight );
00184       delay_us( 12 );
00185       __IR_Light[ GroundRight ] = read_adc();
00186       output_high( PIN_B1 );
00187       delay_us( 300 );
00188       __IR_Proximity[ GroundRight ] = __IR_Light[ GroundRight ] - read_adc();
00189       set_adc_channel( GroundLeft );
00190       delay_us( 12 );
00191       __IR_Proximity[ GroundLeft ] = __IR_Light[ GroundRight ] - read_adc();
00192       output_low( PIN_B1 );
00193       break;
00194    }
00195    delay_ms( 5 );
00196 }

void __TV_Remote_Control void   ) 
 

Definition at line 202 of file hemisson.c.

References __PwmMotLeft, __PwmMotRight, and __TV_DATA.

Referenced by RC5_Decoding_Interrupt().

00203 {
00204 
00205    switch( __TV_DATA )
00206    {
00207       case 1 :
00208       __PwmMotLeft = 5;
00209       __PwmMotRight = 10;
00210       break;
00211       case 2 :
00212       __PwmMotLeft = 10;
00213       __PwmMotRight = 10;
00214       break;
00215       case 3 :
00216       __PwmMotLeft = 10;
00217       __PwmMotRight = 5;
00218       break;
00219       case 4:
00220       __PwmMotLeft = -10;
00221       __PwmMotRight = 10;
00222       break;
00223       case 5 :
00224       __PwmMotLeft = 0;
00225       __PwmMotRight = 0;
00226       break;
00227       case 6 :
00228       __PwmMotLeft = 10;
00229       __PwmMotRight = -10;
00230       break;
00231       case 7 :
00232       __PwmMotLeft = -5;
00233       __PwmMotRight = -10;
00234       break;
00235       case 8:
00236       __PwmMotLeft = -10;
00237       __PwmMotRight = -10;
00238       break;
00239       case 9 :
00240       __PwmMotLeft = -10;
00241       __PwmMotRight = -5;
00242       break;
00243       case 12 :   // Touche On/Off
00244       break;
00245       case 16 :   // Touche Son +
00246       break;
00247       case 17 :   // Touche Son -
00248       break;
00249    }
00250 }

void __TV_Remote_Interrupt void   ) 
 

Definition at line 257 of file hemisson.c.

References __Auto_Refresh_TV_Remote, __StartBit1, __TV_Counter, INT_RB, INT_TIMER2, PIN_B4, and T2_DIV_BY_16.

00258 {
00259    if( __Auto_Refresh_TV_Remote == 1 )
00260    {
00261       delay_us(150);
00262       if(input(PIN_B4)== 0)
00263       {
00264          __TV_Counter=0;
00265          __StartBit1=!input(PIN_B4);
00266          __TV_Counter++;
00267          disable_interrupts(INT_RB);
00268          setup_timer_2(T2_DIV_BY_16,0xBB,3);                                     // Interrupt every 1.780 ms
00269          set_timer2(0);
00270          enable_interrupts(INT_TIMER2);
00271       }
00272    }
00273 }

char chartohex char  valuetoconvert  ) 
 

Definition at line 36 of file hemisson.c.

Referenced by Serial_Interrupt().

00037 {
00038    char convertedval;
00039    if( valuetoconvert >= 'A' )
00040    {
00041       convertedval = valuetoconvert-'A'+10;
00042    }
00043    else
00044    {
00045       convertedval = valuetoconvert -'0';
00046    }
00047    return convertedval;
00048 }

void RC5_Decoding_Interrupt void   ) 
 

Definition at line 467 of file hemisson.c.

References __DataBit0, __DataBit1, __DataBit2, __DataBit3, __DataBit4, __DataBit5, __Enable_TV_Remote_Control, __StartBit2, __SystemBit0, __SystemBit1, __SystemBit2, __SystemBit3, __SystemBit4, __ToggleBit, __TV_Counter, __TV_DATA, __TV_Data_Available, __TV_Remote_Control(), INT_RB, INT_TIMER2, PIN_B4, and T2_DISABLED.

00468 {
00469    switch(__TV_Counter)
00470    {
00471       case 1 :
00472       __StartBit2 = !input(PIN_B4);
00473       if(__StartBit2 != 1)
00474       {
00475          setup_timer_2(T2_DISABLED,0xBB,3);
00476          disable_interrupts(INT_TIMER2);
00477          enable_interrupts(INT_RB);
00478       }
00479       break;
00480       case 2 :
00481       __ToggleBit=!input(PIN_B4);
00482       break;
00483       case 3 :
00484       __SystemBit4 = !input( PIN_B4 );
00485       if( __SystemBit4 != 0 )
00486       {
00487          setup_timer_2(T2_DISABLED,0xBB,3);
00488          disable_interrupts(INT_TIMER2);
00489          enable_interrupts( INT_RB );
00490       }
00491       break;
00492       case 4 :
00493       __SystemBit3 = !input( PIN_B4 );
00494       if( __SystemBit3 != 0 )
00495       {
00496          setup_timer_2(T2_DISABLED,0xBB,3);
00497          disable_interrupts(INT_TIMER2);
00498          enable_interrupts( INT_RB );
00499       }
00500       break;
00501       case 5 :
00502       __SystemBit2 = !input( PIN_B4 );
00503       if( __SystemBit2 != 0 )
00504       {
00505          setup_timer_2(T2_DISABLED,0xBB,3);
00506          disable_interrupts(INT_TIMER2);
00507          enable_interrupts( INT_RB );
00508       }
00509       break;
00510       case 6 :
00511       __SystemBit1 = !input( PIN_B4 );
00512       if( __SystemBit1 != 0 )
00513       {
00514          setup_timer_2(T2_DISABLED,0xBB,3);
00515          disable_interrupts(INT_TIMER2);
00516          enable_interrupts( INT_RB );
00517       }
00518       break;
00519       case 7 :
00520       __SystemBit0 = !input( PIN_B4 );
00521       break;
00522       case 8 :
00523       __DataBit5 = !input( PIN_B4 );
00524       break;
00525       case 9 :
00526       __DataBit4 = !input( PIN_B4 );
00527       break;
00528       case 10 :
00529       __DataBit3 = !input( PIN_B4 );
00530       break;
00531       case 11 :
00532       __DataBit2 = !input( PIN_B4 );
00533       break;
00534       case 12 :
00535       __DataBit1 = !input( PIN_B4 );
00536       break;
00537       case 13 :
00538       __DataBit0 = !input( PIN_B4 );
00539       __TV_DATA = ( __DataBit5 << 5 ) | ( __DataBit4 << 4 ) | ( __DataBit3 << 3 ) | ( __DataBit2 << 2 ) | ( __DataBit1 << 1 ) | __DataBit0 ;
00540       if( __Enable_TV_Remote_Control == 1 )
00541       {
00542          __TV_Remote_Control();
00543       }
00544       __TV_Data_Available = 1;                                                // Just a Flag
00545       setup_timer_2(T2_DISABLED,0xBB,3);
00546       disable_interrupts(INT_TIMER2);
00547       enable_interrupts( INT_RB );
00548       break;
00549    }
00550    __TV_Counter++;
00551 }

void Scheduler_Interrupt void   ) 
 

Definition at line 276 of file hemisson.c.

References __Auto_Refresh_Sensors, __Divider, __IR_Light, __IR_Proximity, __PwmCounter, __PwmMotLeft, __PwmMotRight, __SchedulerTask, __Sensors_Refreshed_Flag, __Switchs, __TimeTip, __TimeTipDivider, hemisson_task1(), hemisson_task2(), hemisson_task3(), hemisson_task4(), PIN_B1, PIN_B2, PIN_B3, PIN_C0, PIN_C1, PIN_C2, PIN_C5, PIN_D0, PIN_D1, PIN_D2, PIN_D3, and PIN_D7.

00277 {                                                                                // Sensors Powered during 400us, refreshed every 40ms
00278    // Time function
00279    __TimeTipDivider++;
00280    if(__TimeTipDivider == 5)
00281    {
00282       __TimeTipDivider = 0;
00283       __TimeTip++;                                                               // __TimeTip incremented every 1 ms (counter up to 4294967296 ms = 1193 hours ...)
00284    }
00285    // Motor Task, PWM freq 300 Hz
00286    if( __PwmMotLeft >= 0 )                                                       // Left Motor
00287    {
00288       if( ( 15 - __PwmMotLeft + __PwmCounter ) >= 15 )
00289       {
00290          output_bit( PIN_D0 , 0 );
00291          output_bit( PIN_D1 , 0 );
00292       }
00293       else
00294       {
00295          output_bit( PIN_D0 , 1 );
00296          output_bit( PIN_D1 , 0 );
00297       }
00298    }
00299    else
00300    {
00301       if( ( 15 - ( - __PwmMotLeft ) + __PwmCounter ) >= 15 )
00302       {
00303          output_bit( PIN_D0 , 0 );
00304          output_bit( PIN_D1 , 0 );
00305       }
00306       else
00307       {
00308          output_bit( PIN_D0 , 0 );
00309          output_bit( PIN_D1 , 1 );
00310       }
00311    }
00312    if( __PwmMotRight >= 0 )                                                      // Right Motor
00313    {
00314       if( ( 15 - __PwmMotRight + __PwmCounter ) >= 15 )
00315       {
00316          output_bit( PIN_D2 , 0 );
00317          output_bit( PIN_D3 , 0 );
00318       }
00319       else
00320       {
00321          output_bit( PIN_D2 , 1 );
00322          output_bit( PIN_D3 , 0 );
00323       }
00324    }
00325    else
00326    {
00327       if( ( 15 - ( - __PwmMotRight ) + __PwmCounter ) >= 15 )
00328       {
00329          output_bit( PIN_D2 , 0 );
00330          output_bit( PIN_D3 , 0 );
00331       }
00332       else
00333       {
00334          output_bit( PIN_D2 , 0 );
00335          output_bit( PIN_D3 , 1 );
00336       }
00337    }
00338    __PwmCounter++;                                                               // Counter
00339    if( __PwmCounter > 15 )
00340    {
00341       __PwmCounter = 0;
00342    }
00343 
00344    // Other Tasks
00345    switch( __SchedulerTask )
00346    {
00347       case 1 :                                                                   // Brightness measurement zone 1
00348       if( __Auto_Refresh_Sensors == 1 )
00349       {
00350          set_adc_channel( GroundLeft );
00351          delay_us( 12 );
00352          __IR_Light[ GroundLeft ] = read_adc();
00353          set_adc_channel( GroundRight );
00354          delay_us( 12 );
00355          __IR_Light[ GroundRight ] = read_adc();
00356          output_high( PIN_B1 );
00357       }
00358       break;
00359       case 3 :                                                                   // Proximity measurement zone 1
00360       if( __Auto_Refresh_Sensors == 1 )
00361       {
00362          __IR_Proximity[ GroundRight ] = __IR_Light[ GroundRight ] - read_adc();
00363          set_adc_channel( GroundLeft );
00364          delay_us( 12 );
00365          __IR_Proximity[ GroundLeft ] = __IR_Light[ GroundRight ] - read_adc();
00366          output_low( PIN_B1 );
00367       }
00368       break;
00369       case 10 :                                                                  // Brightness measurement zone 2
00370       if( __Auto_Refresh_Sensors == 1 )
00371       {
00372          set_adc_channel( FrontLeft );
00373          delay_us( 12 );
00374          __IR_Light[ FrontLeft ] = read_adc();
00375          set_adc_channel( FrontRight );
00376          delay_us( 12 );
00377          __IR_Light[ FrontRight ] = read_adc();
00378          set_adc_channel( Front );
00379          delay_us( 12 );
00380          __IR_Light[ Front ] = read_adc();
00381          output_high( PIN_B2 );
00382       }
00383       break;
00384       case 12 :                                                                 // Proximity measurement zone 2
00385       if( __Auto_Refresh_Sensors == 1 )
00386       {
00387          __IR_Proximity[ Front ] = __IR_Light[ Front ] - read_adc();
00388          set_adc_channel( FrontLeft );
00389          delay_us( 12 );
00390          __IR_Proximity[ FrontLeft ] = __IR_Light[ FrontLeft ] - read_adc();
00391          set_adc_channel( FrontRight );
00392          delay_us( 12 );
00393          __IR_Proximity[ FrontRight ] = __IR_Light[ FrontRight ] - read_adc();
00394          output_low( PIN_B2 );
00395       }
00396       break;
00397       case 15 :
00398       if(__Divider==0)                                                        // Powered during 4ms every 450ms
00399       {
00400          output_bit( PIN_D7 , 1 );
00401       }
00402       break;
00403       case 20 :                                                                  // Brightness measurement zone 3
00404       if( __Auto_Refresh_Sensors == 1 )
00405       {
00406          set_adc_channel(Left);
00407          delay_us(12);
00408          __IR_Light[Left]=read_adc();
00409          set_adc_channel(Right);
00410          delay_us(12);
00411          __IR_Light[Right]= read_adc();
00412          set_adc_channel(Rear);
00413          delay_us(12);
00414          __IR_Light[Rear]= read_adc();
00415          output_high(PIN_B3);
00416       }
00417       break;
00418       case 22 :                                                                 // Proximity measurement zone 3
00419       if( __Auto_Refresh_Sensors == 1 )
00420       {
00421          __IR_Proximity[Rear]=__IR_Light[Rear]- read_adc();
00422          set_adc_channel(Left);
00423          delay_us(12);
00424          __IR_Proximity[Left]=__IR_Light[Left]- read_adc();
00425          set_adc_channel(Right);
00426          delay_us(12);
00427          __IR_Proximity[Right]=__IR_Light[Right]- read_adc();
00428          output_low(PIN_B3);
00429          __Sensors_Refreshed_Flag = 1;
00430       }
00431       break;
00432       case 25 :                                                                  // Refresh Switchs
00433       __Switchs[0]=!input(PIN_C0);
00434       __Switchs[1]=!input(PIN_C1);
00435       __Switchs[2]=!input(PIN_C2);
00436       __Switchs[3]=!input(PIN_C5);
00437       break;
00438       case 35 :
00439       if(__Divider==0)
00440       {
00441          output_bit( PIN_D7 , 0 );
00442       }
00443       break;
00444       case 100 :
00445       hemisson_task1();
00446       break;
00447       case 120 :
00448       hemisson_task2();
00449       break;
00450       case 140 :
00451       hemisson_task3();
00452       break;
00453       case 160 :
00454       hemisson_task4();
00455       break;
00456       case 200 :                                                                 // Every 40 ms
00457       __SchedulerTask=0;
00458       __Divider++;
00459       if(__Divider>10)
00460          __Divider=0;
00461       break;
00462    }
00463    __SchedulerTask++;                                                            // Task Counter
00464 }

void Serial_Interrupt void   ) 
 

Definition at line 555 of file hemisson.c.

References __IR_Light, __IR_Proximity, __PwmMotLeft, __PwmMotRight, __Sensors_Refreshed_Flag, __SERIAL_BUFFER_SIZE, __SerialBuffer, __SerialCounter, __Switchs, __TV_DATA, chartohex(), getc, HEMIOS_REVISION, HEMIOS_VERSION, PIN_A4, PIN_D4, PIN_D5, PIN_D6, and PIN_D7.

00556 {
00557    unsigned char __memaddress = 0;
00558    unsigned char __rcvalue = 0;
00559    unsigned char __TempVal;
00560    unsigned char __i;
00561 
00562    while(kbhit())                                                                // Read while data available
00563    {
00564       __SerialBuffer[ __SerialCounter ] = getc();
00565       if (__SerialCounter < ( __SERIAL_BUFFER_SIZE-1 ))                          // To discard buffer overflow
00566       {
00567          __SerialCounter++;
00568       }
00569    }
00570    if( __SerialBuffer[ __SerialCounter-1 ] == 13 )                               // '\n'
00571    {
00572       //delay_ms(6);                                                             // Only for HemBasicStamp
00573       switch( __SerialBuffer[ 0 ] )
00574       {
00575          //case 'A' : Unused
00576          case 'B' :                                                             // HemiOs Version
00577          printf( "b,HemiOS_v_%d.%d\r\n" , HEMIOS_VERSION , HEMIOS_REVISION );
00578          break;
00579          //case 'C' : Unused
00580          case 'D' :                                                             // Set Motors Speed
00581          if( __SerialBuffer[2] == '-' )
00582          {
00583             __PwmMotLeft = - ( __SerialBuffer[3] - '0' );
00584             if( __SerialBuffer[5] == '-' )
00585             {
00586                __PwmMotRight = - ( __SerialBuffer[6] - '0' );
00587             }
00588             else
00589             {
00590                __PwmMotRight = __SerialBuffer[5] - '0';
00591             }
00592          }
00593          else
00594          {
00595             __PwmMotLeft = __SerialBuffer[2] - '0';
00596             if( __SerialBuffer[4] == '-' )
00597             {
00598                __PwmMotRight = - ( __SerialBuffer[5] - '0' );
00599             }
00600             else
00601             {
00602                __PwmMotRight = __SerialBuffer[4] - '0';
00603             }
00604          }
00605          printf( "d\r\n" );
00606          break;
00607          case 'E' :                                                             // Read Motors Speed
00608          printf("e,%02d,%02d\r\n",__PwmMotLeft,__PwmMotRight);
00609          break;
00610          //case 'F' : Unused
00611          //case 'G' : Unused
00612          case 'H' :                                                             // Buzzer
00613          output_bit( PIN_D4 , __SerialBuffer[ 2 ] - '0' );
00614          printf( "h\r\n" );
00615          break;
00616          case 'I' :
00617          printf( "i,%d,%d,%d,%d\r\n" , __Switchs[ 0 ] , __Switchs[ 1 ] , __Switchs[ 2 ] , __Switchs[ 3 ] );
00618          break;
00619          case 'J' :                                                              // Scan I2C Bus
00620          printf("j");
00621          for(__i=3;__i<254;__i=__i+2)
00622          {
00623             i2c_start();
00624             if(i2c_write(__i-1)==0)
00625             {
00626                i2c_write(0x00);  // Version Register
00627                i2c_start();
00628                i2c_write(__i);
00629                __TempVal=i2c_read(0);
00630                i2c_stop();
00631                printf(",%2x",__i-1);
00632             }
00633             else
00634             {
00635                i2c_stop();
00636             }
00637          }
00638          printf("\r\n");
00639          break;
00640          //case 'K' : Unused
00641          case 'L' :                                                             // Leds
00642          output_bit( PIN_D7 , __SerialBuffer[2] - '0' );
00643          output_bit( PIN_D5 , __SerialBuffer[4] - '0' );
00644          output_bit( PIN_D6 , __SerialBuffer[6] - '0' );
00645          output_bit( PIN_A4 , !(__SerialBuffer[8] - '0') );
00646          printf( "l\r\n" );
00647          break;
00648          case 'M' :                                                             // Get Brightness Zone Sensors
00649          switch(__SerialBuffer[2])
00650          {
00651             case '0' :  // Front Zone
00652             printf( "m,%03u,%03u,%03u\r\n",__IR_Light[ Front ],__IR_Light[ FrontRight ],__IR_Light[ FrontLeft ] );
00653             break;
00654             case '1' :  // Rear Zone
00655             printf( "m,%03u,%03u,%03u\r\n",__IR_Light[ Right],__IR_Light[ Left],__IR_Light[ Rear ] );
00656             break;
00657             case '2' :  // Ground Zone
00658             printf( "m,%03u,%03u\r\n",__IR_Light[ GroundRight ],__IR_Light[ GroundLeft ]);
00659             break;
00660          }
00661          break;
00662          case 'N' :                                                             // Get all Proximity Sensors
00663          printf( "n,%03u,%03u,%03u,%03u,%03u,%03u,%03u,%03u\r\n" , __IR_Proximity[ Front ] , __IR_Proximity[ FrontRight ] ,
00664          __IR_Proximity[ FrontLeft ] , __IR_Proximity[ Right] , __IR_Proximity[ Left] , __IR_Proximity[ Rear ] ,
00665          __IR_Proximity[ GroundRight ] , __IR_Proximity[ GroundLeft ] );
00666          break;
00667          case 'O' :                                                             // Get all Brightness Sensors
00668          printf( "o,%03u,%03u,%03u,%03u,%03u,%03u,%03u,%03u\r\n" , __IR_Light[ Front ] , __IR_Light[ FrontRight ] ,
00669          __IR_Light[ FrontLeft ] , __IR_Light[ Right] , __IR_Light[ Left] , __IR_Light[ Rear ] ,
00670          __IR_Light[ GroundRight ] , __IR_Light[ GroundLeft ] );
00671          break;
00672          case 'P' :                                                             // Get Proximity Zone Sensors
00673          switch(__SerialBuffer[2])
00674          {
00675             case '0' :  // Front Zone
00676             printf( "p,%03u,%03u,%03u\r\n",__IR_Proximity[ Front ],__IR_Proximity[ FrontRight ],__IR_Proximity[ FrontLeft ] );
00677             break;
00678             case '1' :  // Rear Zone
00679             printf( "p,%03u,%03u,%03u\r\n",__IR_Proximity[ Right],__IR_Proximity[ Left],__IR_Proximity[ Rear ] );
00680             break;
00681             case '2' :  // Ground Zone
00682             printf( "p,%03u,%03u\r\n",__IR_Proximity[ GroundRight ],__IR_Proximity[ GroundLeft ]);
00683             break;
00684          }
00685          break;
00686          //case 'Q' : Reserved for Webots-Hemisson
00687          case 'R' :                                                             // Read I2C
00688          __memaddress = chartohex(__SerialBuffer[2]);
00689          __memaddress = (__memaddress<<4) + chartohex(__SerialBuffer[3]);
00690          i2c_start();
00691          i2c_write( __memaddress );                                        // Writing Address of the module
00692          __rcvalue = chartohex(__SerialBuffer[5]);
00693          __rcvalue = (__rcvalue<<4) + chartohex(__SerialBuffer[6]);
00694          i2c_write( __rcvalue );                                           // Writing Address of the register
00695          __rcvalue = chartohex(__SerialBuffer[8]);
00696          __rcvalue = (__rcvalue<<4) + chartohex(__SerialBuffer[9]);
00697          i2c_start();
00698          i2c_write( __memaddress + 1 );                                    // Writing Address of the module in Read Mode
00699          printf("r",__TempVal);
00700          while(__rcvalue > 1)
00701          {
00702             __TempVal = i2c_read();
00703             printf(",%03u",__TempVal);
00704             __rcvalue--;
00705          }
00706          __TempVal = i2c_read(0);
00707          printf(",%03u",__TempVal);
00708          i2c_stop();
00709          printf("\r\n");
00710          break;
00711          //case 'S' : Reserved for Webots-Hemisson
00712          case 'T' :                                                             // Read TV Remote Sensor
00713          printf( "t,%03u\r\n" , __TV_DATA );
00714          break;
00715          //case 'U' : Reserved for Webots-Hemisson
00716          //case 'V' : Unused
00717          case 'W' :                                                             // Write I2C
00718          __rcvalue = chartohex(__SerialBuffer[2]);
00719          __rcvalue = (__rcvalue<<4) + chartohex(__SerialBuffer[3]);
00720          i2c_start();
00721          i2c_write( __rcvalue );                                           // Writing Address of the module
00722          __rcvalue = chartohex(__SerialBuffer[5]);
00723          __rcvalue = (__rcvalue<<4) + chartohex(__SerialBuffer[6]);
00724          i2c_write( __rcvalue );                                           // Writing Address of the register
00725          __rcvalue = chartohex(__SerialBuffer[8]);
00726          __rcvalue = (__rcvalue<<4) + chartohex(__SerialBuffer[9]);
00727          i2c_write( __rcvalue );                                           // Writing Data in the register
00728          i2c_stop();
00729          printf("w\r\n");
00730          break;
00731          //case 'X' : Reserved for Webots-Hemisson
00732          case 'Y' :                                                        // Write I2C (Pointer Method)
00733          __rcvalue = chartohex(__SerialBuffer[2]);
00734          __rcvalue = (__rcvalue<<4) + chartohex(__SerialBuffer[3]);
00735          i2c_start();
00736          i2c_write( __rcvalue );                                           // Writing Address of the module
00737          __rcvalue = chartohex(__SerialBuffer[5]);
00738          __rcvalue = (__rcvalue<<4) + chartohex(__SerialBuffer[6]);
00739          i2c_write( __rcvalue );                                           // Writing Address of the register
00740          __TempVal = chartohex(__SerialBuffer[8]);
00741          __TempVal = (__TempVal<<4) + chartohex(__SerialBuffer[9]);        // Number of Data to Write
00742          i2c_write( __TempVal );                                           // Writing Number of Data
00743          for(__i=0;__i<__TempVal;__i++)
00744          {
00745             //delay_ms(10);
00746             __rcvalue = chartohex(__SerialBuffer[11+__i+__i+__i]);
00747             __rcvalue = (__rcvalue<<4) + chartohex(__SerialBuffer[12+__i+__i+__i]);
00748             i2c_write( __rcvalue );                                           // Writing Data in the register
00749             //delay_ms(1);
00750          }
00751          i2c_stop();
00752          printf("y\r\n");
00753          break;
00754          case 'Z' :                                                             // Reset
00755          printf("z\r\n");
00756          reset_cpu();
00757          break;
00758          case '&' :                                                             // Fast binary read
00759          printf("&%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c%c\r\n",__PwmMotLeft,__PwmMotRight ,__IR_Proximity[ Front ] , __IR_Proximity[ FrontRight ] ,
00760          __IR_Proximity[ FrontLeft ] , __IR_Proximity[ Right] , __IR_Proximity[ Left] , __IR_Proximity[ Rear ] ,
00761          __IR_Proximity[ GroundRight ] , __IR_Proximity[ GroundLeft ] , __IR_Light[ Front ] , __IR_Light[ FrontRight ] ,
00762          __IR_Light[ FrontLeft ] , __IR_Light[ Right] , __IR_Light[ Left] , __IR_Light[ Rear ] ,
00763          __IR_Light[ GroundRight ] , __IR_Light[ GroundLeft ] , (__Switchs[ 0 ]|(__Switchs[ 1 ]<<1)|(__Switchs[ 2 ]<<2)|(__Switchs[ 3 ]<<3)) ,
00764          __TV_DATA , HEMIOS_VERSION, HEMIOS_REVISION );
00765          break;
00766          case '*' :                                                             // Fast binary write
00767          __PwmMotLeft = __SerialBuffer[1];
00768          __PwmMotRight = __SerialBuffer[2];
00769          output_bit( PIN_D7 , __SerialBuffer[3]&0x01 );
00770          output_bit( PIN_D5 , __SerialBuffer[3]&0x02 );
00771          output_bit( PIN_D6 , __SerialBuffer[3]&0x04 );
00772          output_bit( PIN_A4 , !(__SerialBuffer[3]&0x08) );
00773          printf("*\r\n");
00774          break;
00775          case '!' :
00776          printf("!%c\r\n",__Sensors_Refreshed_Flag);
00777          if(__Sensors_Refreshed_Flag == 1)
00778          {
00779             __Sensors_Refreshed_Flag = 0;
00780          }
00781          break;
00782          default :                                                              // Default
00783          printf( "Unknown Command ?!\r\n" );
00784          break;
00785       }
00786       __SerialCounter = 0;
00787    }
00788 }


Generated on Mon Feb 23 23:53:22 2004 for HemiOs by doxygen 1.3.4