Example #1
1
int main(){
	signal(SIGINT, &sig_handler);

	uint16_t rotary_value = 0;
	float value = 0.0f;
	mraa_pwm_context pwm1;
	mraa_aio_context rotary;

	pwm1 = mraa_pwm_init(5);
	rotary = mraa_aio_init(0);

	if (rotary == NULL || pwm1 == NULL) {
		return 1;
		printf("Broken\n");
	 }

	mraa_pwm_period_ms(pwm1, 20);
	mraa_pwm_enable(pwm1, 1);


	while(isrunning){
		rotary_value = mraa_aio_read(rotary);
		//convert to 0.00 to 1.00 scale
		value = ((float) rotary_value)/102;

		//convert to 0.025 to 0.1 scale (avoid rattle)
		value = value/13.33;
		value = value + 0.025;
 if (value >= .25){
	 	mraa_pwm_enable(pwm1, 1);
		printf("%f\n", value);
		mraa_pwm_write(pwm1, value);
 }
 else{
//		mraa_pwm_write(pwm1, 0);
		mraa_pwm_enable(pwm1, 0);

	}
	}
		mraa_pwm_write(pwm1, 0.025f);
		mraa_pwm_enable(pwm1, 0);
	return 0;
}
void tb6612::diffDrive(float dcA, float dcB)
{
  _dcA=dcA;
  _dcB=dcB;
  if (dcA < 0)
  {
    revA();
    dcA *= -1;
  }
  else
  {
    fwdA();
  }
  if (dcB < 0)
  {
    revB();
    dcB *= -1;
  }
  else
  {
    fwdB();
  }
  mraa_pwm_write(_pwmA, dcA);
  mraa_pwm_write(_pwmB, dcB);
}
void speed_control(mraa_pwm_context in1, mraa_pwm_context in2, float speed) {
	speed = speed/100;                                  
        if (speed >= 0) {                                   
                mraa_pwm_write(in2, 1.0f);        
                mraa_pwm_write(in1, 1.0f - speed);
        }                                                   
        else if (speed < 0) {                               
                mraa_pwm_write(in1, 1.0f);        
                mraa_pwm_write(in2, 1.0f + speed);
        }    
}
void right_turn ()
{
	float speed1 = mraa_pwm_read(pwm1);
	float speed2 = mraa_pwm_read(pwm2);

	if (speed1 == speed2) {
		mraa_pwm_write(pwm2, speed2/3);
	}

	else if (speed2 > speed1) {
		mraa_pwm_write(pwm1, speed2);
		mraa_pwm_write(pwm2, speed1);
	}
}
Example #5
0
void set_B(float speed)
{
    if (speed > 0 && speed <= 1.0f) {
		mraa_pwm_write(pwm1, speed);
		forward_B();
    }
	else if (speed < 0 && speed >= -1.0f) {
		mraa_pwm_write(pwm1, -speed);
		reverse_B();
    }
    else
    {
		mraa_pwm_write(pwm1, 0.);
        brake_B();
    }
}
tb6612::tb6612():
  _dcA(0.0), _dcB(0.0)
{
  
  // _pwmA is pwm channel 0, on pin 20 in mraa
  _pwmA = mraa_pwm_init(20);
  mraa_pwm_period_us(_pwmA, 1000);
  mraa_pwm_enable(_pwmA, 1);
 
  // _pwmB is pwm channel 1, on pin 14 in mraa
  _pwmB = mraa_pwm_init(14);
  mraa_pwm_period_us(_pwmB, 1000);
  mraa_pwm_enable(_pwmB, 1);

  mraa_pwm_write(_pwmA, 0.01);
  mraa_pwm_write(_pwmB, 0.01);
  mraa_pwm_write(_pwmA, 0.0);
  mraa_pwm_write(_pwmB, 0.0);

  // _A1 and _A2 are on GPIO48 and GPIO47, respectively, which are pins 33 and
  //  46 in mraa, respectively.
  _A1 = mraa_gpio_init(33);
  _A2 = mraa_gpio_init(46);
  mraa_gpio_dir(_A1, MRAA_GPIO_OUT);
  mraa_gpio_mode(_A1, MRAA_GPIO_STRONG);
  mraa_gpio_write(_A1, 1);
  mraa_gpio_dir(_A2, MRAA_GPIO_OUT);
  mraa_gpio_mode(_A2, MRAA_GPIO_STRONG);
  mraa_gpio_write(_A2, 1);

  // _B1 and _B2 are on GPIO15 and GPIO14, respectively, which are pins 48 and
  //  36, respectively
  _B1 = mraa_gpio_init(48);
  _B2 = mraa_gpio_init(36);
  mraa_gpio_dir(_B1, MRAA_GPIO_OUT);
  mraa_gpio_mode(_B1, MRAA_GPIO_STRONG);
  mraa_gpio_write(_B1, 1);
  mraa_gpio_dir(_B2, MRAA_GPIO_OUT);
  mraa_gpio_mode(_B2, MRAA_GPIO_STRONG);
  mraa_gpio_write(_B2, 1);

  // _standbyPin is on GPIO49, which is pin 47 in mraa
  _standbyPin = mraa_gpio_init(47);
  mraa_gpio_dir(_standbyPin, MRAA_GPIO_OUT);
  mraa_gpio_mode(_standbyPin, MRAA_GPIO_STRONG);
  mraa_gpio_write(_standbyPin, 1);
}
Example #7
0
int rotate_left (int i)     

