christian.cunatbrule/CARIA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

CARIA.1.0.0

Browse Source 
Restruct all repositories
Add :
- Files UserWebSite
- IA openCV Tuto
- Alphabot docs for first maquette
This commit is contained in:
ccunatbrule
2023-02-12 12:24:39 +01:00
parent 1f9312201e
commit 0a6ce8df24
61 changed files with 989 additions and 375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
AlphaBot-CARIA/AlphaBot-Assembly-Diagram.pdf Normal file
View File

Binary file not shown.

BIN
AlphaBot-CARIA/AlphaBot-User-Manual.pdf Normal file
View File

Binary file not shown.

BIN
AlphaBot-CARIA/AlphaBot_Schematic.pdf Normal file
View File

Binary file not shown.

82
AlphaBot-CARIA/Pi-python/AlphaBot.py Normal file
View File

@@ -0,0 +1,82 @@
import RPi.GPIO as GPIO
import time
class AlphaBot(object):
def __init__(self,in1=12,in2=13,ena=6,in3=20,in4=21,enb=26):
self.IN1 = in1
self.IN2 = in2
self.IN3 = in3
self.IN4 = in4
self.ENA = ena
self.ENB = enb
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(self.IN1,GPIO.OUT)
GPIO.setup(self.IN2,GPIO.OUT)
GPIO.setup(self.IN3,GPIO.OUT)
GPIO.setup(self.IN4,GPIO.OUT)
GPIO.setup(self.ENA,GPIO.OUT)
GPIO.setup(self.ENB,GPIO.OUT)
self.forward()
self.PWMA = GPIO.PWM(self.ENA,500)
self.PWMB = GPIO.PWM(self.ENB,500)
self.PWMA.start(50)
self.PWMB.start(50)
def forward(self):
GPIO.output(self.IN1,GPIO.HIGH)
GPIO.output(self.IN2,GPIO.LOW)
GPIO.output(self.IN3,GPIO.LOW)
GPIO.output(self.IN4,GPIO.HIGH)
def stop(self):
GPIO.output(self.IN1,GPIO.LOW)
GPIO.output(self.IN2,GPIO.LOW)
GPIO.output(self.IN3,GPIO.LOW)
GPIO.output(self.IN4,GPIO.LOW)
def backward(self):
GPIO.output(self.IN1,GPIO.LOW)
GPIO.output(self.IN2,GPIO.HIGH)
GPIO.output(self.IN3,GPIO.HIGH)
GPIO.output(self.IN4,GPIO.LOW)
def left(self):
GPIO.output(self.IN1,GPIO.LOW)
GPIO.output(self.IN2,GPIO.LOW)
GPIO.output(self.IN3,GPIO.LOW)
GPIO.output(self.IN4,GPIO.HIGH)
def right(self):
GPIO.output(self.IN1,GPIO.HIGH)
GPIO.output(self.IN2,GPIO.LOW)
GPIO.output(self.IN3,GPIO.LOW)
GPIO.output(self.IN4,GPIO.LOW)
def setPWMA(self,value):
self.PWMA.ChangeDutyCycle(value)
def setPWMB(self,value):
self.PWMB.ChangeDutyCycle(value)
def setMotor(self, left, right):
if((right >= 0) and (right <= 100)):
GPIO.output(self.IN1,GPIO.HIGH)
GPIO.output(self.IN2,GPIO.LOW)
self.PWMA.ChangeDutyCycle(right)
elif((right < 0) and (right >= -100)):
GPIO.output(self.IN1,GPIO.LOW)
GPIO.output(self.IN2,GPIO.HIGH)
self.PWMA.ChangeDutyCycle(0 - right)
if((left >= 0) and (left <= 100)):
GPIO.output(self.IN3,GPIO.HIGH)
GPIO.output(self.IN4,GPIO.LOW)
self.PWMB.ChangeDutyCycle(left)
elif((left < 0) and (left >= -100)):
GPIO.output(self.IN3,GPIO.LOW)
GPIO.output(self.IN4,GPIO.HIGH)
self.PWMB.ChangeDutyCycle(0 - left)

239
AlphaBot-CARIA/Pi-python/Infrared_Line_Tracking.py Normal file
View File

