Merge pull request #176 from CoderBotOrg/develop

RC6

Author: previ

.circleci/_config.yml

@@ -1,7 +1,7 @@
 # This workflow will do a clean install of node dependencies, cache/restore them, build the source code and run tests across different versions of node
 # For more information see: https://help.github.com/actions/language-and-framework-guides/using-nodejs-with-github-actions
 
-name: build CoderBot backend
+name: Build CoderBot backend
 
 on: push
 

.github/workflows/build_backend.yml

@@ -1,5 +1,5 @@
 # backend
-[![CoderBotOrg](https://circleci.com/gh/CoderBotOrg/backend.svg?style=svg)](https://circleci.com/gh/CoderBotOrg/backend/tree/master)
+[![Build CoderBot backend](https://github.com/CoderBotOrg/backend/actions/workflows/build_backend.yml/badge.svg)
 
 > CoderBot is a RaspberryPI-based programmable robot for educational purposes. Check the [project website](https://www.coderbot.org) for more information.
 >

README.md

@@ -3,36 +3,40 @@
 This file contains every method called by the API defined in v2.yml
 """
 
+import logging
 import os
 import subprocess
-import logging
-import connexion
-from werkzeug.datastructures import Headers
-from flask import (request,
-                   send_file,
-                   Response)
-import picamera
 import urllib
+
 import connexion
+import picamera
+from flask import Response, request, send_file
+from werkzeug.datastructures import Headers
 
-from program import ProgramEngine, Program
 from config import Config
 from activity import Activities
+from audio import Audio
 from camera import Camera
 from cnn.cnn_manager import CNNManager
-from musicPackages import MusicPackageManager
-from audio import Audio
 from coderbotTestUnit import run_test as runCoderbotTestUnit
-from coderbot import CoderBot
+from musicPackages import MusicPackageManager
+from program import Program, ProgramEngine
+
 from balena import Balena
+from coderbot import CoderBot
 
 BUTTON_PIN = 16
 
 config = Config.read()
-bot = CoderBot.get_instance(
-    motor_trim_factor=float(config.get("move_motor_trim", 1.0)),
-    hw_version=config.get("hw_version")
-)
+bot = CoderBot.get_instance(motor_trim_factor=float(config.get('move_motor_trim', 1.0)),
+                            motor_max_power=int(config.get('motor_max_power', 100)),
+                            motor_min_power=int(config.get('motor_min_power', 0)),
+                            hw_version=config.get('hardware_version'),
+                            pid_params=(float(config.get('pid_kp', 1.0)),
+                                        float(config.get('pid_kd', 0.1)),
+                                        float(config.get('pid_ki', 0.01)),
+                                        float(config.get('pid_max_speed', 200)),
+                                        float(config.get('pid_sample_time', 0.01))))
 audio_device = Audio.get_instance()
 cam = Camera.get_instance()
 
@@ -125,9 +129,10 @@ def move(body):
 def turn(body):
     speed=body.get("speed")
     elapse=body.get("elapse")
-    if speed is None or speed == 0:
+    distance=body.get("distance")
+    if (speed is None or speed == 0) or (elapse is not None and distance is not None):
         return 400
-    bot.turn(speed=speed, elapse=elapse)
+    bot.turn(speed=speed, elapse=elapse, distance=distance)
     return 200
 
 def takePhoto():

coderbot/api.py

@@ -20,6 +20,7 @@
 import os
 import sys
 import time
+from math import copysign
 import logging
 import pigpio
 import sonar
@@ -100,7 +101,7 @@ class CoderBot(object):
 
     # pylint: disable=too-many-instance-attributes
 
-    def __init__(self, motor_trim_factor=1.0, hw_version="5"):
+    def __init__(self, motor_trim_factor=1.0, motor_min_power=0, motor_max_power=100, hw_version="5", pid_params=(0.8, 0.1, 0.01, 200, 0.01)):
         try:
             self._mpu = mpu.AccelGyroMag()
             logging.info("MPU available")
@@ -116,6 +117,8 @@ def __init__(self, motor_trim_factor=1.0, hw_version="5"):
         self._cb_elapse = dict()
         self._encoder = self.GPIOS.HAS_ENCODER
         self._motor_trim_factor = motor_trim_factor
+        self._motor_min_power = motor_min_power
+        self._motor_max_power = motor_max_power
         self._twin_motors_enc = WheelsAxel(
             self.pi,
             enable_pin=self.GPIOS.PIN_MOTOR_ENABLE,
@@ -126,7 +129,8 @@ def __init__(self, motor_trim_factor=1.0, hw_version="5"):
             right_forward_pin=self.GPIOS.PIN_RIGHT_FORWARD,
             right_backward_pin=self.GPIOS.PIN_RIGHT_BACKWARD,
             right_encoder_feedback_pin_A=self.GPIOS.PIN_ENCODER_RIGHT_A,
-            right_encoder_feedback_pin_B=self.GPIOS.PIN_ENCODER_RIGHT_B)
+            right_encoder_feedback_pin_B=self.GPIOS.PIN_ENCODER_RIGHT_B,
+            pid_params=pid_params)
         self.motor_control = self._dc_enc_motor
 
         self._cb1 = self.pi.callback(self.GPIOS.PIN_PUSHBUTTON, pigpio.EITHER_EDGE, self._cb_button)
@@ -153,21 +157,23 @@ def exit(self):
             s.cancel()
 
     @classmethod
-    def get_instance(cls, motor_trim_factor=1.0, hw_version="5", servo=False):
+    def get_instance(cls, motor_trim_factor=1.0, motor_max_power=100, motor_min_power=0, hw_version="5", pid_params=(0.8, 0.1, 0.01, 200, 0.01)):
         if not cls.the_bot:
-            cls.the_bot = CoderBot(motor_trim_factor=motor_trim_factor, hw_version=hw_version)
+            cls.the_bot = CoderBot(motor_trim_factor=motor_trim_factor,  motor_max_power= motor_max_power, motor_min_power=motor_min_power, hw_version=hw_version, pid_params=pid_params)
         return cls.the_bot
 
+    def get_motor_power(self, speed):
+        return int(copysign(min(max(((self._motor_max_power - self._motor_min_power) * abs(speed) / 100) + self._motor_min_power, self._motor_min_power), self._motor_max_power), speed))
+
     def move(self, speed=100, elapse=None, distance=None):
-        self._motor_trim_factor = 1.0
-        speed_left = min(100, max(-100, speed * self._motor_trim_factor))
-        speed_right = min(100, max(-100, speed / self._motor_trim_factor))
+        speed_left = speed * self._motor_trim_factor
+        speed_right = speed / self._motor_trim_factor
         self.motor_control(speed_left=speed_left, speed_right=speed_right, time_elapse=elapse, target_distance=distance)
 
-    def turn(self, speed=100, elapse=-1):
-        speed_left = min(100, max(-100, speed * self._motor_trim_factor))
-        speed_right = -min(100, max(-100, speed / self._motor_trim_factor))
-        self.motor_control(speed_left=speed_left, speed_right=speed_right, time_elapse=elapse)
+    def turn(self, speed=100, elapse=None, distance=None):
+        speed_left = speed * self._motor_trim_factor
+        speed_right = -speed / self._motor_trim_factor
+        self.motor_control(speed_left=speed_left, speed_right=speed_right, time_elapse=elapse, target_distance=distance)
 
     def turn_angle(self, speed=100, angle=0):
         z = self._mpu.get_gyro()[2]
@@ -225,8 +231,8 @@ def _servo_control(self, pin, angle):
         self.pi.set_PWM_dutycycle(pin, duty)
 
     def _dc_enc_motor(self, speed_left=100, speed_right=100, time_elapse=None, target_distance=None):
-        self._twin_motors_enc.control(power_left=speed_left,
-                                      power_right=speed_right,
+        self._twin_motors_enc.control(power_left=self.get_motor_power(speed_left),
+                                      power_right=self.get_motor_power(speed_right),
                                       time_elapse=time_elapse,
                                       target_distance=target_distance)
 

coderbot/coderbot.py

@@ -12,13 +12,13 @@
     If no test was executed on that component, 0 is preserved.
 """
 from coderbot import CoderBot
-c = CoderBot.get_instance()
 
 # Single components tests
 
 # encoder motors
 def __test_encoder():
     try:
+        c = CoderBot.get_instance()
         # moving both wheels at speed 100 clockwise
         print("moving both wheels at speed 100 clockwise")
         assert(c.speed() == 0)

coderbot/coderbotTestUnit.py

@@ -22,10 +22,10 @@
 # Logging configuration
 logger = logging.getLogger()
 logger.setLevel(os.environ.get("LOGLEVEL", "INFO"))
-sh = logging.StreamHandler()
-formatter = logging.Formatter('%(message)s')
-sh.setFormatter(formatter)
-logger.addHandler(sh)
+# sh = logging.StreamHandler()
+# formatter = logging.Formatter('%(message)s')
+# sh.setFormatter(formatter)
+# logger.addHandler(sh)
 
 ## (Connexion) Flask app configuration
 
@@ -68,8 +68,7 @@ def run_server():
         try:
             app.bot_config = Config.read()
 
-            bot = CoderBot.get_instance(motor_trim_factor=float(app.bot_config.get('move_motor_trim', 1.0)),
-                                        hw_version=app.bot_config.get('hardware_version'))
+            bot = CoderBot.get_instance()
 
             try:
                 audio_device = Audio.get_instance()

coderbot/main.py

@@ -156,18 +156,19 @@ def rotary_callback(self, tick):
 
         # taking groups of n ticks each
         if (self._ticks_counter == 0):
-            self._start_timer = time()  # clock started
+            self._start_timer = tick  # clock started
         elif (abs(self._ticks_counter) == self._ticks_threshold):
-            self._current_timer = time()
-            elapse = self._current_timer - self._start_timer # calculating time elapse
+            self._current_timer = tick
+            elapse = (self._current_timer - self._start_timer) / 1000000.0 # calculating time elapse
             # calculating current speed
             self._encoder_speed = self._ticks_threshold * self._distance_per_tick / elapse  # (mm/s)
 
-        self._ticks += tick  # updating ticks
+        self._ticks += 1  # updating ticks
 
         if(abs(self._ticks_counter) < self._ticks_threshold):
             self._ticks_counter += 1
         else:
+            self._start_timer = tick  # clock started
             self._ticks_counter = 0
 
         # updating ticks counter using module

coderbot/rotary_encoder/motorencoder.py

@@ -27,8 +27,8 @@ def __init__(self, pi, feedback_pin_A, feedback_pin_B, callback):
         self._pi.set_pull_up_down(feedback_pin_B, pigpio.PUD_UP)
 
         # callback function on EITHER_EDGE for each pin
-        self._callback_triggerA = self._pi.callback(feedback_pin_A, pigpio.EITHER_EDGE, self._pulse)
-        self._callback_triggerB = self._pi.callback(feedback_pin_B, pigpio.EITHER_EDGE, self._pulse)
+        self._callback_triggerA = self._pi.callback(feedback_pin_A, pigpio.EITHER_EDGE, self._pulseA)
+        self._callback_triggerB = self._pi.callback(feedback_pin_B, pigpio.EITHER_EDGE, self._pulseA)
 
         self._lastGpio = None
 
@@ -91,6 +91,9 @@ def _pulse(self, gpio, level, tick):
         self._lock.release()
         self._callback(direction)
 
+    def _pulseA(self, gpio, level, tick):
+        self._callback(tick)
+
     def cancel(self):
 
         """