Bonjour à tous !
Déjà merci aux personnes présentes sur ce forum pour aider ceux qui comme moi se lance dans l’arduino pour réaliser des petits projets d’électronique malgré ma profonde méconnaissance du code.
J’espère que je ne me suis pas tromper quant à la publication de ce post mais si c’est la cas n’hésiter pas à me le signaler. Également si jamais je ne suis pas clair dans ce que je raconte ou si je le fais mal n’hésiter pas à me le signaler aussi.
Alors voilà, je suis en début d’études d’ingénierie et je tente un petit projet : j’essaye de réaliser un « incubateur » soit en fait une enceinte calorifugée d’un petit volume (20cm**3 environ donc rien d’énorme). Mon projet est de maintenir la température à l’intérieur de cette boîte à 37°C à l’aide de modules Peltier dont voici la référence (https://peltiermodules.com/peltier.datasheet/TEC1-12706.pdf)
J’ai deux modules avec des dissipateurs thermiques qui sont déjà « encastrés » dans ma boîte, une face 1 qui est à l’intérieur de la boîte et une face 2 qui est à l’extérieur de la boîte. (je vais garder ces notations par la suite.)
En réalité il ne me reste ‘’juste’’ qu’à réaliser le code arduino qui contrôlerait mon asservissement.
Voici comment je voudrais procéder grossièrement : si la température est en dessous de 35°C mes Peltier sont alimentés avec une différence de potentiel de +7V ce qui (avec les branchements réalisés) réchaufferait les faces 1 et donc l’intérieur de la boîte. Si la température est au dessus de 39°C, les Peltier sont alimentés avec une différence de potentiel de -7V, ce qui cette fois refroidit les faces 1.
En théorie le code m’a l’air assez simple, mais j’ai quelques blocages.
Alors, voilà ce dont je dispose :
-J’ai 3 sondes DS18B20 avec lesquelles je mesure la température à trois endroits différents de l’intérieur de la boîte pour ensuite travailler avec la moyenne de ces trois températures (j’ai choisi trois sondes afin aussi de pouvoir vérifier un certain critère d’homogénéité dans ma boîte)
J’ai déjà un programme pris dans la bibliothèque DallasTemperature qui me permet de mesurer les températures, programme que je vous mets ici. Ce programme est fonctionnel.
// Include the libraries we need
#include <OneWire.h>
#include <DallasTemperature.h>
// Data wire is plugged into port 2 on the Arduino
#define ONE_WIRE_BUS 2
#define TEMPERATURE_PRECISION 12
// Setup a oneWire instance to communicate with any OneWire devices (not just Maxim/Dallas temperature ICs)
OneWire oneWire(ONE_WIRE_BUS);
// Pass our oneWire reference to Dallas Temperature.
DallasTemperature sensors(&oneWire);
// arrays to hold device addresses
DeviceAddress one, two, three;
// Assign address manually. The addresses below will need to be changed
// to valid device addresses on your bus. Device address can be retrieved
// by using either oneWire.search(deviceAddress) or individually via
// sensors.getAddress(deviceAddress, index)
// DeviceAddress insideThermometer = { 0x28, 0x1D, 0x39, 0x31, 0x2, 0x0, 0x0, 0xF0 };
// DeviceAddress outsideThermometer = { 0x28, 0x3F, 0x1C, 0x31, 0x2, 0x0, 0x0, 0x2 };
void setup()
{
// start serial port
Serial.begin(9600);
Serial.println("Dallas Temperature IC Control Library Demo");
// Start up the library
sensors.begin();
// locate devices on the bus
Serial.print("Locating devices...");
Serial.print("Found ");
Serial.print(sensors.getDeviceCount(), DEC);
Serial.println(" devices.");
// report parasite power requirements
Serial.print("Parasite power is: ");
if (sensors.isParasitePowerMode()) {
Serial.println("ON");
}
else {
Serial.println("OFF");
}
// Search for devices on the bus and assign based on an index. Ideally,
// you would do this to initially discover addresses on the bus and then
// use those addresses and manually assign them (see above) once you know
// the devices on your bus (and assuming they don't change).
//
// method 1: by index
if (!sensors.getAddress(one, 0)) {
Serial.println("Unable to find address for Device 0"); }
if (!sensors.getAddress(two, 2)) {
Serial.println("Unable to find address for Device 2"); }
if (!sensors.getAddress(three, 1)) {
Serial.println("Unable to find address for Device 1"); }
// method 2: search()
// search() looks for the next device. Returns 1 if a new address has been
// returned. A zero might mean that the bus is shorted, there are no devices,
// or you have already retrieved all of them. It might be a good idea to
// check the CRC to make sure you didn't get garbage. The order is
// deterministic. You will always get the same devices in the same order
//
// Must be called before search()
//oneWire.reset_search();
// assigns the first address found to insideThermometer
//if (!oneWire.search(insideThermometer)) Serial.println("Unable to find address for insideThermometer");
// assigns the seconds address found to outsideThermometer
//if (!oneWire.search(outsideThermometer)) Serial.println("Unable to find address for outsideThermometer");
// show the addresses we found on the bus
Serial.print("Device 0 Address: ");
printAddress(one);
Serial.println();
Serial.print("Device 1 Address: ");
printAddress(two);
Serial.println();
Serial.print("Device 2 Address: ");
printAddress(three);
Serial.println();
// set the resolution to 9 bit per device
sensors.setResolution(one, TEMPERATURE_PRECISION);
sensors.setResolution(two, TEMPERATURE_PRECISION);
sensors.setResolution(three, TEMPERATURE_PRECISION);
Serial.print("Device 0 Resolution: ");
Serial.print(sensors.getResolution(one), DEC);
Serial.println();
Serial.print("Device 1 Resolution: ");
Serial.print(sensors.getResolution(two), DEC);
Serial.println();
Serial.print("Device 1 Resolution: ");
Serial.print(sensors.getResolution(three), DEC);
Serial.println();
}
// function to print a device address
void printAddress(DeviceAddress deviceAddress)
{
for (uint8_t i = 0; i < 8; i++)
{
// zero pad the address if necessary
if (deviceAddress[i] < 16) Serial.print("0");
Serial.print(deviceAddress[i], HEX);
}
}
// function to print the temperature for a device
void printTemperature(DeviceAddress deviceAddress)
{
float tempC = sensors.getTempC(deviceAddress);
if(tempC == DEVICE_DISCONNECTED_C)
{
Serial.println("Error: Could not read temperature data");
return;
}
Serial.print("Temp C: ");
Serial.print(tempC);
Serial.print(" Temp F: ");
Serial.print(DallasTemperature::toFahrenheit(tempC));
}
// function to print a device's resolution
void printResolution(DeviceAddress deviceAddress)
{
Serial.print("Resolution: ");
Serial.print(sensors.getResolution(deviceAddress));
Serial.println();
}
// main function to print information about a device
void printData(DeviceAddress deviceAddress)
{
Serial.print("Device Address: ");
printAddress(deviceAddress);
Serial.print(" ");
printTemperature(deviceAddress);
Serial.println();
}
/*
Main function, calls the temperatures in a loop.
*/
void loop(void)
{
// call sensors.requestTemperatures() to issue a global temperature
// request to all devices on the bus
Serial.print("Requesting temperatures...");
sensors.requestTemperatures();
Serial.println("DONE");
// print the device information
printData(one);
printData(two);
printData(three);
delay(1000);
}
Je me demandais par ailleurs si vous saviez comment je pourrai récupérer les valeurs afficher à la toute fin du programme (« printData(one) ») afin de réaliser ma moyenne, (donc en fait ((one+two+three)/3), opération que ne peux pas réaliser mais ce n’est pas mon plus gros problème.
-J’ai une carte arduino UNO et un grove based shield
-Et on arrive au cœur du problème, j’ai un module I2C motor driver V1.3 (Grove - I2C Motor Driver V1.3 - Seeed Wiki) que l’on m’a fourni afin que je l’utilise pour pouvoir alimenter mes modules dans des tensions supérieures à 5V et aussi pour pouvoir profiter du hâcheur intégré afin de pouvoir alimenter soit en +7V soit en -7V. J’ai de quoi alimenter ce module à la bonne tension par le réseau.
Ce module est normalement utilisé pour alimenter des moteurs, comme c’est le cas par exemple dans ce code dans la librairie « Grove_I2C_Motor_Driver.h » qui permet d'alimenter deux moteurs et de pouvoir changer le sens de rotation du moteur (en changeant le signe de la différence de potentiel je présume)
#include "Grove_I2C_Motor_Driver.h"
// default I2C address is 0x0f
#define I2C_ADDRESS 0x0f
void setup() {
Motor.begin(I2C_ADDRESS);
}
void loop() {
// Set speed of MOTOR1, Clockwise, speed: -100~100
Motor.speed(MOTOR1, 50);
// Set speed of MOTOR2, Anticlockwise
Motor.speed(MOTOR2, -70);
delay(2000);
// Change speed and direction of MOTOR1
Motor.speed(MOTOR1, -100);
// Change speed and direction of MOTOR2
Motor.speed(MOTOR2, 100);
delay(2000);
// Stop MOTOR1 and MOTOR2
Motor.stop(MOTOR1);
Motor.stop(MOTOR2);
delay(2000);
}
Je me demande ainsi comment adapter ce code (ou utiliser ce module) à ce que je souhaite faire, notamment savoir quelle est la tension en sortie de mon alimentation en fonction de la vitesse de rotation d’un supposé moteur ? (soit, comment avoir +/-7V à la sortie de mon module I2C.
Voilà je vous remercie de votre lecture et de votre temps, bonne journée à tous !