Discussion :

[seriousmath]

effectivement j'ai failli abandonner des le début mais heureusement que j'ai trouvé un sketch sur le net reprenant les fonctions que j'avais besoin.

Je repasserais si jamais je décide de changer de capteur hall pour mettre l'analogique à la place.

Encore merci à vous tous.

[seriousmath]

Re,

j'ai fais une petite vidéo pour montrer la finalité du système.

Vraiment c'est le top, il ne manque plus qu'1 ciel sans nuage pour tester in live

Pas une idée pour enlever la sale tache de glue 3 que j'ai fais sur le capot ? lol

[Auteur]

il y a eu un peu d'hésitation pour le home . On voit bien les phases d'accélération et de décélération du moteur.
J'espère que ton système est assez rapide.

C'est quoi comme colle ? Tu as essayé l'eau chaude ?

[seriousmath]

salut !

oui beaucoup hésité avec le capteur hall, d'ailleurs j'en encore un analogique ou j'arrive a mesurer la baisse de tension quand l'aimant est présent, je me le garde sous le coude au cas ou.

La colle c'est de la glue 3, a l’époque il existait un produit pour la retirer mais il a été enlevé du commerce

[seriousmath]

Re Salut !

Petit passage pour vous présenter le résultat par l'image de ce que donne mon projet sur le terrain.

Donc pour résumer j'ai utilisé pour la première fois la roue à filtre sur Jupiter. J'ai fais 4 vidéos de 1000 images chacune avec respectivement un filtre Rouge un Vert un Bleu et un UV/IR dans le but de reproduire à partir d'une camera noir et blanc les couleurs primaires....
Avec ma caméra spéciale astro en usb 3 à 60 img/sec et la vitesse de rotation de la roue à filtre, il m'a fallu 2 min 30 sec maximum pour faire les 4 séries

Le tout est travaillé dans des logiciels spécial astro qui me font :

- L'alignement des images les unes par rapport aux autres et le classement en qualité des 4x1000 images puis l'empilement suivant un % que je défini (AutoStakkert_2.6.1.4).
- Ensuite je fais monter les détails dans les 4 images obtenues,en jouant sur les ondelettes (curseurs) de Registax 6
- Pour finir je crée une image LRVB à partir de mes 4 images.....

Les conditions étaient médiocres pour la photo de Jupiter mais compatibles pour effectuer un test.... Les prochaines seront mieux



++

[seriousmath]

Salut à tous !

Comment ça va depuis !

De mon coté la roue à filtre fonctionne du tonnerre, j'ai rajouté un condo 470µF et un interrupteur entre le RESET et 5V de l'arduino, ca m’évite des réinitialisations intempestives de la RAF quand je branche un port USB sur mon HUB et que la roue est déjà en fonctionnement.
Je ne sais pas pourquoi ca faisait ca mais avec mon petit câblage j'ai plus de souci.

Je revenais vers vous pour voir si on pouvait optimiser mon comme je l'avais demandé en post #21.

Faire en sorte que la roue à filtre prenne le chemin le plus rapide vers le filtre demandé sachant qu'un zéro est défini avec ma fonction home.

Je pense qu'il faudrait modifier le code du genre si distance vers filtre demandé <> ou = fais si ou fais ca...

Faut il que je crée chaque CASE pour chaque filtre en fonction de sa destination ?

En gros 25 CASE ou avec des if je peux m'en sortir ?

Encore une fois j'ai cherché mais rien trouvé qui pourrait ressembler à ce que je voudrais faire.

