Esempio n. 1
0
/* Calculate backemf and save in g_pos

*/
void calculate_backemf (uint8_t motor)
{
     int16_t backemf=0;
  // Read backemf
		adc_init(3);
		backemf = read_adc(0x10);		
		if (backemf & 0x200)
		{
		    backemf = (~(backemf) & (0x03FF))+1;
//			backemf -= 512; 
		}
		if (backemf  < MOTOR_OFFSET)
			backemf = 0;
 
		g_pos[motor] += backemf;
	if (g_mode[motor] != MOTOR_STOP)	
 		debug_value(backemf,10);
 
//Compare voltage	
	if (((g_angle[motor] > 1)) && ( g_mode[motor] != MOTOR_STOP))
	{   
			if ( g_pos[motor]  >= (g_angle[motor]))  //  Check for position
			{
 				motor_control(1, MOTOR_BRAKE);
				delay(3);
				g_mode[motor] = MOTOR_STOP;
				uart_puts ("Voltage SUM");
				debug_value(g_pos[motor],10);
				g_pos[motor] =0;				
			}
	}		
}
Esempio n. 2
0
void File::plan() {

  debug_value("Vykdomas failo planuotojas: ", this->id);
  debug_value("Failo vardas: ", this->file_name);
  
  if (!this->is_free()) {
    debug_string("\tFailas užimtas.\n");
    return;
    }

  while (!this->process_queue.is_empty()) {

    ProcessContainer container = process_queue.pop_front();

    if (container.process_id == 0) {
      debug_string("\tProcesas jau nebegyvas.\n");
      }
    else {
      this->set_free(false);
      this->reset();
      this->file_manager->give_file(
          container.process_id, this->id, container.mode);
      this->file_manager->activate_process(container.process_id);

      debug_value("\tAtiduotas procesui: ", container.process_id);
      break;
      }

    }

  }