{

while(i!=0)

{mraa_pwm_enable(en1,1);          
mraa_pwm_enable(en2,1);

mraa_pwm_write(en1,1.0f);        

mraa_pwm_write(en2,1.0f);        

mraa_gpio_write(in1,0);          

mraa_gpio_write(in2,1);          

mraa_gpio_write(in3,0);          

mraa_gpio_write(in4,1);          

usleep(( 50000));     ///chagne the value accordingly              

printf("front");

mraa_gpio_write(in1,0);        

mraa_gpio_write(in2,0);        

mraa_gpio_write(in3,0);        

mraa_gpio_write(in4,0);        

mraa_pwm_enable(en1,0);

mraa_pwm_enable(en2,0);

i--;			

}

 return 0;                 

}
Example #8
0
int main()
{

mraa_gpio_context in1;
mraa_gpio_context in2;
mraa_gpio_context in3;
mraa_gpio_context in4;

in1=mraa_gpio_init(7);
in2=mraa_gpio_init(8);
in3=mraa_gpio_init(9);
in4=mraa_gpio_init(10);

mraa_pwm_context en1;
en1=mraa_pwm_init(6);
mraa_pwm_context en2;
en2=mraa_pwm_init(5);
mraa_gpio_dir(in1,MRAA_GPIO_OUT);
mraa_gpio_dir(in2,MRAA_GPIO_OUT);
mraa_pwm_enable(en1,1);
mraa_pwm_period_ms(en1,20);
mraa_gpio_dir(in3,MRAA_GPIO_OUT);
mraa_gpio_dir(in4,MRAA_GPIO_OUT);
mraa_pwm_enable(en2,1);
mraa_pwm_period_ms(en2,20);

mraa_pwm_write(en1,1.0f);
mraa_pwm_write(en2,1.0f);
mraa_gpio_write(in1,1);
mraa_gpio_write(in2,0);
mraa_gpio_write(in3,0);          
mraa_gpio_write(in4,1);          
printf("right90");
usleep(2300000);                 
mraa_gpio_write(in1,0);  
mraa_gpio_write(in2,0);  
mraa_gpio_write(in3,0);  
mraa_gpio_write(in4,0);  
mraa_pwm_enable(en1,0);
mraa_pwm_enable(en2,0);
usleep(2300000);
return 0;              
} 
Example #9
0
void straight (float speed)
{	
	if (speed >= 0 && speed <= 1.0f) {
		mraa_pwm_write(pwm1, speed);
		mraa_pwm_write(pwm2, speed);

		forward_A();
		forward_B();
	}
	
	else if (speed < 0 && speed >= -1.0f) {
		mraa_pwm_write(pwm1, -speed);
		mraa_pwm_write(pwm2, -speed);

		reverse_A();
		reverse_B();
	}

	else
		printf("Wrong speed value. Choose between -1.0 and 1.0\n");
}
Example #10
0
int rotate_left90()
{
mraa_pwm_enable(en1,1);          
mraa_pwm_enable(en2,1);
mraa_pwm_write(en1,1.0f);        
mraa_pwm_write(en2,1.0f);        
mraa_gpio_write(in1,0);          
mraa_gpio_write(in2,1);    
mraa_gpio_write(in3,0);    
mraa_gpio_write(in4,1);          
printf("left90");               
usleep(2300000);                 
mraa_gpio_write(in1,0);          
mraa_gpio_write(in2,0);          
mraa_gpio_write(in3,0);          
mraa_gpio_write(in4,0);          
mraa_pwm_enable(en1,0);          
mraa_pwm_enable(en2,0);          
//usleep(2300000);                 
return 0;                        
}
Example #11
0
void BuzzerAlarm::start(note tone, float vol, int delay) {
	mraa_pwm_period_us(myAlarm, tone);
	float volume;
	// éviter les valeurs impossibles
	if (vol > 1.0) volume = 1.0;
	else if (vol < 0.0) volume = 0.0;
	else volume = vol;
	// la volume correspond au rapport cyclique, 50% sera donc la volume max
	mraa_pwm_write(myAlarm, volume*0.5);
	usleep(delay*1000);
	BuzzerAlarm::stop();
}
Example #12
0
int move_front (int i)     
{

while(i!=0)
{
mraa_pwm_enable(en1,1);          
mraa_pwm_enable(en2,1);
mraa_pwm_write(en1,1.0f);
mraa_pwm_write(en2,1.0f); 
mraa_gpio_write(in1,0);          

mraa_gpio_write(in2,1);          

mraa_gpio_write(in3,0);          

mraa_gpio_write(in4,1);          

usleep(50000);                 

printf("front");

mraa_gpio_write(in1,0);        

mraa_gpio_write(in2,0);        

mraa_gpio_write(in3,0);        

mraa_gpio_write(in4,0);        

mraa_pwm_enable(en1,0);

mraa_pwm_enable(en2,0);

i--;			

}

 return 0;                 

}
Example #13
0
void PWM_Run(void)
{
	mraa_pwm_period_ms(pwm, TIME_PERIOD);
	//printf("Time Period set to %dms\n", TIME_PERIOD);

	mraa_pwm_enable(pwm,1);
	//printf("PWM enabled\n");

	mraa_pwm_write(pwm, DUTY_CYCLE);
	//printf("Duty Cycle set to %f%%\n", (100 * DUTY_CYCLE));

	//printf("PWM running\n");
}
Example #14
0
void initialize()
{
	pwm1 = mraa_pwm_init(20);
	mraa_pwm_period_us(pwm1, 870);
	mraa_pwm_enable(pwm1, 1);

	pwm2 = mraa_pwm_init(14);
	mraa_pwm_period_us(pwm2, 870);
	mraa_pwm_enable(pwm2, 1);

	mraa_pwm_write(pwm1, 0.01);
	mraa_pwm_write(pwm2, 0.01);
	mraa_pwm_write(pwm1, 0.0);
	mraa_pwm_write(pwm2, 0.0);

	A1 = mraa_gpio_init(48);
	A2 = mraa_gpio_init(36);
	mraa_gpio_dir(A1, MRAA_GPIO_OUT);
	mraa_gpio_mode(A1, MRAA_GPIO_STRONG);
	mraa_gpio_write(A1, 1);
	mraa_gpio_dir(A2, MRAA_GPIO_OUT);
	mraa_gpio_mode(A2, MRAA_GPIO_STRONG);
	mraa_gpio_write(A2, 1);

	B1 = mraa_gpio_init(33);
	B2 = mraa_gpio_init(46);
	mraa_gpio_dir(B1, MRAA_GPIO_OUT);
	mraa_gpio_mode(B1, MRAA_GPIO_STRONG);
	mraa_gpio_write(B1, 1);
	mraa_gpio_dir(B2, MRAA_GPIO_OUT);
	mraa_gpio_mode(B2, MRAA_GPIO_STRONG);
	mraa_gpio_write(B2, 1);

	standbyPin = mraa_gpio_init(47);
	mraa_gpio_dir(standbyPin, MRAA_GPIO_OUT);
	mraa_gpio_mode(standbyPin, MRAA_GPIO_STRONG);
	mraa_gpio_write(standbyPin, 1);
}
Example #15
0
FskErr mraaPWMSetDutyCycle(FskPinPWM pin, double value)
{
	mraaPWM mpwm = (mraaPWM)pin;
	int result = mraa_pwm_write(mpwm->context, value);

	if (MRAA_SUCCESS != result)
		return kFskErrOperationFailed;

	if (!mpwm->enabled) {
		mraa_pwm_enable(mpwm->context, 1);
		mpwm->enabled = 1;
	}
	return  kFskErrNone;
}
void send_high_bit() {
	int i = 0;
	printf("1");
	
	mraa_pwm_write(pwm1,DUTY);
	mraa_pwm_write(pwm2,DUTY);
	mraa_pwm_write(pwm3,DUTY);
	mraa_pwm_write(pwm4,DUTY);
	for(i = LONG_DELAY; i > 0; i--); //20 ms

	mraa_pwm_write(pwm1,0);
	mraa_pwm_write(pwm2,0);
	mraa_pwm_write(pwm3,0);
	mraa_pwm_write(pwm4,0);
	for(i = SHORT_DELAY; i > 0; i--); // 5 ms
}
Example #17
0
upm_result_t speaker_set_frequency(const speaker_context dev,
                                   unsigned int freq)
{
    assert(dev != NULL);

    if (!dev->is_pwm)
        return UPM_ERROR_NO_RESOURCES;

    if (freq < 50 || freq > 32000)
    {
        printf("%s: freq must be between 50 and 32000.\n", __FUNCTION__);

        return UPM_ERROR_OPERATION_FAILED;
    }

    float period = 1.0 / (float)freq;

    // printf("PERIOD: %f (freq %d)\n", period, freq);

    if (period >= 0.001) // ms range
    {
        if (mraa_pwm_period(dev->pwm, period))
        {
            printf("%s: mraa_pwm_period() failed.\n", __FUNCTION__);

            return UPM_ERROR_OPERATION_FAILED;
        }
    }
    else // us range.  With a max of 32KHz, no less than 3.125 us.
    {
        if (mraa_pwm_period_us(dev->pwm, (int)(period * 1000000)))
        {
            printf("%s: mraa_pwm_period_us() failed.\n", __FUNCTION__);

            return UPM_ERROR_OPERATION_FAILED;
        }
    }

    // save it for later if needed
    dev->default_freq = freq;

    // A 10% duty cycle enables better results at high frequencies
    mraa_pwm_write(dev->pwm, 0.1);

    return UPM_SUCCESS;
}
void send_preamble_sequence(int preamble_length) {
	int i = 0, j = 0;
	
	for(i = preamble_length; i > 0; i--){
		
		//equal durations
		mraa_pwm_write(pwm1,DUTY);
		mraa_pwm_write(pwm2,DUTY);
		mraa_pwm_write(pwm3,DUTY);
		mraa_pwm_write(pwm4,DUTY);
		for(j = PREAMBLE_DELAY; j > 0; j--);

		mraa_pwm_write(pwm1,0);
		mraa_pwm_write(pwm2,0);
		mraa_pwm_write(pwm3,0);
		mraa_pwm_write(pwm4,0);
		for(j = PREAMBLE_DELAY; j > 0; j--);
	}
}
Example #19
0
FskErr mraaPWMNew(FskPinPWM *pin, SInt32 number, const char *name)
{
	FskErr err;
	mraaPWM mpwm;

	err = FskMemPtrNewClear(sizeof(mraaPWMRecord), &mpwm);
	if (err) return err;

	mpwm->context = mraa_pwm_init(number);
	if (!mpwm->context) {
		FskMemPtrDispose(mpwm);
		return kFskErrOperationFailed;
	}

	mraa_pwm_period_ms(mpwm->context, PWMDEFAULTPERIOD);
	mpwm->period = PWMDEFAULTPERIOD;
	mraa_pwm_write(mpwm->context, 0.0);

	*pin = (FskPinPWM)mpwm;

	return err;
}
int main()
{
	int sockfd;
	float brightness;
	struct sockaddr_in server_addr;
	char response[MAX_SIZE];
	char cmd[MAX_SIZE];
	char cmd2[MAX_SIZE];                                
        FILE *fp, *fp2;                                          
        char component_string[MAX_SIZE];
	char value_string[MAX_SIZE]; 
	int value_int;

	mraa_pwm_context speed_pwm_in1, speed_pwm_in2, turn_pwm;
	speed_pwm_in1 = mraa_pwm_init(3);
	speed_pwm_in2 = mraa_pwm_init(5);
	turn_pwm = mraa_pwm_init(6);
	
	if (speed_pwm_in1 == NULL || speed_pwm_in2 == NULL || turn_pwm == NULL) {
		fprintf(stderr, "Failed to initialized.\n");
		return 1;
	}

	mraa_pwm_period_us(speed_pwm_in1,870); //1150Hz
	mraa_pwm_enable(speed_pwm_in1, 1);
	mraa_pwm_period_us(speed_pwm_in2,870);
	mraa_pwm_enable(speed_pwm_in2, 1);
	
	mraa_pwm_period_ms(turn_pwm,20);
   	mraa_pwm_enable(turn_pwm, 1);

	mraa_pwm_write(speed_pwm_in1, 1.0f);
	mraa_pwm_write(speed_pwm_in2, 1.0f);
	mraa_pwm_write(turn_pwm, CENTER);

	//Set the protocol to mqtt and
	//restart iotkit-agent to ensure that it is running.
	system("iotkit-admin protocol mqtt");
	system("systemctl restart iotkit-agent");

	//create a socket with the following attributes:
	socklen_t len = sizeof(server_addr);	
	sockfd = socket(AF_INET, SOCK_DGRAM, 0);

	bzero(&server_addr,sizeof(server_addr));

	//Name of the socket as agreed with the server
	server_addr.sin_family = AF_INET;
	server_addr.sin_addr.s_addr = inet_addr(localhost);
	server_addr.sin_port = htons(41235);	
	
	if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
        	fprintf(stderr, "Failed to bind");
        	return 1;
    	}

	while(1)	
    	{
		//Use recvfrom function to send JSON message to iotkit-agent
		if(recvfrom(sockfd, response, MAX_SIZE, 0, (struct sockaddr *)&server_addr, &len) < 0)
    		{
			fprintf(stderr, "Failed to receive actuation\n");
    			return 1;
		}
		//printf("Received JSON message: %s\n", response);


		//---This part extracts the component name----------------
		snprintf(cmd, sizeof(cmd), "echo '%s' | sed 's/\"/ /g' | tr ' ' '\n' | awk '/component/{getline; getline; print}'", response);
		fp = popen(cmd, "r");

	  	if (fp == NULL) {
    			fprintf(stderr, "Failed to run command\n" );
    			exit(1);
  		}
	
	  	while (fgets(component_string, sizeof(component_string)-1, fp) != NULL) {
  		}
  		pclose(fp);

		//---This part extracts the value-------------------------		
		snprintf(cmd2, sizeof(cmd2), "echo '%s' | sed 's/\"/ /g' | tr ' ' '\n' | awk '/value/{getline; getline; print}'", response);

                fp2 = popen(cmd2, "r");

                if (fp2 == NULL) {
                        fprintf(stderr, "Failed to run command\n" );
                        exit(1);
                }

                while (fgets(value_string, sizeof(value_string)-1, fp) != NULL) {
                }
                pclose(fp2);

		//printf(value_string);
		//---This part is for actuation
		if (!strcmp(component_string, "vehicleControl\n")) {
			if (!strcmp(value_string, "forward\n")) {
				printf("Going forward for 1 second.\n\n");
				mraa_pwm_write(turn_pwm, CENTER); //straight                                                          
                                usleep(100000);                                                                                       
                                speed_control(speed_pwm_in1, speed_pwm_in2, 100);                                                     
                                sleep(1);                                                                                             
                                speed_control(speed_pwm_in1, speed_pwm_in2, 0);                                                       
			}
			else if (!strcmp(value_string, "reverse\n")) {
				printf("Going backward for 1 second.\n\n");
				mraa_pwm_write(turn_pwm, CENTER); //reverse                                                             
                                usleep(100000);                                                                                       
                                speed_control(speed_pwm_in1, speed_pwm_in2, -100);                                                     
                                sleep(1);                                                                                             
                                speed_control(speed_pwm_in1, speed_pwm_in2, 0); 
			}
			else if (!strcmp(value_string, "left\n")) {                                                                         
				printf("Making a left turn.\n\n");
				mraa_pwm_write(turn_pwm, CENTER - 0.015f); //left                                                              
                                usleep(100000);                                                                                       
                                speed_control(speed_pwm_in1, speed_pwm_in2, 100);                                                     
                                sleep(1);                                                                                             
                                speed_control(speed_pwm_in1, speed_pwm_in2, 0);                                                                                                                                               
                        }
			else if (!strcmp(value_string, "right\n")) {                                                                         
				printf("Making a right turn.\n\n");
				mraa_pwm_write(turn_pwm, CENTER + 0.015f); //right                                                           
                                usleep(100000);                                                                                       
                                speed_control(speed_pwm_in1, speed_pwm_in2, 100);                                                    
                                sleep(1);                                                                                             
                                speed_control(speed_pwm_in1, speed_pwm_in2, 0);                                                                                                                                               
                        }
			else
				fprintf(stderr, "Wrong actuation command received!\n");
		}		
	}
	close(sockfd);
	return 0;
} 
Example #21
0
 /**
  * Set the output duty-cycle percentage, as a float
  *
  * @param percentage A floating-point value representing percentage of
  * output. The value should lie between 0.0f (representing on 0%) and
  * 1.0f Values above or below this range will be set at either 0.0f or
  * 1.0f
  * @return Result of operation
  */
 mraa_result_t
 write(float percentage)
 {
     return mraa_pwm_write(m_pwm, percentage);
 }
