Main Page | Modules | File List | Globals

hemisson.c

Go to the documentation of this file.
00001 //--------------------------------------------------------------------------------//
00002 //-                   HemiOs ( Hemisson Operating System )                       -//
00003 //-                                                                              -//
00004 //-  Copyright (C) Alexandre Colot, K-Team S.A. 2002                             -//
00005 //-  This library is free software; you can redistribute it and/or               -//
00006 //-  modify it under the terms of the GNU Lesser General Public                  -//
00007 //-  License as published by the Free Software Foundation; either                -//
00008 //-  version 2.1 of the License, or any later version.                           -//
00009 //-                                                                              -//
00010 //-  This library is distributed in the hope that it will be useful,             -//
00011 //-  but WITHOUT ANY WARRANTY; without even the implied warranty of              -//
00012 //-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU           -//
00013 //-  Lesser General Public License for more details.                             -//
00014 //-                                                                              -//
00015 //-  You should have received a copy of the GNU Lesser General Public            -//
00016 //-  License along with this library; if not, write to the Free Software         -//
00017 //-  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA   -//
00018 //-                                                                              -//
00019 //-                               __  __  ________                               -//
00020 //- K-Team S.A.                  |  |/  /|__    __|___  _____  ___  ___          -//
00021 //- Chemin de Vuasset, CP 111    |     / __ |  | _____|/  _  \|   \/   |         -//
00022 //- 1028 Preverenges             |  |  \    |  | ____|/  /_\  |        |         -//
00023 //- Switzerland                  |__|\__\   |__|______|_/   \_|__|\/|__|         -//
00024 //- alexandre.colot@k-team.com   tel:+41 21 802 5472 fax:+41 21 802 5471         -//
00025 //-                                                                              -//
00026 //--------------------------------------------------------------------------------//
00027 
00029 
00032 
00033 
00034 //----------------------------------------------------------------//
00035 //-                Conversion Function                           -//
00036 char chartohex( char valuetoconvert )
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 }
00049 
00050 //----------------------------------------------------------------//
00051 //-                Robot Initialisation                          -//
00052 void __hemisson_init(void)
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 }
00130 
00131 //---------------------------------------------------------------//
00132 //-                        IR Sensors                           -//
00133 void __hemisson_refresh_sensors( int zone )
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 }
00197 
00198 //---------------------------------------------------------------//
00199 //-                        TV Remote                            -//
00200 
00201 // TV Remote Control
00202 void __TV_Remote_Control( void )
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 }
00251 
00252 
00253 //-----------------------------------------------------------//
00254 //                  Internal Interrupts                     -//
00255 
00256 #INT_RB
00257 void __TV_Remote_Interrupt(void)
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 }
00274 
00275 #INT_TIMER0
00276 void Scheduler_Interrupt(void)                                                   // Internal Task Manager, Interrupt every 200 us
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 }
00465 
00466 #INT_TIMER2
00467 void RC5_Decoding_Interrupt(void)
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 }
00552 
00553 
00554 #INT_RDA
00555 void Serial_Interrupt(void)
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 }
00789 
00790 
00791 
00792 
00793 
00794 
00795 
00796 
00797 
00798 
00799 

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