@@ -0,0 +1,239 @@
#!/usr/bin/python
# -*- coding:utf-8 -*-
import RPi.GPIO as GPIO
import time
CS = 5
Clock = 25
Address = 24
DataOut = 23
class TRSensor(object):
def __init__(self,numSensors = 5):
self.numSensors = numSensors
self.calibratedMin = [0] * self.numSensors
self.calibratedMax = [1023] * self.numSensors
self.last_value = 0
"""
Reads the sensor values into an array. There *MUST* be space
for as many values as there were sensors specified in the constructor.
Example usage:
unsigned int sensor_values[8];
sensors.read(sensor_values);
The values returned are a measure of the reflectance in abstract units,
with higher values corresponding to lower reflectance (e.g. a black
surface or a void).
"""
def AnalogRead(self):
value = [0,0,0,0,0,0]
#Read Channel0~channel4 AD value
for j in range(0,6):
GPIO.output(CS, GPIO.LOW)
for i in range(0,4):
#sent 4-bit Address
if(((j) >> (3 - i)) & 0x01):
GPIO.output(Address,GPIO.HIGH)
else:
GPIO.output(Address,GPIO.LOW)
#read MSB 4-bit data
value[j] <<= 1
if(GPIO.input(DataOut)):
value[j] |= 0x01
GPIO.output(Clock,GPIO.HIGH)
GPIO.output(Clock,GPIO.LOW)
for i in range(0,6):
#read LSB 8-bit data
value[j] <<= 1
if(GPIO.input(DataOut)):
value[j] |= 0x01
GPIO.output(Clock,GPIO.HIGH)
GPIO.output(Clock,GPIO.LOW)
#no mean ,just delay
for i in range(0,6):
GPIO.output(Clock,GPIO.HIGH)
GPIO.output(Clock,GPIO.LOW)
# time.sleep(0.0001)
GPIO.output(CS,GPIO.HIGH)
return value[1:]
"""
Reads the sensors 10 times and uses the results for
calibration. The sensor values are not returned; instead, the
maximum and minimum values found over time are stored internally
and used for the readCalibrated() method.
"""
def calibrate(self):
max_sensor_values = [0]*self.numSensors
min_sensor_values = [0]*self.numSensors
for j in range(0,10):
sensor_values = self.AnalogRead();
for i in range(0,self.numSensors):
# set the max we found THIS time
if((j == 0) or max_sensor_values[i] < sensor_values[i]):
max_sensor_values[i] = sensor_values[i]
# set the min we found THIS time
if((j == 0) or min_sensor_values[i] > sensor_values[i]):
min_sensor_values[i] = sensor_values[i]
# record the min and max calibration values
for i in range(0,self.numSensors):
if(min_sensor_values[i] > self.calibratedMin[i]):
self.calibratedMin[i] = min_sensor_values[i]
if(max_sensor_values[i] < self.calibratedMax[i]):
self.calibratedMax[i] = max_sensor_values[i]
"""
Returns values calibrated to a value between 0 and 1000, where
0 corresponds to the minimum value read by calibrate() and 1000
corresponds to the maximum value. Calibration values are
stored separately for each sensor, so that differences in the
sensors are accounted for automatically.
"""
def readCalibrated(self):
value = 0
#read the needed values
sensor_values = self.AnalogRead();
for i in range (0,self.numSensors):
denominator = self.calibratedMax[i] - self.calibratedMin[i]
if(denominator != 0):
value = (sensor_values[i] - self.calibratedMin[i])* 1000 / denominator
if(value < 0):
value = 0
elif(value > 1000):
value = 1000
sensor_values[i] = value
print("readCalibrated",sensor_values)
return sensor_values
"""
Operates the same as read calibrated, but also returns an
estimated position of the robot with respect to a line. The
estimate is made using a weighted average of the sensor indices
multiplied by 1000, so that a return value of 0 indicates that
the line is directly below sensor 0, a return value of 1000
indicates that the line is directly below sensor 1, 2000
indicates that it's below sensor 2000, etc. Intermediate
values indicate that the line is between two sensors. The
formula is:
0*value0 + 1000*value1 + 2000*value2 + ...
--------------------------------------------
value0 + value1 + value2 + ...
By default, this function assumes a dark line (high values)
surrounded by white (low values). If your line is light on
black, set the optional second argument white_line to true. In
this case, each sensor value will be replaced by (1000-value)
before the averaging.
"""
def readLine(self, white_line = 0):
sensor_values = self.readCalibrated()
avg = 0
sum = 0
on_line = 0
for i in range(0,self.numSensors):
value = sensor_values[i]
if(white_line):
value = 1000-value
# keep track of whether we see the line at all
if(value > 200):
on_line = 1
# only average in values that are above a noise threshold
if(value > 50):
avg += value * (i * 1000); # this is for the weighted total,
sum += value; #this is for the denominator
if(on_line != 1):
# If it last read to the left of center, return 0.
if(self.last_value < (self.numSensors - 1)*1000/2):
#print("left")
return 0;
# If it last read to the right of center, return the max.
else:
#print("right")
return (self.numSensors - 1)*1000
self.last_value = avg/sum
return self.last_value
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(Clock,GPIO.OUT)
GPIO.setup(Address,GPIO.OUT)
GPIO.setup(CS,GPIO.OUT)
GPIO.setup(DataOut,GPIO.IN,GPIO.PUD_UP)
# Simple example prints accel/mag data once per second:
if __name__ == '__main__':
from AlphaBot import AlphaBot
maximum = 35;
integral = 0;
last_proportional = 0
TR = TRSensor()
Ab = AlphaBot()
Ab.stop()
print("Line follow Example")
time.sleep(0.5)
for i in range(0,400):
TR.calibrate()
print(i)
print(TR.calibratedMin)
print(TR.calibratedMax)
time.sleep(0.5)
Ab.backward()
while True:
position = TR.readLine()
#print(position)
# The "proportional" term should be 0 when we are on the line.
proportional = position - 2000
# Compute the derivative (change) and integral (sum) of the position.
derivative = proportional - last_proportional
integral += proportional
# Remember the last position.
last_proportional = proportional
'''
// Compute the difference between the two motor power settings,
// m1 - m2. If this is a positive number the robot will turn
// to the right. If it is a negative number, the robot will
// turn to the left, and the magnitude of the number determines
// the sharpness of the turn. You can adjust the constants by which
// the proportional, integral, and derivative terms are multiplied to
// improve performance.
'''
power_difference = proportional/25 + derivative/100 #+ integral/1000;
if (power_difference > maximum):
power_difference = maximum
if (power_difference < - maximum):
power_difference = - maximum
print(position,power_difference)
if (power_difference < 0):
Ab.setPWMB(maximum + power_difference)
Ab.setPWMA(maximum);
else:
Ab.setPWMB(maximum);
Ab.setPWMA(maximum - power_difference)