Voici le code d'emplacement de mes filtres en sachant que le CASE 0 et toujours le home et filtre 1

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
void MoveFilter(int pos) 
{
 CurrentFilter = pos;   
 switch (CurrentFilter) 
       {    
      case 0:                    // DEPLACEMENT FILTER 1
analogWrite(LEDverte,0);  
analogWrite(LEDrouge,1023);
stepper1.setAcceleration(Acceleration);
stepper1.setMaxSpeed(Vitesse); 
stepper1.run();
stepper1.runToNewPosition(CurrentFilter * DistanceFiltre);  
stepper1.disableOutputs();
analogWrite(LEDrouge,0);
delay(750);
analogWrite(LEDverte,1023);
stepper1.disableOutputs();
Serial.print(CurrentFilter); Serial.println("#");
break;
 
       case 1:                  // DEPLACEMENT FILTER 2
analogWrite(LEDverte,0);  
analogWrite(LEDrouge,1023);
stepper1.setAcceleration(Acceleration);
stepper1.setMaxSpeed(Vitesse); 
stepper1.run();
stepper1.runToNewPosition(CurrentFilter * DistanceFiltre);  
stepper1.disableOutputs();
analogWrite(LEDrouge,0);
delay(750);
analogWrite(LEDverte,1023);
stepper1.disableOutputs();
Serial.print(CurrentFilter); Serial.println("#");
break;
 
     case 2:                  // DEPLACEMENT FILTER 3
analogWrite(LEDverte,0);  
analogWrite(LEDrouge,1023);
stepper1.setAcceleration(Acceleration);
stepper1.setMaxSpeed(Vitesse); 
stepper1.run();
stepper1.runToNewPosition(CurrentFilter * DistanceFiltre);  
stepper1.disableOutputs();
analogWrite(LEDrouge,0);
delay(750);
analogWrite(LEDverte,1023);
stepper1.disableOutputs();
Serial.print(CurrentFilter); Serial.println("#");
break;
 
     case 3:                    // // DEPLACEMENT FILTER 4
analogWrite(LEDverte,0);  
analogWrite(LEDrouge,1023);
stepper1.setAcceleration(Acceleration);
stepper1.setMaxSpeed(Vitesse); 
stepper1.run();
stepper1.runToNewPosition(CurrentFilter * DistanceFiltre);  
stepper1.disableOutputs();
analogWrite(LEDrouge,0);
delay(750);
analogWrite(LEDverte,1023);
stepper1.disableOutputs();
Serial.print(CurrentFilter); Serial.println("#");
break;
 
     case 4:                     // DEPLACEMENT FILTER 5
analogWrite(LEDverte,0);  
analogWrite(LEDrouge,1023);
stepper1.setAcceleration(Acceleration);
stepper1.setMaxSpeed(Vitesse); 
stepper1.run();
stepper1.runToNewPosition(CurrentFilter * DistanceFiltre);  
stepper1.disableOutputs();
analogWrite(LEDrouge,0);
delay(750);
analogWrite(LEDverte,1023);
stepper1.disableOutputs();
Serial.print(CurrentFilter); Serial.println("#");
break;
}

merci

[Auteur]

De mon coté la roue à filtre fonctionne du tonnerre, j'ai rajouté un condo 470µF et un interrupteur entre le RESET et 5V de l'arduino, ca m’évite des réinitialisations intempestives de la RAF quand je branche un port USB sur mon HUB et que la roue est déjà en fonctionnement.
Je ne sais pas pourquoi ca faisait ca mais avec mon petit câblage j'ai plus de souci.

c'est curieux effectivement. Où as-tu placé ton condensateur ? Si tu as une réinitialisation de ta carte cela voudrait dire que tu aurais une perte de puissance assez conséquente quand tu branches quelque chose sur ton hub. Mais que branches-tu sur ce hub ?

Ton arduino est alimenté par le 12V du moteur ou par le 5V du port USB ?

[seriousmath]

Salut,

Pour le condensateur voici son cablage, je prends le RESET et le 5V de l'arduino.



Sur mon HUB j'ai pas grand chose dessus, le plus gourmand doit être la monture du télescope mais tout ça tourne en 12V donc .

L'Arduino est alimenté par le 5V de l'USB.

Avec le bouton ON, le démarrage de l'arduino est instantané, la led sur celui ci ne clignote pas quand je le branche et la roue s'initialise de suite.
Avec le bouton OFF, l'arduino clignote quelques secondes puis la roue s'initialise. Impératif d’être en mode OFF pour reprogrammer le Nano.

++
math

[Vincent PETIT]

Salut,
Je te recommande, si tu le veux bien, de faire autrement pour plusieurs raisons :
- La broche d'entrée "reset" est en l'air lorsque l'interrupteur est ouvert et ce n'est pas bon du tout. Le moindre parasite/perturbation et le micro peut faire un "reset".
- Le démarrage du micro n'est pas contrôlé, un micro ne doit pas se mettre en route en même temps que le démarrage de son alimentation, il doit se mettre en route après la stabilisation.

Tu devrais faire ceci :

Au premier démarrage C1 sera déchargé et tu peux donc le considérer comme un fil (relié au 0V) donc le micro sera maintenu en RESET. C1 va commencer a se charger exponentiellement à raison de R1*C1 soit 1ms. Et quelques temps après il y aura suffisamment de tension dans C1 pour faire démarrer le micro puisque RESET sera égal a une certaine tension que le micro considérera comme un 1 logique (pour les puristes il faudrait regarder la doc du micro pour voir a partir de quelle tension exacte il voit un 1 logique). Ensuite si tu appuies sur l'interrupteur tu vas venir courtcircuiter le condensateur et tu auras 0V a ses bornes dons le micro fera un RESET. Si tu as des rebonds ils seront automatiquement gérés (annulés) par le temps de charge R1 * C1.

Il faut conserver le condensateur de 470µF mais il faut le placer entre +5V et 0V du micro pour qu'il joue le rôle de réservoir d'énergie.

A+

[Auteur]

C'est curieux que tu doives ajouter un condo sur le reset
Il y a déjà des condensateurs de 4,7µF et un de 100nF sur le 5V de l'alimentation, ils devraient logiquement suffire.

[brown_rb]

Please explain why you deleted my name as the author of this code

Veuillez expliquer pourquoi vous avez supprimé mon nom comme l'auteur de ce code

Bonjour à tous,

Je me permets de passer sur ce forum car après 2 semaines de recherche et de consultation de tutoriaux je suis toujours aussi perdu avec l'Arduino et surtout je ne trouve pas de sketch correspondant à mon besoin.

Donc pour la petite histoire je suis astrophotographe amateur, j'ai un télescope et tout ce qui va avec et je fais des photos des étoiles, galaxies, nébuleuses et autres.

Pour réaliser une photo, j'ai une caméra CCD avec capteur noir et blanc devant laquelle se trouve une roue à filtre. C'est un boitier dans lequel est placé un disque percé de 5 emplacement correspondant à chacun de mes filtres colorés.
Donc, je fais tourner avec mon doigt le disque pour placer le bon filtre devant le capteur et je lance mes photos.

Ce que je voudrais c'est automatiser la rotation de ce disque par l'intermédiaire d'un moteur PaP et Arduino comme dans cette vidéo:

Pour ce faire j'ai commandé un moteur 28BYJ-48, un driver ULN2003 et un Arduino Nano, et j'ai trouvé les schémas de câblage mais voila LE GROS PROBLÈME est que mes compétences s'arrêtent là. J'ai tout pour faire mais pas le savoir en programmation.

Je me tourne donc vers vous en espérant tomber sur le DIEU de la programmation Arduino lol ou du moins une âme charitable qui pourrait me développer un bout de code pour faire tourner cette fameuse roue.

J'ai trouvé un joli sujet à concernant le moteur que j'ai acheté mais là aussi j'y pers mon latin et meme en essayant de parler un bon anglais je n'ai pas eu de réponse de ce coté.

Le sketch initiale devrait être capable, à l'allumage de l'Arduino, de prendre la position de départ du stepper comme home/référence puis de le faire tourner d'un certain nombre de pas.
Par la suite, si le projet se concrétise, je rajouterais un ou des capteurs à effet hall pour vraiment affiner la prise du home et le placement de chaque logement de filtre en face du capteur.
Mais dans un premier temps et pour ne pas m'embrouiller de trop, je veux juste tester la précision du moteur.

Je ne suis pas riche mais s'il faut faire un don paypal pour le développement je suis ouvert à propositions.

Merci pour votre lecture et j'espère avoir des retours positifs?

Mathieu

voici un code que j'ai trouvé mais qui comme je n'y connais rien donc je ne peux pas l'utiliser. Pensez qu'on peut le rendre compatible avec ma demande ?

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
// myfilterwheel example
// ONLY FOR USE WITH 28BYJ-48 AND ULN2003 DRIVER
 
// v1.00_ULN2003 25032016
// Initial code
 
#include <Arduino.h>
#include <Stepper.h>                  // needed for stepper motor
#include <EEPROM.h>                   // needed for EEPROM
#include "eepromanything.h"           // needed for EEPROM
 
// #define EEPROMSIZE 512              // ATMEGA168 512 EEPROM
#define EEPROMSIZE 1024               // ATMEGA328P 1024 EEPROM
 
#define FRED 1
#define FGREEN 2
#define FBLUE 3
#define FLUMIN 4
#define FOTHER 5
 
// these are stored in EEPROM - all variables in a structure
struct config_t
{
  int validdata;
  int slots[5];        // slot[0] = home, this is a 5 position filter wheel, numbered 0 to 4, each holds a color value
  int steps[5] = { 0, 1000, 2000, -2000, -1000 };
} myfilter;
 
// will hold size of the struct myfocuser - 6 bytes
int datasize;      // will hold size of the struct myfocuser - 6 bytes
int nlocations;    // number of storage locations available in EEPROM
int currentaddr;   // will be address in eeprom of the data stored
bool writenow;     // should we update values in eeprom
bool found;        // did we find any stored values?
long previousMillis = 0L;   // used as a delay whenever the EEPROM settings need to be updated
long interval = 10000L;     // interval in milliseconds to wait after a move before writing settings to EEPROM, 30s
 
const String programName = "myFilter_ULN2003";
const String programVersion = "1.0.0";
 
const int stepsPerRevolution = 2048; // there are 2048 steps for one rotation of the 28BYJ-48 shaft
// initialize the stepper library on pins 4 (IN1), 5 (IN2), 6 (IN3), 7 (IN4)
Stepper mystepper(stepsPerRevolution, 4, 6, 7, 5);
// note that the stepper does not release current to the coils after a step so it gets hot
// the code below used by clearoutputs() releases the stepper after a step preventing it from getting hot
int motorPins[] = { 4, 5, 6, 7 };  // used to disable the output so it does not overheat
int motorSpeed = 2;
 
long maxsteps = 3000L;         // default maximum number of steps of filter wheel
int currentslotnumber = 0;
int targetslotnumber = 0;
int homepin = 2;               // this is where the index for home is connected to D2 pin
#define dirclockwise 1
#define diranticlockwise 2
 
char inChar;
boolean isMoving = false;        // is the motor currently moving
long pos;
 
#define MAXCOMMAND 8
char mycmd[MAXCOMMAND];
char param[MAXCOMMAND];
char line[MAXCOMMAND];
int eoc = 0;    // end of command
int idx = 0;    // index into command string
 
// disable the stepper motor outputs
void clearOutput()
{
    for (int i = 0; i < 4; i++)
    {
      digitalWrite(motorPins[i], 0);
    }
}
 
// Move stepper anticlockwise
void anticlockwise()
{
  mystepper.step(-1);        // step the motor one step anticlockwise
}
 
// Move stepper clockwise
void clockwise()
{
  mystepper.step(1);         // step the motor one step clockwise
}
 
void findindex()
{
  // this homes the filter wheel to slot 0
  // it uses a hall-effect or magnet which gives true on Pin2 when its home
  // avoid going too fast else will miss the home signal
  int steps = 0;
  int mydirection = dirclockwise;
  while ( digitalRead( homepin ) == false )
  {
    if ( mydirection == dirclockwise )
    {
      clockwise();    // move the filter wheel
      steps++;
      if ( steps > maxsteps )
      {
        steps = 0;
        mydirection = diranticlockwise;
      }
    }
    else if ( mydirection == diranticlockwise )
    {
      anticlockwise();
      steps--;
      if ( steps < 0 )
      {
        steps = 0;
        mydirection = dirclockwise;
      }
    }
  }
  // found signal, so
  // ismoving = false;
  currentslotnumber = 0;
  targetslotnumber = 0;
}
 
void movetoslotnumber( int slottomoveto )
{
  targetslotnumber = slottomoveto;
  // check if we are already there
  if ( targetslotnumber == currentslotnumber )
  {
    // we are already there
    // so do nothing
  }
  else
  {
    // we are not there so move
    // work out direction and number of steps
 
    // yet to finish this code
 
  }
}
 
// ASCOM Serial Commands
void processCommand(String command)
{
  memset(mycmd, 0, MAXCOMMAND);
  memset(param, 0, MAXCOMMAND);
  int len = strlen(line);
  if (len >= 2)
  {
    strncpy(mycmd, line, 2);
  }
  if (len > 2)
  {
    strncpy(param, line + 2, len - 2);
  }
 
  memset(line, 0, MAXCOMMAND);
  eoc = 0;
  idx = 0;
 
  // get the current filter position
  if (!strcasecmp(mycmd, "GP"))
  {
    Serial.print("P");
    Serial.print(currentslotnumber);
    Serial.print("#");
  }
 
  // motor is moving - 1 if moving, 0 otherwise
  else if (!strcasecmp(mycmd, "GI"))
  {
    if (isMoving )
    {
      Serial.print("I01#");
    }
    else {
      Serial.print("I00#");
    }
  }
 
  // home the filter, slot 0
  else if (!strcasecmp(mycmd, "PH"))
  {
    isMoving = true;
    findindex();
    currentslotnumber = 0;
    isMoving = true;
  }
 
  // get current slot number
  else if (!strcasecmp( mycmd, "GS"))
  {
    Serial.print("S");
    Serial.print(currentslotnumber);
    Serial.print("#");
  }
 
  // move to slot position
  else if (!strcasecmp( mycmd, "MS"))
  {
    // get the slot number to move to
    pos = decstr2long(param);
    movetoslotnumber( pos);    // move to the slot number
    writenow = true;             // updating of EEPROM ON
    previousMillis = millis();   // start time interval
  }
 
  // assign filter color to slot position
  else if (!strcasecmp(mycmd, "AF"))
  {
     // there are two arguments, slotnumber, filtercolor
     // get slotnumber (range is 0 to 4)
     int slotnumber;
     pos = decstr2long(param);
     slotnumber = pos;
 
     // now get filtercolor, 1=R, 2=G, B=3, L=4, O=5
     int colorfilter;
     pos = decstr2long(param);
     colorfilter = pos;
     // check for valid slot number
     if( (slotnumber >= 0) && (slotnumber <= 4))
     {  
       // check that colorfilter is in range 1-5
       if( (colorfilter >=1) && (colorfilter <=5) )
       {
         // assign the color filter to the slot number
         myfilter.slots[slotnumber] = colorfilter;
       }
       else
       {
         // colorfilter is outside range
         // do nothing
       }
     }
     else
     {
       // slotnumber is outside range
       // do nothing
     }   
  }
 
  // troubleshooting only - print currentaddr value, use in serial monitor mode is best
  else if (!strcasecmp(mycmd, "XY"))
  {
    Serial.println();
    Serial.print("Current Slot number=");
    Serial.println(currentslotnumber);
    Serial.print("maxsteps=");
    Serial.println(maxsteps);
    Serial.print("Slot[0]=");
    switch(myfilter.slots[0])
    {
      case 1: // RED
        Serial.println("RED");
        break;
      case 2: // GREEN
        Serial.println("GREEN");
        break;
      case 3: // BLUE
        Serial.println("BLUE");
      case 4: // LUMIN
        Serial.println("LUMIN");
      case 5: // OTHER
        Serial.println("OTHER");
      default: // INVALID
        Serial.println("INVALID SLOT NUMBER");        
    }
    Serial.print("Slot[1]=");
    switch(myfilter.slots[1])
    {
      case 1: // RED
        Serial.println("RED");
        break;
      case 2: // GREEN
        Serial.println("GREEN");
        break;
      case 3: // BLUE
        Serial.println("BLUE");
      case 4: // LUMIN
        Serial.println("LUMIN");
      case 5: // OTHER
        Serial.println("OTHER");
      default: // INVALID
        Serial.println("INVALID SLOT NUMBER");        
    }
    Serial.print("Slot[2]=");
    switch(myfilter.slots[2])
    {
      case 1: // RED
        Serial.println("RED");
        break;
      case 2: // GREEN
        Serial.println("GREEN");
        break;
      case 3: // BLUE
        Serial.println("BLUE");
      case 4: // LUMIN
        Serial.println("LUMIN");
      case 5: // OTHER
        Serial.println("OTHER");
      default: // INVALID
        Serial.println("INVALID SLOT NUMBER");        
    }
    Serial.print("Slot[3]=");
    switch(myfilter.slots[3])
    {
      case 1: // RED
        Serial.println("RED");
        break;
      case 2: // GREEN
        Serial.println("GREEN");
        break;
      case 3: // BLUE
        Serial.println("BLUE");
      case 4: // LUMIN
        Serial.println("LUMIN");
      case 5: // OTHER
        Serial.println("OTHER");
      default: // INVALID
        Serial.println("INVALID SLOT NUMBER");        
    }
    Serial.print("Slot[4]=");
    switch(myfilter.slots[4])
    {
      case 1: // RED
        Serial.println("RED");
        break;
      case 2: // GREEN
        Serial.println("GREEN");
        break;
      case 3: // BLUE
        Serial.println("BLUE");
      case 4: // LUMIN
        Serial.println("LUMIN");
      case 5: // OTHER
        Serial.println("OTHER");
      default: // INVALID
        Serial.println("INVALID SLOT NUMBER");        
    }
    Serial.print("#");
  }
 
  // troubleshooting only - reset focuser defaults
  else if (!strcasecmp(mycmd, "XZ"))
  {
    currentslotnumber = 0;
    targetslotnumber = 0;
 
    // setup the slots table
    myfilter.validdata = 99;
    myfilter.steps[0] = 0;
    myfilter.steps[1] = 1000;
    myfilter.steps[2] = 2000;
    myfilter.steps[3] = -2000;
    myfilter.steps[4] = -1000;
    myfilter.slots[0] = FRED;
    myfilter.slots[1] = FGREEN;
    myfilter.slots[2] = FBLUE;
    myfilter.slots[3] = FLUMIN;
    myfilter.slots[4] = FOTHER;
    // now write the data to EEPROM
    EEPROM_writeAnything(currentaddr, myfilter);    // update values in EEPROM
    // Set focuser defaults.
    findindex();
  }
}
 
// convert string to long int
long decstr2long(char *line) 
{
  long ret = 0;
  ret = strtol(line, NULL, 10);
  return (ret);
}
 
// Setup
void setup() 
{
  // initialize serial for ASCOM
  Serial.begin(9600);
 
  eoc = 0;
  idx = 0;
  isMoving = false;
  memset(line, 0, MAXCOMMAND);
 
  mystepper.setSpeed(motorSpeed); // medium speed
 
  currentaddr = 0;    // start at 0 if not found later
  found = false;
  writenow = false;
  datasize = sizeof( myfilter );    // should be 14 bytes
  nlocations = EEPROMSIZE / datasize;  // for AT328P = 1024 / datasize = 73 locations
 
  for (int lp1 = 0; lp1 < nlocations; lp1++ )
  {
    int addr = lp1 * datasize;
    EEPROM_readAnything( addr, myfilter );
    // check to see if the data is valid
    if ( myfilter.validdata == 99 ) 
    {
      // data was erased so write some default values
      currentaddr = addr;
      found = true;
    }
  }
  if ( found == true )
  {
    // set the filter back to the previous settings
    EEPROM_readAnything( currentaddr, myfilter );
    myfilter.validdata = 0;
    EEPROM_writeAnything(currentaddr, myfilter);    // update values in EEPROM
 
    // goto next free address and write data
    currentaddr += datasize;
    // bound check the eeprom storage and if greater than last index [0-EEPROMSIZE-1] then set to 0
    if ( currentaddr >= (nlocations * datasize) ) currentaddr = 0;
 
    myfilter.validdata = 99;
    EEPROM_writeAnything(currentaddr, myfilter);    // update values in EEPROM
  }
  else
  {
    // set defaults because not found
    myfilter.validdata = 99;
    myfilter.steps[0] = 0;
    myfilter.steps[1] = 1000;
    myfilter.steps[2] = 2000;
    myfilter.steps[3] = -2000;
    myfilter.steps[4] = -1000;
    myfilter.slots[0] = FRED;
    myfilter.slots[1] = FGREEN;
    myfilter.slots[2] = FBLUE;
    myfilter.slots[3] = FLUMIN;
    myfilter.slots[4] = FOTHER;
    // now write the data to EEPROM
    EEPROM_writeAnything(currentaddr, myfilter);    // update values in EEPROM
  }
  findindex();
}
 
// Main Loop
void loop()
{
  // process the command string when a hash arrives:
  if (eoc)
  {
    processCommand(line);
    memset(line, 0, MAXCOMMAND);
    eoc = false;
  }
}
 
// SerialEvent occurs whenever new data comes in the serial RX.
void serialEvent()
{
  // : starts the command, # ends the command, do not store these in the command buffer
  // read the command until the terminating # character
  while (Serial.available() && !eoc)
  {
    inChar = Serial.read();
    if (inChar != '#' && inChar != ':')
    {
      line[idx++] = inChar;
      if (idx >= MAXCOMMAND)
      {
        idx = MAXCOMMAND - 1;
      }
    }
    else
    {
      if (inChar == '#')
      {
        eoc = 1;
        idx = 0;
      }
    }
  }
}