Un flip flat pour 4 sous

JMDSomme · 24 avril 2019

gehelem · 24 avril 2019

j'ai commencé la mise à jour du premier post

c'est pas fini, hein, on est d'accord 🙂

manudu74 · 24 avril 2019

il y a 50 minutes, gehelem a dit :

j'ai commencé la mise à jour du premier post

c'est pas fini, hein, on est d'accord 🙂

Et concernant l'arduino Atmega32u4 il faut prendre en 5V ou 3,3v ???

gehelem · 24 avril 2019

il y a 2 minutes, manudu74 a dit :

Et concernant l'arduino Atmega32u4 il faut prendre en 5V ou 3,3v ???

Là comme ça je dirais 5v

Je regarderai

JMDSomme · 24 avril 2019

je vais attendre tranquille la mise au point des détails !

le 5V l'avantage c'est que c'est quasi "la norme", non ?

🙂

gehelem · 24 avril 2019

Le 24/04/2019 à 22:28, JMDSomme a dit :

je vais attendre tranquille la mise au point des détails !

Je veux bien que tu me dises quand même si la forme convient

Mon premier "Pull request" sur Github

https://github.com/jwellman80/ArduinoLightbox/pull/2

La pression !!

J'ai jamais fait ça, c'est vraiment tordu Git...

olivier1986 · 24 avril 2019

@gehelemGilles,

j'ai ce soir tester mon code (enfin plus exactement le tiens avec ma ptite tambouille) et il s'avère que celui ci fonctionne très bien:

-> pas de remise à 90° au démarrage avec l'ajout d'un write(0) et l'utilisation d'un relais.

->utilisation de la PWM en utilisant une alim externe quelques soit le voltage demandé (3, 5, 12V) mais qui permet une utilisation supérieure à 40mA max sur le pin de sortie grâce à l'ajout d'un transistor NPN.

j'ai test cette configuration avec SGP et Linux ma principale cible.

-> mode cam sim + ccd sim + flat flip: j'ai crée une séquence depark, ouverture CAP, pointage cible, prise de light lum, fermeture CAP, prise de flat light, park monture.

-> tout est fonctionnel sans accros, enfin presque!

j'ai remarqué 2 choses:

lors du branchement de l'arduino EKOS ne connait jamais la dernière position, il indique donc toujours open or closed. Si à la dernière utilisation tu as bien fermé le cap alors quand tu cliques sur open pas de soucis le CAP s'ouvre et indique open. Par contre si tu cliques sur closed alors le CAP s'ouvre puis se referme pour enfin indiquait closed. à partir de ce moment il se rappelle toujours de sa position sauf si tu éteint la tinker ou si tu débranche L’USB.

deuxième chose, par défaut, même si tu enregistre tes la configuration, la luminosité de la sortie "led" indique toujours 0. Du coup, si tu oublies de remettre une valeur avant de lancer ta séquence alors la led ne s'allumera pas et les flats seront ratés! c'est certes pas trop méchant mais si tu oublies c'est con!

Petit plus: dans la séquence, si tu paramètres par ex 5 light rouge puis 5 flats rouges puis 5 light bleu puis 5 flats bleus..... et que dans les options des flats tu as mis park, alors à chaque début de séquence flat le cap se ferme et se ré ouvre!! et ca c'est franchement cool!!! tu fais tes flats juste avant ou juste après ta série puis tu changes de filtre et hop c'est reparti!! pas de risques de voir des poussières se déplacer lors d'un changement de position de filtre et que les flats soient ratés!!

Bon, allez, c'est pas tout mais demain boulot tôt!!! hâte de voir la suite!!

Pour le plaisir, le code utilisé:

Révélation

/*
What: LEDLightBoxAlnitak - PC controlled lightbox implmented using the
Alnitak (Flip-Flat/Flat-Man) command set found here:
http://www.optecinc.com/astronomy/pdf/Alnitak Astrosystems GenericCommandsR3.pdf

Who:
Created By: Jared Wellman - jared@mainsequencesoftware.com

When:
Last modified: 2013/May/05

Typical usage on the command prompt:
Send : >S000\n //request state
Recieve : *S19000\n //returned state

Send : >B128\n //set brightness 128
Recieve : *B19128\n //confirming brightness set to 128

Send : >J000\n //get brightness
Recieve : *B19128\n //brightness value of 128 (assuming as set from above)

Send : >L000\n //turn light on (uses set brightness value)
Recieve : *L19000\n //confirms light turned on

Send : >D000\n //turn light off (brightness value should not be changed)
Recieve : *D19000\n //confirms light turned off.
*/

#include <Servo.h>
Servo myservo;

volatile int ledPin = 11;
volatile int servoPin = 9; // the pin that the servo signal is attached to, needs to be a PWM pin.
int brightness = 0;

enum devices
{
    FLAT_MAN_L = 10,
    FLAT_MAN_XL = 15,
    FLAT_MAN = 19,
    FLIP_FLAT = 99
};

enum motorStatuses
{
STOPPED = 0,
RUNNING
};

enum lightStatuses
{
OFF = 0,
ON
};

enum shutterStatuses
{
    UNKNOWN = 0, // ie not open or closed...could be moving
    CLOSED,
    OPEN
};

int deviceId = FLIP_FLAT;
int motorStatus = STOPPED;
int lightStatus = OFF;
int coverStatus = UNKNOWN;

const int impulsion_min=500;
const int impulsion_max=2500;
int relai=7;

void setup()
{

Serial.begin(9600);
pinMode(ledPin, OUTPUT);
pinMode(servoPin, OUTPUT);
pinMode(relai, OUTPUT);
analogWrite(ledPin, 0);
digitalWrite(relai, LOW);
myservo.write(0);
myservo.attach(9,impulsion_min,impulsion_max);

}

void loop()
{
handleSerial();
}

