Hey there,
im working on a Pan/Tilt Camerahead powered by an Arduino Duemilanove.
Im new to programming in C so please dont kill me for my question ...i´m kind a stuck in a program-problem... I already read the The Arduino.cc reference, playground but couldn´t find anything for my problem.
My plan is to Control the Speed of a Servo with a Potentiometer.
The pot. is divided into 5 sections in my current program.
Fast Up
Up
Nothing
Down
Fast Down
these movements should be controlled by setting the servoposition to +-2 for fast moving, +-1 for normal speed or +-0 for middle position of the pot, refering to the position the servo was at before...
Ya know what I mean?
So heres what I dare to call "code" for my thoughts...:
i set the delay to 150 to check whats going on, because when i run this with shorter delay the servo just makes tiny oscillating movements with no direction and without influence of the poti-setting...
Is this a simple programmig fail or an epic thinking fail?
Please Help...
thanks in advance
non-existence
Your Servo1.read() call does nothing since the function is meant to return a value.
For instance:
whereIsMyServo = Servo1.read();
...would store the returned value in a variable called whereIsMyServo. In your case it returns a value to nowhere. Besides it's not necesary since the value it would return would be the same as that of your variable posServo1.
The delay(150) is called in all cases so why not put it in the end and avoid having it 5 times.
And actually Servo1.write(posServo1 += 0) doesn't do anything either cause you're adding 0 the the variable posServo1, and setting the servo position to where it allread is.
Not sure about the strange servo behaviour BUT:
You should make sure the posServo1 NEVER exceeds it's min. value 0 or it's max. value 180!!!!
Have you made sure the analogRead(0) returns the values you expect?
It could be because the servo doesn't like that you call Servo1.write() while it's still moving and trying to reach the last position you gave it, but of this I'm not sure...
I increased the steps to 7 and modified it for two servos. (Each Servo is controlled by its own pot.)
If I run this program now it works for a normal servo.
But in my Project I will transmit the power of the servo with a tooth belt and use different tooth amounts to slow down the motion. As a consequence of this i need a continuous rotation servo because the servo will have to make more turns to get the belt far enough.
Now if I connect a Servo with removed Potentiometer (continuous Motion) the following happens:
The servo spins into the direction that is given by the setting of the SpeedControlPot. but with constant speed. ?
Im aware that because of the missing pot the servo cant get any position details, this is probably why my idea of "pos = pos+1" thing doesnt work any more and control the speed... (By the way, the hacked servo always spins at full speed)
So how can I do a speed control on a continuous rotation servo?
A workaround that could be used would be attaching the position servo of the potentiometer to the slower secondary axis that is driven by the servo and so make the servo believe that this position is his one, not the direct servo output. Aside from the mechanical difficulties this only allows a 180° angle... :-[
So what now?
Once you mechanically disconnect the pot to convert the servo for continuous rotation, you no longer control the position because the servo has no information about where it is. You only speed have control over the speed where approximately 90 degrees is stopped and as the angle increases the servo speeds up in one direction, as it decreases it speed up in the other direction.
Your idea about connecting the pot to the remote wheel is a good one. But if the remote wheel needs to turn more t360 degrees then you may be able to rig up some gear reduction so that the pot turns 180 degrees when your wheel rotates 360 degrees
There was a thread recently about using continuous rotation modded servo.
I think if you want to stop the servo, you can use the "detach" method, otherwise, you need to experiment with "angles" around 90 degrees to find the point where the servo stops.
Also, consider using the "time" (pulse width) approach to specify servo position, rather than "degrees".
I just messed arround with the servo insides a bit and found out that if you set the position to 90° and take the potentiometer that originally detectect the position inside of it you can actually also control the speed of the movement.
If you turn the poti to what is expected to be the 90° angle (where the resistance is half as big as at the max. position) the motor stops.
Ive you turn the pot. slightly forwards/backwards the motor begins to turn into both directions ( depending on the pot. direction).
And it also accelerates the more you turn it away from the stop postion. (So this is probably a thing caused by the servo-intern-circuit)
I measuered the values and found out that it is a 4,6kOhm Pot. The stop point for 90 degrees is (logicaly half of the max. resistance) at 2,3kOhm. In a range that is about 1,3kOhm large, around the stop value you are in speed controlled mode.
So i will try to make a little circiout that allows me to control that 1,3KOhm range. And use it thate way to have continuous rotation and speed control as a workaround...
Or what other methods could work?
If i´d set the resistance value at the ports for the poti on the servo-board to a fix value that stands for 90° and add (according to a value inputed by a potentiometer [ to set the speed]) let´s say one degree to the servoposition, write that to the servo and reset the postion value back to 90... what happens?
Does the arduino say goto position 91 and the servo is like yeah okay, and turns the motor on forever, cause the resistors tell him he is still at pos90? how could this be solved?
Or does the arduino tell the servo goto 91, the motor runs and when the value on the arduino is set back to 90 the motor stops?
Does the arduino say goto position 91 and the servo is like yeah okay, and turns the motor on forever, cause the resistors tell him he is still at pos90?
That's pretty much it.
In a normal (non continuous rotation) servo, the electronics in the servo compares the position command pulses to the actual position as measured on the pot. It will turn the motor in the direction needed to move the pot to minimize the error (difference between commanded and actual position). The power applied to drive the motor is increased if the error is large and decreased when the error is small.
In a continuous rotation servo, the pot is physically disconnected from the shaft. The servo electronics responds to an error value by powering the motor as if it could move the pot into the commanded position. The pot never moves but the result is that the motor direction and speed is controlled by the command pulses.
Just to clear this up: The code I posted before did EXACTLY the same as your code. I just cleaned it up. Having a lot of unnecesary code is one way to invite errors.
Your second example also has a lot of unnecesary code...
The poservo1 = Servo1.read() is unnecesary cause the value of poservo1 is ALLREADY the same as Servo1.read() in all cases, as I explained before. Besides the SoftwareServo::refresh() could be placed in the end like delay(5) thus you'd only have to write it once. Your code would then be:
And the idea of a servo modified for continuous rotation is exactly that you no longer control the position but instead it's speed. It allways "thinks" it's position is 90 degrees, so if you tell it to go to 90 it wont move. Tell it to go to 91 and it will move SLOWLY in one direction. 89 and it will move slowly in the other direction. 180 or 0 and it will move FAST in their respective directions...
Isn't this what you want?
Another thing: It seems that your code keeps adding/subtracting to the poservo1/poservo2 variables INDEFINATELY when val1/val2 is less/more than 3, so eventually you'll surpass it's valid min/max values 0/180.
Heureka! (As once an old greek said)
So it works now. Thanks for helping mem, Aniss1001 and AWOL.
I took the pot. that was originaly mounted inside the servo for positioning outside and ran a program that set the servo to a 90° angle. This way i could easily find the value where the servo stopped with the ex-servo-potentiometer ( half the resistance of the full pot. value ). So i set it to that value and sent the arduino servo.write() commands of 91°, 92°,... and so on. That way i found out that there are (at least concerning the servo i used) 13° around 90° where the servo´s speed is throttled.
I added a Potentiometer on an Analog input and divided its value to 30 steps. Two of these (in the middle position of the pot., two to make it a broader stop position) are used to stop the servo, by sending a 90° request. The other 14 steps on each sides send position signals to the servo which increase the servos speed when the pot.´s offset is increased, refering to the middle position. This way you can control speed and direction directly with one potentiometer.
You can simplify the code if you map the pot input directly to the servo output:
#include <Servo.h>
Servo myservo1;
int potpin1 = 0; // defines pin used for the potentiometer
int pot1val;
int servoVal
void setup()
{
myservo1.attach(6); // defines pin used for the servo
}
void loop()
{
pot1val = analogRead(potpin1);
servoVal = map(pot1val, 0, 1023, 76, 104);
myservo1.write(servoVal);
delay(20);
}
The delay in loop prevents the code from constantly rewriting values to the servo. The servo library disables interrupts when a new value is written and there is no point in doing this more often then every 20ms or so, the value is only used every 20 ms.
...i´m kind a stuck in a program-problem... I already read the The Arduino.cc reference, playground but couldn´t find anything for my problem.