38
AlphaBot-CARIA/Pi-python/Infrared_Obstacle_Avoidance.py Normal file
View File

@@ -0,0 +1,38 @@
import RPi.GPIO as GPIO
import time
from AlphaBot import AlphaBot
Ab = AlphaBot()
DR = 16
DL = 19
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(DR,GPIO.IN,GPIO.PUD_UP)
GPIO.setup(DL,GPIO.IN,GPIO.PUD_UP)
try:
while True:
DR_status = GPIO.input(DR)
DL_status = GPIO.input(DL)
if((DL_status == 1) and (DR_status == 1)):
Ab.forward()
print("forward")
elif((DL_status == 1) and (DR_status == 0)):
Ab.left()
print("left")
elif((DL_status == 0) and (DR_status == 1)):
Ab.right()
print("right")
else:
Ab.backward()
time.sleep(0.2)
Ab.left()
time.sleep(0.2)
Ab.stop()
print("backward")
except KeyboardInterrupt:
GPIO.cleanup();

99
AlphaBot-CARIA/Pi-python/Infrared_Remote_Control.py Normal file
View File

@@ -0,0 +1,99 @@
import RPi.GPIO as GPIO
import time
from AlphaBot import AlphaBot
Ab = AlphaBot()
IR = 18
PWM = 50
n=0
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(IR,GPIO.IN,GPIO.PUD_UP)
def getkey():
if GPIO.input(IR) == 0:
count = 0
while GPIO.input(IR) == 0 and count < 200: #9ms
count += 1
time.sleep(0.00006)
count = 0
while GPIO.input(IR) == 1 and count < 80: #4.5ms
count += 1
time.sleep(0.00006)
idx = 0
cnt = 0
data = [0,0,0,0]
for i in range(0,32):
count = 0
while GPIO.input(IR) == 0 and count < 15: #0.56ms
count += 1
time.sleep(0.00006)
count = 0
while GPIO.input(IR) == 1 and count < 40: #0: 0.56mx
count += 1 #1: 1.69ms
time.sleep(0.00006)
if count > 8:
data[idx] |= 1<<cnt
if cnt == 7:
cnt = 0
idx += 1
else:
cnt += 1
print(data)
if data[0]+data[1] == 0xFF and data[2]+data[3] == 0xFF: #check
return data[2]
if data[0] == 255 and data[1] == 255 and data[2] == 15 and data[3] == 255:
return "repeat"
print('IRremote Test Start ...')
Ab.stop()
try:
while True:
key = getkey()
if(key != None):
if key == "repeat":
n = 0
if key == 0x18:
Ab.forward()
# print("forward")
if key == 0x08:
Ab.left()
# print("left")
if key == 0x1c:
Ab.stop()
# print("stop")
if key == 0x5a:
Ab.right()
# print("right")
if key == 0x52:
Ab.backward()
# print("backward")
if key == 0x15:
if(PWM + 10 < 101):
PWM = PWM + 10
Ab.setPWMA(PWM)
Ab.setPWMB(PWM)
print(PWM)
if key == 0x07:
if(PWM - 10 > -1):
PWM = PWM - 10
Ab.setPWMA(PWM)
Ab.setPWMB(PWM)
print(PWM)
else:
n += 1
if n > 20000:
n = 0
Ab.stop()
except KeyboardInterrupt:
GPIO.cleanup();