void handleSerial()
{
delay(100);
if( Serial.available() >= 5 ) // all incoming communications are fixed length at 6 bytes including the \n
{
    char* cmd;
    char* data;
    char temp[10];

    int len = 0;

    char str[20];
    memset(str, 0, 20);

    // I don't personally like using the \n as a command character for reading.
    // but that's how the command set is.
// Serial.readBytesUntil('\n', str, 20);
Serial.readBytes( str, 5);

    cmd = str + 1;
    data = str + 2;

    // useful for debugging to make sure your commands came through and are parsed correctly.
    if( false )
    {
      sprintf( temp, "cmd = >%s%s;", cmd, data);
      Serial.println(temp);
    }

    switch( *cmd )
    {
      /*
        Ping device
            Request: >P000\n
            Return : *Pii000\n
                id = deviceId
      */
      case 'P':
          sprintf(temp, "*P%d000\n", deviceId);
          Serial.print(temp);
          break;

      /*
        Open shutter
            Request: >O000\n
            Return : *Oii000\n
                id = deviceId

            This command is only supported on the Flip-Flat!
      */
      case 'O':
          sprintf(temp, "*O%d000\n", deviceId);
          SetShutter(OPEN);
          Serial.print(temp);
          break;

      /*
        Close shutter
            Request: >C000\n
            Return : *Cii000\n
                id = deviceId

            This command is only supported on the Flip-Flat!
      */
      case 'C':
          sprintf(temp, "*C%d000\n", deviceId);
          SetShutter(CLOSED);
          Serial.print(temp);
          break;

      /*
        Turn light on
            Request: >L000\n
            Return : *Lii000\n
                id = deviceId
      */
      case 'L':
          sprintf(temp, "*L%d000\n", deviceId);
          Serial.print(temp);
          lightStatus = ON;
          analogWrite(ledPin, brightness);
          break;

      /*
        Turn light off
            Request: >D000\n
            Return : *Dii000\n
                id = deviceId
      */
      case 'D':
          sprintf(temp, "*D%d000\n", deviceId);
          Serial.print(temp);
          lightStatus = OFF;
          analogWrite(ledPin, 0);
          break;

      /*
        Set brightness
            Request: >Bxxx\n
                xxx = brightness value from 000-255
            Return : *Biiyyy\n
                id = deviceId
                yyy = value that brightness was set from 000-255
      */
      case 'B':
          brightness = atoi(data);
          if( lightStatus == ON )
              analogWrite(ledPin, brightness);
              sprintf( temp, "*B%d%03d\n", deviceId, brightness );
          Serial.print(temp);
        break;

      /*
        Get brightness
            Request: >J000\n
            Return : *Jiiyyy\n
                id = deviceId
                yyy = current brightness value from 000-255
      */
      case 'J':
        sprintf( temp, "*J%d%03d\n", deviceId, brightness);
        Serial.print(temp);
        break;

      /*
        Get device status:
            Request: >S000\n
            Return : *SidMLC\n
                id = deviceId
                M = motor status( 0 stopped, 1 running)
                L = light status( 0 off, 1 on)
                C = Cover Status( 0 moving, 1 closed, 2 open)
      */
      case 'S':
        sprintf( temp, "*S%d%d%d%d\n",deviceId, motorStatus, lightStatus, coverStatus);
        Serial.print(temp);
        break;

      /*
        Get firmware version
            Request: >V000\n
            Return : *Vii001\n
                id = deviceId
      */
      case 'V': // get firmware version
          sprintf(temp, "*V%d001\n", deviceId);
          Serial.print(temp);
          break;
    }

    while( Serial.available() > 0 )
        Serial.read();

}
}

void SetShutter(int val)
{
if( val == OPEN && coverStatus != OPEN )
{
    digitalWrite(relai, HIGH);
    for (int angle = 0; angle <= 30; angle+=1)
    {
      myservo.write (angle);
      delay (70);
    }
    myservo.write (150);
    for (int angle = 150; angle <= 180; angle+=1)
    {
      myservo.write (angle);
      delay (70);
    }
    coverStatus = OPEN;
        digitalWrite(relai, LOW);
    // TODO: Implement code to OPEN the shutter.
}
else if( val == CLOSED && coverStatus != CLOSED )
{
    digitalWrite(relai, HIGH);
    for (int angle = 180; angle > 150; angle-=1)
    {
      myservo.write (angle);
      delay (70);
    }
    myservo.write (30);
    for (int angle = 30; angle > 0; angle-=1)
    {
      myservo.write (angle);
      delay (70);
    }
    coverStatus = CLOSED;
        digitalWrite(relai, LOW);
    // TODO: Implement code to CLOSE the shutter
}
else
{
    // TODO: Actually handle this case
    coverStatus = val;
}

}

et une photo de l'ensemble utilisé ce soir pour les tests

JMDSomme · 25 avril 2019

Il y a 8 heures, gehelem a dit :

Je veux bien que tu me dises quand même si la forme convient

Ok, je regarde ça de près dès que je suis plus au boulot... !

En tous cas merci pour ce boulot fort utile !

EDIT: je suis allé voir quand même (les collègues sont au café...) ça me semble clair .

