|
||
     |
// ***********************************************************
// Project: Intervallometre pour EOS 350D
// Author: Pierre NERZIC, 16 avril 2007
// Site: http://pierre.nerzic.free.fr/
// Module description: firmware de TimEOS,
// permet d´effectuer N poses de T secondes
//
// Licence: proposé pour information sous licence GPL
// Vous avez le droit de vous en servir à condition de toujours
// laisser mon nom et la référence à mon site internet.
// ***********************************************************
// fichier de compatibilité IAR - GCC, il inclut les defs du contrôleur
#include "compat.h"
// prototypes des fonctions
void LCDcommand(unsigned char code);
void ClearLCD(void);
//void GotoLC(unsigned char l, unsigned char c);
void Write(const unsigned char *s);
//void Write4C(unsigned long abcd);
void WriteShort(unsigned short nb);
void WriteTextAdr4(unsigned char adr);
void WriteTextAdr8(unsigned char adr1, unsigned char adr2);
#define GotoL0C0 LCDcommand(0x80);
#define GotoL1C0 LCDcommand(0xC0);
//#define Mk4C(a,b,c,d) ((((unsigned long)a)<<24)|(((unsigned long)b)<<16)|(((unsigned long)c)<<8)|((unsigned long)d))
/************ Affectation des ports d´entrées-sorties du ATtiny2313 :
AFFICHEUR :
S PD5 rétroéclairage (PWM)
S PB6 E
S PB5 Rs
S PB4 R/W
S PB3 DB7
S PB2 DB6
S PB1 DB5
S PB0 DB4
CLAVIER :
E PD6 menu bas
E PD4 menu haut
E PD3 plus
E PD2 moins
EOS :
S PD1 prise de vue
S PD0 mise au point
*/
/************************************/
/******** GESTION DE L´EEPROM *******/
/************************************/
/************ Utilisation de l´EEPROM :
les 16 premiers octets = valeurs numériques de config
ensuite : les textes affichés sur le LCD, voir WriteTextAdr4
0F 03 0F 00 00 02 00 01 00 A7 61 FF FF FF FF FF
FF FF FF FF FF FF FF FF 4E 62 20 50 6F 73 65 73
54 70 73 20 4D 61 50 20 4D 69 72 20 50 73 65 20
46 69 6E 20 52 65 74 72 6F 45 63 6C 45 6E 72 20
43 6F 6E 66 50 72 65 74 41 6E 6E 75 6C 65 65 20
2D 53 61 75 76 65 65 2D 4E 75 6D 20 43 61 6C 69
62 43 6C 6B 25 49 6E 63 FF FF FF FF FF FF FF FF
20 54 69 6D 45 4F 53 20 50 2E 4E 65 72 7A 69 63
*/
void EEPROM_write(unsigned char adr, unsigned char *data, unsigned char size)
{
while (size-- > 0) {
while (EECR & (1<<EEPE));
EEAR = adr++;
EEDR = *data++;
EECR |= (1<<EEMPE);
EECR |= (1<<EEPE);
}
}
void EEPROM_read(unsigned char adr, unsigned char *data, unsigned char size)
{
while (size-- > 0) {
while (EECR & (1<<EEPE));
EEAR = adr++;
EECR |= (1<<EERE);
*data++ = EEDR;
}
}
/************************************/
/******* VARIABLES DE CONTRÔLE ******/
/************************************/
//// valeurs de configuration du logiciel, stockées en eeprom
struct configuration {
unsigned char RetroEclRatio; // ratio d´éclairage de l´écran 0..255
unsigned char NbrePoses; // nombre de poses 1..255
unsigned short DureePoses; // durée de chaque pose 1..9999s
unsigned char AllongementPoses; // allongement des poses 0..500%
unsigned char DureeMiseAuPoint; // durée de gestion de la mise au point 0..9s
unsigned char DureeMiroir; // durée de relevage du miroir 0..9s
unsigned short DureeFinPose; // durée de fin de pose 1..9999s
unsigned short CalibrationTicks; // ajustement de l´horloge CTC (timer1)
};
// valeurs des variables, copie de l´eeprom
struct configuration Configuration; // = { 15, 3, 15, 0, 2, 2, 0, 24999 };
//// lecture et enregistrement des valeurs de configuration dand l´eeprom
// nb: la directive inline ne semble pas marcher sur le compilo utilisé ici
#define InitConfig() { EEPROM_read(0, (unsigned char *)&Configuration, sizeof(Configuration)); }
#define SaveConfig() { EEPROM_write(0, (unsigned char *)&Configuration, sizeof(Configuration)); }
/************************************/
/******** GESTION DU CLAVIER ********/
/************************************/
//// Le clavier est connecté au PortD bits 2,3,4 et 6
//// On examine l´état des touches pour affecter la variable globale Touche
//// On évite les problèmes de rebond en comptant le nombre de Ticks pendant
//// laquelle la touche est restée enfoncée. On produit aussi les répétitions
//// au bout d´un certain nombre de ticks, et ça gère aussi la vitesse de répétition.
enum ToucheCode {
NONE=0,
MOINS=1, // bleu
PLUS=2, // rouge
UP=3, // noir
DOWN=4 // jaune
};
// variable globale à utiliser dans main()
Register(r2, unsigned char Touche); // = NONE; // contient le code de la touche enfoncée ou NONE
// variables de gestion : touche précédemment enfoncée et durée d´enfoncement
Register(r3, unsigned char ToucheEnfoncee); // = NONE;
Register(r4, unsigned char ToucheEnfonceeDepuis); // = 0;
#define Limite1 2 // nombre de ticks avant prise en compte (2/10s)
#define Limite2 9 // nombre de ticks avant début de répétition (9/10s)
#define Limite3 11 // (Limite3-Limite2) = vitesse de répétition (en nbre de ticks)
unsigned char TestTouche(unsigned char bit, enum ToucheCode code)
{
// la touche est-elle enfoncée ?
if (bit == 0) {
// était-elle déjà enfoncée ?
Touche = 0; //NONE;
if (ToucheEnfoncee == code) {
// oui, elle était déjà enfoncée précédemment
if (ToucheEnfonceeDepuis == Limite1 || ToucheEnfonceeDepuis == Limite2) {
Touche = code;
}
if (ToucheEnfonceeDepuis >= Limite3) ToucheEnfonceeDepuis = Limite2;
else ToucheEnfonceeDepuis++;
} else {
// c´est une nouvelle touche enfoncée
ToucheEnfoncee = code;
ToucheEnfonceeDepuis = 1;
}
}
return !bit;
}
void MajToucheEnfoncee(void)
// fonction appelée par l´IT Tick, pour mettre à jour la variable globale Touche
{
// l´une des touches est-elle enfoncée ?
if (TestTouche(BIT2(PIND), MOINS) ||
TestTouche(BIT3(PIND), PLUS) ||
TestTouche(BIT4(PIND), UP) ||
TestTouche(BIT5(PIND), DOWN))
return;
// aucune touche n´est enfoncée
Touche = ToucheEnfoncee = 0; //NONE;
ToucheEnfonceeDepuis = 0;
}
/************************************/
/********* GESTION DE l´EOS *********/
/************************************/
//// le déroulement des opérations avec l´appareil photo est géré par un
//// automate à états. Selon son état, on commute de telle ou telle manière
//// les signaux sur la prise jack. Des compteurs sont utilisés pour changer
//// l´état courant quand ils arrivent à zéro.
// état de l´automate d´état : où en est-il ?
enum EtatAutomate {
STOP=0, // aucune série en cours
DEBUT, // début d´une série de poses
MISEAUPOINT, // la mise au point est en cours
MIROIR, // le relevage du miroir est en cours
POSE, // une pose est en cours
FINPOSE // une pose se finit, on attend avant la suivante
};
Register(r5, unsigned char EtatAutomate);
// compteurs de cycles (= 1 seconde sur telle ou telle chose) restant à faire
Register(r6, unsigned char RestantNbrePoses); // nombre de poses restant à faire
unsigned short RestantCpt; // temps restant dans l´état courant
unsigned short DureePose; // durée de la pose courante = Configuration.DureePose
// cette routine gère l´avancement des poses, elle est appelée par l´IT Tick
// à chaque fois qu´elle fait return, 1 seconde s´écoule avant l´appel suivant
void EvolutionAutomate(void)
{
switch (EtatAutomate) {
case STOP:
// rien n´est en cours, on RAZ toutes les variables
BIT0(PORTD) = 0; // mise au point = off
BIT1(PORTD) = 0; // prise de vue = off
RestantNbrePoses = 0;
RestantCpt = 0;
return;
case DEBUT:
// initialisation d´une série
RestantNbrePoses = Configuration.NbrePoses;
DureePose = Configuration.DureePoses;
EtatAutomate = MISEAUPOINT;
RestantCpt = Configuration.DureeMiseAuPoint;
case MISEAUPOINT:
// phase de mise au point
if (RestantCpt > 0) {
RestantCpt--;
BIT0(PORTD) = 1; // début de la mise au point
return;
}
BIT0(PORTD) = 0; // fin de la mise au point
// fin de la mise au point, on commence les poses
loop:
EtatAutomate = MIROIR;
RestantCpt = Configuration.DureeMiroir;
BIT1(PORTD) = 1; // relever le miroir ou démarrer la pose
if (RestantCpt > 0) return;
case MIROIR:
// phase de relevage du miroir
if (RestantCpt > 0) {
RestantCpt--;
BIT1(PORTD) = 0; // fin de relever le miroir
return;
}
EtatAutomate = POSE;
RestantCpt = DureePose;
BIT1(PORTD) = 1; // début de la pose
case POSE:
// une pose est en cours
if (RestantCpt > 0) {
RestantCpt--;
return;
}
// fin de la pose
EtatAutomate = FINPOSE;
BIT1(PORTD) = 0; // fin de la pose
RestantCpt = Configuration.DureeFinPose;
case FINPOSE:
// on attend avant la pose suivante
if (RestantCpt > 0) {
RestantCpt--;
} else {
// fin de la pose : autres poses ou fin totale ?
RestantNbrePoses--;
if (RestantNbrePoses == 0) {
// il ne reste plus aucune pose à faire, on arrête
EtatAutomate = STOP;
Touche = MOINS; // débloque la boucle princ, fait afficher "Pret..."
return;
}
DureePose = (DureePose * (100+Configuration.AllongementPoses)) / 100;
goto loop; // retourne au niveau du verrouillage miroir
}
return;
}
}
void WriteEtatAutomate(void)
// affiche l´état d´avancement de la série, appelé par l´IT Tick
{
if (EtatAutomate == STOP) return;
ClearLCD();
WriteTextAdr4(0x58); // "Num "
WriteShort(RestantNbrePoses);
GotoL1C0;
WriteTextAdr4(0x1C + (EtatAutomate<<2)); // Mir ou Map ou Pse ou Fin
WriteShort(RestantCpt+1); // nombre+1 (10..1 p. ex.)
}
/************************************/
/********* GESTION DU TEMPS *********/
/************************************/
//// Le temps est géré par interruption. Le Timer1 (16 bits) est configuré en
//// mode CTC : retour à zéro quand le compteur égale OCR1A. Ca permet d´ajuster
//// exactement la fréquence des interruptions.
//// Sa routine d´interruption est donc appelée TICKS=10 fois par seconde
//// Elle met à jour l´état du clavier et gère l´avancement des poses.
//// Le timer0 (8 bits) sert à gérer l´intensité du rétroéclairage à l´aide
//// de sa 2e sortie PWM (OC0B).
#define TICKS 10 // nombre d´IT par seconde
// ce nombre est ajusté à l´aide de Configuration.CalibrationTicks
// le but est d´obtenir !exactement! TICKS interruptions par seconde
//// NB : version béta : les horloges et calculs n´ont pas été vérifiés !
void InitTimers(void)
// configuration des timers : timer0 = PWM, timer1 = CTC
{
// modif du prescaler, voir page 30 du datasheet complet
// prescaler/4 = fIO = finterne/4 = 250 kHz
CLKPR = 0x80; // armer l´écriture de CLKPR
CLKPR = 0x02; // => prescaler = 4,horloge = 250000 Hz
//// NB: A VERIFIER EXACTEMENT !!
/*** configurer le timer0 et sa sortie PWM OC0B ***/
//// config timer0 en mode "phase correct PWM" avec sortie du signal sur OC0B
// WGM0 = 001 phase correct PWM
// COM0A = 00 pas de sortie sur OC0A
// COM0B = 11 sortie OC0B : set on match when upcounting, clear on downcounting
// CS0 = 001 pas de prescaling => freq PWM = 510 Hz (fIO/510)
/* TCCR0B : Timer/Counter 0 Control Register B */
// #define FOC0A 7 0
// #define FOC0B 6 0
// #define - 5 0
// #define - 4 0
// #define WGM02 3 0
// #define CS02 2 0
// #define CS01 1 0
// #define CS00 0 1
TCCR0B = 0x01;
/* TCCR0A : Timer/Counter 0 Control Register A */
// #define COM0A1 7 0 // COMA = 00 => pas de sortie
// #define COM0A0 6 0
// #define COM0B1 5 1 // COMB = 11 => sortie inversée
// #define COM0B0 4 1
// #define - 3 0
// #define - 2 0
// #define WGM01 1 0
// #define WGM00 0 1
TCCR0A = 0x31;
/*** configurer le timer1 = ticks = IT régulière ***/
//// config timer1 en mode "CTC" sans sorties
// WGM1 = 0100 CTC = clear timer on compare match
// COM1A = 00 pas de sortie
// COM1B = 00 pas de sortie
// CS1 = 001 division par N=1 =>
/* TCCR1A : Timer/Counter 1 Control Register */
// #define COM1A1 7 0 // COM* = 00 => pas de sortie
// #define COM1A0 6 0
// #define COM1B1 5 0
// #define COM1B0 4 0
// #define WGM11 1 0 // WGM1 = 0100 => CTC
// #define WGM10 0 0
// TCCR1A = 0x00;
/* TCCR1B : Timer/Counter 1 Control and Status Register */
// #define ICNC1 7 0
// #define ICES1 6 0
// 5 0
// #define WGM13 4 0
// #define WGM12 3 1
// #define CS12 2 0 // CS1 = 000 => clk/2 (N=2)
// #define CS11 1 1
// #define CS10 0 0
TCCR1B = 0x0A;
// limite haute du compteur CTC : p99 du datasheet
// on veut freq = horloge / (N*(1+OCR1A)) =exactement TICKS hertz
// avec horloge = 1250000 et N=1
// OCR1A = Configuration.CalibrationTicks; // exactement TICKS interruptions par seconde à 1MHz
// NB: OCR1A est positionnée dans la routine d´interruption, donc inutile de le faire ici
// autoriser l´interruption TIMER1_COMPA (IT quand égalité entre OCR1A et le compteur)
BIT6(TIMSK) = 1;
// on lance la mécanique des interruptions
__enable_interrupt();
}
//// routine d´interruption du timer 1 : appelée pour TCNT1 == OCR1A
// elle est appelée exactement TICKS fois par seconde
Register(r7, unsigned char NbTicksIgnores); // pour ignorer TICKS-1/TICKS appels
#ifdef __ICCAVR__
#pragma vector=TIMER1_COMPA_vect
#endif
ISR(TIMER1_COMPA_vect)
{
//// deux parties : 1) gérer le clavier TICKS fois par seconde,
//// 2) gérer l´EOS une seule fois par seconde
// consulter l´état des touches du clavier
MajToucheEnfoncee();
// mettre à jour les limites de comptage des timers
OCR0B = Configuration.RetroEclRatio;
OCR1A = Configuration.CalibrationTicks;
//// ignorer TICKS-1 appels, pour ne continuer qu´1 seule fois par seconde
NbTicksIgnores++;
if (NbTicksIgnores < TICKS) return;
NbTicksIgnores = 0;
// évolution de la pose en cours
EvolutionAutomate();
WriteEtatAutomate();
}
/************************************/
/**** GESTION DE L´AFFICHEUR LCD ****/
/************************************/
inline void InitPorts(void)
{
/*** configurer les ports et les valeurs par défaut ***/
// le port D = 0, 1 et 5 sorties, le reste = entrées avec pull-up
DDRD = 0x23;
PORTD = 0x5C;
// PortB0-6 sont tous des sorties
DDRB = 0x7F;
// PORTB = 0x00;
}
/** Partie bas-niveau : bit banging sur le port B **/
void shortpause(unsigned short nb)
// il faudrait la calibrer... pour supprimer tous les délais inutiles
{
while (nb > 0) nb--;
}
void LCDset(unsigned char RS, unsigned char RW, unsigned char DB)
{
// positionner RS, RW et DB, mettre E à 0
unsigned char bits = (DB & 0x0F); // ne garder que le poids faible de DB
if (RS) bits |= 0x20; // bit5 = Rs
if (RW) bits |= 0x10; // bit4 = R/W
PORTB = bits; // mettre ce nombre en sortie
// mettre E à 1 pendant 250ns au moins
BIT6(PORTB) = 1;
// attendre quelques cycles d´horloge à 8MHz >= 250nS
shortpause(10);
// mettre E à 0
BIT6(PORTB) = 0;
}
void LCDcommand(unsigned char code)
{
LCDset(0, 0, code>>4);
LCDset(0, 0, code); // rq: le masquage est fait dans LCDset
}
void LCDdata(unsigned char code)
{
LCDset(1, 0, code>>4);
LCDset(1, 0, code);
}
void InitLCD(void)
{
//// séquence d´initialisation
// attendre plus de 30 ms
// __sleep(); // marche bien sans ça
LCDset(0,0,0x2);
LCDcommand(0x2C);
// attendre 39us
shortpause(200);
LCDcommand(0x0C);
// attendre 39us
shortpause(200);
LCDcommand(0x01);
// attendre 1.53ms
shortpause(8000);
LCDcommand(0x06);
}
/** Partie haut-niveau : fonctions d´affichage **/
void ClearLCD(void)
{
LCDcommand(0x01);
shortpause(1000);
}
//void GotoLC(unsigned char l, unsigned char c)
//{
// // positionner le curseur en l,c
// LCDcommand((c&0x7)|(l?0xC0:0x80));
//}
//void Write4C(unsigned long abcd)
//{
// LCDdata(abcd>>24);
// LCDdata((abcd>>16)&0xFF);
// LCDdata((abcd>>8)&0xFF);
// LCDdata(abcd&0xFF);
//}
void Write(const unsigned char *s)
{
while (*s) {
LCDdata(*s);
s++;
}
}
// buffer pour contenir des textes temporaires
unsigned char tmp[9];
void WriteShort(unsigned short nb)
// écrit le nombre nb avec ch chiffres, ex : ch=4 pour 0..9999
{
// convertir le nombre en chaine
signed char i;
for (i=4; i>=0; i--) {
tmp[i] = (nb % 10) + ´0´;
nb = nb / 10;
if (nb == 0) break;
}
tmp[5] = 0;
// afficher la chaine (infini + premiers chiffres si > ch)
if (nb != 0) tmp[i] = 0xF3;
Write(&tmp[i]);
}
void WriteTextAdr4(unsigned char adr)
{
EEPROM_read(adr, tmp, 4);
tmp[4] = 0;
Write(tmp);
}
void WriteTextAdr8(unsigned char adr1, unsigned char adr2)
{
EEPROM_read(adr1, tmp, 4);
EEPROM_read(adr2, tmp+4, 4);
tmp[8] = 0;
Write(tmp);
}
/************************************/
/******* PROGRAMME PRINCIPAL ********/
/************************************/
//// Gestion des menus cycliques pour configurer chaque valeur
enum Menu {
TITRE=0,
CONFIGNBREPOSE,
CONFIGDUREEPOSE,
CONFIGINCPOSE,
CONFIGDUREEMAP,
CONFIGDUREEMIR,
CONFIGDUREEFIN,
CONFIGRETRO,
CONFIGCLOCK,
CONFIGRECORD,
POSES,
MENUDERNIER
};
Register(r8, unsigned char Menu);
// état de la configuration : changée par rapport à l´EEprom ?
Register(r9, signed char ConfigSauvee); // pour afficher le message sauvee (+1) ou remise (-1)
// permet d´accelérer dans la sélection de la durée des poses
#define ACCELERATIONPOSE 24
__C_task void main(void)
{
// initialisation des sous-systèmes
InitPorts();
InitConfig();
InitTimers();
InitLCD();
ConfigSauvee = 1;
// boucle infinie de gestion du clavier
for (;;) {
// afficher le titre du menu et récupérer la valeur à configurer
ClearLCD();
unsigned short valeur=0,min=0,max=9,pas=1;
switch (Menu) {
case TITRE:
WriteTextAdr8(0x70,0x74);
break;
case CONFIGNBREPOSE:
WriteTextAdr8(0x18,0x1C);
valeur = Configuration.NbrePoses;
min = 1; max = 255;
break;
case CONFIGDUREEPOSE:
WriteTextAdr8(0x20,0x2C);
valeur = Configuration.DureePoses;
pas = 1 + (valeur/ACCELERATIONPOSE);
min = 1; max = 9999;
break;
case CONFIGINCPOSE:
WriteTextAdr8(0x64,0x2B);
valeur = Configuration.AllongementPoses;
max = 250; pas=25;
break;
case CONFIGDUREEMAP:
WriteTextAdr8(0x20,0x24);
valeur = Configuration.DureeMiseAuPoint;
break;
case CONFIGDUREEMIR:
WriteTextAdr8(0x20,0x28);
valeur = Configuration.DureeMiroir;
break;
case CONFIGDUREEFIN:
WriteTextAdr8(0x20,0x30);
valeur = Configuration.DureeFinPose;
pas = 1 + (valeur/ACCELERATIONPOSE);
min=1; max = 9999;
break;
case CONFIGRETRO:
WriteTextAdr8(0x34,0x38);
valeur = Configuration.RetroEclRatio;
max = 255; pas = 3;
break;
case CONFIGCLOCK:
WriteTextAdr8(0x5C,0x60);
valeur = Configuration.CalibrationTicks;
min = 22000; max = 27000;
break;
case CONFIGRECORD:
WriteTextAdr8(0x3C,0x40);
break;
case POSES:
WriteTextAdr4(0x44);
break;
}
// afficher la valeur numérique à configurer
GotoL1C0;
switch (Menu) {
case TITRE:
WriteTextAdr8(0x78,0x7C);
break;
case CONFIGNBREPOSE:
case CONFIGDUREEPOSE:
case CONFIGINCPOSE:
case CONFIGDUREEMAP:
case CONFIGDUREEMIR:
case CONFIGDUREEFIN:
case CONFIGRETRO:
case CONFIGCLOCK:
WriteShort(valeur);
break;
case CONFIGRECORD:
switch (ConfigSauvee) {
case -1:
WriteTextAdr8(0x48,0x4C);
break;
case 1:
WriteTextAdr8(0x50,0x54);
break;
}
break;
case POSES:
WriteShort(Configuration.NbrePoses);
LCDdata(´x´);
WriteShort(Configuration.DureePoses);
break;
}
// attendre qu´on enfonce une touche (ou que la pose soit finie)
Touche = NONE;
while (Touche == NONE) __sleep();
// selon la touche
unsigned char menuprec = Menu;
GotoL1C0;
switch (Touche) {
case MOINS:
switch (Menu) {
case CONFIGNBREPOSE:
case CONFIGDUREEPOSE:
case CONFIGINCPOSE:
case CONFIGDUREEMAP:
case CONFIGDUREEMIR:
case CONFIGDUREEFIN:
case CONFIGRETRO:
case CONFIGCLOCK:
if (valeur >= min+pas) valeur-=pas;
else valeur = min;
break;
case CONFIGRECORD:
InitConfig();
ConfigSauvee = -1;
break;
case POSES:
EtatAutomate = STOP;
break;
}
ConfigSauvee = 0;
break;
case PLUS:
switch (Menu) {
case CONFIGNBREPOSE:
case CONFIGDUREEPOSE:
case CONFIGINCPOSE:
case CONFIGDUREEMAP:
case CONFIGDUREEMIR:
case CONFIGDUREEFIN:
case CONFIGRETRO:
case CONFIGCLOCK:
if (valeur <= max-pas) valeur+=pas;
else valeur = max;
break;
case CONFIGRECORD:
SaveConfig();
ConfigSauvee = 1;
break;
case POSES:
EtatAutomate = DEBUT;
break;
}
ConfigSauvee = 0;
break;
case UP:
if (EtatAutomate != STOP) break;
if (ConfigSauvee < 0) ConfigSauvee = 1;
if (Menu > 1) Menu--;
else Menu = MENUDERNIER-1;
break;
case DOWN:
if (EtatAutomate != STOP) break;
if (ConfigSauvee < 0) ConfigSauvee = 1;
if (Menu < MENUDERNIER-1) Menu++;
else Menu = 1;
break;
}
// réaffecter la valeur configurée
switch (menuprec) {
case CONFIGNBREPOSE:
Configuration.NbrePoses = valeur;
break;
case CONFIGDUREEPOSE:
Configuration.DureePoses = valeur;
break;
case CONFIGINCPOSE:
Configuration.AllongementPoses = valeur;
break;
case CONFIGDUREEMAP:
Configuration.DureeMiseAuPoint = valeur;
break;
case CONFIGDUREEMIR:
Configuration.DureeMiroir = valeur;
break;
case CONFIGDUREEFIN:
Configuration.DureeFinPose = valeur;
break;
case CONFIGRETRO:
Configuration.RetroEclRatio = valeur;
break;
case CONFIGCLOCK:
Configuration.CalibrationTicks = valeur;
break;
}
}
}
|
Accueil |
La dernière mise à jour de ce site date du 14/10/2007. © Pierre Nerzic 2007.