Esempio n. 3
0
File: eval.c Progetto: Pilen/ubertex
Value eval(Value expression, Environment *environment) {
    switch (expression.type) {
        /* Self evaluating: */
    case ERROR:
    case NIL:
    case INTEGER:
    case FLOAT:
    case STRING:
    case VECTOR:
    case HASH:
    case LAMBDA: // Evaluation is not the same as calling
    default:
        return expression;
    case SYMBOL: {
        Value result;
        Bool found = environment_lookup_variable(expression, &result, environment);
        if (found) {
            return result;
        } else {
            /* TODO: log error */
            /* TODO: "Did you mean?" */
            debug_value(expression);
            log_error("Variable XXX not found");
            return VALUE_ERROR;
        }
    }
    case CONS:
        return eval_list(expression, environment);
    }
}
Esempio n. 4
0
File: eval.c Progetto: Pilen/ubertex
Value eval_list(Value expression, Environment *environment) {
    w_assert(expression.type == CONS);

    Bool lambda_call = false;
    Value function_symbol = NEXT(expression);
    Value lambda;
    Function *function;

    if (function_symbol.type == CONS) {
        if (CAR(function_symbol).type == SYMBOL &&
            CAR(function_symbol).val.symbol_val == symbols_lambda.val.symbol_val) {
            lambda = eval(function_symbol, environment);
            lambda_call = true;
        } else {
            return VALUE_ERROR;
        }
    } else if (function_symbol.type == LAMBDA) {
        lambda = function_symbol;
        lambda_call = true;
    } else if (function_symbol.type == SYMBOL) {
        Value function_value;
        Bool found = hash_get(environment -> functions, function_symbol, &function_value);
        if (!found) {
            /* TODO: log error */
            /* TODO: "Did you mean?" */
            debug_value(function_symbol);
            log_error("Function XXX not found");
            return VALUE_ERROR;
        }
        w_assert(function_value.type == FUNCTION);
        function = function_value.val.function_val;
    } else {
        return VALUE_ERROR;
    }

    Value args;
    if (lambda_call || function -> eval) {
        args = VALUE_NIL;
        while (expression.type == CONS) {
            Value arg = NEXT(expression);
            args = CONS(eval(arg, environment), args);
        }
        args = list_reverse(args);
        w_assert(expression.type == NIL);

        /* TODO: benchmark, which approach is better, the above or below? */

        /* if (expression.type == CONS) { */
        /*     args = CONS1(VALUE_NIL); */
        /* } else { */
        /*     args = expression; */
        /* } */
        /* Cons *top = args.val.cons_val; */
        /* while (true) { */
        /*     Value arg = NEXT(expression); */
        /*     top -> car = eval(arg, environment); */
        /*     if (expression.type == CONS) { */
        /*         top -> cdr = CONS1(VALUE_NIL); */
        /*         top = top -> cdr.val.cons_val; */
        /*     } else { */
        /*         top -> cdr = expression; */
        /*         break; */
        /*     } */
        /* } */
    } else {
        /* To ensure we avoid mutation in altering code the list is copied
           If we guaranteed that no function with eval = false modifies the list we could give it directly
           This would be an obvious performance optimization. But needs tests.
           We can only guarantee this for c_code, not for userdefined macros.
           TODO: Do this */
        args = list_copy(expression);
    }

    Value result;
    if (lambda_call) {
        result = eval_lambda(lambda, args, environment);
    } else {
        result = eval_apply(function_symbol, function, args, environment);
    }
    list_destroy(args);
    return result;
}
Esempio n. 5
0
int16_t cmd_decode (uint8_t *buffer_ptr)
{

 uint8_t  cmd_no =0;
 uint8_t  *cmd_argument;
 uint8_t   i,j ;
 
// Should repeat until end of buffer
 
// Loop until end of text

   cmd_argument = buffer_ptr;
     
   while ( cmd_no !=  CMD_LINE_END)     // Until end of line which mean g_motor will change
   {
 		cmd_no =  text_decode (buffer_ptr,cmd_argument);
#ifdef DEBUG		
		uart_puts("Command :");
 		uart_putc(0x30+cmd_no);
 		uart_putc('*');
 		uart_puts(cmd_argument);
#endif        
 		switch (cmd_no)
		{
			case MOTOR_CMD: 
				g_motor = (uint8_t)atoi(cmd_argument);
				if (g_motor > 0)
				   g_motor--;                //  > 0 Start from 0 need -1
				else
				   g_motor = 0;
 				break;
			case  SPEED_CMD:	
				i = (uint8_t)atoi(cmd_argument);
				if ( i >=  MOTOR_MAX_SPEED)
						i = MOTOR_MAX_SPEED;    // Start from 0
				if (i)   // i > 0; 		
					i--;   //Start from 0;		
				g_speed[g_motor] =  g_speed_table[i];
				if (g_speed[g_motor] == 0)
				        g_mode[g_motor] = MOTOR_STOP;
  				break;
			case  ANGLE_CMD:   // Can be - 	             			 
     			g_angle[g_motor] = atoi(cmd_argument);
				if (g_angle[g_motor] < 0)
				{   
						g_mode[g_motor] = MOTOR_BACKWARD;
 
// Set g_angle to positive value by invert all bit and +1                
                        g_angle[g_motor] = (~(g_angle[g_motor])+1);
                        if  (g_angle[g_motor] > 1)
						{
 						   g_angle[g_motor] *= MOTOR_ANGLE_COEF;
						   g_status[g_motor] = 1;
 						   g_speed[g_motor] = g_speed_table[MOTOR_ANGLE_SPEED] ;
						}		
				}	
				else  if (g_angle[g_motor] == 0)
				       {  	
							g_mode[g_motor] = MOTOR_STOP;
 					   }
				else	  
				{
					if ((g_angle[g_motor] > 0))   //  +
					{
						g_mode[g_motor] = MOTOR_FORWARD;
 					}
					if  (g_angle[g_motor] > 1)
					{
 						g_angle[g_motor] *=  MOTOR_ANGLE_COEF;	
						g_status[g_motor] = 1;
  						g_speed[g_motor]  = g_speed_table[MOTOR_ANGLE_SPEED] ;
					}
 				}
                g_pos[g_motor] = 0;
				break;	
			case PROGRAM_CMD:
				g_program_flag = (uint8_t)atoi(cmd_argument);
				if (g_program_flag)   // Start  program save in buffer
				{
					uart_puts ("Program Start to save : ");
				     g_program_index = 0;
				}
				else
				{  
					uart_puts ("Program End : ");
				}
				break;
 			case SAVE_CMD:
				j = (uint8_t)atoi(cmd_argument);
				if ( j > 0)    // Save commmand to eeprom
                {
					g_program_buff[g_program_index] = 0x00 ;  // Put null at the end
                    g_program_index++;   
                    for ( i =0; i < g_program_index; i++)
                    {
						while (!eeprom_is_ready());
							eeprom_write_byte(&g_program_eeprom[i],g_program_buff[i]);
					}
					debug_value( g_program_index,10);
					uart_puts ("Save complete ");
					g_program_index = 0;	
				}
				break;
		    case RUN_CMD:
			    program_run();
			    break;
 			default:
			    uart_putc(0x0D);
				uart_putc(0x0A);
 		        break;	  
		}		
    }
 
 return 0; 
}
Esempio n. 6
0
void main()
{
  uint8_t sw1,sw2;
  uint16_t  memaddr = 0;   // Start memory Address
  uint8_t  dat,c,i;
  
 /*
 *  Initialize UART library, pass baudrate and AVR cpu clock
 *  with the macro 
 *  UART_BAUD_SELECT() (normal speed mode )
 *  or 
 *  UART_BAUD_SELECT_DOUBLE_SPEED() ( double speed mode)
*/
  DDRC = 0xFC;
  uart_init(); 
 
  
  d7segment_init();
  i2ceeprom_init();
//  i2c_set_localdeviceaddr(I2C_EEPROM_MASTER_ADDR,FALSE);
//  i2c_set_localdeviceaddr(I2C_EEPROM_SLAVE_ADDR,FALSE);

  sei();
// To Wrie and read the same device. Need to delay. Maybe the wait state is not correct.... 
//  dat = 0x44;
//  memaddr = 0;
//  i2ceeprom_write_byte(I2C_EEPROM_SLAVE_ADDR, memaddr,dat);
//  debug_value (dat,16); 
//  	_delay_ms(20);
//  dat = i2ceeprom_read_byte(I2C_EEPROM_SLAVE_ADDR,memaddr);
//  debug_value (dat,16); 
 			

		
 
  while (1)
  {
 		
		
   sw1 = _7SEGMENT_SW1_IN_PORT & _7SEGMENT_SW1; 
   sw2 = _7SEGMENT_SW2_IN_PORT & _7SEGMENT_SW2; 
     
  
 // Delay
   
   if (!sw1) // Start copy eeprom 
    {   	
        i = 0;
		for (memaddr = 0  ; memaddr < E_24LC32_MEM_ADDR ;memaddr++)
		{
   
			dat = i2ceeprom_read_byte(I2C_EEPROM_MASTER_ADDR,memaddr);

			debug_value (dat,16); 
 			i2ceeprom_write_byte(I2C_EEPROM_SLAVE_ADDR, memaddr,dat);
//			_delay_ms( EEPROM_DELAY);
	          
			if (i < 100)
			{
				c =0;
			}
			if (i > 100) 
			{
				c ='-';			
            }			
			if (i > 200)
				i = 0;
			
			d7segment_display(c,1);
			_delay_ms(2);
			d7segment_display(c,2);
			_delay_ms(2);
			
		    i++;
   
		}  

//	

	}
// Finish copy   	
   	d7segment_display(0,2);
	_delay_ms( 10);
	d7segment_display(0,1);
	_delay_ms( 10);
    
  }
     
}
Esempio n. 7
0
/* Calculate backemf and save in g_pos

*/
void calculate_backemf (uint8_t motor)
{
     int16_t backemf=0;
  // Read backemf
     static uint8_t  i = 0;

	adc_init(1);
	backemf = read_adc(g_adc_channel[motor]);	


// Cut offset	
	if ((backemf > 0) && (backemf < MOTOR_OFFSET))
			backemf =0;
			
// Negative convert to positive with 2 complement	
	if (g_mode[motor] == MOTOR_STOP)   
    {	
		if (backemf & 0x200)
		{
		    backemf = (~(backemf) & (0x03FF))+1;
 		}		
	}		
			
	if (g_mode[motor] == MOTOR_FORWARD)   // Motor stop backemf -  Forward backemf +
    {	
		if (backemf & 0x200)
		{
		    backemf = (~(backemf) & (0x03FF))+1;
 		}
		else
			backemf = 0;
    }
	if (g_mode[motor] == MOTOR_BACKWARD)   // Motor stop backemf +  backward backemf -
    {	
		if (backemf & 0x200)
		{
			backemf =0;
		}
    }
	
	g_pos[motor] += backemf;
    if (g_mode[motor] != MOTOR_STOP)	
 	{   
	    i++;
		if (i == 100 )
		{
		    uart_putc(motor+0x30);
			uart_putc('-');
			debug_value(backemf,10);
			i = 0;
		}
	}	
//Compare voltage	
	if (((g_angle[motor] > 1)) && ( g_mode[motor] != MOTOR_STOP))
	{   
			if ( g_pos[motor]  >= (g_angle[motor]))  //  Check for position
			{
//				delay(3);
				g_mode[motor] = MOTOR_STOP;
				uart_puts ("Voltage SUM");
				debug_lvalue(g_pos[motor],10);
				g_pos[motor] =0;				
			}
	}
    		
}