RAW: correspond donc au fil rouge du servo? (jaune ou orange c'est toujours signal et noir la masse).

Je vais commander une arduino tt à l'heure, je testerais avec des servos modélistes qui traînent dans mes tiroirs ensuite ce sera fonction du poids du couvercle.

Je n'ai pas vu de lien vers l'application (windows ou code SGP) ? mais j'ai regardé vite fait...., si ça y est perds pas ton temps à me répondre....

@+

Discret68 · 25 avril 2019

Il y a 10 heures, olivier1986 a dit :

lors du branchement de l'arduino EKOS ne connait jamais la dernière position, il indique donc toujours open or closed.

Je ne connais pas bien l'Arduino, même pas du tout, mais n'est il pas possible de stocker la position du flat dans un registre ou un fichier à chaque mouvement et de lire la valeur à chaque démarrage? C'est ainsi que je procède avec mes programme sur RPI en python ou sur PC en VB.net. Comme ça, même en cas de plantage et redémarrage du système, je connais la position de mon obturateur et masque de bahtinov motorisés, ou des relais lorsque c'est une carte relais pilotée par un de mes programmes.

olivier1986 · 25 avril 2019

@Discret68

oui c'est ce que j'essai de mettre en place dans le code maintenant que le problème du servo est réglé!

Qui peut essayer ce code avec INDI voir si quand on débranche et rebranche l'arduino la position du CAP est bien mémorisée?

Lors de l'upload du fichier il est normal qu'à la 1ère utilisation le servo ne sache pas où il est! il devrait, si le code fonctionne, s'en rappeler après le 1er ordre de mouvement ouvrir ou fermer!

je voudrais bien mais je suis ps là ce soir 😕

Protocole :

charger le fichier ci après dans l'arduino,

lancer indi (EKOS),

faire un unpark sur le CAP,

refaire un park,

fermer INDI (EKOS),

débrancher, puis rebrancher l'arduino,

ouvrir INDI (EKOS),

regarder ce qu'un indique la position de CAP.

code:

Révélation

/*
What: LEDLightBoxAlnitak - PC controlled lightbox implmented using the
Alnitak (Flip-Flat/Flat-Man) command set found here:
http://www.optecinc.com/astronomy/pdf/Alnitak Astrosystems GenericCommandsR3.pdf

Who:
Created By: Jared Wellman - jared@mainsequencesoftware.com

When:
Last modified: 2013/May/05

Typical usage on the command prompt:
Send : >S000\n //request state
Recieve : *S19000\n //returned state

Send : >B128\n //set brightness 128
Recieve : *B19128\n //confirming brightness set to 128

Send : >J000\n //get brightness
Recieve : *B19128\n //brightness value of 128 (assuming as set from above)

Send : >L000\n //turn light on (uses set brightness value)
Recieve : *L19000\n //confirms light turned on

Send : >D000\n //turn light off (brightness value should not be changed)
Recieve : *D19000\n //confirms light turned off.
*/

#include <EEPROM.h>
int position_cap;

#include <Servo.h>
Servo myservo;

volatile int ledPin = 11;
volatile int servoPin = 9; // the pin that the servo signal is attached to, needs to be a PWM pin.
int brightness = 0;

enum devices
{
FLAT_MAN_L = 10,
FLAT_MAN_XL = 15,
FLAT_MAN = 19,
FLIP_FLAT = 99
};

enum motorStatuses
{
STOPPED = 0,
RUNNING
};

enum lightStatuses
{
OFF = 0,
ON
};

enum shutterStatuses
{
UNKNOWN = 0, // ie not open or closed...could be moving
CLOSED,
OPEN
};

int deviceId = FLIP_FLAT;
int motorStatus = STOPPED;
int lightStatus = OFF;
int coverStatus = EEPROM.get(position_cap,coverStatus);

const int impulsion_min=450;
const int impulsion_max=2500;
int relai=7;

void setup()
{

Serial.begin(9600);
pinMode(ledPin, OUTPUT);
pinMode(servoPin, OUTPUT);
pinMode(relai, OUTPUT);
analogWrite(ledPin, 0);
digitalWrite(relai, LOW);
myservo.write(0);
myservo.attach(9,impulsion_min,impulsion_max);

}

void loop()
{
handleSerial();
}

void handleSerial()
{
delay(100);
if( Serial.available() >= 5 ) // all incoming communications are fixed length at 6 bytes including the \n
{
char* cmd;
char* data;
char temp[10];

int len = 0;

char str[20];
memset(str, 0, 20);

// I don't personally like using the \n as a command character for reading.
// but that's how the command set is.
// Serial.readBytesUntil('\n', str, 20);
Serial.readBytes( str, 5);

cmd = str + 1;
data = str + 2;

// useful for debugging to make sure your commands came through and are parsed correctly.
if( false )
{
sprintf( temp, "cmd = >%s%s;", cmd, data);
Serial.println(temp);
}

switch( *cmd )
{
/*
Ping device
Request: >P000\n
Return : *Pii000\n
id = deviceId
*/
case 'P':
sprintf(temp, "*P%d000\n", deviceId);
Serial.print(temp);
break;

/*
Open shutter
Request: >O000\n
Return : *Oii000\n
id = deviceId

This command is only supported on the Flip-Flat!
*/
case 'O':
sprintf(temp, "*O%d000\n", deviceId);
SetShutter(OPEN);
EEPROM.put(position_cap,OPEN);
Serial.print(temp);
break;

/*
Close shutter
Request: >C000\n
Return : *Cii000\n
id = deviceId

This command is only supported on the Flip-Flat!
*/
case 'C':
sprintf(temp, "*C%d000\n", deviceId);
SetShutter(CLOSED);
EEPROM.put(position_cap,CLOSED);
Serial.print(temp);
break;

/*
Turn light on
Request: >L000\n
Return : *Lii000\n
id = deviceId
*/
case 'L':
sprintf(temp, "*L%d000\n", deviceId);
Serial.print(temp);
lightStatus = ON;
analogWrite(ledPin, brightness);
break;

/*
Turn light off
Request: >D000\n
Return : *Dii000\n
id = deviceId
*/
case 'D':
sprintf(temp, "*D%d000\n", deviceId);
Serial.print(temp);
lightStatus = OFF;
analogWrite(ledPin, 0);
break;

/*
Set brightness
Request: >Bxxx\n
xxx = brightness value from 000-255
Return : *Biiyyy\n
id = deviceId
yyy = value that brightness was set from 000-255
*/
case 'B':
brightness = atoi(data);
if( lightStatus == ON )
analogWrite(ledPin, brightness);
sprintf( temp, "*B%d%03d\n", deviceId, brightness );
Serial.print(temp);
break;

/*
Get brightness
Request: >J000\n
Return : *Jiiyyy\n
id = deviceId
yyy = current brightness value from 000-255
*/
case 'J':
sprintf( temp, "*J%d%03d\n", deviceId, brightness);
Serial.print(temp);
break;

/*
Get device status:
Request: >S000\n
Return : *SidMLC\n
id = deviceId
M = motor status( 0 stopped, 1 running)
L = light status( 0 off, 1 on)
C = Cover Status( 0 moving, 1 closed, 2 open)
*/
case 'S':
sprintf( temp, "*S%d%d%d%d\n",deviceId, motorStatus, lightStatus, EEPROM.get(position_cap,coverStatus));
Serial.print(temp);
break;

/*
Get firmware version
Request: >V000\n
Return : *Vii001\n
id = deviceId
*/
case 'V': // get firmware version
sprintf(temp, "*V%d001\n", deviceId);
Serial.print(temp);
break;
}

while( Serial.available() > 0 )
Serial.read();

}
}

void SetShutter(int val)
{
   if( val == OPEN && coverStatus != OPEN )
   {
digitalWrite(relai, HIGH);
for (int angle = 0; angle <= 30; angle+=1)
{
myservo.write (angle);
delay (70);
}
myservo.write (150);
for (int angle = 150; angle <= 180; angle+=1)
{
myservo.write (angle);
delay (70);
}
       coverStatus = OPEN;
digitalWrite(relai, LOW);
       // TODO: Implement code to OPEN the shutter.
   }
   else if( val == CLOSED && coverStatus != CLOSED )
   {
digitalWrite(relai, HIGH);
for (int angle = 180; angle > 150; angle-=1)
{
myservo.write (angle);
delay (70);
}
myservo.write (30);
for (int angle = 30; angle > 0; angle-=1)
{
myservo.write (angle);
delay (70);
}
       coverStatus = CLOSED;
digitalWrite(relai, LOW);
       // TODO: Implement code to CLOSE the shutter
   }
   else
   {
       // TODO: Actually handle this case
       coverStatus = val;
   }

}

Merci!

Olivier

Alarcon yves · 25 avril 2019

Bonjour, chouette manip, sinon attention pour ceux qui pilote un relais par l'ardino, ne pas oublier la diode de "roue libre" au borne de la bobine.

Pour régler le problème de connaitre la position du flip-flap au démarrage, on peut toujours mettre des capteurs optiques à fourche, qui indiquerais la position ouverte et fermée, c'est plus sur qu'une variable dans un registre.

Yves.

supaii · 25 avril 2019

il y a 25 minutes, olivier1986 a dit :

Qui peut essayer ce code avec INDI voir si quand on débranche et rebranche l'arduino la position du CAP est bien mémorisée?

Lors de l'upload du fichier il est normal qu'à la 1ère utilisation le servo ne sache pas où il est! il devrait, si le code fonctionne, s'en rappeler après le 1er ordre de mouvement ouvrir ou fermer!

je voudrais bien mais je suis ps là ce soir 😕

Protocole :

charger le fichier ci après dans l'arduino,

lancer indi (EKOS),

faire un unpark sur le CAP,

refaire un park,

fermer INDI (EKOS),

débrancher, puis rebrancher l'arduino,

ouvrir INDI (EKOS),

regarder ce qu'un indique la position de CAP.

code:

Révéler le contenu masqué

/*
What: LEDLightBoxAlnitak - PC controlled lightbox implmented using the
Alnitak (Flip-Flat/Flat-Man) command set found here:
http://www.optecinc.com/astronomy/pdf/Alnitak Astrosystems GenericCommandsR3.pdf

Who:
Created By: Jared Wellman - jared@mainsequencesoftware.com

When:
Last modified: 2013/May/05

Typical usage on the command prompt:
Send : >S000\n //request state
Recieve : *S19000\n //returned state

Send : >B128\n //set brightness 128
Recieve : *B19128\n //confirming brightness set to 128

Send : >J000\n //get brightness
Recieve : *B19128\n //brightness value of 128 (assuming as set from above)

Send : >L000\n //turn light on (uses set brightness value)
Recieve : *L19000\n //confirms light turned on

Send : >D000\n //turn light off (brightness value should not be changed)
Recieve : *D19000\n //confirms light turned off.
*/

#include <EEPROM.h>
int position_cap;

#include <Servo.h>
Servo myservo;

volatile int ledPin = 11;
volatile int servoPin = 9; // the pin that the servo signal is attached to, needs to be a PWM pin.
int brightness = 0;

enum devices
{
FLAT_MAN_L = 10,
FLAT_MAN_XL = 15,
FLAT_MAN = 19,
FLIP_FLAT = 99
};

enum motorStatuses
{
STOPPED = 0,
RUNNING
};

enum lightStatuses
{
OFF = 0,
ON
};

enum shutterStatuses
{
UNKNOWN = 0, // ie not open or closed...could be moving
CLOSED,
OPEN
};

int deviceId = FLIP_FLAT;
int motorStatus = STOPPED;
int lightStatus = OFF;
int coverStatus = EEPROM.get(position_cap,coverStatus);

const int impulsion_min=450;
const int impulsion_max=2500;
int relai=7;

void setup()
{

Serial.begin(9600);
pinMode(ledPin, OUTPUT);
pinMode(servoPin, OUTPUT);
pinMode(relai, OUTPUT);
analogWrite(ledPin, 0);
digitalWrite(relai, LOW);
myservo.write(0);
myservo.attach(9,impulsion_min,impulsion_max);

}

void loop()
{
handleSerial();
}

void handleSerial()
{
delay(100);
if( Serial.available() >= 5 ) // all incoming communications are fixed length at 6 bytes including the \n
{
char* cmd;
char* data;
char temp[10];

int len = 0;

char str[20];
memset(str, 0, 20);

// I don't personally like using the \n as a command character for reading.
// but that's how the command set is.
// Serial.readBytesUntil('\n', str, 20);
Serial.readBytes( str, 5);

cmd = str + 1;
data = str + 2;

// useful for debugging to make sure your commands came through and are parsed correctly.
if( false )
{
sprintf( temp, "cmd = >%s%s;", cmd, data);
Serial.println(temp);
}


switch( *cmd )
{
/*
Ping device
Request: >P000\n
Return : *Pii000\n
id = deviceId
*/
case 'P':
sprintf(temp, "*P%d000\n", deviceId);
Serial.print(temp);
break;

/*
Open shutter
Request: >O000\n
Return : *Oii000\n
id = deviceId

This command is only supported on the Flip-Flat!
*/
case 'O':
sprintf(temp, "*O%d000\n", deviceId);
SetShutter(OPEN);
EEPROM.put(position_cap,OPEN);
Serial.print(temp);
break;

/*
Close shutter
Request: >C000\n
Return : *Cii000\n
id = deviceId

This command is only supported on the Flip-Flat!
*/
case 'C':
sprintf(temp, "*C%d000\n", deviceId);
SetShutter(CLOSED);
EEPROM.put(position_cap,CLOSED);
Serial.print(temp);
break;

/*
Turn light on
Request: >L000\n
Return : *Lii000\n
id = deviceId
*/
case 'L':
sprintf(temp, "*L%d000\n", deviceId);
Serial.print(temp);
lightStatus = ON;
analogWrite(ledPin, brightness);
break;

/*
Turn light off
Request: >D000\n
Return : *Dii000\n
id = deviceId
*/
case 'D':
sprintf(temp, "*D%d000\n", deviceId);
Serial.print(temp);
lightStatus = OFF;
analogWrite(ledPin, 0);
break;

/*
Set brightness
Request: >Bxxx\n
xxx = brightness value from 000-255
Return : *Biiyyy\n
id = deviceId
yyy = value that brightness was set from 000-255
*/
case 'B':
brightness = atoi(data);
if( lightStatus == ON )
analogWrite(ledPin, brightness);
sprintf( temp, "*B%d%03d\n", deviceId, brightness );
Serial.print(temp);
break;

/*
Get brightness
Request: >J000\n
Return : *Jiiyyy\n
id = deviceId
yyy = current brightness value from 000-255
*/
case 'J':
sprintf( temp, "*J%d%03d\n", deviceId, brightness);
Serial.print(temp);
break;

/*
Get device status:
Request: >S000\n
Return : *SidMLC\n
id = deviceId
M = motor status( 0 stopped, 1 running)
L = light status( 0 off, 1 on)
C = Cover Status( 0 moving, 1 closed, 2 open)
*/
case 'S':
sprintf( temp, "*S%d%d%d%d\n",deviceId, motorStatus, lightStatus, EEPROM.get(position_cap,coverStatus));
Serial.print(temp);
break;

/*
Get firmware version
Request: >V000\n
Return : *Vii001\n
id = deviceId
*/
case 'V': // get firmware version
sprintf(temp, "*V%d001\n", deviceId);
Serial.print(temp);
break;
}

while( Serial.available() > 0 )
Serial.read();


}
}

void SetShutter(int val)
{
   if( val == OPEN && coverStatus != OPEN )
   {
digitalWrite(relai, HIGH);
for (int angle = 0; angle <= 30; angle+=1)
{
myservo.write (angle);
delay (70);
}
myservo.write (150);
for (int angle = 150; angle <= 180; angle+=1)
{
myservo.write (angle);
delay (70);
}
       coverStatus = OPEN;
digitalWrite(relai, LOW);
       // TODO: Implement code to OPEN the shutter.
   }
   else if( val == CLOSED && coverStatus != CLOSED )
   {
digitalWrite(relai, HIGH);
for (int angle = 180; angle > 150; angle-=1)
{
myservo.write (angle);
delay (70);
}
myservo.write (30);
for (int angle = 30; angle > 0; angle-=1)
{
myservo.write (angle);
delay (70);
}
       coverStatus = CLOSED;
digitalWrite(relai, LOW);
       // TODO: Implement code to CLOSE the shutter
   }
   else
   {
       // TODO: Actually handle this case
       coverStatus = val;
   }

}

Merci!

Olivier

televersement sur arduino uno

fin de televersement, le servo bouge vers sa position "fermé"

lancer indi (EKOS), ok

faire un unpark sur le CAP, ok

refaire un park, ok

fermer INDI (EKOS), ok

débrancher, puis rebrancher l'arduino, ok mon servo bouge un peu (c'est peu etre due au 270° du servo et des 544µs)

