Develop Reference

Problem handling interruption with Raspberry Pi 4 with a DC Motor

I have some troubles handling interruptions with my Raspberry Pi 4, using Python.
I have a DC motor with an encoder , I would like to make a speed control of this motor. But I have some issues with reading the encoder values with my Raspberry.
Here is the code I run :
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
HallA = 5 # GPIO pin for Hall A
HallB = 6 # GPIO pin for Hall B
GPIO.setup(HallA, GPIO.IN) #set up the input
GPIO.setup(HallB, GPIO.IN)
incmot = 0 # set up the counter
def encodeur_inc(channel) : #function of the interruption
B = GPIO.input(HallB) #read the second signal
global incmot
if B == 1 :
incmot = incmot +1
else :
incmot = incmot -1
GPIO.add_event_detect(HallA, GPIO.RISING, callback = encodeur_inc) #setting up the interruption
try :
while True :
print(incmot)
except :
GPIO.cleanup()
The problem is that, for the same number of revolutions, I get a different number of pulses each time (from 480 to 650 pulses per revolution, while the manufacturer announces 690). I tried to identify where the problem could come from:
It does not come from the encoder, I displayed on an oscilloscope the signals of the two outputs of the encoder, they were indeed phase quadrature rectangle waves
The raspberry does not miss interrupts, by rising a pin high when entering the interrupt then low when leaving, I displayed on the oscilloscope the inputs and outputs of the interrupt.
GPIO.output(20, GPIO.HIGH) #at the beginning of the function
GPIO.output(20, GPIO.LOW) #at the end of the function
So I don't see where the inconsistencies I see could come from. I you have any clue that could help me don't hesitate.
Thanks for your help !

Thanks to #quamrana, I understood where the problem came from. When the program was interrupted, the time taken to execute the interrupt was variable and, going clockwise, Hall B could be at 1 or 0, instead of 1 all the time.
To get around this problem, using a D latch allows Python time to execute the interrupt and correctly read whether the engine is moving forward or backward. Hall A is the clock of the latch and Hall B is the data.

HC-SR04 gets stuck (Python and Raspberry Pi)

I'm trying to use the HC-SR04 ultrasonic sensor on a Raspberry Pi 3 with Python. I got the majority the code from this site. However, When I reduce the sleep time between each measurement of distance, The code gets stuck in the while GPIO.input(ECHO)==0: loop and then that stops everything. Maybe I'm setting the sleep time too low, But I really don't see how that would change anything.
import RPi.GPIO as GPIO
import time
GPIO.setmode(GPIO.BCM)
TRIG=23
ECHO=24
GPIO.setup(TRIG,GPIO.OUT)
GPIO.setup(ECHO,GPIO.IN)
def pulseIn():
while True:
GPIO.output(TRIG, False)
time.sleep(.000005)
GPIO.output(TRIG, True) # Sending out a trigger pulse for 10 microseconds
time.sleep(.00001)
GPIO.output(TRIG, False)
pulse_start = time.time()
pulse_end = time.time()
while GPIO.input(ECHO)==0: # This is where it keeps getting stuck
pulse_start = time.time()
#if pulse_start-pulse_end>.5: # This is one of my attempts to fix the problem.
# It caused some bad output values
# continue
while GPIO.input(ECHO)==1:
pulse_end = time.time()
return pulse_end-pulse_start
time.sleep(2) # Giving the sensor some time to warm up
for i in range(100):
print(pulseIn()*17500)
time.sleep(.001) # It seems to work when I set this to 1, but I would prefer if it worked faster

Raspberry pi, unlike Arduino or other microcontroller platform, is a computer based on a Microprocessor and therefore has an operating system running on it to control software/hardware aspects of its operation. Multitasking Operating systems have schedulers that essentially provides all running processes, a chunk of hardware(cpu) to process instructions.
The caveat that comes with this is that, an instruction may not be executed immediately if the scheduler gives priority to other processes.
The following chunk of code would likely cause issues since getting the pulse is a time sensitive operation.
while GPIO.input(ECHO)==0:
pulse_start = time.time()
while GPIO.input(ECHO)==1:
pulse_end = time.time()
return pulse_end-pulse_start
Your loop would likely run infinitely if the sensor is done sending the low pulse and process start reading it then.
You could also get wildly incorrect values attributing to such delays.
So, what's the solution ?
If I were you, I would use a microcontroller to read the values from the sensor and then read the recorded data from it using I2c or any other communication protocol supported.
However you could also add a counter in your while loops to handle such cases like it is described here:
https://raspberrypi.stackexchange.com/questions/82833/hc-sr04-randomly-stops-taking-readings

From the datasheet we can see that this sensor has a maximum distance range of 4 meters. Hence, as you decrease the delay between two consecutive measurements, you might be sending another ultrasonic signal from the sensor when the previous signal has not arrived. Datasheet recommends 60 ms measurement cycle for this sensor. Your measurement cycle is much smaller than the recommended value.
Sensor datasheet:
https://cdn.sparkfun.com/datasheets/Sensors/Proximity/HCSR04.pdf