int main() {
    float speed, turn;
    char speed_user_input[MAXBUFSIZ];
    char turn_user_input[MAXBUFSIZ];
    char time_user_input[MAXBUFSIZ];
    mraa_pwm_context speed_pwm_in1, speed_pwm_in2, turn_pwm;
    speed_pwm_in1 = mraa_pwm_init(3);
    speed_pwm_in2 = mraa_pwm_init(5);
    turn_pwm = mraa_pwm_init(6);

    if (speed_pwm_in1 == NULL || speed_pwm_in2 == NULL || turn_pwm == NULL) {
        fprintf(stderr, "Failed to initialized.\n");
        return 1;
    }

    mraa_pwm_period_us(speed_pwm_in1,870); //1150Hz
    mraa_pwm_enable(speed_pwm_in1, 1);
    mraa_pwm_period_us(speed_pwm_in2,870);
    mraa_pwm_enable(speed_pwm_in2, 1);

    mraa_pwm_period_ms(turn_pwm,20);
    mraa_pwm_enable(turn_pwm, 1);

    mraa_pwm_write(turn_pwm, CENTER);
    mraa_pwm_write(speed_pwm_in1, 1.0f);
    mraa_pwm_write(speed_pwm_in2, 1.0f);

    RearWheel *rw = new RearWheel();

    //go for the curve
    thread t1;

    while(1) {
        t1 = rw->threading();
        printf("Turn (L, C, R): ");
        scanf("%s", turn_user_input);

        if (!strcmp(turn_user_input, "L") || !strcmp(turn_user_input, "l"))
            turn = CENTER - 0.015f;
        else if (!strcmp(turn_user_input, "C") || !strcmp(turn_user_input, "c"))
            turn = CENTER;
        else if (!strcmp(turn_user_input, "R") || !strcmp(turn_user_input, "r"))
            turn = CENTER + 0.018f;
        else {
            printf("Wrong turn type!\n");
            return 1;
        }

        printf("Speed value (-100-100): ");
        scanf("%s", speed_user_input);
        speed = atof(speed_user_input);

        printf("time: ");
        scanf("%s", time_user_input);
        int time = atoi(time_user_input);

        if (speed > 100 || speed < -100)
            printf("Error: Choose between -100 and 100\n");
        else {
            mraa_pwm_write(turn_pwm, turn);
            usleep(100000);
            speed_control(speed_pwm_in1, speed_pwm_in2, speed);
        }
        sleep(time);
        speed_control(speed_pwm_in1, speed_pwm_in2, 0.0f);
        float count = rw->getCount();
        printf("%.2f \n", count);
        rw->clear();
        t1.join();
    }
    return 0;
}
int main(int argc, char *argv[]) {
	
	printf("\n---------------------ir_transmit.c---------------------\n");
	//const struct sched_param priority={1};
	//sched_setscheduler(0,SCHED_FIFO,&priority);
	
	int transmit_counter = 0;
	int i = 0;
	int temp = -1;
	// GPIO Initialization - Edison has 4 PWM pins
	
	pwm1 = mraa_pwm_init(3);
	mraa_pwm_period_us(pwm1, 26);
	mraa_pwm_enable(pwm1, 1);
	
	pwm2 = mraa_pwm_init(5);
	mraa_pwm_period_us(pwm2, 26);
	mraa_pwm_enable(pwm2, 1);
	
	pwm3 = mraa_pwm_init(6);
	mraa_pwm_period_us(pwm3, 26);
	mraa_pwm_enable(pwm3, 1);
	
	pwm4 = mraa_pwm_init(9);
	mraa_pwm_period_us(pwm4, 26);
	mraa_pwm_enable(pwm4, 1);

	printf("\n---------------------Part 0: Apply Settings from Config Files---------------------\n");
	temp = check_preamble_length();
	if (temp != -1) {
		printf("\nGot Preamble Length from /etc/IR/preamble_length.txt\n");
		printf("ID I got was %d\n", temp);
		printf("But we are still going to use 5\n", temp);
		//preamble_length = temp;
	}
	temp = -1;
	
	// check file for edisonID
	temp = check_edison_id();
	if (temp != -1) {
		printf("Got Edison ID from /etc/IR/edisonID.txt\n");
		printf("ID I got was %d\n", temp);
		edisonID = temp;
	}
	temp = -1;
	
	printf("\n---------------------Part 0: Apply Settings from Passed in Arguments---------------------\n");
	// if we pass in an argument, use it for the preamble_length, takes
	// priority over what's in the file. please pass in an integer
	if (argc == 2) {
		preamble_length = atoi(argv[1]);
		printf("Argument(1) Passed In! Preamble Length set to: %d\n", preamble_length);
	}
	else {
		printf("No Argument(1), preamble Length set to default value: %d\n", preamble_length);
	}
	// if we pass in an argument, use it for the edisonID, takes
	// priority over what's in the file. please pass in an integer
	if (argc == 3) {
		preamble_length = atoi(argv[1]);
		printf("Argument(1) Passed In! Preamble Length set to: %d\n", preamble_length);
		
		edisonID = atoi(argv[2]);
		printf("Argument(2) Passed In! edisonID set to: %d\n", edisonID);		
	}
	else {
		printf("No Argument(2), edisonID set to default value: %d\n", edisonID);		
	}	
	// This will transmit IR data on all 4 pins at once
	// on a single Edison board

	
	// Continuously Transmit IR Signal when the program is running
	while(1) {
		printf("\n---------------------Transmission---------------------\n");
	
		// Updates the preamble_length variable based on info from server
		temp = check_preamble_length();
		if (temp != -1) {
			printf("ID from /etc/IR_conf/preamble_length.txt was %d\n", temp);
			preamble_length = temp;
		}
		
		// Preamble - Signals the Receiver Message Incoming
		printf("Sending preamble_length = %d, ", preamble_length);
		send_preamble_sequence(preamble_length);
		
		// Sending Edison Board ID # - 2 bits, MSB then LSB
		printf("EdisonID: %d - ", edisonID);
		switch (edisonID) {
			case 0:
				send_low_bit();		// Send lsb bit 0 = LOW
				send_low_bit();		// Send msb bit 1 = LOW
				break;
			case 1:
				send_low_bit();		// Send msb bit 1 = LOW
				send_high_bit();	// Send lsb bit 0 = HIGH
				break;
			case 2:
				send_high_bit();	// Send msb bit 1 = HIGH
				send_low_bit();		// Send lsb bit 0 = LOW
				break;
			case 3:
				send_high_bit();	// Send lsb bit 0 = HIGH
				send_high_bit();	// Send msb bit 1 = HIGH
				break;
			default:
				send_low_bit();		// Send lsb bit 0 = LOW
				send_low_bit();		// Send msb bit 1 = LOW				
		}
		
		// Sending Edison IR Emitter ID # - 2 bits, MSB then LSB
		
		// pwm1,DUTY = 00 = short-long/short-long = 5-20/5-20
		// pwm2,DUTY = 01 = short-long/long-short = 5-20/20-5
		// pwm3,DUTY = 10 = long-short/short-long = 20-5/5-20
		// pwm4,DUTY = 11 = long-short/long-short = 20-5/20-5
		
		printf(", EmitterIDs 0-3\n");
		// First Bit
		mraa_pwm_write(pwm1,DUTY);
		mraa_pwm_write(pwm2,DUTY);
		mraa_pwm_write(pwm3,DUTY);
		mraa_pwm_write(pwm4,DUTY);
		for(i = SHORT_DELAY; i > 0; i--); // 5 ms
		
		mraa_pwm_write(pwm1,0);
		mraa_pwm_write(pwm2,0);
		//mraa_pwm_write(pwm3,DUTY, DUTY);
		//mraa_pwm_write(pwm4,DUTY, DUTY);
		for(i = MID_DELAY; i > 0; i--); // 15 ms

		//mraa_pwm_write(pwm1, 0);
		//mraa_pwm_write(pwm2, 0);
		mraa_pwm_write(pwm3,0);
		mraa_pwm_write(pwm4,0);
		for(i = SHORT_DELAY; i > 0; i--); // 5 ms
		
		// Second Bit	
		mraa_pwm_write(pwm1,DUTY);
		mraa_pwm_write(pwm2,DUTY);
		mraa_pwm_write(pwm3,DUTY);
		mraa_pwm_write(pwm4,DUTY);
		for(i = SHORT_DELAY; i > 0; i--); // 20 ms

		mraa_pwm_write(pwm1,0);
		//mraa_pwm_write(pwm2,DUTY, DUTY);	
		mraa_pwm_write(pwm3,0);
		//mraa_pwm_write(pwm4,DUTY, DUTY);	
		for(i = MID_DELAY; i > 0; i--); // 15 ms

		//mraa_pwm_write(pwm1, 0);
		mraa_pwm_write(pwm2,0);
		//mraa_pwm_write(pwm3, 0);
		mraa_pwm_write(pwm4,0);
		for(i = SHORT_DELAY; i > 0; i--); // 5 ms
		
		/*
		send_message_bit(edisonID, 0, DUTY, pwm1,DUTY);
		send_message_bit(edisonID, 0, DUTY, pwm1,DUTY);
		send_message_bit(edisonID, 0, DUTY, pwm1,DUTY);
		send_message_bit(edisonID, 0, DUTY, pwm1,DUTY);
		
		
		for (transmit_counter = TRANSMIT_DURATION; transmit_counter >= 0; transmit_counter--) {
			send_message_bit(edisonID, 0, DUTY, pwm1,DUTY);
		}
		for (transmit_counter = TRANSMIT_DURATION; transmit_counter >= 0; transmit_counter--) {
			send_message_bit(edisonID, 1, DUTY, pwm2,DUTY);			
		}
		for (transmit_counter = TRANSMIT_DURATION; transmit_counter >= 0; transmit_counter--) {
			send_message_bit(edisonID, 2, DUTY, pwm3,DUTY);
		}
		for (transmit_counter = TRANSMIT_DURATION; transmit_counter >= 0 ;transmit_counter--) {
			send_message_bit(edisonID, 3, DUTY, pwm4,DUTY);
		}
		*/
		
	}// end while loop

	mraa_pwm_write (pwm1, 0);
	mraa_pwm_enable(pwm1, 0);
	mraa_pwm_write (pwm2, 0);
	mraa_pwm_enable(pwm2, 0);
	mraa_pwm_write (pwm3, 0);
	mraa_pwm_enable(pwm3, 0);
	mraa_pwm_write (pwm4, 0);
	mraa_pwm_enable(pwm4, 0);

	return 0;
}//end main
Example #24
0
void BuzzerAlarm::stop() {
	mraa_pwm_period_us(myAlarm, 1);
	mraa_pwm_write(myAlarm, 0);
}
Example #25
0
void set_speed(float speed)
{
	mraa_pwm_write(pwm1, speed);
	mraa_pwm_write(pwm2, speed);
}
int main(){
 








/**********************************************************************/
/**********************************************************************/
/* Begin. */
	mraa_uart_context uart;
	uart = mraa_uart_init(0);
	mraa_uart_set_baudrate(uart, 115200);
	char buffer[] = "hhh";
	char flush[]="xxxxxxxxxxxx";
	char str[] = "HELLO";
	if (uart == NULL) {
        	fprintf(stderr, "UART failed to setup\n");
        	printf("UART failed");
		return 1;
    	}
	printf("firstavail:%d\n",mraa_uart_data_available(uart,0));
	while (mraa_uart_data_available(uart,0))
	{
		mraa_uart_read(uart, flush, sizeof(uart));
		printf("Flush: %c %c %c %c %c %c %c %c",flush[0], flush[1], flush[2],flush[3],flush[4],flush[5],flush[6],flush[7]);
		usleep(150);
	}
	printf("available: %d",mraa_uart_data_available(uart,0));
        char speed_user_input[MAXBUFSIZ];
        char turn_user_input[MAXBUFSIZ];
        mraa_pwm_context speed_pwm_in1, speed_pwm_in2, turn_pwm;
        speed_pwm_in1 = mraa_pwm_init(3);
        speed_pwm_in2 = mraa_pwm_init(5);
        turn_pwm = mraa_pwm_init(6);
        if (speed_pwm_in1 == NULL || speed_pwm_in2 == NULL || turn_pwm == NULL) {
                fprintf(stderr, "Failed to initialized.\n");
                return 1;
        }

        mraa_pwm_period_us(speed_pwm_in1,870); //1150Hz
        mraa_pwm_enable(speed_pwm_in1, 1);
        mraa_pwm_period_us(speed_pwm_in2,870);
        mraa_pwm_enable(speed_pwm_in2, 1);

        mraa_pwm_period_ms(turn_pwm,20);
        mraa_pwm_enable(turn_pwm, 1);

        mraa_pwm_write(turn_pwm, CENTER);
        mraa_pwm_write(speed_pwm_in1, 1.0f);
        mraa_pwm_write(speed_pwm_in2, 1.0f);

        int n = 5;
        int spd = 0;
        char direction = 'C';
	char cross_clr = 'B';
        float angle = 0.0f;
	while (1)
        {
	//sleep(2);
        //readCharAry(uart,flush);
	spd = 50;
	mraa_uart_read(uart, buffer, 1);
	if(buffer[0]=='\n')
	{
		printf("new line ");	
		mraa_uart_read(uart, buffer, 1);
		if(buffer[0]=='\n')
		{
			printf("new line ");
                	mraa_uart_read(uart, buffer, 1);
		}
	}
	mraa_uart_read(uart, buffer+1, 1);
	if(buffer[1]=='\n')
        {
		buffer[0] = 'h';
		buffer[1] = 'h';
        }
	int sign = 0;
	if(cross_clr == 'M')	
	{
		speed_control(speed_pwm_in1, speed_pwm_in2, 0.0f);
		sleep(1);
		char* nearestBeaconID = (char*)malloc(5);
		getStrongestBeacon(nearestBeaconID);
		printf("the nearestBeaconID is: %s\n", nearestBeaconID);
		sign = 1;
		angle = CENTER + 0.015f;
        mraa_pwm_write(turn_pwm, angle);
        usleep(15000);
        speed_control(speed_pwm_in1, speed_pwm_in2, 54);
        printf("speed: %d",spd);
        usleep(5500000);
                speed_control(speed_pwm_in1, speed_pwm_in2, 0.0f);
		//sleep(1);
		mraa_uart_write(uart, str, 1);
		//while(!mraa_uart_data_available(uart, 10)){};
        mraa_uart_read(uart, buffer, 1);
        while(buffer[0] == '\n')
		{
			mraa_uart_read(uart, buffer, 1);
		}
		if(buffer[0] == '\0') direction = 'C';
                mraa_uart_read(uart, buffer + 1, 1);
                cross_clr = buffer[1];
	}
	printf("buff:%c %c %c \n",buffer[0], buffer[1],buffer[2]);
	if(!sign){
        if (direction == 'L')   angle = CENTER - 0.005f;
        if (direction == 'R')   angle = CENTER + 0.005f;
        if (direction == 'C')   angle = CENTER;}
	else
	{
		if (direction == 'C')	angle = CENTER +0.013f; 
		if (direction == 'L')   angle = CENTER +0.005f;
        	if (direction == 'R')   angle = CENTER + 0.019f;
	}
	mraa_pwm_write(turn_pwm, angle);
        speed_control(speed_pwm_in1, speed_pwm_in2, spd);
	printf("speed: %d",spd);
	usleep(250000);

	direction = buffer[0];
	cross_clr = buffer[1];
        }
        return 0;
}