🆕 Tête de marionnette animatronique

/* Test servomoteurs avec seeeduino lotus + module grove PCA9685 16-Chan I2C PWM driver
 
    arduino 1.8.5 @ Kirin, pierre@lesporteslogiques.net / 23 nov. 2022
      + lib. Seeed PCA9685 library, https://github.com/Seeed-Studio/Seeed_PCA9685
 
    Grove PCA9685 : https://wiki.seeedstudio.com/Grove-16-Channel_PWM_Driver-PCA9685
    Servo MG90 à 270° (DMS-MG90-A) https://www.dfrobot.com/product-1970.html
*/
 
#include "PCA9685.h"
#include <Wire.h>
 
ServoDriver servo;
 
void setup() {
  Wire.begin();  // join I2C bus
  Serial.begin(9600);
  servo.init(0x7f);
}
 
void loop() {
  // Test avec 4 servos
  for (int i = 1; i < 5; i++) {
    servo.setAngle(i, 0);
    delay(1000);
    servo.setAngle(i, 90);
    delay(1000);
  }
}

/*  Test / Remise à zéro de servomoteurs
 
    servomoteurs avec seeeduino lotus + module grove PCA9685 16-Chan I2C PWM driver
    pour programmer la lotus, choisir arduino uno dans l'IDE
 
    arduino 1.8.5 @ Kirin, pierre@lesporteslogiques.net / 7 déc. 2022
      + lib. Seeed PCA9685 library, https://github.com/Seeed-Studio/Seeed_PCA9685
 
    Grove PCA9685 : https://wiki.seeedstudio.com/Grove-16-Channel_PWM_Driver-PCA9685
    Servo MG90 à 270° (DMS-MG90-A) https://www.dfrobot.com/product-1970.html
 
    On peut relancer la procédure en faisant un reset de la carte
*/
 
#include "PCA9685.h"
#include <Wire.h>
 
ServoDriver servo;
 
boolean centerdone = false;
 
void setup() {
  Wire.begin();  // join I2C bus
  Serial.begin(9600);
  servo.init(0x7f);
}
 
void loop() {
  // Remettre les servos au centre
  if (!centerdone) {
    for (int i = 1; i < 6; i++) {
      servo.setAngle(i, 45);
      delay(2000);
      servo.setAngle(i, 135);
      delay(3000);
      servo.setAngle(i, 90);
      delay(2000);
    }
    centerdone = true;
  } else {
    delay(100);
  }
}

// Bechele2 Joystick Code V2.1 Sept 2021
//
// Arduino code for the joystick used for programming servo movements in Bechele2 animatronic software:
// http://bechele.de/pages/english/72-0.html
//
// Based on original code written by Rolf Jethon:
// http://bechele.de/pages/english/77-0.html
//
// For more info on building this joystck:
// https://zappedmyself.com/animatronics/bechele2-info/
//
// This code sends the Joystick X & Y values and the button status to the Raspberry Pi
// Each time the number 4 (ASCII value 52) is received from Raspberry Pi the data is sent
//
// Can run on any Arduino variant (I used a NANO clone)
// - Cleaned up comments and naming
// - Added code internal pullups to simplify wiring
// - Changed the joystick averaging code to get better range of ADC values
 
 
//***PIN ASSIGNMENTS***//
#define Y_PIN A0        // Analog input pin that the X axis pot is connected to
#define X_PIN A1        // Analog input pin that the Y axis pot is connected to
#define BUTTON1_PIN 2   // Digital input pin the START button is connected to
#define BUTTON2_PIN 3   // Digital input pin the STOP button is connected to
 
 
//***CUSTOMIZE VALUES***//
#define BAUD_RATE 19200       // Baud rate for serial port 
#define ALPHA_VALUE 0.9       // Averaging factor (0.1 - 1.0) higher value = faster averaging
 
 
//***VARIABLE DECLARATION***//
int xAxisValue = 496;             // set X value to middle of possible range
int yAxisValue = 496;             // set Y value to middle of possible range
int xAxisMax = 1022;
int yAxisMax = 1022;
int xVal;
int yVal;
int inByte = 0;                   // incoming serial byte
float alphaFactor = ALPHA_VALUE;     // set to defined value
 
 
 
