CARIA.1.0.0

Restruct all repositories
Add :
- Files UserWebSite
- IA openCV Tuto
- Alphabot docs for first maquette

AlphaBot-CARIA/Pi-python/AlphaBot.py

@@ -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)
+
+	

AlphaBot-CARIA/Pi-python/Infrared_Line_Tracking.py

@@ -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)
+			 
+

AlphaBot-CARIA/Pi-python/Infrared_Obstacle_Avoidance.py

@@ -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();
+

AlphaBot-CARIA/Pi-python/Infrared_Remote_Control.py

@@ -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();
+

AlphaBot-CARIA/Pi-python/Infrared_Tracking_Objects.py

@@ -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();
+

AlphaBot-CARIA/Pi-python/Ultrasonic_Obstacle_Avoidance.py

@@ -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();

AlphaBot-CARIA/Pi-python/Ultrasonic_Ranging.py

@@ -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()

IA/IA-Tuto-YT.url

@@ -0,0 +1,5 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,11
+[InternetShortcut]
+IDList=
+URL=https://www.youtube.com/watch?v=-3xbAkCWJCc&list=PLALfJegMRGp2dJh-n1EVw2ESAUY-Et9KE

IA/Tuto.url

@@ -0,0 +1,5 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,11
+[InternetShortcut]
+IDList=
+URL=https://github.com/L42Project/Tutoriels

IA/haarcascades.url

@@ -0,0 +1,5 @@
+[{000214A0-0000-0000-C000-000000000046}]
+Prop3=19,11
+[InternetShortcut]
+IDList=
+URL=https://github.com/opencv/opencv/tree/master/data/haarcascades