Esempio n. 1
0
void run_SensDispl() {
	int cam_mode,cam_width,cam_heigth,cam_zoom,cam_size;
	int i;
	unsigned long cam_light;
	unsigned char *buf_ptr;
	/*Cam default parameter*/
	cam_mode=GREY_SCALE_MODE;
	cam_width=20;
	cam_heigth=20;
	cam_zoom=8;
	cam_size=cam_width*cam_heigth;
	e_poxxxx_init_cam();
	e_poxxxx_config_cam((ARRAY_WIDTH -cam_width*cam_zoom)/2,(ARRAY_HEIGHT-cam_heigth*cam_zoom)/2,cam_width*cam_zoom,cam_heigth*cam_zoom,cam_zoom,cam_zoom,cam_mode);
	e_poxxxx_set_mirror(1,1);
	e_poxxxx_write_cam_registers();

	e_acc_calibr();
	while (1) {
		e_poxxxx_launch_capture(&buffer[0]);	// start camera capture
		e_led_clear();
		e_set_body_led(0);
		e_set_front_led(0);
		if (e_get_micro_volume(0)>30 || e_get_micro_volume(1)>30 || e_get_micro_volume(2)>30)
			e_set_body_led(1);
		if (e_get_prox(0)>400) 
			e_set_led(0,1);
		if (e_get_prox(1)>400) 
			e_set_led(1,1);
		if (e_get_prox(2)>400) 
			e_set_led(2,1);
		if (e_get_prox(3)>400) 
			e_set_led(3,1);
		if (e_get_prox(4)>400) 
			e_set_led(4,1);
		if (e_get_prox(5)>400) 
			e_set_led(5,1);
		if (e_get_prox(6)>400) 
			e_set_led(6,1);
		if (e_get_prox(7)>400) 
			e_set_led(7,1);
		while(!e_poxxxx_is_img_ready());	// wait end of capture
		cam_light=0;
		buf_ptr=(unsigned char*)&buffer[0];
		for (i=0; i<cam_size; i++) {
			cam_light+=*buf_ptr;
			buf_ptr++;
		}
		sprintf(buffer, "Cam light %lu\r\n", cam_light);
		e_send_uart1_char(buffer, strlen(buffer));
		if (cam_light>48000)	// 20*20pixels*120grayValue
			e_set_front_led(1);
		wait(5000);
	}								
}
Esempio n. 2
0
// *** behaviour insired by a dust cleaner
void run_DustCleaner() {	
	int i;
	int sensor;
	int leftwheel, rightwheel;
	int spiral=100;
	int weightleft[8] = {-10,-10,-5,0,0,5,10,10};
	int weightright[8] = {10,10,5,0,0,-5,-10,-10};

	while (1) {
		e_led_clear();
		e_set_body_led(0);
		e_set_front_led(0);
		if (e_get_prox(0)>600) 
			e_set_led(0,1);
		if (e_get_prox(1)>600) 
			e_set_led(1,1);
		if (e_get_prox(2)>600) 
			e_set_led(2,1);
		if (e_get_prox(3)>600) 
			e_set_led(3,1);
		if (e_get_prox(4)>600) 
			e_set_led(4,1);
		if (e_get_prox(5)>600) 
			e_set_led(5,1);
		if (e_get_prox(6)>600) 
			e_set_led(6,1);
		if (e_get_prox(7)>600) 
			e_set_led(7,1);

		if  (e_get_prox(0)>600 || e_get_prox(1)>600 || e_get_prox(2)>600 || 
 			e_get_prox(5)>600 || e_get_prox(6)>600 || e_get_prox(7)>600 ){  // obstacle
			e_set_body_led(1);
			// *** avoid
			leftwheel=200;
			rightwheel=200;
			for (i=0; i<8; i++) {
				sensor=e_get_prox(i); //-sensorzero[i];
				sprintf(buffer, "%d, ", sensor);
				e_send_uart1_char(buffer, strlen(buffer));
				leftwheel+=weightleft[i]*(sensor>>4);
				rightwheel+=weightright[i]*(sensor>>4);
			}
			sprintf(buffer, "setspeed %d %d\r\n", leftwheel, rightwheel);
			e_send_uart1_char(buffer, strlen(buffer));
			if (leftwheel>800) {leftwheel=800;}
			if (rightwheel>800) {rightwheel=800;}
			if (leftwheel<-800) {leftwheel=-800;}
			if (rightwheel<-800) {rightwheel=-800;}
			e_set_speed_left(leftwheel);
			e_set_speed_right(rightwheel);

		} else { // spiral
Esempio n. 3
0
void set_LEDs()
{
  char ring, body_front;
  ring = recv_char();
  body_front = recv_char();

  /* Each one of eight bits of "char ring" represents one of eight ring    *
   * LEDs in e-puck, the rightmost bit meaning the LED 0. With a bit being *
   * true the LED will be on, with a bit being false the LED will be off.  */
  int led;
  for(led = 0; led< RING_LED_NUMBER; led++)
  {
    if((ring&(0x01<<led))!=0)
    {
      e_set_led(led, LED_ON);
    }
    else
    {
      e_set_led(led, LED_OFF);
    }
  }

  if((body_front & 0x01) != 0)
  {
    e_set_front_led(LED_ON);
  }
  else
  {
    e_set_front_led(LED_OFF);
  }

  if((body_front & 0x02) != 0)
  {
    e_set_body_led(LED_ON);
  }
  else
  {
    e_set_body_led(LED_OFF);
  }

  send_char(1);/* Send a char to signalize the end set LED operation. */
}
Esempio n. 4
0
void run_CameraTurn() {
	int cam_mode,cam_width,cam_heigth,cam_zoom,cam_size;
	int i;
	unsigned char *buf_ptr, pixel, lightest;
	unsigned int left, right, lightPos;

	#include "DataEEPROM.h"
	/*read HW version from the eeprom (last word)*/
	int HWversion=0xFFFF;
	int temp = 0;
	temp = ReadEE(0x7F,0xFFFE,&HWversion, 1);
	temp = temp & 0x03;	// get the camera rotation from the HWversion byte

	/*Cam default parameter*/
	cam_mode=GREY_SCALE_MODE;
	if ((temp==3)||(temp==0)) { // 0' and 180' camera rotation
		cam_width=1;
		cam_heigth=60;
	} else {
		cam_width=60;
		cam_heigth=1;
	}
	cam_zoom=8;
	cam_size=cam_width*cam_heigth;
	e_poxxxx_init_cam();
	e_poxxxx_config_cam((ARRAY_WIDTH -cam_width*cam_zoom)/2,(ARRAY_HEIGHT-cam_heigth*cam_zoom)/2,cam_width*cam_zoom,cam_heigth*cam_zoom,cam_zoom,cam_zoom,cam_mode);
	e_poxxxx_set_mirror(1,1);
	e_poxxxx_write_cam_registers();

	while (1) {
		e_poxxxx_launch_capture(&buffer[0]);	// start camera capture
		e_led_clear();
		e_set_body_led(0);
		e_set_front_led(0);

		while(!e_poxxxx_is_img_ready());	// wait end of capture
		buf_ptr=(unsigned char*)&buffer[0];
		left=0; right=0; lightPos=0; lightest=0;
		for (i=0; i<30; i++) {	//left
			pixel=*buf_ptr;
			buf_ptr++;
			left+=pixel;
			if (pixel>lightest) {
				lightest=pixel;
				lightPos=i;
			}
		}
		for (; i<cam_heigth; i++) {	//right
			pixel=*buf_ptr;
			buf_ptr++;
			right+=pixel;
			if (pixel>lightest) {
				lightest=pixel;
				lightPos=i;
			}
		}
		if (lightPos<20) {	//led on at lightest position
			e_set_led(7,1); }
		else if (lightPos<40) {
			e_set_led(0,1); }
		else {
			e_set_led(1,1); }

		if ((temp==3)||(temp==2)) { // 0' and 90' camera rotation
			e_set_speed_left(10*(lightPos-30));  // motor speed in steps/s
			e_set_speed_right(-10*(lightPos-30));
		} else {
			e_set_speed_left(-10*(lightPos-30));  // motor speed in steps/s
			e_set_speed_right(10*(lightPos-30));
		}

		sprintf(buffer, "left %u, right %u, lightest %u, lightPos %u\r\n", left, right, lightest, lightPos);
		e_send_uart1_char(buffer, strlen(buffer));
		wait(5000);
	}								
}
Esempio n. 5
0
/*! \brief The "main" function of the demo */
void run_accelerometer() {
	int accx, accy, accz;
	long ampl;
	long amplavg;
//	char buffer[80];
	int state;
	int lednum;
	double angle;
	int soundsel;

	// Init sound
	e_init_port();
    e_init_ad_scan(ALL_ADC);
	e_init_sound();
#ifdef MOVE
	e_init_motors();
	e_start_agendas_processing();
#endif

	// Calibrate accelerometers
	e_set_led(8, 1);
	e_acc_calibr();
	e_set_led(8, 0);

#ifdef MOVE
	// Move forwards
	e_set_speed_left(100);
	e_set_speed_right(100);
#endif
	// Detect free fall and shocks
	state=STATE_NORMAL;
	amplavg=1000;
	while (1) {

		accx = e_get_acc(0);
		accy = e_get_acc(1);
		accz = e_get_acc(2) + 744; //744 is 1g

		if ((accz<0) && (accz>-600)) {accz=0;}
		ampl=((long)(accx)*(long)(accx))+((long)(accy)*(long)(accy))+((long)(accz)*(long)(accz));
		amplavg=(amplavg>>2)+ampl;

		if (! e_dci_unavailable) {
			if (state!=STATE_NORMAL) {
				state=STATE_NORMAL;
				e_set_led(8, 0);
				e_set_body_led(0);
			}
		}

		if (amplavg<1000) {
			if (state!=STATE_FREEFALL) {
				state=STATE_FREEFALL;
				e_stop_flag=1;
				while (e_dci_unavailable);
//				sprintf(buffer, "Free fall: %ld, (%d, %d, %d) -> (%ld)\r\n", amplavg, accx, accy, accz, ampl);
//				e_send_uart1_char(buffer, strlen(buffer));
				e_play_sound(11028, 8016);
				e_set_body_led(1);
				e_set_led(8, 0);
			}
		} else if (amplavg>4000000) {
			if (state!=STATE_SHOCK) {
				state=STATE_SHOCK;
				e_stop_flag=1;
				while (e_dci_unavailable);
//				sprintf(buffer, "Shock: %ld, (%d, %d, %d) -> (%ld)\r\n", amplavg, accx, accy, accz, ampl);
//				e_send_uart1_char(buffer, strlen(buffer));
				soundsel=(accx & 3);
				if (soundsel==0) {
					e_play_sound(0, 2112);
				} else if (soundsel==1) {
					e_play_sound(2116, 1760);
				} else {
					e_play_sound(3878, 3412);
				}
				e_set_body_led(0);

				angle=atan2(accy, accx);
				lednum=floor(atan2(accy, accx)/PI*4+PI/2+PI/8);
				while (lednum>8) {lednum=lednum-8;}
				while (lednum<0) {lednum=lednum+8;}
//				sprintf(buffer, "(x=%d, y=%d) -> angle=%f, led=%d\r\n", accx, accy, angle, lednum);
//				e_send_uart1_char(buffer, strlen(buffer));
				e_set_led(lednum, 1);
			}
		}
	}
}
Esempio n. 6
0
int main()
{
    // init robot
    e_init_port();
    e_init_ad_scan();
    e_init_uart1();
    e_led_clear();
    e_init_motors();
    e_start_agendas_processing();

    // initialise buffer
    int k;
    for (k = 0; k < NB_NEIGHBOURS; k++)
        neighbours[k].id = -1;


    // wait for s to start
    /*     btcomWaitForCommand('s'); */

    btcomSendString("-OK-\n");

    e_calibrate_ir();

    // initialize ircom, then rng and start listening
    ircomStart();
    //ircomEnableContinuousListening();
    //ircomEnableProximity();

    initRandomNumberGenerator();
    // after rng init we can disable prox sensors
    //ircomDisableProximity();
    ircomEnableContinuousListening();
    ircomListen();


    id = getselector();

    ircomResetTime();
    lastClock = ircomGetTime();

    // activate movement
    //e_activate_agenda(move, 2500);

    organiseInit();

    // advertise current direction
    e_led_clear();
    e_set_led(0,1);
    e_set_led(4,1);

    while(1)
    {
        int messageReceived = 0;
        while(((ircomGetTime() - lastClock < COM_CYCLE_SPEED) || (ircomIsReceiving() == 1)))
        {
            IrcomMessage msg;
            ircomPopMessage(&msg);

            if (msg.error == 0)
            {
                processNewMessage(&msg);
                messageReceived = 1;
                SetRobotSeen(msg);
            }
        }
        e_set_body_led(messageReceived);


        SendData();
        //sendId();
        //sendAngleToNeighbours();
        lastClock = ircomGetTime();

        e_set_body_led(0);
    }

    ircomStop();
    return 0;
}
Esempio n. 7
0
int run_asercom(void) {
	static char c1,c2,wait_cam=0;
	static int	i,j,n,speedr,speedl,positionr,positionl,LED_nbr,LED_action,accx,accy,accz,sound;
	static int cam_mode,cam_width,cam_heigth,cam_zoom,cam_size,cam_x1,cam_y1;
	static char first=0;
	char *ptr;
	static int mod, reg, val;
#ifdef IR_RECEIVER
	char ir_move = 0,ir_address= 0, ir_last_move = 0;
#endif
	static TypeAccSpheric accelero;
	//static TypeAccRaw accelero_raw;
	int use_bt=0;
	//e_init_port();    // configure port pins
	//e_start_agendas_processing();
	e_init_motors();
	//e_init_uart1();   // initialize UART to 115200 Kbaud
	//e_init_ad_scan();

	selector = getselector(); //SELECTOR0 + 2*SELECTOR1 + 4*SELECTOR2 + 8*SELECTOR3;
	if(selector==10) {
		use_bt=0;
	} else {
		use_bt=1;
	}

#ifdef FLOOR_SENSORS
	if(use_bt) {	// the I2C must remain disabled when using the gumstix extension
		e_i2cp_init();
	}
#endif

#ifdef IR_RECEIVER
	e_init_remote_control();
#endif
	if(RCONbits.POR) {	// reset if power on (some problem for few robots)
		RCONbits.POR=0;
		RESET();
	}
	/*read HW version from the eeprom (last word)*/
	static int HWversion=0xFFFF;
	ReadEE(0x7F,0xFFFE,&HWversion, 1);

	/*Cam default parameter*/
	cam_mode=RGB_565_MODE;
	cam_width=40; // DEFAULT_WIDTH;
	cam_heigth=40; // DEFAULT_HEIGHT;
	cam_zoom=8;
	cam_size=cam_width*cam_heigth*2;

	if(use_bt) {
		e_poxxxx_init_cam();
		//e_po6030k_set_sketch_mode(E_PO6030K_SKETCH_COLOR);
		e_poxxxx_config_cam((ARRAY_WIDTH -cam_width*cam_zoom)/2,(ARRAY_HEIGHT-cam_heigth*cam_zoom)/2,cam_width*cam_zoom,cam_heigth*cam_zoom,cam_zoom,cam_zoom,cam_mode);
		e_poxxxx_set_mirror(1,1);
		e_poxxxx_write_cam_registers();
	}
	
	e_acc_calibr();
	
	if(use_bt) {
	uart1_send_static_text("\f\a"
			"WELCOME to the SerCom protocol on e-Puck\r\n"
			"the EPFL education robot type \"H\" for help\r\n");
	} else {
	uart2_send_static_text("\f\a"
			"WELCOME to the SerCom protocol on e-Puck\r\n"
			"the EPFL education robot type \"H\" for help\r\n");
	}


	while(1) {
		if(use_bt) {
			while (e_getchar_uart1(&c)==0)
			#ifdef IR_RECEIVER
					{
						ir_move = e_get_data();
						ir_address = e_get_address();
						if (((ir_address ==  0)||(ir_address ==  8))&&(ir_move!=ir_last_move)){
							switch(ir_move) {
								case 1:
									speedr = SPEED_IR;
									speedl = SPEED_IR/2;
									break;
								case 2:
									speedr = SPEED_IR;
									speedl = SPEED_IR;
									break;
								case 3:
									speedr = SPEED_IR/2;
									speedl = SPEED_IR;
									break;
								case 4:
									speedr = SPEED_IR;
									speedl = -SPEED_IR;
									break;
								case 5:
									speedr = 0;
									speedl = 0;
									break;
								case 6:
									speedr = -SPEED_IR;
									speedl = SPEED_IR;
									break;
								case 7:
									speedr = -SPEED_IR;
									speedl = -SPEED_IR/2;
									break;
								case 8:
									speedr = -SPEED_IR;
									speedl = -SPEED_IR;
									break;
								case 9:
									speedr = -SPEED_IR/2;
									speedl = -SPEED_IR;
									break;
								case 0:
									if(first==0){
										e_init_sound();
										first=1;
									}
									e_play_sound(11028,8016);
									break;
								default:
									speedr = speedl = 0;
							}
							ir_last_move = ir_move;
							e_set_speed_left(speedl);
							e_set_speed_right(speedr);
							}
					}
			#else 
					;
			#endif
		} else {
			while (e_getchar_uart2(&c)==0)
			#ifdef IR_RECEIVER
					{
						ir_move = e_get_data();
						ir_address = e_get_address();
						if (((ir_address ==  0)||(ir_address ==  8))&&(ir_move!=ir_last_move)){
							switch(ir_move) {
								case 1:
									speedr = SPEED_IR;
									speedl = SPEED_IR/2;
									break;
								case 2:
									speedr = SPEED_IR;
									speedl = SPEED_IR;
									break;
								case 3:
									speedr = SPEED_IR/2;
									speedl = SPEED_IR;
									break;
								case 4:
									speedr = SPEED_IR;
									speedl = -SPEED_IR;
									break;
								case 5:
									speedr = 0;
									speedl = 0;
									break;
								case 6:
									speedr = -SPEED_IR;
									speedl = SPEED_IR;
									break;
								case 7:
									speedr = -SPEED_IR;
									speedl = -SPEED_IR/2;
									break;
								case 8:
									speedr = -SPEED_IR;
									speedl = -SPEED_IR;
									break;
								case 9:
									speedr = -SPEED_IR/2;
									speedl = -SPEED_IR;
									break;
								case 0:
									if(first==0){
										e_init_sound();
										first=1;
									}
									e_play_sound(11028,8016);
									break;
								default:
									speedr = speedl = 0;
							}
							ir_last_move = ir_move;
							e_set_speed_left(speedl);
							e_set_speed_right(speedr);
							}
					}
			#else 
					;
			#endif
		}

		if (c<0) { // binary mode (big endian)
			i=0;
			do {
				switch(-c) { 
        		case 'a': // Read acceleration sensors in a non
                  // filtered way, some as ASCII
          			accx = e_get_acc_filtered(0, 1); 
          			accy = e_get_acc_filtered(1, 1); 
          			accz = e_get_acc_filtered(2, 1); 
				
				//accx = e_get_acc(0);	//too much noisy
				//accy = e_get_acc(1);
				//accz = e_get_acc(2);

				buffer[i++] = accx & 0xff;
          			buffer[i++] = accx >> 8;
          			buffer[i++] = accy & 0xff;
          			buffer[i++] = accy >> 8;
          			buffer[i++] = accz & 0xff;
          			buffer[i++] = accz >> 8;
				
				/*
          			accelero_raw=e_read_acc_xyz();
				ptr=(char *)&accelero_raw.acc_x;
				buffer[i++]=(*ptr);
				ptr++;
				buffer[i++]=(*ptr);
				ptr++;

				ptr=(char *)&accelero_raw.acc_y;
				buffer[i++]=(*ptr);
				ptr++;
				buffer[i++]=(*ptr);
				ptr++;

				ptr=(char *)&accelero_raw.acc_z;
				buffer[i++]=(*ptr);
				ptr++;
				buffer[i++]=(*ptr);
				ptr++;
				*/
          			break;
				case 'A': // read acceleration sensors
					accelero=e_read_acc_spheric();
					ptr=(char *)&accelero.acceleration;
					buffer[i++]=(*ptr);
					ptr++;
					buffer[i++]=(*ptr);
					ptr++;
					buffer[i++]=(*ptr);
					ptr++;
					buffer[i++]=(*ptr);
				
					ptr=(char *)&accelero.orientation;
					buffer[i++]=(*ptr);
					ptr++;
					buffer[i++]=(*ptr);
					ptr++;
					buffer[i++]=(*ptr);
					ptr++;
					buffer[i++]=(*ptr);
		
					ptr=(char *)&accelero.inclination;
					buffer[i++]=(*ptr);
					ptr++;
					buffer[i++]=(*ptr);
					ptr++;
					buffer[i++]=(*ptr);
					ptr++;
					buffer[i++]=(*ptr);
				
					break;
				case 'b': // battery ok?
					buffer[i++] = BATT_LOW;
					break;
				case 'D': // set motor speed
					if(use_bt) {
						while (e_getchar_uart1(&c1)==0);
						while (e_getchar_uart1(&c2)==0);
					} else {
						while (e_getchar_uart2(&c1)==0);
						while (e_getchar_uart2(&c2)==0);
					}
					speedl=(unsigned char)c1+((unsigned int)c2<<8);
					if(use_bt) {
						while (e_getchar_uart1(&c1)==0);
						while (e_getchar_uart1(&c2)==0);
					} else {
						while (e_getchar_uart2(&c1)==0);
						while (e_getchar_uart2(&c2)==0);					
					}
					speedr=(unsigned char)c1+((unsigned  int)c2<<8);
					e_set_speed_left(speedl);
					e_set_speed_right(speedr);
					break;
        		case 'E': // get motor speed
          			buffer[i++] = speedl & 0xff;
          			buffer[i++] = speedl >> 8;
          			buffer[i++] = speedr & 0xff;
          			buffer[i++] = speedr >> 8;
          			break;
				case 'I': // get camera image
					if(use_bt) {
						e_poxxxx_launch_capture(&buffer[i+3]);
						wait_cam=1;
						buffer[i++]=(char)cam_mode&0xff;//send image parameter
						buffer[i++]=(char)cam_width&0xff;
						buffer[i++]=(char)cam_heigth&0xff;
						i+=cam_size;
					}
					break;
				case 'L': // set LED
					if(use_bt) {
						while (e_getchar_uart1(&c1)==0);
						while (e_getchar_uart1(&c2)==0);
					} else {
						while (e_getchar_uart2(&c1)==0);
						while (e_getchar_uart2(&c2)==0);
					}
					switch(c1) {
						case 8:
							if(use_bt) {
								e_set_body_led(c2);
							}
							break;
						case 9:
							if(use_bt) {
								e_set_front_led(c2);
							}
							break;
						default:
							e_set_led(c1,c2);
							break;
					}
					break;
				case 'M': // optional floor sensors
#ifdef FLOOR_SENSORS
					if(use_bt) {
	          			e_i2cp_init();
	          			e_i2cp_enable();
	          			e_i2cp_read(0xC0, 0);
	          			for(j = 0; j < 6; j++) {
	            			if (j % 2 == 0) buffer[i++] = e_i2cp_read(0xC0, j + 1);
	            			else            buffer[i++] = e_i2cp_read(0xC0, j - 1);
	          			}
#ifdef CLIFF_SENSORS
          				for(j=13; j<17; j++) {
            				if (j % 2 == 0) buffer[i++] = e_i2cp_read(0xC0, j - 1);
            				else            buffer[i++] = e_i2cp_read(0xC0, j + 1);	          				
	          			}
#endif
	          			e_i2cp_disable();
					}
#else
					for(j=0;j<6;j++) buffer[i++]=0;
#endif
					break;
				case 'N': // read proximity sensors
					if(use_bt) {
						for(j=0;j<8;j++) {
							n=e_get_calibrated_prox(j);	// or ? n=e_get_prox(j);
							buffer[i++]=n&0xff;
							buffer[i++]=n>>8;
						}
					} else {
						for(j=0;j<10;j++) {
							n=e_get_calibrated_prox(j);	// or ? n=e_get_prox(j);
							buffer[i++]=n&0xff;
							buffer[i++]=n>>8;
						}
					}
					break;
				case 'O': // read light sensors
					if(use_bt) {
						for(j=0;j<8;j++) {
	
							n=e_get_ambient_light(j);
							buffer[i++]=n&0xff;
							buffer[i++]=n>>8;
						}
					} else {
						for(j=0;j<10;j++) {
							n=e_get_ambient_light(j);
							buffer[i++]=n&0xff;
							buffer[i++]=n>>8;
						}
					}
					break;
				case 'Q': // read encoders
                    n=e_get_steps_left();
					buffer[i++]=n&0xff;
					buffer[i++]=n>>8;
                    n=e_get_steps_right();
					buffer[i++]=n&0xff;
					buffer[i++]=n>>8;
					break;
        		case 'u': // get last micro volumes
          			n = e_get_micro_volume(0);
          			buffer[i++] = n & 0xff;
          			buffer[i++] = n >> 8;

          			n = e_get_micro_volume(1);
          			buffer[i++] = n & 0xff;
          			buffer[i++] = n >> 8;

          			n = e_get_micro_volume(2);
          			buffer[i++] = n & 0xff;
          			buffer[i++] = n >> 8;
          			break;
				case 'U': // get micro buffer
					ptr=(char *)e_mic_scan;
					if(use_bt) {
						e_send_uart1_char(ptr,600);//send sound buffer
					} else {
						e_send_uart2_char(ptr,600);//send sound buffer
					}
					n=e_last_mic_scan_id;//send last scan
					buffer[i++]=n&0xff;
					break;
				default: // silently ignored
					break;
				}
				if(use_bt) {
					while (e_getchar_uart1(&c)==0); // get next command
				} else {
					while (e_getchar_uart2(&c)==0); // get next command
				}
			} while(c);