ouvrir INDI (EKOS), ok

final en image

supaii · 25 avril 2019

j ai modifier le code pour pouvoir modifier les angles du servo plus rapidement.

le code comprend les dit angles, le ralentissement à l'ouverture/ fermeture, la position dans l eeprom.

Testé sous indi.

*
What: LEDLightBoxAlnitak - PC controlled lightbox implmented using the
    Alnitak (Flip-Flat/Flat-Man) command set found here:
   http://www.optecinc.com/astronomy/pdf/Alnitak Astrosystems GenericCommandsR3.pdf

Who:
    Created By: Jared Wellman - jared@mainsequencesoftware.com

When:
    Last modified:  2013/May/05


Typical usage on the command prompt:
Send     : >S000\n      //request state
Recieve  : *S19000\n    //returned state

Send     : >B128\n      //set brightness 128
Recieve  : *B19128\n    //confirming brightness set to 128

Send     : >J000\n      //get brightness
Recieve  : *B19128\n    //brightness value of 128 (assuming as set from above)

Send     : >L000\n      //turn light on (uses set brightness value)
Recieve  : *L19000\n    //confirms light turned on

Send     : >D000\n      //turn light off (brightness value should not be changed)
Recieve  : *D19000\n    //confirms light turned off.
*/

#include <Servo.h>
Servo myservo;