38
AlphaBot-CARIA/Pi-python/Infrared_Tracking_Objects.py Normal file
View File

@@ -0,0 +1,38 @@
import RPi.GPIO as GPIO
import time
from AlphaBot import AlphaBot
import smbus
Ab = AlphaBot()
DR = 16
DL = 19
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(DR,GPIO.IN,GPIO.PUD_UP)
GPIO.setup(DL,GPIO.IN,GPIO.PUD_UP)
Ab.stop()
try:
while True:
DR_status = GPIO.input(DR)
DL_status = GPIO.input(DL)
if((DL_status == 0) and (DR_status == 0)):
Ab.forward()
print("forward")
elif((DL_status == 1) and (DR_status == 0)):
Ab.right()
print("right")
elif((DL_status == 0) and (DR_status == 1)):
Ab.left()
print("left")
else:
Ab.stop()
print("stop")
except KeyboardInterrupt:
GPIO.cleanup();

73
AlphaBot-CARIA/Pi-python/Ultrasonic_Obstacle_Avoidance.py Normal file
View File

@@ -0,0 +1,73 @@
import RPi.GPIO as GPIO
import time
from AlphaBot import AlphaBot
SERVO = 27
TRIG = 17
ECHO = 5
Ab = AlphaBot()
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(SERVO, GPIO.OUT, initial=GPIO.LOW)
GPIO.setup(TRIG,GPIO.OUT,initial=GPIO.LOW)
GPIO.setup(ECHO,GPIO.IN)
p = GPIO.PWM(SERVO,50)
p.start(0)
def ServoAngle(angle):
p.ChangeDutyCycle(2.5 + 10.0 * angle / 180)
def Distance():
GPIO.output(TRIG,GPIO.HIGH)
time.sleep(0.000015)
GPIO.output(TRIG,GPIO.LOW)
while not GPIO.input(ECHO):
pass
t1 = time.time()
while GPIO.input(ECHO):
pass
t2 = time.time()
return (t2-t1)*34000/2
ServoAngle(90)
print("Ultrasonic_Obstacle_Avoidance")
try:
while True:
middleDistance = Distance()
print("MiddleDistance = %0.2f cm"%middleDistance)
if middleDistance <= 20:
Ab.stop()
# time.sleep(0.5)
ServoAngle(5)
time.sleep(1)
rightDistance = Distance()
print("RightDistance = %0.2f cm"%rightDistance)
# time.sleep(0.5)
ServoAngle(180)
time.sleep(1)
leftDistance = Distance()
print("LeftDistance = %0.2f cm"%leftDistance)
# time.sleep(0.5)
ServoAngle(90)
time.sleep(1)
if rightDistance <20 and leftDistance < 20:
Ab.backward()
time.sleep(0.3)
Ab.stop()
elif rightDistance >= leftDistance:
Ab.right()
time.sleep(0.3)
Ab.stop()
else:
Ab.left()
time.sleep(0.3)
Ab.stop()
time.sleep(0.3)
else:
Ab.forward()
time.sleep(0.02)
except KeyboardInterrupt:
GPIO.cleanup();

30
AlphaBot-CARIA/Pi-python/Ultrasonic_Ranging.py Normal file
View File

@@ -0,0 +1,30 @@
import RPi.GPIO as GPIO
import time
TRIG = 17
ECHO = 5
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
GPIO.setup(TRIG,GPIO.OUT,initial=GPIO.LOW)
GPIO.setup(ECHO,GPIO.IN)
def dist():
GPIO.output(TRIG,GPIO.HIGH)
time.sleep(0.000015)
GPIO.output(TRIG,GPIO.LOW)
while not GPIO.input(ECHO):
pass
t1 = time.time()
while GPIO.input(ECHO):
pass
t2 = time.time()
return (t2-t1)*34000/2
try:
while True:
print("HELLO")
print("Distance:%0.2f cm" % dist())
time.sleep(1)
except KeyboardInterrupt:
GPIO.cleanup()