//***MICROCONTROLLER CONFIGURATION***//
void setup() {
  pinMode(BUTTON1_PIN, INPUT_PULLUP);
  pinMode(BUTTON2_PIN, INPUT_PULLUP);
  Serial.begin(BAUD_RATE);                    // Setup serial port speed
}
 
 
//***START OF MAIN LOOP***//
void loop() {
  xAxisValue = alphaFactor * analogRead(X_PIN) + (1 - alphaFactor) * xAxisValue;    // Get Xaxis value and average it
  delay(3);
  yAxisValue = alphaFactor * analogRead(Y_PIN) + (1 - alphaFactor) * yAxisValue;    // Get Yaxis value and average it
  int button1State = digitalRead(BUTTON1_PIN);                                      // Get Button 1 state
  int button2State = digitalRead(BUTTON2_PIN);                                      // Get Button 2 state
 
  xVal = xAxisMax - xAxisValue;
  yVal = yAxisMax - yAxisValue;
 
  // Test
  /*
  Serial.print(xVal);
  Serial.print(" ");
  Serial.print(yVal);
  Serial.print(" ");
  Serial.print(button1State);
  Serial.print(" ");
  Serial.println(button2State);
 
  */
  // Test 2 (graphique)
  Serial.print(xVal);
  Serial.print(",");
  Serial.print(yVal);
  Serial.print(",");
  Serial.print(button1State * 1000);
  Serial.print(",");
  Serial.println(button2State * 1000);
 
  delay(50);
  /*
    if (Serial.available() > 0) {                             // Check to see if serial data request has been received
    inByte = Serial.read();                                 // Store serial data
    if (inByte == 52) {                                     // Send data values if ASCII '4' is received
      Serial.print(xAxisValue);
      Serial.print(" ");
      Serial.print(yAxisValue);
      Serial.print(" ");
      Serial.print(button1State);
      Serial.print(" ");
      Serial.println(button2State);
    }
    inByte = 0;                                              // Clear inByte value for next command
    }*/
}

/*  Test servo
 
    arduino 1.8.5 @ Kirin, pierre@lesporteslogiques.net / 27 mars 2023
      + lib. Adafruit PWM Servo https://github.com/adafruit/Adafruit-PWM-Servo-Driver-Library
 
    Réglages de la carte PCA9685
    Testé avec Grove Beginner Kit (vu Comme Arduino Genuino/Uno)
 
    Sans réglage, ça fonctionne corectement à l'adresse I2C : 0x40
 */
 
#include <Wire.h>
#include <Adafruit_PWMServoDriver.h>
 
// called this way, it uses the default address 0x40
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
 
// Depending on your servo make, the pulse width min and max may vary, you 
// want these to be as small/large as possible without hitting the hard stop
// for max range. You'll have to tweak them as necessary to match the servos you
// have!
#define SERVOMIN  150 // This is the 'minimum' pulse length count (out of 4096)
#define SERVOMAX  600 // This is the 'maximum' pulse length count (out of 4096)
#define USMIN  600 // This is the rounded 'minimum' microsecond length based on the minimum pulse of 150
#define USMAX  2400 // This is the rounded 'maximum' microsecond length based on the maximum pulse of 600
#define SERVO_FREQ 50 // Analog servos run at ~50 Hz updates
 
// our servo # counter
uint8_t servonum = 0;
uint8_t servonum_max = 1;
 
void setup() {
  Serial.begin(9600);
  Serial.println("8 channel Servo test!");
 
  pwm.begin();
  /*
   * In theory the internal oscillator (clock) is 25MHz but it really isn't
   * that precise. You can 'calibrate' this by tweaking this number until
   * you get the PWM update frequency you're expecting!
   * The int.osc. for the PCA9685 chip is a range between about 23-27MHz and
   * is used for calculating things like writeMicroseconds()
   * Analog servos run at ~50 Hz updates, It is importaint to use an
   * oscilloscope in setting the int.osc frequency for the I2C PCA9685 chip.
   * 1) Attach the oscilloscope to one of the PWM signal pins and ground on
   *    the I2C PCA9685 chip you are setting the value for.
   * 2) Adjust setOscillatorFrequency() until the PWM update frequency is the
   *    expected value (50Hz for most ESCs)
   * Setting the value here is specific to each individual I2C PCA9685 chip and
   * affects the calculations for the PWM update frequency. 
   * Failure to correctly set the int.osc value will cause unexpected PWM results
   */
  pwm.setOscillatorFrequency(27000000);
  pwm.setPWMFreq(SERVO_FREQ);  // Analog servos run at ~50 Hz updates
 
  delay(10);
}
 
