The reason I sent you that information is because the simple left() and right() methods don’t allow you to control the degree of turn - it simply goes right or left.
By using the set_speed methods, (and some simple calculations), you can make both speed and the sharpness of the turn directly related to the amount of joystick deflection.
The issue is the robot can only do one thing at a time using the forward/backward/right/left commands, but the joystick can command two things at the same time - a little forward AND a little left or right. The robot doesn’t know which to do - forward OR left/right.
You have two choices, simple or complex:
SIMPLE: create a class variable - fwd_bwd=False
if (fwd_bwd == False): to on_L3_right and on_L3_leftCOMPLEX:
do_drive_command()
BTW, it appears when you changed the drive_cm(5) and -5 to forward() backward(), you forgot to change the print statements; made the code harder to grasp at first glance.
This is because the basic forward, backward, left, and right commands don’t allow for precision in turning or motion - these commands are intended to be used in simple “teach me about the robot” cases - like bloxter - where precision is not a requirement.
To move and turn with precision, you need to use the set_motor_dps commands like this:
max_speed to that value.
desired_speed = int((max_speed * y_axis) * -1)
int makes sure the value is a whole number without a fractional part.)my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_LEFT, desired_speed)
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_RIGHT, desired_speed)
differential_speed = int(desired_speed - abs(desired_speed * x_axis))
This requires a bit more explanation:
desired_speed * x_axis) gives the fractional part of the desired speed represented by the x_axis movement.
differential_speed to the inside wheel.desired_speed to the right wheel and differential_speed to the left wheel.desired_speed to the left wheel and the differential_speed to the right wheel. This will make the robot turn in the correct direction regardless of if it is moving backwards or forward.Try it and tell me how it works.
=======================
Update
I tried adjusting my calculations as shown above and there were difficulties.
My original logic works.
############################
## Motion Selection ##
############################
# Depending on the position of the x and y axes
# and the state of trigger_1, we determine
# **IF** the robot should be moving,
# and **WHAT DIRECTION** it should be moving in.
#
if force == 0 or trigger_1 == 0:
my_gopigo3.stop()
print("Robot Stopped. . .\n")
elif trigger_1 == 1 and y_axis < 0:
# We're moving forward - either straight, left, or right.
print("The robot is moving forward and is ", end="")
# if we're not moving directly forward, the inside wheel must be slower
# than the outside wheel by some percentage.
# When moving to the left, the left wheel must be moving slower than
# the right wheel by some percentage, depending on the sharpness of the turn.
# "set_motor_dps" allows the wheels to be set to individual speeds.
if x_axis < 0: # Moving fowrard to the left
desired_speed = int(calc_desired_speed(speed, force))
differential_speed = int(calculate_differential_speed(desired_speed, x_axis))
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_RIGHT, desired_speed)
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_LEFT, differential_speed)
print("moving forward to the left\n")
# Moving to the right, we apply the same logic as before, but swap wheels.
elif x_axis > 0: # Moving fowrard to the right
desired_speed = int(calc_desired_speed(speed, force))
differential_speed = int(calculate_differential_speed(desired_speed, x_axis))
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_LEFT, desired_speed)
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_RIGHT, differential_speed)
print("moving forward to the right\n")
else: # Moving directly forward
desired_speed = int(calc_desired_speed(speed, force))
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_LEFT, desired_speed)
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_RIGHT, desired_speed)
print("moving forward straight ahead\n")
elif trigger_1 == 1 and y_axis > 0:
# We're moving backward
# This is the exact same logic and calculation as moving forward
# Except that it's "backwards" (bad pun!)
# We do this by changing the sign of the speed requested.
# if we're not moving directly backward, the inside wheel must be slower
# than the outside wheel by some percentage.
print("The robot is moving backward and is ", end="")
# reduce maximum reverse speed to 1/2 forward speed
speed = speed * 0.5
if x_axis < 0: # Moving backward to the left
# Moving to the left, the left wheel must be moving slower than
# the right wheel by some percentage.
desired_speed = int(calc_desired_speed(speed, force))
differential_speed = int(calculate_differential_speed(desired_speed, x_axis))
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_RIGHT, -desired_speed)
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_LEFT, -differential_speed)
print("moving backward to the left\n")
elif x_axis > 0: # Moving backward to the right
# Moving to the right, we apply the same logic, but swap wheels.
desired_speed = int(calc_desired_speed(speed, force))
differential_speed = int(calculate_differential_speed(desired_speed, x_axis))
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_LEFT, -desired_speed)
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_RIGHT, -differential_speed)
print("moving backward to the right\n")
else: # Moving directly backward.
desired_speed = int(calc_desired_speed(speed, force))
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_LEFT, -desired_speed)
my_gopigo3.set_motor_dps(my_gopigo3.MOTOR_RIGHT, -desired_speed)
print("moving straight backward\n")
You will have to adjust variable names and such to match your code.
This is what I have done so far I have created in a class MotorModule which determines the speed, turning and timing and then have my PlayStationController class aswell I have tested this and it doesn’t work. I think I may need to change the buttons because the d-pad doesn’t seem to be recognised at all when I press the buttons.
@jimrh I’m going to change the buttons to how I had them previously and try again! Because the joystick seems to be recognised by the PyPS4 library. I’ve just tried the ‘on_L3_up’ and it went forward so I’m hoping right and left may run smoother with the added logic that I’ve done in the MotorModule.py
Get rid of the gpg= instantiation and the gopigo3.GoPiGo3 import
Change all gpg to GPG
(Then change all GPG to egpg)
Reason: EasyGoPiGo class is derived from the GoPiGo3 class, so all GoPiGo3 class methods are available.
Python conventions:
If you want a shorter constant name than egpg.MOTOR_RIGHT, I suggest RMOTOR=EasyGoPiGo3.MOTOR_RIGHT
That Motor=MotorModule statement makes me want to lock up your robot in my closet until you complete a Python course. Sorry to have to say it, but that scrambled my brain so much I cannot help you further.
@cyclicalobsessive Ok I didn’t know this I will make these changes to my code now thank you! And I will also check I have the correct Python conventions and make changes to these aswell.
Haha I do apologise for that 
, to be honest this is my first time working with Python I may need to look over some of the basics again. My background is more in Java.
There is a complete Java API library for the GoPiGo3
Perhaps there is a Java lib for the joystick somewhere.
Not too many folks doing GoPiGo3 in Java though. I was forced by employment to endure Java and JavaScript, and was fortunate to be able to say goodbye to all that many years ago.
Wishing you fun and success with your GoPiGo3!
I will have a look at that just to see what it is like. Thank you!
But to be honest I will stick with Python it is a lot more appealing to me and I’ve always wanted to work with it. Java was the first programming language I learned in my Software Engineering degree. Oh really? Yeah Java isn’t my favourite language I’ve worked with
Thank you very much!
Re: Programming/naming conventions.
With all due apologies to @cyclicalobsessive, my opinion about “naming conventions” is more Calvin and Hobbs than Guido and Python.
If I think it’s a good idea, if I think it’s visually appealing, and if it makes sense to me, I do it. Otherwise, I do what makes sense to me, regardless of what the “naming conventions” say. 
The bottom line is that YOU have to read the code, and YOU have to maintain it.
It also depends on who is going to be grading your project. If this guy is really strict about PEP compliance, then be strict. If he likes Java naming conventions, do it the way he’ll like best.
With regard to your gamepad:
I found this little gem on-line, (https://gamepadtest.com/), that allows you to use a browser to check and verify that all the analog axes and buttons are doing what you expect them to do. You can also use it to verify what the joystick and button indexes are.
In my case, I bought a cheap “Ritmix” gamepad. Before I started coding with it, I tried it with the gamepad tester - and boy was it a revelation!
It turned out that:
So, I went out and spent about 4-5 times the money and bought a Logitech gamepad, and the difference was like night-and-day!
Translation: The difference between a 400₽ gamepad and a gamepad that was more than 2000₽ was massive - being like $5 vs $25 USD - and the quality difference was immense.
I am going to recommend you take a peek at your gamepad online, just to make sure the joystick and button action is smooth and correct. This way you don’t waste time trying to make your program compensate for a poor quality joystick - or conversely, you can concentrate on your code when you have confidence that your gamepad is working properly.
Here is an illustration I shamelessly stole from the W3C’s “Standard Gamepad” site. I also changed the colors around, (made it black-and-white), changed the font size and moved a few things around to make them easier to see.
Here’s my “Standard Gamepad” reference diagram that I use primarily to remind me which direction the values of the joystick axes go.
As far as classes and stuff is concerned, @cyclicalobsessive is your man. He probably knows more about that than any five other people here, including - ESPECIALLY including - me.
As far as getting a joystick and a robot talking to each other - that’s something I’m working on and I will be glad to give you whatever help I can.
Keep on Truckin’!
(Don’t loose your faith in yourself!)
Oooh! I did that too. . .
I had this brilliant brainstorm, (probably helped by a bit of (ahem!) “rocket fuel”, or if you’re in Russia, “anti-freeze”), of changing all the class references from “gopigo3_robot” to “gopigo3” throughout my code - to make it easier to read. 
The results were, well, “interesting” and I couldn’t figure out why my beautifully working piece of software had suddenly gone all pear-shaped on me. What was especially interesting was that there were no exceptions or errors or conflicts or whatever thrown at all - things were just as peachy and calm as the weather in the eye of a hurricane.
When I RE-re-named everything to “my_gopigo3”, things were happy again - and it took me a few moments to figure it out. (Actually more than a “few” moments if I’m going to be perfectly honest.)
What happened is that my “gopigo3” instance was derived from the EasyGoPiGo3 class, which was, (surprise!), derived from the original “gopigo3” base-class.
I don’t know what the computer was thinking I was telling it to do, but it was interesting!
Haha that is fair enough I think I could definitely brush up on Python conventions though. Yes that’s true it is me that will be reading my code I will also add comments aswell.
For my project, my supervisor and an assessor will be grading it. From what I’ve gathered, the implementation is worth 20% and my dissertation is worth 70% and presentation 10%. I don’t think they are really strict with the compliance. I’ll be graded on lots of different things like background research, design documentation, and proving that I have created the Autonomous Car. Whereas one of my modules Embedded Systems will mainly be assessing my C++ implementation. I think my coding is still very important of course but I’ll be assessed on other things aswell.
Oh okay that’s great thank you very much! To be honest the library I used PyPS4 in the github page: https://github.com/ArturSpirin/pyPS4Controller it outlines flaws of the package like ‘not all buttons are recognised’ which I did notice that the d-pad wasn’t working at all so I had to use other buttons that were recognised on the PS4 Controller. There is no harm in double checking though definitely! My supervisor also gave me a PS2 Controller to try 
That is really annoying though about your gamepad. I feel like with mine it has been very temperamental so I definitely will check out that website! I do have 2 PS4 Controllers so if it is to do with one of them at least I have a backup.
Yes exactly, to be honest i have tested it now and it is working fine but I can always double check my controller and ensure some of the buttons that aren’t registering actually work.
Haha thank you!!!
Remind me what “Autonomous Car” means with respect to this project.
)Also remind me, what connection interface are you using? I don’t know what “ds4drv” is, (Sony PlayStation Dual-Shock 4 - whatever that is), but it sound like poison to me - at least with regard to this gamepad.
Is a wireless gamepad connection required? In my case, I have my gamepad/joystick connected to my computer via USB so I avoid all the wireless issues.
The way my robot works is that the core functionality is on the robot itself, which connects to my household network via WiFi, and I connect to the robot via a web browser, (a whole different set of problems!), and use my “big” Saitek X52 joystick to drive it around. Theoretically, (
), any computer with access to my network, (and another Saitek joystick!) could connect to my robot and drive it around.
I did not implement any kind of Bluetooth control just to avoid the issues that using a wireless gamepad would produce.
Another question:
What is the definition of “success”? Does it have to drive across the room? Drive across the room and avoid obstacles like the Professor’s cat? Or maybe drive across the room, avoid the cat, and bring back fresh cat-treats?
Haha if my car could drop my dissertation off at my supervisors office and then fetch me a gin after that would be great 
The connection interface I am using is ds4drv and is via Bluetooth I watched a YouTube video on the PyPS4 library and the guy who created this library shown how he used it by connecting the controller via Bluetooth using this interface so I assumed I needed to do that. It isn’t always reliable sometimes the controller connects better the closer it is to my car but it always says on the terminal that the ‘signal is very low’.
A wireless controller isn’t required I can use any. My supervisor gave me a wired ps2 pad but he said I can use any. It is only so that I can control the car to drive around a track and collect data from the track.
The main objective for the project is for the Autonomous Car to follow a track. For the track I am just using white A4 paper. I have implemented the rpi camera using OpenCV for image processing and colour detection.
Another feature I need to implement is obstacle detection so when there are objects near the car in front or behind the car will stop. I will implement this part after lane detection. My supervisor told me that a student last year implemented these 2 and got 85%/100.
Optionally and if I have time, I want to implement traffic light detection. So when the light is green the car will go and if the light is red the car will stop. I will have to see though because I’m not too sure if I will have time to do this and it isn’t required for the project but it is something I’d like to do!
Definition of success:
Car can drive around a track and identify curves and patterns
Car can detect objects, obstacles/avoid collisions
Car can detect traffic lights
I’m going to invite @superbam to join us as he’s already done this.
You may want to go check out his thread, he was doing the exact same thing except that he was doing lane detection.
Viz.:
There’s a lot of good information there that may well be useful to you.
I’m doing lane detection in my project aswell. Thank you I will have a look at the thread! 
I don’t know how much of “his work” you can use without getting in trouble for plagiarism, but hopefully this will give you ideas.
Maybe you can/should cite his efforts as a research source?
Side Note:
My how times have changed! I remember during my freshman year at Virginia Tech, my big (independent) project was wiring up a boot loader circuit that took the place of a stack of punched cards and was used to make a GE-4020 mainframe self-booting.
Today’s projects?
Self driving cars that can avoid obstacles, find the liquor store, know the best sources for weed, and find you a hot date!
Sheesh!
Well, if you use A4 paper as your track, I would recommend you this youtube series:
To track obstacles, you could use a haar cascade, but it’s not very reliable… But I am pretty sure, there are a lot of projects on github that let you detect the state of traffic lights
I’ll have a look at the thread but I wouldn’t copy anything. Yes definitely it will give me ideas for how I’d like to approach mine.
Wow that sounds interesting! I’m only just working with circuits this semester I do enjoy it. For mine I have to make an environmental home monitoring system that monitors temperature, humidity and other things in C++.
Haha yes there is quite a difference
Oh okay I’ll have a look at that YouTube series thank you!
