I bought mg995 servo motor but it seems controlling is different from the mg90 because it is digital.
What I want to do is spinning mg995 loop, stops when I press ctrl+c and starts loop again when I press the enter. the code is below but it won't loop again after servo1.stop()
from cmath import inf
from PIL import Image
import numpy as np
import RPi.GPIO as GPIO
from time import sleep
################# -----------------------------
GPIO.setmode(GPIO.BCM)
servo1_pin = 18
GPIO.setup(servo1_pin, GPIO.OUT)
servo1 = GPIO.PWM(servo1_pin, 50)
servo1.start(0)
servo_min_duty = 3
servo_max_duty = 12
def set_servo_degree(servo_num, degree):
if degree > 180:
degree = 180
elif degree < 0:
degree = 0
duty = servo_min_duty+(degree*(servo_max_duty-servo_min_duty)/180.0)
if servo_num == 1:
servo1.ChangeDutyCycle(duty)
#################-------------------------------
try:
while True:
set_servo_degree(1, 0)
except KeyboardInterrupt:
servo1.stop() # after servo stops, it won't start again.
print("should be end")
pass
go_button = input('go? press enter!')
if go_button == "":
## after press the enter, starts loop again.
try:
while True:
set_servo_degree(1, 0)
else:
break()
sleep(2)
GPIO.cleanup()
thank you!
The while loop should be outside of the set_servo_degree function.
The modified part of your code is as below
servo_num = 1
servo_deg = 0
while True:
try:
set_servo_degree(servo_num, servo_deg)
except KeyboardInterrupt:
servo1.stop()
go_button = input('go? press enter!')
if go_button == "":
set_servo_degree(servo_num, servo_deg)
else:
break
sleep(2)
GPIO.cleanup()
Related
I am trying to make a task for school with Python. But the problem is that I don't understand how the following function works: So we are trying to make a smarthome with lights and relays(now we use LED). If we push the button once, lights go on, if we push twice within 1.5sec: all lights go on and so on...
Also we have to make a function when lights are already on...
So my question is "How do I tell or let python know that I pushed the button once or twice or more or hold it so it does a function?"
This is my code (we work with on the air uploading to Raspberry Pi
#!/usr/bin/env
__author__ = "Zino Henderickx"
__version__ = "1.0"
# LIBRARIES
from gpiozero import LED
from gpiozero import Button
from gpiozero.pins.pigpio import PiGPIOFactory
import time
IP = PiGPIOFactory('192.168.0.207')
# LED's
LED1 = LED(17, pin_factory=IP)
LED2 = LED(27, pin_factory=IP)
LED3 = LED(22, pin_factory=IP)
LED4 = LED(10, pin_factory=IP)
# BUTTONS
BUTTON1 = Button(5, pin_factory=IP)
BUTTON2 = Button(6, pin_factory=IP)
BUTTON3 = Button(13, pin_factory=IP)
BUTTON4 = Button(19, pin_factory=IP)
# LISTS
led [10, 17, 22, 27]
button [5, 6, 13, 19]
def button_1():
if BUTTON1.value == 1:
LED1.on()
time.sleep(0.50)
if BUTTON1.value == 0:
LED1.on()
time.sleep(0.50)
def button_2():
if BUTTON2.value == 1:
LED2.on()
time.sleep(0.50)
if BUTTON2.value == 0:
LED2.on()
time.sleep(0.50)
def button_3():
if BUTTON3.value == 1:
LED3.on()
time.sleep(0.50)
if BUTTON3.value == 0:
LED3.on()
time.sleep(0.50)
def button_4():
if BUTTON4.value == 1:
LED4.on()
time.sleep(0.50)
if BUTTON4.value == 0:
LED4.on()
time.sleep(0.50)
def check_button():
while True:
for i in range(BUTTON1):
toggle_button(i)
def main():
set_up_led()
set_up_button()
check_button()
# MAIN START PROGRAM
if __name__ == "__main__":
main()
Have you thought about setting up some sort of timer that goes off as soon as a button is pressed? This would then trigger a loop that will check for a given time if the button is pressed again or not. If the time has elapsed, the loop ends and it executes one instruction, and if the button has been reset, the program executes the other instruction.
import time
#define max_time to consider a double execution
max_time = 1
while 1:
time.sleep(0.001) # do not use all the cpu power
# make a loop to test for the button being pressed
if button == pressed:
when_pressed = time.time()
while time.time() - when_pressed < max_time:
time.sleep(0.001) # do not use all the cpu power
if button == pressed:
# Instructions 2
#Instructions 1
I'm trying to write a python code to control the voltage of the GPIO Pins.
The idea behind it is that in a frequency of 1KHz if half of the time the pin is off and half of the time it is on than the voltage will be 50%.
I need to keep the while loop running while waiting for user input so that I can change the speed of the motor.
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.OUT)
# The higher the number for speed the slower the motor will rotate
def motor(speed):
i = 0
run = True
# Runs until user tells it to stop
while run == True:
# Pins should vary at every second
time.sleep(0.001)
i += 1
if i % speed == 0:
GPIO.output(4, GPIO.HIGH)
else:
GPIO.output(4, GPIO.LOW)
# This block is causing the issue
# I need the loop to keep running while waiting for the input
if i % speed * 10 == 0:
com = int(input("Enter 0 to quit"))
if com == -1:
GPIO.output(4, GPIO.LOW)
break
GPIO.output(4, GPIO.LOW)
run = True;
while (run):
speed = int(input("Select Speed"))
if speed == 0:
run = False
else:
motor(speed)
GPIO.cleanup()
I want to change the blinking time of LED with every button press.
The code i written in python do not respond to button input clicks. what chages does it need?looks like callback isnt working
import RPi.GPIO as GPIO
from time import sleep
inbutton = 13
outpin = 7
z = 1
def init():
GPIO.setmode(GPIO.BOARD)
GPIO.setup(outpin, GPIO.OUT)
GPIO.setup(inbutton, GPIO.IN, pull_up_down=GPIO.PUD_UP)
global z
z = 1
def zest():
global z
if z == 1:
z = 2
while z == 2:
GPIO.output(outpin, 1)
print("led on")
sleep(1)
GPIO.output(outpin, 0)
print("led off")
sleep(1)
elif z == 2:
z = 1
while z == 1:
GPIO.output(outpin, 1)
print("led on")
sleep(2)
GPIO.output(outpin, 0)
print("led off")
sleep(2)
def loop():
GPIO.add_event_detect(inbutton, GPIO.FALLING, callback=zest(), bouncetime=1000)
if __name__ == '__main__':
init()
try:
while True:
loop()
except KeyboardInterrupt:
GPIO.output(outpin, 0)
GPIO.cleanup()
On running LED blinks with 1second interval. but dont respond to button click.experts out there please have a look.
Change this line:
GPIO.add_event_detect(inbutton, GPIO.FALLING, callback=zest(), bouncetime=1000)
to this:
GPIO.add_event_detect(inbutton, GPIO.FALLING, callback=zest, bouncetime=1000)
As you have it, the callback is called once when registering it and registered callback is saved as None since that is what was returned by zest().
The callback also needs to accept a single argument: channel. So change your function definition to:
def zest(channel):
I am developing a system where I am avoiding an accident by slowing down the motor speed using distance provided by ultrasonic sensor. Also, if accident happens, it must be sense through sw420 and accident occurred result should be displayed.
The problem is that, i have code for both motor mgmt. - distance sensing and impact detection. But as I want them to run parallel i.e.., both are running at same time. How to do it?
Eg. If car is running smoothly, suddenly another car hits you from, let's say, from back.....then automatically, sw420 sensor should sense it and alert the accident occurred message.
Or in other words, some type of multiprocessing concept is needed which i am unaware of.
Here's what i have done till now -
1. Motor is perfectly slowing down when ultrasonic sensor senses shorter distance.
import RPi.GPIO as GPIO
import time
# Define GPIO For Driver motors
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT)
GPIO.setup(16, GPIO.OUT)
GPIO.setup(18, GPIO.OUT)
gpio.setwarnings(False)
gpio.setmode(gpio.BOARD)
gpio.setup(7,gpio.OUT)
pwm=GPIO.PWM(18,100)
# Define GPIO for ultrasonic central
GPIO_TRIGGER_CENTRAL = 23
GPIO_ECHO_CENTRAL = 24
GPIO.setup(GPIO_TRIGGER_CENTRAL, GPIO.OUT) # Trigger > Out
GPIO.setup(GPIO_ECHO_CENTRAL, GPIO.IN) # Echo < In
# Functions for driving
def goforward():
pwm.start(100)
GPIO.output(12, True)
GPIO.output(16, False)
GPIO.output(18, True)
def goforwardslow():
GPIO.output(12, True)
GPIO.output(16, False)
GPIO.output(18, True)
def stopmotors():
GPIO.output(12, False)
GPIO.output(16, False)
GPIO.output(18, False)
def buzzer():
try:
while True:
gpio.output(7,0)
time.sleep(0.2)
gpio.output(7,1)
time.sleep(0.2)
except KeyboardInterrupt:
gpio.cleanup()
exit
#Detect front obstacle
def frontobstacle():
# Set trigger to False (Low)
GPIO.output(GPIO_TRIGGER_CENTRAL, False)
# Allow module to settle
time.sleep(0.2)
# Send 10us pulse to trigger
GPIO.output(GPIO_TRIGGER_CENTRAL, True)
time.sleep(0.00001)
GPIO.output(GPIO_TRIGGER_CENTRAL, False)
start = time.time()
while GPIO.input(GPIO_ECHO_CENTRAL) == 0:
start = time.time()
while GPIO.input(GPIO_ECHO_CENTRAL) == 1:
stop = time.time()
# Calculate pulse length
elapsed = stop - start
# Distance pulse travelled in that time is time
# Multiplied by the speed of sound (cm/s)
distance = elapsed * 17150 # distance of both directions so divide by 2
print "Front Distance : %.1f" % distance
return distance
# Check front obstacle and stop if there is an obstacle
def checkanddrivefront():
while frontobstacle() < 15:
pwm.ChangeDutyCycle(25)
buzzer()
goforwardslow()
time.sleep(3)
goforward()
# Avoid obstacles and drive forward
def obstacleavoiddrive():
goforward()
start = time.time()
# Drive 5 minutes
while start > time.time() - 300: # 300 = 60 seconds * 5
if frontobstacle() < 15:
pwm.ChangeDutyCycle(25)
goforwardslow()
checkanddrivefront()
#elif rightobstacle() < 30:
# stopmotors()
# checkanddriveright()
#elif leftobstacle() < 30:
# stopmotors()
#checkanddriveleft()
# Clear GPIOs, it will stop motors
#cleargpios()
#def cleargpios():
#print "clearing GPIO"
#GPIO.output(12, False)
#GPIO.output(13, False)
#print "All GPIOs CLEARED"
def main():
# First clear GPIOs
#cleargpios()
print "start driving: "
# Start obstacle avoid driving
obstacleavoiddrive()
if __name__ == "__main__":
main()
Vibrations is also detecting by sw420
import RPi.GPIO as GPIO
from time import sleep
channel = 17
GPIO.setmode(GPIO.BCM)
GPIO.setup(channel, GPIO.IN)
sleep(0.1)
while True:
result = GPIO.input(channel)
if result == 1:
print ("Vibration")
Now the problem is that, where should i place or how can i use vibration/sw420 code in the MAIN CODE so that both run parallel and whenever accident happens, sw420'code occupies higher priority than motor code and gives accident occurred message.
Please share your advice.
NOW THIS IS WHAT LATEST I HAVE DONE TILL NOW -
import RPi.GPIO as GPIO
import time
from multiprocessing import Process
# Define GPIO For Driver motors
GPIO.setmode(GPIO.BOARD)
GPIO.setup(12, GPIO.OUT)
GPIO.setup(16, GPIO.OUT)
GPIO.setup(18, GPIO.OUT)
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(7,GPIO.OUT)
pwm=GPIO.PWM(18,100)
channel = 11
GPIO.setmode(GPIO.BOARD)
GPIO.setup(channel, GPIO.IN)
sleep(0.1)
# Define GPIO for ultrasonic central
GPIO_TRIGGER_CENTRAL = 23
GPIO_ECHO_CENTRAL = 24
GPIO.setup(GPIO_TRIGGER_CENTRAL, GPIO.OUT) # Trigger > Out
GPIO.setup(GPIO_ECHO_CENTRAL, GPIO.IN) # Echo < In
# Functions for driving
def goforward():
pwm.start(100)
GPIO.output(12, True)
GPIO.output(16, False)
GPIO.output(18, True)
def goforwardslow():
GPIO.output(12, True)
GPIO.output(16, False)
GPIO.output(18, True)
def stopmotors():
GPIO.output(12, False)
GPIO.output(16, False)
GPIO.output(18, False)
def buzzer():
while True:
GPIO.output(7,0)
time.sleep(0.2)
GPIO.output(7,1)
time.sleep(0.2)
def vib():
while True:
result = GPIO.input(channel)
if result == 1:
print ("Vibration")
#Detect front obstacle
def frontobstacle():
# Set trigger to False (Low)
GPIO.output(GPIO_TRIGGER_CENTRAL, False)
# Allow module to settle
time.sleep(0.2)
# Send 10us pulse to trigger
GPIO.output(GPIO_TRIGGER_CENTRAL, True)
time.sleep(0.00001)
GPIO.output(GPIO_TRIGGER_CENTRAL, False)
start = time.time()
while GPIO.input(GPIO_ECHO_CENTRAL) == 0:
start = time.time()
while GPIO.input(GPIO_ECHO_CENTRAL) == 1:
stop = time.time()
# Calculate pulse length
elapsed = stop - start
# Distance pulse travelled in that time is time
# Multiplied by the speed of sound (cm/s)
distance = elapsed * 17150 # distance of both directions so divide by 2
print "Front Distance : %.1f" % distance
return distance
# Check front obstacle and stop if there is an obstacle
def checkanddrivefront():
while frontobstacle() < 15:
pwm.ChangeDutyCycle(25)
buzzer()
goforwardslow()
time.sleep(3)
goforward()
# Avoid obstacles and drive forward
def obstacleavoiddrive():
goforward()
start = time.time()
# Drive 5 minutes
while start > time.time() - 300: # 300 = 60 seconds * 5
if frontobstacle() < 15:
pwm.ChangeDutyCycle(25)
buzzer()
goforwardslow()
checkanddrivefront()
#elif rightobstacle() < 30:
# stopmotors()
# checkanddriveright()
#elif leftobstacle() < 30:
# stopmotors()
#checkanddriveleft()
# Clear GPIOs, it will stop motors
#cleargpios()
#def cleargpios():
#print "clearing GPIO"
def main():
print "start driving: "
# Start obstacle avoid driving
obstacleavoiddrive()
if __name__ == "__main__":
p1 = multiprocess.Process(target = main)
p2 = multiprocess.Process(target = vib)
p1.start()
p2.start()
I HAVE USED MULTIPROCESSING ....BUT YET AGAIN ONLY MOTOR DRIVE FUNCTION IS EXECUTING, VIBRATION CODE IS NOT ACTIVE IN THE CODE....means no output from it.
I'm trying to make a Python program with Raspberry Pi that when I push a button, only the red LED brightens, and when I press another button, only the green LED brightens. When no buttons are pushed, all the LEDs are off. But when I try to run it, both LEDs stay on, and when I press the button, the monitor says I pressed it, but nothing changes. What can I do to fix this? I'm 100% certain there are no wiring problems, and the monitor shows no errors. BTW, here's the code:
import RPi.GPIO as GPIO
import time
GPIO.setwarnings(False)
red_walk_LED = 16
green_traf_LED = 15
Btn_one = 22 # pin12 --- button
Btn_two = 29 # pin29 --- 2nd button
# GLOBAL VARIABLES
red_Led_status = 1
Green_Led_status = 1
flag_btn_one_pushed = 0
flag_btn_two_pushed = 0
def all_leds_off():
GPIO.output(green_traf_LED, GPIO.HIGH)
GPIO.output(yellow_traf_LED, GPIO.HIGH)
GPIO.output(red_traf_LED, GPIO.HIGH)
GPIO.output(red_walk_LED, GPIO.HIGH)
GPIO.output(white_walk_LED, GPIO.HIGH)
def setup():
global green_LED_frequence
global red_LED_frequence
GPIO.setmode(GPIO.BOARD) # Numbers GPIOs by physical location
#set LEDs as outputs
GPIO.setup(green_traf_LED, GPIO.OUT)
GPIO.setup(red_traf_LED, GPIO.OUT)
GPIO.setup(Btn_one, GPIO.IN, pull_up_down=GPIO.PUD_UP) # Set BtnPin's mode as input, and pull up to high level(3.3V)
GPIO.setup(Btn_two, GPIO.IN, pull_up_down=GPIO.PUD_UP)
red_LED_frequence = GPIO.PWM(red_traf_LED, 1000) # set Frequece to 1KHz
green_LED_frequence = GPIO.PWM(green_traf_LED, 1000)
red_LED_frequence.start(0) # Duty Cycle = 0
green_LED_frequence.start(0)
def Btn_one_push(ev=None):
print('OK, the 1st button was pushed')
global red_Led_status #we are allowed to change these variables in this function
global my_counter
global flag_btn_one_pushed
global red_LED_frequence
red_Led_status = not red_Led_status #change LED status 0-1 or 1-0
flag_btn_one_pushed = 1
my_delay = 0.2
GPIO.output(green_traf_LED, GPIO.HIGH)
if red_Led_status == 1: #1-on
print('ok, reds on')
for dc in range(0, 101, 4): # Increase duty cycle: 0~100
red_LED_frequence.ChangeDutyCycle(dc) # Change duty cycle
time.sleep(0.02)
for dc in range(100, -1, -4): # Decrease duty cycle: 100~0
red_LED_frequence.ChangeDutyCycle(dc)
time.sleep(0.02)
all_leds_off() #turn all LEDs off!!
flag_btn_pushed = 0
def Btn_two_push(ev=None):
print('OK, the 2nd button was pushed')
global Green_Led_status
global flag_btn_two_pushed
global green_LED_frequence
Green_Led_status = not Green_Led_status #change LED status 0-1 or 1-0
flag_btn_two_pushed = 1
my_delay = 0.2
GPIO.output(red_traf_LED, GPIO.HIGH)
if Green_Led_status == 1: #1-on
print('This is supposed to work!')
for dc in range(0, 101, 4): # Increase duty cycle: 0~100
print(green_LED_frequence)
green_LED_frequence.ChangeDutyCycle(dc) # Change duty cycle
time.sleep(0.08)
for dc in range(100, -1, -4): # Decrease duty cycle: 100~0
green_LED_frequence.ChangeDutyCycle(dc)
time.sleep(0.08)
all_leds_off() #turn all LEDs off!!
flag_btn_two_pushed = 0
def loop():
global flag_btn_one_pushed
global flag_btn_two_pushed
GPIO.add_event_detect(Btn_one, GPIO.FALLING, callback=Btn_one_push) # wait for change in GPIO 0-1 or 1-0
GPIO.add_event_detect(Btn_two, GPIO.FALLING, callback=Btn_two_push)
while True: #when the button isn't pushed, do this
all_leds_off()
else:
pass
def destroy():
all_leds_off()
GPIO.cleanup() # Release resource
if __name__ == '__main__': # Program start from here
setup()
try:
loop()
except KeyboardInterrupt: # When 'Ctrl+C' is pressed, the child program destroy() will be executed.
destroy()
You should try removing these lines:
while True: #when the button isn't pushed, do this
all_leds_off()
else:
pass
and replacing them with:
all_leds_off()
The callbacks should be fired every button press.
Here is another example to look at:
https://www.raspberrypi.org/forums/viewtopic.php?f=63&t=102631&p=760629
Also, have you tried some simple snippets of code to individually turn the LED's on and off and detect the button presses to prove that's its not a wiring problem? It doesn't take much to get the wiring wrong!