#include <EEPROM.h>
int position_cap;

volatile int ledPin   = 6;      // the pin that the LED is attached to, needs to be a PWM pin.
volatile int servoPin = 9;      // the pin that the servo signal is attached to, needs to be a PWM pin.
int brightness = 0;
const int closeAngle=25;        // Angle of the servo when the cap is close
const int openAngle=145;        // Angle of the servo when the cap is open
const int slowAngle=30;         // Angle of the servo for approach to close/open

enum devices
{
    FLAT_MAN_L = 10,
    FLAT_MAN_XL = 15,
    FLAT_MAN = 19,
    FLIP_FLAT = 99
};

enum motorStatuses
{
    STOPPED = 0,
    RUNNING
};

enum lightStatuses
{
    OFF = 0,
    ON
};

enum shutterStatuses
{
    UNKNOWN = 0, // ie not open or closed...could be moving
    CLOSED,
    OPEN
};


int deviceId = FLIP_FLAT;
int motorStatus = STOPPED;
int lightStatus = OFF;
int coverStatus = EEPROM.get(position_cap,coverStatus);

void setup()
{
  // initialize the serial communication:
  Serial.begin(9600);
  // initialize the ledPin as an output:
  pinMode(ledPin, OUTPUT);
  analogWrite(ledPin, 0);
  myservo.write(closeAngle);
  myservo.attach(servoPin,500,2500);  
}

void loop()
{
  handleSerial();
}


void handleSerial()
{
  delay(100);
  if( Serial.available() >= 5 )  // all incoming communications are fixed length at 6 bytes including the \n
  {
    char* cmd;
    char* data;
    char temp[10];
    
    int len = 0;

    char str[20];
    memset(str, 0, 20);
    
    // I don't personally like using the \n as a command character for reading.  
    // but that's how the command set is.
  //  Serial.readBytesUntil('\n', str, 20);
  Serial.readBytes( str, 5);

    cmd = str + 1;
    data = str + 2;
    
    // useful for debugging to make sure your commands came through and are parsed correctly.
    if( false )
    {
      sprintf( temp, "cmd = >%s%s;", cmd, data);
      Serial.println(temp);
    }
    


    switch( *cmd )
    {
      /*
        Ping device
            Request: >P000\n
            Return : *Pii000\n
                id = deviceId
      */
      case 'P':
          sprintf(temp, "*P%d000\n", deviceId);
          Serial.print(temp);
          break;

      /*
        Open shutter
            Request: >O000\n
            Return : *Oii000\n
                id = deviceId

            This command is only supported on the Flip-Flat!
      */
      case 'O':
          sprintf(temp, "*O%d000\n", deviceId);
          SetShutter(OPEN);
          EEPROM.put(position_cap,OPEN);
          Serial.print(temp);
          break;


      /*
        Close shutter
            Request: >C000\n
            Return : *Cii000\n
                id = deviceId

            This command is only supported on the Flip-Flat!
      */
      case 'C':
          sprintf(temp, "*C%d000\n", deviceId);
          SetShutter(CLOSED);
          EEPROM.put(position_cap,CLOSED);
          Serial.print(temp);
          break;

      /*
        Turn light on
            Request: >L000\n
            Return : *Lii000\n
                id = deviceId
      */
      case 'L':
          sprintf(temp, "*L%d000\n", deviceId);
          Serial.print(temp);
          lightStatus = ON;
          analogWrite(ledPin, brightness);
          break;

      /*
        Turn light off
            Request: >D000\n
            Return : *Dii000\n
                id = deviceId
      */
      case 'D':
          sprintf(temp, "*D%d000\n", deviceId);
          Serial.print(temp);
          lightStatus = OFF;
          analogWrite(ledPin, 0);
          break;

      /*
        Set brightness
            Request: >Bxxx\n
                xxx = brightness value from 000-255
            Return : *Biiyyy\n
                id = deviceId
                yyy = value that brightness was set from 000-255
      */
      case 'B':
          brightness = atoi(data);    
          if( lightStatus == ON )
              analogWrite(ledPin, brightness);   
          sprintf( temp, "*B%d%03d\n", deviceId, brightness );
          Serial.print(temp);
        break;

      /*
        Get brightness
            Request: >J000\n
            Return : *Jiiyyy\n
                id = deviceId
                yyy = current brightness value from 000-255
      */
      case 'J':
        sprintf( temp, "*J%d%03d\n", deviceId, brightness);
        Serial.print(temp);
        break;
      
      /*
        Get device status:
            Request: >S000\n
            Return : *SidMLC\n
                id = deviceId
                M  = motor status( 0 stopped, 1 running)
                L  = light status( 0 off, 1 on)
                C  = Cover Status( 0 moving, 1 closed, 2 open)
      */
      case 'S':
        sprintf( temp, "*S%d%d%d%d\n",deviceId, motorStatus, lightStatus, EEPROM.get(position_cap,coverStatus));
        Serial.print(temp);
        break;

      /*
        Get firmware version
            Request: >V000\n
            Return : *Vii001\n
                id = deviceId
      */
      case 'V': // get firmware version
          sprintf(temp, "*V%d001\n", deviceId);
          Serial.print(temp);
          break;
    }    

    while( Serial.available() > 0 )
        Serial.read();
            

  }
}