// You can use this function if you'd like to set the pulse length in seconds
// e.g. setServoPulse(0, 0.001) is a ~1 millisecond pulse width. It's not precise!
void setServoPulse(uint8_t n, double pulse) {
  double pulselength;
 
  pulselength = 1000000;   // 1,000,000 us per second
  pulselength /= SERVO_FREQ;   // Analog servos run at ~60 Hz updates
  Serial.print(pulselength); Serial.println(" us per period"); 
  pulselength /= 4096;  // 12 bits of resolution
  Serial.print(pulselength); Serial.println(" us per bit"); 
  pulse *= 1000000;  // convert input seconds to us
  pulse /= pulselength;
  Serial.println(pulse);
  pwm.setPWM(n, 0, pulse);
}
 
void loop() {
  // Drive each servo one at a time using setPWM()
  Serial.println(servonum);
  for (uint16_t pulselen = SERVOMIN; pulselen < SERVOMAX; pulselen++) {
    pwm.setPWM(servonum, 0, pulselen);
  }
 
  delay(500);
  for (uint16_t pulselen = SERVOMAX; pulselen > SERVOMIN; pulselen--) {
    pwm.setPWM(servonum, 0, pulselen);
  }
 
  delay(500);
 
  // Drive each servo one at a time using writeMicroseconds(), it's not precise due to calculation rounding!
  // The writeMicroseconds() function is used to mimic the Arduino Servo library writeMicroseconds() behavior. 
  for (uint16_t microsec = USMIN; microsec < USMAX; microsec++) {
    pwm.writeMicroseconds(servonum, microsec);
  }
 
  delay(500);
  for (uint16_t microsec = USMAX; microsec > USMIN; microsec--) {
    pwm.writeMicroseconds(servonum, microsec);
  }
 
  delay(500);
 
  servonum++;
  if (servonum > servonum_max) servonum = 0; // Testing the first 8 servo channels
}

import time
from adafruit_servokit import ServoKit
 
# Set channels to the number of servo channels on your kit.
# 8 for FeatherWing, 16 for Shield/HAT/Bonnet.
kit = ServoKit(channels=16)
 
kit.servo[0].angle = 180
#kit.continuous_servo[1].throttle = 1
time.sleep(1)
#kit.continuous_servo[1].throttle = -1
time.sleep(1)
kit.servo[0].angle = 0
#kit.continuous_servo[1].throttle = 0

import time
from adafruit_servokit import ServoKit
 
# Set channels to the number of servo channels on your kit.
# 8 for FeatherWing, 16 for Shield/HAT/Bonnet.
kit = ServoKit(channels=16)
 
# Correspondances (gauche/droite pour la tête)
# commands du côté droit inversées
# 0 : sourcil gauche 			(50, 135)
# 1 : sourcil droit 	(inv) 	(135, 50)
# 2 : machoire basse           	(?, ?)
# 3 : oeil gauche				(50, 130)
# 4 : oeil droit   				(50, 130)
# 5 : paupière gauche			()			PROBLEME
# 6 : paupière droite			()   		PROBLEME
# 7 : bouche gauche				(50, 110)   PROB : refaire mécanisme
# 8 : bouche droite		(inv)	(110, 50)   PROB : refaire mécanisme
# 9 : yeux						(50, 130)
 