This is a common problem with hc-src04. It stops working somehow. You should create another counter inside while loop. And then you should check that time to break inner while loop. Here is how I do it.
def distance(myStartingTime):
calculation_starting_time = time.time()
GPIO.output(trigger_pin,True)
time.sleep(0.00001)
GPIO.output(trigger_pin, False)
start = time.time()
end = time.time()
while GPIO.input(echo_pin) == 0:
calculation_starting_time = time.time()
if calculation_starting_time - myStartingTime > 1:
break
start = time.time()
while GPIO.input(echo_pin) == 1:
calculation_starting_time = time.time()
if calculation_starting_time - myStartingTime > 1:
break
end = time.time()
difference = end-start
distance = (difference*34300)/2
return distance
while True:
start = time.time()
my_distance = distance(start)
print("dist: ", my_distance)

Controlling a relay using a DHT22 on raspberry pi B model

I am trying to create essentially a thermostat control using a DHT22 sensor. I would like to read the data from the sensor and using an if statement compare the sensor value to a set temperature value. If achieved the if statement would turn on a relay using a normally off outlet. Below is the code i have wrote in Geany programming to get a general idea of what i would like to do.
from time import sleep
import RPi.GPIO as GPIO
import Adafruit_DHT as dht
GPIO.setmode(GPIO.BCM)
AC_1_GPIO = 17 #sets relay to GPIO pin 17 for AC unit control
DHT_1_GPIO = 3
GPIO.setup(AC_1_GPIO, GPIO.OUT) #sets up GPIO to be on or off based on condition
#GPIO.setup(DHT_1_GPIO, GPIO.OUT) #
humdtemp = dht.read_retry(dht.DHT22, DHT_1_GPIO)
Temp_Max = 32 #this is temperature maximum value for tent
#Humd_Max = 60 #this is relative humidity maximum value for
#Humd_Min = 30 #this is relative humidity mininum value for
while True: #creates continuous loop
if humdtemp > Temp_Max: #compares sensor value to maximum
# temperature value
GPIO.output(AC_1_GPIO, GPIO.LOW) #turns on AC unit using controllable relay
elif humdtemp == Temp_Max:
print ("Achieving 72 degree temperature") #we need to select a temperature setpoint value
else:
GPIO.output(AC_1_GPIO, GPIO.HIGH) #turns 'on' normally off relay

Python, RPi + MCP3008 + 2xForce Sensitive Resistor - Square

I have a MCP3008 connected to RPi and 2 x Force Sensitive Resistor - Square connected to the MCP3008. The sensors are laying side by side horisontal on my desk and I can read and print the data (0-100) from both sensors (sensor1 and sensor2) separately. I just can't come up with any idea of python code to detect when I touch sensor1 (left) and move my finger to sensor2 (right).
In addition I need to know how many milliseconds it takes from that I touch sensor1 until I lifted from sensor2.
from time import sleep
from gpiozero import MCP3008
sensor1 = MCP3008(1) # Pin 2 on the ADC
sensor2 = MCP3008(2) # Pin 3 on the ADC
# Read data from the ADC
def getData(readSensor):
value = readSensor
rawValue = value.value
return rawValue
while True:
print('Sensor1 = {0:.0f}'.format(getData(sensor1)*100))
print('Sensor2 = {0:.0f}'.format(getData(sensor2)*100))
print('')
sleep(0.1)

You are going to need to timestamp the events and then use the time stamps to determine what action to take. Something like the below might help you.
if getData(sensor1) > TOUCH_THRESHOLD:
sensor1LastPressedAt = time.time()
Do the same for sensor2 and compare the time stamps.
(TOUCH_THRESHOLD is the value that you measure to be someone touching the button)

Trouble coding an LED selector in Python

I have 4 LEDs connected to GPIO outputs of a Raspberry Pi. I want to use the argv command so that I can select the LEDs using a simple binary code. For example:
python test.py 1010
This would light up the first and third LEDs in the row. The problem is I don't think Im approaching this correctly. Here is my code so far
from sys import argv
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BOARD)
GPIO.setup(11, GPIO.OUT)
GPIO.setup(12, GPIO.OUT)
GPIO.setup(13, GPIO.OUT)
GPIO.setup(15, GPIO.OUT)
x, y = argv
print "Script:", x
if y == '0000':
GPIO.output(11, 0)
GPIO.output(12, 0)
GPIO.output(13, 0)
GPIO.output(15, 0)
if y == '0001':
GPIO.output(11, 0)
GPIO.output(12, 0)
GPIO.output(13, 0)
GPIO.output(15, 1)
GPIO.cleanup()
Im leaving out the rest of the combinations so I dont bloat this question. Im running into several syntax issues, but Im wondering if I should just scrap this and go about it another way. Im new and any advice would be appreciated.

It sounds very much like what you really want is to map the pieces of your input string to the values of your calls to GPIO.output. You can do that easily (and with far less code than you currently have) by iterating over the control string:
led_map = {
# This maps each "bit" of your input string to the correct ID for GPIO.
0 : 11,
1 : 12,
2 : 13,
3 : 15
}
for i in xrange(len(y)):
bit = y[i]
GPIO.output(led_map[i], int(bit))
This setup prevents you from having to code each permutation separately (which quickly becomes terrible even with only two or three bits, let alone four or more). Rather than thinking in terms of permutations, you can just consider the bits individually, and perform the appropriate functions on each of them in turn.