void SetShutter(int val)
{
  if( val == OPEN && coverStatus != OPEN )
  {
    for (int angle = closeAngle; angle <= closeAngle + slowAngle; angle+=1) 
    {
      myservo.write (angle);
      delay (70);
    } 
    myservo.write (openAngle - slowAngle);
    for (int angle = openAngle - slowAngle; angle <= openAngle; angle+=1) 
    {
      myservo.write (angle);
      delay (70);
    } 
    coverStatus = OPEN;
    // TODO: Implement code to OPEN the shutter.
  }
  else if( val == CLOSED && coverStatus != CLOSED )
  {
    for (int angle = openAngle; angle > openAngle - slowAngle; angle-=1) 
    {
      myservo.write (angle);
      delay (70);
    }   
    myservo.write (closeAngle + slowAngle);  
    for (int angle = closeAngle + slowAngle; angle > closeAngle; angle-=1) 
    {
      myservo.write (angle);
      delay (70);
    } 
    coverStatus = CLOSED;
    // TODO: Implement code to CLOSE the shutter
  }
  else
  {
    // TODO: Actually handle this case
    coverStatus = val;
  }
  
}

gehelem · 25 avril 2019

Z'êtes chauds les mecs !

olivier1986 · 25 avril 2019

@supaii

merci du test! Ravi que ca marche!

j’ai lutté!

je sais que @gehelem ne veut pas d’eeprom mais les fonctions utilisées n’ecrivent pas en permanence mais verifie si l’etat a changé. Si inchangé rien ne se passe.

dans le cas contraire on ecrit.

il est prevu 100000 cycles d’ecriture...

disons qu’a la moitie l’arduino lache soit 50000 cycles.

ca fait 25000 ouvertures fermetures!!

on va dire qu’on fait 50 soirées par an et qu’avec les flats et tout on ouvre et ferme 50 fois par nuit.

Ca fait donc 250 ouverture fermeture par an soit 10 ans d’utilisation...

je vais pas m’en privé pour 6€ sur ebey!

et pire encore on utilise pas tous les bytes d’eeprom dispo et on pourra toujours modifier ça en temps et en heure!!

@supaii le pb du moteur qui bouge a la connexion je l’ai résolu en mettant un petit relais 5v. Je regarderai pour la diode de roue libre je connais pas!

enfin, merci pour le code avec les angles, ce sera plus facile pour les futurs utilisateurs qui auront besoin de paramétrer ces angles, surtout celui de l’ouverture pour pas taper sur autre chose!!

Modifié 25 avril 2019 par olivier1986

supaii · 25 avril 2019

il y a 16 minutes, olivier1986 a dit :

@supaii le pb du moteur qui bouge a la connexion je l’ai résolu en mettant un petit relais 5v. Je regarderai pour la diode de roue libre je connais pas!

Je n ai plus ce souci.

L'erreur était, un myservo.write (0) au lieu de (25) pour ma config

Alarcon yves · 25 avril 2019

Bonjour,

Il y a 20 heures, olivier1986 a dit :

je l’ai résolu en mettant un petit relais 5v. Je regarderai pour la diode de roue libre je connais pas!

Un petit court d'électronique / d'électromagnétisme.

Un relais est un contact qui se ferme quand on alimente une bobine, là je pense que c'est ok pour tout le monde, mais le problème c'est la bobine.

Une bobine, quand on l'alimente en courant-continu, elle emmagasine de l’énergie, cette énergie elle est obligé de la restitué quand on ne l'alimente plus, c'est ce qu'on nomme la self-induction, qui crée une surtension de polarité inverse au borne de la bobine, cette surtension peut créer une étincelle au niveau du contact d'un interrupteur ou se propager sur la patte de commande de l'arduino et détruire le transistor de sortie.

Pour éviter la destruction du transistor de commande on branche en parallèle sur les bornes de la bobine une diode en inverse, qui vas limiter la surtension à 0,6V.

Bien sur suivant la tension de la bobine du relais, prévoir une résistance de limitation de courant, et bien faire attention au sens de branchement de la diode.

sur le dessin la cathode est du coté de la sortie, car l'autre partie du montage est relié au 0v.

Yves.

Modifié 26 avril 2019 par Alarcon yves

olivier1986 · 26 avril 2019

@Alarcon yves Merci pour ce cours!! j'ai pris note et ajouté cela à mon montage.

@gehelem Je peux trouver quelques minutes et fournir un plan pour conception de la partie hardware sur plaque l'essais à souder un peu comme le projet myfocuserpro.

Si ça te dit!

Malik · 26 avril 2019

Yo les bidouilleurs !