for boucle in range(0, 3) :
	kit.servo[0].angle = 135
	kit.servo[1].angle = 50
	kit.servo[2].angle = 50
	kit.servo[3].angle = 130
	kit.servo[4].angle = 130
	# ~ kit.servo[5].angle = 80
	# ~ kit.servo[6].angle = 80
	kit.servo[7].angle = 50
	kit.servo[8].angle = 110
	kit.servo[9].angle = 50
	time.sleep(1)
 
	kit.servo[0].angle = 50
	kit.servo[1].angle = 135
	kit.servo[2].angle = 120
	kit.servo[3].angle = 50
	kit.servo[4].angle = 50
	# ~ kit.servo[5].angle = 100
	# ~ kit.servo[6].angle = 100
	kit.servo[7].angle = 110
	kit.servo[8].angle = 50
	kit.servo[9].angle = 130
	time.sleep(1)
 
	kit.servo[0].angle = 90
	kit.servo[1].angle = 90
	kit.servo[2].angle = 90
	kit.servo[3].angle = 90
	kit.servo[4].angle = 90
	# ~ kit.servo[5].angle = 90
	# ~ kit.servo[6].angle = 90
	kit.servo[7].angle = 90
	kit.servo[8].angle = 90
	kit.servo[9].angle = 90
	time.sleep(2)

import time
from adafruit_servokit import ServoKit
 
# Set channels to the number of servo channels on your kit.
# 8 for FeatherWing, 16 for Shield/HAT/Bonnet.
kit = ServoKit(channels=16)
 
# Correspondances (gauche/droite pour la tête)
# commands du côté droit inversées
# 0 : sourcil gauche 			(50, 135)
# 1 : sourcil droit 	(inv) 	(135, 50)
# 2 : machoire basse           	(?, ?)
# 3 : oeil gauche				(50, 130)
# 4 : oeil droit   				(50, 130)
# 5 : paupière gauche			()			PROBLEME
# 6 : paupière droite			()   		PROBLEME
# 7 : bouche gauche				(50, 110)   PROB : refaire mécanisme
# 8 : bouche droite		(inv)	(110, 50)   PROB : refaire mécanisme
# 9 : yeux						(50, 130)
 
def moue():
	kit.servo[0].angle = 50
	kit.servo[1].angle = 135
	kit.servo[2].angle = 120
	kit.servo[3].angle = 70
	kit.servo[4].angle = 110
	# ~ kit.servo[5].angle = 100
	# ~ kit.servo[6].angle = 100
	kit.servo[7].angle = 110
	kit.servo[8].angle = 50
	kit.servo[9].angle = 130
	time.sleep(2)
 
def sleep():
	kit.servo[0].angle = 90
	kit.servo[1].angle = 90
	kit.servo[2].angle = 90
	kit.servo[3].angle = 90
	kit.servo[4].angle = 90
	# ~ kit.servo[5].angle = 90
	# ~ kit.servo[6].angle = 90
	kit.servo[7].angle = 90
	kit.servo[8].angle = 90
	kit.servo[9].angle = 90
	time.sleep(2)
 
def louche():
	kit.servo[0].angle = 135
	kit.servo[1].angle = 50
	kit.servo[2].angle = 120
	kit.servo[3].angle = 130
	kit.servo[4].angle = 50
	# ~ kit.servo[5].angle = 100
	# ~ kit.servo[6].angle = 100
	kit.servo[7].angle = 110
	kit.servo[8].angle = 50
	kit.servo[9].angle = 130
	time.sleep(2)
 
louche()
moue()
sleep()
louche()
sleep()

#!/usr/bin/env python3
 
# source : https://roboticsbackend.com/raspberry-pi-arduino-serial-communication/
# arduino relié à /dev/ttyUSB0 (pour trouver le port : ls /dev/tty*)
# baud rate à 19200, correspond à celui défini dans arduino
# timeout : durée allouée à la lecture série
# readline() : lit jusqu'au caractère de fin de ligne
# decode('utf- 8') : transforme les bytes réçues dans le type souhaité
# rstrip() : retire les caractères de fin de ligne
import serial
if __name__ == '__main__':
    ser = serial.Serial('/dev/ttyUSB0', 19200, timeout=1)
    # vider le buffer série en début de communication
    ser.reset_input_buffer()
    while True:
		# y a t'il des données en attente ?
        if ser.in_waiting > 0:
            line = ser.readline().decode('utf-8').rstrip()
            print(line)