Example #1
0
void
input_state_first(u_char ch, struct input_ctx *ictx)
{
	ictx->intermediate = '\0';

	if (INPUT_C0CONTROL(ch)) {
		if (ch == 0x1b)
			input_state(ictx, input_state_escape);
		else
			input_handle_c0_control(ch, ictx);
		return;
	}

#if 0
  	if (INPUT_C1CONTROL(ch)) {
		ch -= 0x40;
		if (ch == '[')
			input_state(ictx, input_state_sequence_first);
		else if (ch == ']') {
			input_start_string(ictx, STRING_SYSTEM);
			input_state(ictx, input_state_string_next);
		} else if (ch == '_') {
			input_start_string(ictx, STRING_APPLICATION);
			input_state(ictx, input_state_string_next);
		} else
			input_handle_c1_control(ch, ictx);
		return;
	}
#endif

	if (INPUT_DELETE(ch))
		return;

	input_handle_character(ch, ictx);
}
Example #2
0
void main(void)
{	
	printf("System enabled\n\r");
	Motor_Init(PWM_PERIOD);
    enable_interrupts(INT_RDA);		
	//enable_interrupts(INT_EXT0);
	//ext_int_edge(L_TO_H);
    while(true)
	{
		Set_Motor_Duty(0,0);
		while(!input_state(PIN_F6)&&!RUN )//&& !RUN)   //While loop used for waiting an input high  in D8 to start
   		{
			output_toggle(PIN_E2);
      		delay_ms(15);
			Read_Sensors_Digital(sensors_BIN);
			Get_Average_Center_Digital(sensors_BIN,2,12,&center); 
			printf("%c\n\r",(center+65));
   		}
		output_high(PIN_E2);
		delay_ms(2000);
		if(!RUN) RUN=0xFF;
		while(RUN){
			//output_toggle(PIN_E2); 
         	Read_Sensors_Digital(sensors_BIN);
         	Get_Average_Center_Digital(sensors_BIN,2,12,&center); 
         	if(center==-1)	center=last_center;
			Print_Center(center);
		 	last_center=center;
      	 	error=SET_POINT-center;
		 	derivative=error-last_error;
			//if(derivative<-6||derivative>6) {derivative=0; error=last_error;}
		 	if(error>4 || error<-4) integral=integral+error;
			else integral=0;
			if(integral>100) integral=100;
			if(integral*(-1)>100) integral=-100;
	     	correction=error*(KP)+derivative*(KD)+integral*(KI);
		 	last_error=error;

		   	if(center>13 && center<19 && BoostCounter<24) 
			{
				BoostCounter++;
				if(BoostCounter>3) base_speed=1400; //set_motor_pwm_duty(3,3,2500);correction=0 ;//Boost=499-BaseSpeed;
			}	
		    else
			{
				BoostCounter=0; base_speed=1000;//set_motor_pwm_duty(3,3,2650);}
			}

         	left_correction=(base_speed)-correction;
     	 	right_correction=(base_speed)+correction;      
			Set_Motor_Duty(left_correction,right_correction);
	  		delay_us(delay_time);
			printf("%c\n\r",(center+65));
			//for(i=2;i<=12;i++)printf("%d",Sensors_BIN[i]);
			//printf("%c\n",(center+65));
		}
   }
}
Example #3
0
static int16_t core_input_state_poll(unsigned port,
      unsigned device, unsigned idx, unsigned id)
{
   if (current_core.poll_type == POLL_TYPE_LATE)
   {
      if (!current_core.input_polled)
         input_poll();

      current_core.input_polled = true;
   }
   return input_state(port, device, idx, id);
}
Example #4
0
int8 in_read_charlieplex_inputs()
{
	int8 switches;

	output_drive(PI_CHARLIEPLEX_SWITCH_1_PIN);
	switches = input_state(PI_CHARLIEPLEX_SWITCH_3_PIN);
	switches <<= 1;
	switches |= input_state(PI_CHARLIEPLEX_SWITCH_2_PIN);
	output_high(PI_CHARLIEPLEX_SWITCH_1_PIN);
	output_float(PI_CHARLIEPLEX_SWITCH_1_PIN);
	output_low(PI_CHARLIEPLEX_SWITCH_1_PIN);

	output_drive(PI_CHARLIEPLEX_SWITCH_2_PIN);
	switches <<= 1;
	switches |= input_state(PI_CHARLIEPLEX_SWITCH_3_PIN);	
	switches <<= 1;
	switches |= input_state(PI_CHARLIEPLEX_SWITCH_1_PIN);
	output_high(PI_CHARLIEPLEX_SWITCH_2_PIN);
	output_float(PI_CHARLIEPLEX_SWITCH_2_PIN);
	output_low(PI_CHARLIEPLEX_SWITCH_2_PIN);

	//Note: In this block charliplex1 must be read before charliplex2
	// just to charliplex2 has enough time to recover because charliplex2 was 
	// low in previous block. This avoid to put a delay here.
	output_drive(PI_CHARLIEPLEX_SWITCH_3_PIN);
	switches <<= 1;
	switches |= input_state(PI_CHARLIEPLEX_SWITCH_1_PIN);
	switches <<= 1;
	switches |= input_state(PI_CHARLIEPLEX_SWITCH_2_PIN);
	output_high(PI_CHARLIEPLEX_SWITCH_3_PIN);
	output_float(PI_CHARLIEPLEX_SWITCH_3_PIN);
	output_low(PI_CHARLIEPLEX_SWITCH_3_PIN);

	return ~switches;
}
Example #5
0
void
input_state_escape(u_char ch, struct input_ctx *ictx)
{
	/* Treat C1 control and G1 displayable as 7-bit equivalent. */
	if (INPUT_C1CONTROL(ch) || INPUT_G1DISPLAYABLE(ch))
		ch &= 0x7f;

	if (INPUT_C0CONTROL(ch)) {
		input_handle_c0_control(ch, ictx);
		return;
	}

	if (INPUT_INTERMEDIATE(ch)) {
		log_debug2(":: in1 %zu: %hhu (%c)", ictx->off, ch, ch);
		ictx->intermediate = ch;
		input_state(ictx, input_state_intermediate);
		return;
	}

	if (INPUT_PARAMETER(ch)) {
		input_state(ictx, input_state_first);
		input_handle_private_two(ch, ictx);
		return;
	}

	if (INPUT_UPPERCASE(ch)) {
		if (ch == '[')
			input_state(ictx, input_state_sequence_first);
		else if (ch == ']') {
			input_start_string(ictx, STRING_SYSTEM);
			input_state(ictx, input_state_string_next);
		} else if (ch == '_') {
			input_start_string(ictx, STRING_APPLICATION);
			input_state(ictx, input_state_string_next);
		} else {
			input_state(ictx, input_state_first);
			input_handle_c1_control(ch, ictx);
		}
		return;
	}

	if (INPUT_LOWERCASE(ch)) {
		input_state(ictx, input_state_first);
		input_handle_standard_two(ch, ictx);
		return;
	}

	input_state(ictx, input_state_first);
}
Example #6
0
void
input_state_intermediate(u_char ch, struct input_ctx *ictx)
{
	if (INPUT_INTERMEDIATE(ch)) {
		/* Multiple intermediates currently ignored. */
		log_debug2(":: in2 %zu: %hhu (%c)", ictx->off, ch, ch);
		return;
	}

	if (INPUT_PARAMETER(ch)) {
		input_state(ictx, input_state_first);
		input_handle_private_two(ch, ictx);
		return;
	}

	if (INPUT_UPPERCASE(ch) || INPUT_LOWERCASE(ch)) {
		input_state(ictx, input_state_first);
		input_handle_standard_two(ch, ictx);
		return;
	}

	input_state(ictx, input_state_first);
}
Example #7
0
void
input_init(struct window_pane *wp)
{
	struct input_ctx	*ictx = &wp->ictx;

	ARRAY_INIT(&ictx->args);

	ictx->string_len = 0;
	ictx->string_buf = NULL;

 	memcpy(&ictx->cell, &grid_default_cell, sizeof ictx->cell);

	memcpy(&ictx->saved_cell, &grid_default_cell, sizeof ictx->saved_cell);
	ictx->saved_cx = 0;
	ictx->saved_cy = 0;

	input_state(ictx, input_state_first);
}
Example #8
0
int32 motores3(int32 pasos, int dir)
{
    int32 y=0;
    int1 status=1;
    output_low(PIN_A1);  //STEP
    (dir == 1)?output_high(PIN_A0):output_low(PIN_A0);
    delay_ms(100);
    for(y=0;y<pasos;y++)
    {
        output_low(PIN_A1);
        output_high(PIN_A1);
        status = input_state(PIN_A5);
        if (status == 0){
            printf("status sensor ->%d<-  \n\r",status);
            return y;
        }
        delay_us(200);
    }
    return y;
}
Example #9
0
int32 motores4(int32 pasos, int dir,int32 velocidad)
{
    int32 y=0;
    int1 status=1;
    output_low(PIN_A1);  //STEP
    (dir == 1)?output_high(PIN_A0):output_low(PIN_A0);
    delay_ms(velocidad);
    for(y=0;y<pasos;y++)
    {
        output_low(PIN_A1);
        output_high(PIN_A1);
        status = input_state(PIN_A5);
        if (status == 0){
            printf("status sensor ->%d<-  \n\r",status);
            return y;
        }
        delay_us(velocidad);
    }
    //printf("return pasos dados ->%Ld<-  \n\r",y);
    return y;
}
Example #10
0
void in_encoder_read_and_update()
{
	int1 channelA = input_state(PI_ENCODER_A_PIN);
	int1 channelB = input_state(PI_ENCODER_B_PIN);
	encoder_update( channelA, channelB );
}
Example #11
0
//programa principal      
void main()
{
   set_tris_A(0x00);/* 0000 0000
      RA0   LED1   PIN   02
      RA1   LED2   PIN   03
      RA2   LED3   PIN   04
      RA3   LED4   PIN   05
      RA4   LED5   PIN   06
      RA5   LED6   PIN   07
   */
   set_tris_B(0x00);/* (0000 0000)
      RB0   LED7    PIN   40
      RB1   LED8    PIN   39
      RB2   LED9    PIN   38
      RB3   LED10   PIN   37
      RB4   LED11   PIN   36
      RB5   LED12   PIN   35
      RB6   LED13   PIN   34
      RB7   LED14   PIN   33
   */

   set_tris_C(0X00);/*
      
      RC0   -----   PIN   15
      RC1   -----   PIN   16   
      RC2   -----   PIN   17
      RC6   LED15   PIN   25
      RC7   LED16   PIN   26
   */

   // Configuración de Leds 17 hasta 20 y Pulsadores 1 y 2   
   set_tris_D(0X00);/*
      RD0   SW01    PIN   19 --->Pulsador 1
      RD1   SW02    PIN   20 --->Pulsador 2
      RD2   -----   PIN   21
      RD3   -----   PIN   22
      RD4   LED17   PIN   27
      RD5   LED18   PIN   28
      RD6   LED19   PIN   29
      RD7   LED20   PIN   30
   */

   
   set_tris_E(0x00);/* bits(**** 0000)
      RE0   -----   PIN   08 
      RE1   -----   PIN   09
      RE2   -----   PIN   10
      RE3   -----   PIN   01
   */

   //Habilitando y deshabilitando modulos...
   setup_timer_1(T1_disabled);
   setup_timer_2(T2_disabled,0,1);
   setup_timer_3(T3_disabled);
   setup_ccp1(CCP_OFF);
   setup_ADC(ADC_OFF);
   setup_VREF(FALSE);//no voltaje de referencia
   setup_COMPARATOR(NO_ANALOGS);//
   
   //limpie los puertos
   OUTPUT_A(0x00);
   OUTPUT_B(0x00);
   OUTPUT_C(0X00);
   OUTPUT_D(0X00);

   //limpiar registros, probar limpiar todos los registros en assembler con =0
   //#ZERO_RAM 
   limpiarRegistros();

   /*condicional para lanzar secuencia cuando
     el pulsador esté presionado. */
   output_float(SW01);
   output_float(SW02);
   while(TRUE)
   {
      if (input_state(SW01) == 1 && input_state(SW02) == 1)
      {
         secuencia1();
      }else if (input_state(SW01) == 0 && input_state(SW02) == 1)
      {
         secuencia2();
      }else if (input_state(SW01) == 1 && input_state(SW02) == 0)
      {
         secuencia4();
      }else
      {
      }
   }
   //vuelva a inicio y vuelva y arranque
   reset_cpu();
}
Example #12
0
//============================================================================================================
int main()
{
    
    int N; //system size
    cout <<"set system size: ";
    cin >>N;
    
    int m; //total magnetization counted in multiples of 1
    cout <<"set total magnetization (in multiples of 1/2): ";
    cin >>m;
    
    cout <<endl;


    bool testpos=0; //test the position finder of the states. Set to 1 for test.

    Hamiltonian testHam(N,m);

    
//Test der Suchfunktion:
    
    if (testpos){
        int pos=0;
        char* out;
         for(int i=0;i<testHam.get_dim();i++){
             REP_TYPE state = testHam.get_basis_state(i);
             pos = testHam.find_state(state); 
             out = int2bin(state,NULL);
             out = &(out[sizeof(REP_TYPE)*CHAR_BIT - N]); //cutoff string, borrowed from utilities.c
             cout <<"integer: " <<state<<" binary: "<<out<<" pos: "<<pos<<endl;
         }
    }
    

    cout <<"\n";
    testHam.print_basis_list();
    testHam.print_system_size();
    testHam.print_basis_dimension();
    cout <<"\n";

     
    //GROUND STATE:
    Hamiltonian h1(N,m);
    h1.set_ham(1,0); //mu=1.1
    h1.diagonalize();
    Hamiltonian h2(N,m);
    h2.set_ham(4,0);
    h2.diagonalize();
    plot_groundstate_quench(&h1,&h2,0.01,30);
     
   
     
    //state eingeben :
    char test[testHam.get_system_size()];
    cout << "insert initial state:"<<endl;
    cin.ignore();
    cin.getline(test,testHam.get_system_size()+1);
    cx_vec state=input_state(test,&testHam);
    cout <<"vector is: "<<endl;
    cout << state <<endl;

    testHam.set_ham(0,0);
    testHam.diagonalize();
    plot_lohschmidt_echo(&testHam,state,0.01,50);
     

    /* 
    double T=40; //60
    double dt=0.1; //0.02
    
    double mu=0;
    double lambda=0;
    
    
    while (lambda <= 1){
        testHam.set_ham(mu,lambda); // mu=0,Lambda=0
        cout <<endl<<"<><><><><><><><><><><><><><><><>diagonalisierung<><><><><><><><><><><><><><><>"<<endl<<endl;
        testHam.diagonalize();
        plot_sz(&testHam,state,dt,T);
        T-=5;
        lambda+=0.1;
    } 
    */

    /*(kollision)
    mu=0; 
    testHam.set_ham(mu,lambda); // mu=0,Lambda=0
    cout <<endl<<"<><><><><><><><><><><><><><><><>diagonalisierung<><><><><><><><><><><><><><><>"<<endl<<endl;
    testHam.diagonalize();
    plot_sz(&testHam,state,dt,T);
    mu=5;
    testHam.set_ham(mu,lambda); // mu=5,Lambda=0
    cout <<endl<<"<><><><><><><><><><><><><><><><>diagonalisierung<><><><><><><><><><><><><><><>"<<endl<<endl;
    testHam.diagonalize();
    plot_sz(&testHam,state,dt,T);
    */

    /* (two string)
    mu+=1;
    while (mu <= 3){
        testHam.set_ham(mu,lambda); // mu=0,Lambda=0
        cout <<endl<<"<><><><><><><><><><><><><><><><>diagonalisierung<><><><><><><><><><><><><><><>"<<endl<<endl;
        testHam.diagonalize();
        plot_sz(&testHam,state,dt,T);
        mu+=1;
    }
    */

    //(kurzzeit)
    testHam.set_ham(0,0);
    cout <<endl<<"<><><><><><><><><><><><><><><><>diagonalisierung<><><><><><><><><><><><><><><>"<<endl<<endl;
    testHam.diagonalize();
    plot_kurz_auto(&testHam,state,0.01,10);
    //plot_lohschmidt_echo(&testHam,state,0.01,10);  //(ham,dt,T)
    
    //plot_szsz_n(&testHam,state,1,0.1,10); //(ham,n,dt,T)
    

    /*
  int i=0;
    for (;;){
        cout << "enter component:"<<endl;
        cin.ignore();
        cin >> i;
        cout << i<<" th spin is "<<get_sz(string_to_state(test,testHam.get_system_size()),i,testHam.get_system_size())*1/2.<<endl;
    }
  */  

    return 0;
}