J ai pas tout tout lu surtout quand ça parle en {=ord55 :@« -€

franchement j’y pige rien 😁

si je peux apporter ma petite contribution

je m’était lancé dans une boîte à flat imprimée 3D et voilà les difficultés rencontrées/résolues

- il est effectivement indispensable d’avoir un truc dimmable, s’il ne l’est pas ça ne baisse pas la luminosité mais ça fait un truc qui clignote genre boîte de nuit

- le PWM j’ai essayé aussi, pas concluant car ça ne fait pas varier la tension, ça hache la sortie de courant et restitue une tension moyenne (si j’ai bien compris, je suis pas sûr a 100% et je revendique aussi le droit a dire des bulshit)

- finalement j’ai trouvé un variateur de tension, un stepdown en fait mais avec un potentiomètre manuel qui fait réellement baisser la tension (j’essayerai de retrouver la ref mais cest pas compliqué à trouver)

- Pour la partie luminaire j’ai pri un bandeau led 12v dimmable et recoupable

Avec tout ca, ça fonctionnai nickel, le seul problème que j’ai eu et je me suis arrêté la faute de temp, c’est la dispotion des led que j’ai mal foutu et qui ne restituait pas une flux de lumière uniforme.

bref un truc qui s’arrange facilement, mais faut juste tout démonter et remonter 😅

ensuite dans la pratique sur le terrain. Je me suis rendu compte que finalement un variateur ça complique un peu la vie. Car il faut retrouver à chaque sessions le temps de pose idéal pour un bon flat.

En fait l idéal c’est d’avoir uniquement deux positions de puissance lumineuse. Une «faible » pour les LRVB dan mon cas aux alentours de 8v (attention en dessous d’une certaine tension ça s’éteignait complètement) et une forte pour les SHO

Une fois qu’on a ces deux positions on règles les temps de poses par filtre (et ils seront tjrs identiques), de sorte à ne pas dépasser la seconde et ne pas se faire chier avec des darks de flat

voila voila en espérant avoir aidé 😁

JMDSomme · 26 avril 2019

En fait faut bourrer de leds pour sur-éclairer puis filtrer deux fois dans du plexi blanc en laissant un espace entre les deux (double diffusion), après en effet un step down (ou idéalement deux en commandant une bascule selon les filtres), la commande en sortie de pin de l'ardu peut servir j'imagine à activer un relai ?

ursus · 26 avril 2019

Il y a 17 heures, Alarcon yves a dit :

Bonjour,

Un petit court d'électronique / d'électromagnétisme.

Un relais est un contact qui se ferme quand on alimente une bobine, là je pense que c'est ok pour tout le monde, mais le problème c'est la bobine.

Une bobine, quand on l'alimente en courant-continu, elle emmagasine de l’énergie, cette énergie elle est obligé de la restitué quand on ne l'alimente plus, c'est ce qu'on nomme la self-induction, qui crée une surtension de polarité inverse au borne de la bobine, cette surtension peut créer une étincelle au niveau du contact d'un interrupteur ou se propager sur la patte de commande de l'arduino et détruire le transistor de sortie.

Pour éviter la destruction du transistor de commande on branche en parallèle sur les bornes de la bobine ou diode en inverse, qui vas limiter la surtension à 0,6V.

Bien sur suivant la tension de la bobine du relais, prévoir une résistance de limitation de courant, et bien faire attention au sens de branchement de la diode.

sur le dessin la cathode est du coté de la sortie, car l'autre partie du montage est relié au 0v.

Yves.

Les relais vendus ne sont ils pas déjà protégés (je n'y connais rien)?

image.png.14c7f0710b7a0f6bb42d54db7966927c.png (https://fr.rs-online.com/web/p/products/8750292/?grossPrice=Y)

Cela dépends peut être du fournisseur?

olivier1986 · 26 avril 2019

C'a c'est l'artillerie lourde!!

je vois plus quelque chose comme ça:

https://fr.rs-online.com/web/p/products/5330851/?grossPrice=Y&cm_mmc=FR-PLA-DS3A-_-google-_-PLA_FR_FR_Relais-_-Relais_À Usage_Général|Relais_Sans_Accrochage-_-PRODUCT_GROUP&matchtype=&aud-360224801201:pla-487490479184&gclid=Cj0KCQjw2IrmBRCJARIsAJZDdxAZVo8lYfd_EFqj-1-6qZVrVQbZBimnJExLyJkhJ3RlavQhz9jlpu0aAtgDEALw_wcB&gclsrc=aw.ds

c'est fourni dans les kits débutants!

Alarcon yves · 26 avril 2019

Bonjour, pour la diode de protection, certain montage la possède déjà, c'est le cas pour la platine d'ursus" comme c'est un montage tout fait, les diodes de protection y sont déjà (D1 & D2)

Il y a 4 heures, ursus a dit :

Les relais vendus ne sont ils pas déjà protégés (je n'y connais rien)?

(https://fr.rs-online.com/web/p/products/8750292/?grossPrice=Y)

Cela dépends peut être du fournisseur?

Par contre quand c'est seulement un relais simple, là par contre il ne faut pas oublier d'en mettre une.

il y a une heure, olivier1986 a dit :

C'a c'est l'artillerie lourde!!

je vois plus quelque chose comme ça:

https://fr.rs-online.com/web/p/products/5330851/?grossPrice=Y&cm_mmc=FR-PLA-DS3A-_-google-_-PLA_FR_FR_Relais-_-Relais_À Usage_Général|Relais_Sans_Accrochage-_-PRODUCT_GROUP&matchtype=&aud-360224801201:pla-487490479184&gclid=Cj0KCQjw2IrmBRCJARIsAJZDdxAZVo8lYfd_EFqj-1-6qZVrVQbZBimnJExLyJkhJ3RlavQhz9jlpu0aAtgDEALw_wcB&gclsrc=aw.ds

c'est fourni dans les kits débutants!

C'est surtout quand j'ai vus le montage "d'olivier1986", qui visiblement n'en possède pas, dans ce cas le port de l'ardino qui pilote le relais risque de claquer !

Le 25/04/2019 à 01:24, olivier1986 a dit :

et une photo de l'ensemble utilisé ce soir pour les tests

Bref, faut juste vérifier votre montage pour voir si il faut mettre une diode ou pas.

yves

olivier1986 · 27 avril 2019

@Alarcon yves

Merci pour ces enseignements. Je débute en éléctronique du coup merci des explications fortes utiles

j'ai depuis ajouté une diode comme indiqué!

Pour la forme, est-ce qu'une simple diode 1N4001 est suffisante? je pense que oui car il est indiqué 50V 1A.

Alarcon yves · 27 avril 2019

Bonjour, oui ça passe sans problème, sur le schéma de la platine "d'ursus", c'est des 1N4148 (je te laisse comparer leur spécification).

il y a 27 minutes, olivier1986 a dit :

Pour la forme, est-ce qu'une simple diode 1N4001 est suffisante? je pense que oui car il est indiqué 50V 1A.

Pour revenir au sujet de la discussion, personnellement je préfère avoir une info physique sur l'état ouvert ou fermé, plutôt qu'a me remettre à une simple variable dans un registre, c'est toujours source de bug car il y a toujours un risque que ça foire en cas de coupure de courant ou autre problème.

Disons, que si on as le télescope à porté de main, on peut utiliser la variable, mais en "remote" à distance je m'y risquerais pas, mais c'est qu'un avis perso..

Yves.

olivier1986 · 27 avril 2019

@Alarcon yves

Oui le remote sera dans mon jardin! Donc en effet en cas de plantage c'est facile

Pour du plus longue distance je partirais aussi sur un système avec capteur fin de course. Le code pour un système du genre est très facile à mettre en place.

On pourrait fabriquer un code où les gens choisiraient leur système et avec quelques lignes à commenter ou dé commenter.

Ca donnerait un système un peu plus universel. Ce serait un peu plus long à mettre en place, sinon il reste la possibilité de faire 2 codes séparés!

Discret68 · 27 avril 2019

Il y a 3 heures, Alarcon yves a dit :

Pour revenir au sujet de la discussion, personnellement je préfère avoir une info physique sur l'état ouvert ou fermé, plutôt qu'a me remettre à une simple variable dans un registre, c'est toujours source de bug car il y a toujours un risque que ça foire en cas de coupure de courant ou autre problème.

Il ne faut pas se contenter d’une variable dont le contenu est perdu lors d’une coupure de tension. Il faut sauvegarder cette variable dès qu’on change sa valeur. On sauvegarde la valeur dans un fichier ou dans un registre (qui est normalement sauvegardé). Et à chaque mise en route du système ou lors d’une manœuvre, on lit la valeur pour valider le sens du mouvement. Ce sont ces 2 techniques que je mets en œuvre sur RPI ou sur PC, et ça fonctionne nickel.

Autre solution pour ceux qui utilise des relais. Il est possible d’utiliser des petits relais bistables. Contrairement au relais standard qui est équipé d’une seule bobine et qui revient à l’état zéro lorsque la bobine n’est plus alimentée, le relais bistable a 2 bobines. Pour changer l’état du relais, il faut alimenter l’une ou l’autre bobine en fonction de la position désirée. Le relais conserve sa position une fois la tension bobine coupée, y compris lors d’une perte de tension globale.

JMDSomme · 27 avril 2019

Il y a 8 heures, Discret68 a dit :

Il ne faut pas se contenter d’une variable dont le contenu est perdu lors d’une coupure de tension. Il faut sauvegarder cette variable dès qu’on change sa valeur. On sauvegarde la valeur dans un fichier ou dans un registre (qui est normalement sauvegardé). Et à chaque mise en route du système ou lors d’une manœuvre, on lit la valeur pour valider le sens du mouvement. Ce sont ces 2 techniques que je mets en œuvre sur RPI ou sur PC, et ça fonctionne nickel.

Autre solution pour ceux qui utilise des relais. Il est possible d’utiliser des petits relais bistables. Contrairement au relais standard qui est équipé d’une seule bobine et qui revient à l’état zéro lorsque la bobine n’est plus alimentée, le relais bistable a 2 bobines. Pour changer l’état du relais, il faut alimenter l’une ou l’autre bobine en fonction de la position désirée. Le relais conserve sa position une fois la tension bobine coupée, y compris lors d’une perte de tension globale.

Dans ce cas deux pin à activer low / high et utilisation de contacts fin de course ? Ce serait quasi accessible à un nul du code comme moi en appliquant l'exercice 1 du tuto arduino (allumage de leds). Moteur courant continu à la place du servo (ou servo dépouillé de son électronique pour garder la réduction mécanique).

Me trompe je ?

Discret68 · 28 avril 2019

Il y a 11 heures, JMDSomme a dit :

Dans ce cas deux pin à activer low / high et utilisation de contacts fin de course ? Ce serait quasi accessible à un nul du code comme moi en appliquant l'exercice 1 du tuto arduino (allumage de leds). Moteur courant continu à la place du servo (ou servo dépouillé de son électronique pour garder la réduction mécanique).

Me trompe je ?

En fait, tu es en train glisser petit à petit vers la solution que j'ai mis en oeuvre pour ma lulu (et en cours de fabrication pour le newton) : un motoréducteur, des relais et des fins de course ! J'avais présenté cette solution (avec vidéo) en page 1 de cette présente discussion car comme je l'écrivais, les servos ont toujours tendance à se mettre en mouvement lorsqu'on met le circuit sous tension, ce qui ne me satisfaisait guère. Et vous vous en êtes rendu compte par vous mêmes.

Mais si tu en arrives à une solution qui utilise effectivement relais plus fins de course, le servo (modifié ou non) ne me parait plus être la meilleure solution.

Pour ma lulu, j'avais pris un motoréducteur de 12V en 7 tr/mn ( https://fr.aliexpress.com/item/Wholesale-Jgy-370-12V-Gear-Motor-1-375Rpm-Electric-Motor-6V-12V-Dc-Motor-D-Shaft/32377282290.html?spm=a2g0s.9042311.0.0.27426c37XVb6GI).

Je me suis rendu compte après coups qu'avec ce type de motoréducteur, je ne pouvais pas faire une rotation de 270° pour placer l'obturateur long du tube. Pour la lunette, ce n'est pas grave car le diamètre de l'obturateur ou du bahtinov n'offre pas une grande surface pour un prise au vent. Par contre, pour le newton, il faut absolument "ranger" l'obturateur (ou 2 demi-obturateurs dans ce cas) le long du tube.

Pour le newton, j'ai retenu ce type de motoréducteur : https://fr.aliexpress.com/item/Wholesales-JGB37-520-Motor-Reduction7-1280rpmdc-Motor-High-Torque-Electronic-Motor-Low-Speed-Motor-6v-24v/32362695201.html?spm=a2g0s.9042311.0.0.27426c37XVb6GI

Pour une lulu, il me semble plus simple de s'orienter vers l'utilisation d'un motoréducteur comme ce modèle, qui est petit, léger (95g) et qui offre un couple suffisant compte tenu du réducteur : https://fr.aliexpress.com/item/25GA370-DC-motor-ducteur-motor-ducteur-moteur-basse-vitesse-moteur-vitesse-lente-couple-lev-3V6V7-4V12V24V/32842167169.html?

Il existe en version 6V qui fonctionne sans problème sur du 5V. Vu que j'en ai sous la main en version 12V, je viens de le tester et j'ai baissé la tension jusqu'à 3 volts. Il tourne sans problème mais à une vitesse qui se réduit avec la tension. Je pense que 12 tr/mn est un bon compromis. A titre de comparaison, sur ma vidéo, ce sont des 7 tr/min. Un 12tr/mn ira un juste un peu plus vite.

En ce qui concerne les fins de cours, je les utilise pour l'arrêt du motoréducteur dans les positions ouverture et fermeture. Je ne les utilise pas en indicateur de position car je n'ai pas vu l'utilité. Je pilote l'ensemble avec un IPX800 qui m'indique la position de l'obturateur par le biais de l'état du relais de commande. De plus, j'ai une caméra de surveillance dans l'abri qui me permet de constater la position et une fois que l'obturateur est dans une position, il n'a aucune raison de bouger.

352597738_ContrleIPX800.jpg.b06921de29a31e09be116f6bc8699bbb.jpg

La position repos des relais correspond à un obturateur ferme et un bahtinov non posé.

j'ai pris ce modèle de fdc : https://fr.aliexpress.com/item/10PCS-Micro-Roller-Lever-Arm-Normally-Open-Close-Limit-Switch-KW12-3-125V-5A/32789563542.html?spm=a2g0s.9042311.0.0.27426c37XVb6GI

Pour les relais bistable : https://www.ebay.fr/itm/5V-Coil-Bistable-Latching-Relay-DPDT-2A-30VDC-High-Quality-Free-Postage/122208194158?hash=item1c742d0e6e:m:mEeGHkI8jbqfo-pGLavX3LQ . Il y en a sur Aliexpress pour moins cher, mais les délais sont affolants !!!

L'arduino peut être conservé pour gérer le tout (relais et contrôle de position, interface PC, ...), et qui peut dans ce cas de figure tout à fait remplacer l'IPX800 que j'utilise.

Pour le schéma électrique, je te laisse phosphorer un peu 😂 Si toutefois, tu pars dans ce type de solution !

PS : j'espère que Gehelem ne m'en voudra pas trop de faire de la digression par rapport à ses orientations.

JP

gehelem · 28 avril 2019

il y a une heure, Discret68 a dit :

PS : j'espère que Gehelem ne m'en voudra pas trop de faire de la digression par rapport à ses orientations.

Ah mais pas du tout, au contraire !

Comme ça tout le monde peut choisir ses options comme il veut.

D'autant que le firmware de l'arduino doit être facilement adaptable pour des moteurs CC + fin de course.

Moi je vais sans doute rester sur le servo, avec ses inconvénients 😀

Connexion

Un flip flat pour 4 sous

Messages recommandés

Les pipelettes du sujet

Les pipelettes du sujet

Messages populaires (du sujet)

manudu74

olivier1986

Discret68

Images postées dans ce sujet

Rejoignez la conversation !

En ligne récemment 0 membre est en ligne

Annonces

Aider Webastro

Information importante