_______________________________________________________________________________________________________________________________________
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S D E B A S E D E G E S T I O N D U */
/* D I S Q U E V I D E O ' B E T A - P A L ' ( S O N Y 'LVS6000P-LVR6000' O U 'LVR4000P' ) */
/* E T D U M A G N E T O S C O P E ' B E T A - P A L ' ( S O N Y 'UVW1400P' ) : ) */
/* */
/* */
/* Definition : */
/* */
/* Ce fichier contient toutes les fonctions */
/* de base de gestion du disque-video PAL-Beta. */
/* */
/* */
/* Author of '$xiidP/fonct$vv$FON' : */
/* */
/* Jean-Francois Colonna (LACTAMME, 19890000000000). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P P O R T U N I T E D E C O M P I L E R C E M O D U L E : */
/* */
/*************************************************************************************************************************************/
#ifdef __VERSION__COMPILER_LA_GESTION_DU_DISQUE_PAL_BETA /* Common,DEFV(Fonction,) : indicateur de VERSION. */
DEFV(Common,DEFV(Logical,_______VERSION__COMPILER_LA_GESTION_DU_DISQUE_PAL_BETA));
#Aifdef __VERSION__COMPILER_LA_GESTION_DU_DISQUE_PAL_BETA /* Common,DEFV(Fonction,) : indicateur de VERSION. */
#Eifdef __VERSION__COMPILER_LA_GESTION_DU_DISQUE_PAL_BETA /* Common,DEFV(Fonction,) : indicateur de VERSION. */
#ifdef __VERSION__COMPILER_LA_GESTION_DU_DISQUE_PAL_BETA /* Common,DEFV(Fonction,) : compiler la gestion du disque PAL-Beta. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E S " B U G S " P R E S E N T S : */
/* */
/*************************************************************************************************************************************/
# ifdef BUG_SYSTEME_PAL_BETA_Read /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_PAL_BETA_Read));
# Aifdef BUG_SYSTEME_PAL_BETA_Read /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_PAL_BETA_Read /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS));
# Aifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS_99 /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS_99));
# Aifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS_99 /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS_99 /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_F_SCAN /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_PAL_BETA_PAL_BETA_F_SCAN));
# Aifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_F_SCAN /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_F_SCAN /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_PAL_BETA_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_PAL_BETA_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA));
# Aifdef BUG_SYSTEME_PAL_BETA_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_PAL_BETA_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA /* Common,DEFV(Fonction,) : bug... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E L ' A C C E S A U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define LIGNE_D_ACCES_AU_DISQUE \
Gvar("disqueP") \
/* Definition de la ligne physique d'acces au disque ; celle-ci doit avoir ete */ \
/* parametree par une commande : */ \
/* */ \
/* 1 - cas 'SYSTEME_DPX5000_SPIX' : */ \
/* */ \
/* stty 1200 -cstopb -parity raw -echo < /dev/tty06 */ \
/* */ \
/* la ligne correspondante de 'etc/inittab' etant "06:2:off:/etc/getty...". */ \
/* */ \
/* mais ATTENTION : 'tty06' correspond au connecteur 'J07' du coupleur 'RS232'... */ \
/* */ \
/* */ \
/* 2 - cas 'SYSTEME_SG..._IRIX' : */ \
/* */ \
/* stty 1200 -cstopb -parity raw -echo < /dev/ttyd2 */ \
/* */ \
/* la ligne correspondante de 'etc/inittab' etant "t2:23:off:/etc/getty ttyd2 co_9600...". */ \
/* */ \
/* mais ATTENTION : 'ttyd2' correspond au connecteur 'SERIAL PORT 2'. On notera que */ \
/* L'utilisation de 'ttyd2' est obligatoire car, en effet, 'ttyd1' est reserve a un */ \
/* usage de type "console" sur les machines non graphiques (voir '$LACT28') et meme */ \
/* sur les machines graphiques en cas de problemes graves... */
# define COMMANDE_D_ACCES_A_LA_LIGNE_D_ACCES_AU_DISQUE \
"stty" \
/* Commande d'acces a la ligne physique d'acces au disque. */
# define REINITIALISATION_DE_LA_LIGNE_D_ACCES_AU_DISQUE \
EGAs(chain_Aconcaten2(COMMANDE_D_ACCES_A_LA_LIGNE_D_ACCES_AU_DISQUE," sane < ")) \
/* Reinitialisation de la ligne physique d'acces au disque. */
# define VITESSE_DE_LA_LIGNE_D_ACCES_AU_DISQUE \
GvarDefaut("Nspeed_DKVP","9600") \
/* Vitesse courante et vitesse par defaut de la ligne physique d'acces au disque. */ \
/* Le passage de 1200 bauds a 9600 bauds a ete effectue le 19980218090413. */
# define PARAMETRAGE_DE_LA_LIGNE_D_ACCES_AU_DISQUE \
EGAs(chain_Aconcaten4(COMMANDE_D_ACCES_A_LA_LIGNE_D_ACCES_AU_DISQUE \
,C_BLANC \
,VITESSE_DE_LA_LIGNE_D_ACCES_AU_DISQUE \
," -cstopb -parity raw -echo < " \
) \
) \
/* Parametrage de la ligne physique d'acces au disque. */ \
/* */ \
/* Le reglage de la vitesse du cote du disque se fait a l'aide de deux petits switchs tels */ \
/* que : */ \
/* */ \
/* Down-Down = 1200 bauds, */ \
/* Down-Up = 2400 bauds, */ \
/* Up -Down = 4800 bauds, */ \
/* Up -Up = 9600 bauds. */ \
/* */ \
/* Ils se trouvent dans 'BAUD RATE' sur un disque 'LVS6000-LVR6000' et sont appeles */ \
/* '[SW1,SW2]' dans 'SETUP' sur un disque 'LVR4000P' ('Up' et 'Down' ayant la meme */ \
/* signification que ci-dessus, et sont situes a l'extreme gauche de l'ensemble des */ \
/* 8 switchs de 'SETUP'). */ \
/* */ \
/* ATTENTION, pour une raisons mysterieuse, le 1993022300 j'ai decouvert que le disque */ \
/* etait cable en 1200 bauds, alors que la programmation ci-dessus etait en 9600 bauds... */ \
/* Alors comment cela pouvait-il marcher ??? */ \
/* */ \
/* Mais en fait, je suis revenu a 1200 bauds le 1993022600 car, en effet, dans la position */ \
/* 9600 bauds, apres l'introduction d'un disque, et lorsque celui-ci est pret, le voyant */ \
/* "STILL/STEP" se met a clignoter tres rapidement, ce phenomene disparaissant si le disque */ \
/* est cable en 1200 bauds. En fait, le 19980218090413 j'ai compris que cela etait lie a */ \
/* l'etat "courant" de la liaison cote ordinateur ; des que celle-ci passe a 9600 bauds, le */ \
/* probleme disparait... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D U D I S Q U E U T I L I S E : */
/* */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * ** * * * * * ** * */
/* * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * */
/* * * * * ** * * * * * ** */
/* * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* */
/* ATTENTION : */
/* */
/* Les trois symboles qui sont definis (par */
/* '#define') ou non definis (par '#nodefine') */
/* dans '$xiidP/fonct$vv$DEF' si necessaire, et */
/* dans les commandes 'v $xci/disk_video_P$K' et */
/* 'v $xci/magneto_P$K' systematiquement sont */
/* detruits ci-apres, car, en effet, il est */
/* essentiel que '$xci/disk_video_P$K' n'en */
/* depende pas, afin qu'il suffise de modifier */
/* '$xci/disk_video_P$K' ou '$xci/magneto_P$K' */
/* pour changer de machine utilisee... */
/* */
/*************************************************************************************************************************************/
/* Le 20030314093931, les symboles 'GESTION_D_UN_*' ont ete changes en */
/* '__VERSION__GESTION_D_UN_*' afin de permettre leur recuperation dans */
/* 'v $xcc/cpp$Z _VERSION_'. */
# ifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P
# undef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P
# Aifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P
# Eifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P
# ifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# undef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# Aifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# Eifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# ifdef __VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P
# undef __VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P
# Aifdef __VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P
# Eifdef __VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N T R O L E U R D E L A L I G N E D E C O M M A N D E D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
DEFV(Common,DEFV(Logical,ZINT(IKP_____utiliser_le_mode_PAL_BETA_FRAME_NUMBER_MODE,VRAI)));
/* Cet indicateur permet de controler le mode d'affichage soit "numero d'image" (par */
/* defaut) ou "time code" (introduit le 20020710101513). */
DEFV(Common,DEFV(Logical,ZINT(IKP_____editer_le_message_des_caracteres_en_attente,FAUX)));
/* Cet indicateur permet de controler la sortie du message : */
/* */
/* PRINT_ERREUR("il y avait des caracteres en attente en provenance du disque"); */
/* */
/* Il est mis en 'Common', et non pas comme Argument de 'IKPopen_disque_video(...)' afin */
/* de simplifier les choses. En effet, l'acces a 'IKPopen_disque_video(...)' se fait via */
/* la procedure 'OUVERTURE_DE_LA_LIGNE_PAL_BETA(...)' ; de plus, il ne faut pas oublier */
/* qu'il existe deux versions du logiciel... */
DEFV(Local,DEFV(Int,INIT(descripteur_de_la_ligne,CANNOT_OPEN)));
/* Descripteur du fichier correspondant aux emissions DPX5000 --> disque video PAL-Beta, */
/* et aux receptions disque video PAL-Beta --> DPX5000. Ce descripteur est "Local", et */
/* commun a toutes les fonctions relatives au disque 'PAL-Beta', afin de savoir en */
/* permanence si la ligne est ouverte ou pas (auquel cas, il vaut 'CANNOT_OPEN'). */
DEFV(Local,DEFV(Logical,INIT(il_y_a_eu_une_erreur_de_transmission,FAUX)));
/* Afin de savoir si en fin de compte, tout s'est bien passe ; son etat initial est 'FAUX', */
/* qui est force a chaque ouverture de la ligne... */
DEFV(Common,DEFV(CHAR,DTb1(IKP_____buffer_de_reception,LONGUEUR_MAXIMALE_DES_REPONSES_DU_DISQUE_PAL_BETA)));
/* Buffer de reception des messages en provenance du disque. Il est place en 'Common', */
/* afin que les procedures de commandes du disque puissent recuperer son contenu... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N N A I R E D E S M E S S A G E S C O M P L E T S : */
/* */
/*************************************************************************************************************************************/
# define LONGUEUR_MAXIMALE_DES_MESSAGES_COMPLETS_ENVOYES_AU_DISQUE \
MILLE
DEFV(Local,DEFV(Int,INIT(index_du_buffer_des_messages_complets_envoyes_au_disque,PREMIER_CARACTERE)));
DEFV(Local,DEFV(CHAR,DTb1(buffer_des_messages_complets_envoyes_au_disque,LONGUEUR_MAXIMALE_DES_MESSAGES_COMPLETS_ENVOYES_AU_DISQUE)));
/* Buffer (d'une longueur arbitraire) dans lequel seront stockes tous les caracteres */
/* envoyes au disque entre 'IKPopen_disque_video(...)' et 'IKPclose_disque_video(...)'. */
/* Ce dispositif a ete introduit le 20030205142434. */
# define MEMORISATION_D_UN_CARACTERE_ENVOYE_AU_DISQUE(caractere) \
Bblock \
Test(IFLE(index_du_buffer_des_messages_complets_envoyes_au_disque \
,LSTX(PREMIER_CARACTERE,LONGUEUR_MAXIMALE_DES_MESSAGES_COMPLETS_ENVOYES_AU_DISQUE) \
) \
) \
Bblock \
EGAL(ITb1(buffer_des_messages_complets_envoyes_au_disque \
,INDX(index_du_buffer_des_messages_complets_envoyes_au_disque,PREMIER_CARACTERE) \
) \
,caractere \
); \
/* Memorisation du caractere courant, */ \
INCR(index_du_buffer_des_messages_complets_envoyes_au_disque,I); \
/* Et progression de son index... */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la buffer des caracteres envoyes au disque deborde"); \
Eblock \
ETes \
Eblock \
/* Memorisation d'un caractere envoye au disque... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O U V E R T U R E D E L A L I G N E D E C O M M A N D E D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define LONGUEUR_DES_MESSAGES_ENVOYES_AU_DISQUE \
UN \
/* Longueur des messages elementaires envoyes au disque. */
# define FERMETURE_DE_LA_LIGNE_DU_DISQUE \
Bblock \
CALS(Clos(descripteur_de_la_ligne)); \
/* Lorsque la ligne etait ouverte, on la ferme physiquement, */ \
Eblock \
/* Procedure de fermeture de la ligne... */
BFonctionI
# define OUVERTURE_DE_LA_LIGNE_DU_DISQUE(mode_d_ouverture) \
Bblock \
EGAL(descripteur_de_la_ligne,Open(LIGNE_D_ACCES_AU_DISQUE,mode_d_ouverture)); \
/* Ouverture de la ligne d'emission et de reception des messages en provenance du disque. */ \
Test(IFNE(descripteur_de_la_ligne,CANNOT_OPEN)) \
Bblock \
/* Ca y est, la ligne est ouverte... */ \
EGAL(il_y_a_eu_une_erreur_de_transmission,FAUX); \
/* Il n'y a pas encore eu de problemes... */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la ligne d'acces au disque video PAL-Beta est indisponible"); \
Eblock \
ETes \
Eblock \
/* Procedure d'ouverture de la ligne... */
DEFV(Common,DEFV(FonctionI,IKPopen_disque_video()))
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
DEFV(Int,INIT(compte_rendu,UNDEF));
/* Compte_rendu des fonctions "stty"... */
DEFV(CHAR,INIT(POINTERc(commande_STTY),COMMANDE_UNDEF));
/* Afin d'envoyer une commande fixant les parametres de la ligne d'acces au disque. */
/*..............................................................................................................................*/
Test(IFNE(descripteur_de_la_ligne,CANNOT_OPEN))
Bblock
/* Cas ou la ligne est deja ouverte... */
PRINT_ERREUR("la ligne d'acces au disque video PAL-Beta est deja ouverte");
Eblock
ATes
Bblock
/* Cas normal, ou la ligne est fermee... */
EGAp(commande_STTY,chain_Aconcaten2(REINITIALISATION_DE_LA_LIGNE_D_ACCES_AU_DISQUE,LIGNE_D_ACCES_AU_DISQUE));
EGAL(compte_rendu,SYSTEM(commande_STTY));
CALZ_FreCC(commande_STTY);
/* Au prealable, on reinitialise la ligne d'acces au disque video PAL-Beta, */
Test(PAS_D_ERREUR(compte_rendu))
Bblock
EGAp(commande_STTY,chain_Aconcaten2(PARAMETRAGE_DE_LA_LIGNE_D_ACCES_AU_DISQUE,LIGNE_D_ACCES_AU_DISQUE));
EGAL(compte_rendu,SYSTEM(commande_STTY));
CALZ_FreCC(commande_STTY);
/* Puis, on la programme comme il convient... */
Test(PAS_D_ERREUR(compte_rendu))
Bblock
DEFV(CHAR,DTb1(caracteres_en_attente,LONGUEUR_DES_MESSAGES_ENVOYES_AU_DISQUE));
/* Buffer de reception mono-caractere des caracteres en attente... */
OUVERTURE_DE_LA_LIGNE_DU_DISQUE(OPEN_READ_AND_WRITE_SANS_ATTENTE_EN_LECTURE_SI_LE_FICHIER_EST_VIDE);
/* Ouverture de la ligne d'emission et de reception des messages en provenance du disque, */
/* en vue de tester la presence de caracteres en attente... */
# ifndef BUG_SYSTEME_PAL_BETA_IMPOSSIBLE_DE_PURGER_LE_BUFFER_DES_CARACTERES_EN_ATTENTE_DANS_IKPopen_disque_video
Tant(IFNE(Read(descripteur_de_la_ligne,caracteres_en_attente,LONGUEUR_DES_MESSAGES_ENVOYES_AU_DISQUE)
,FICHIER_VIDE
)
)
# Aifndef BUG_SYSTEME_PAL_BETA_IMPOSSIBLE_DE_PURGER_LE_BUFFER_DES_CARACTERES_EN_ATTENTE_DANS_IKPopen_disque_video
Tant(IFGT(Read(descripteur_de_la_ligne,caracteres_en_attente,LONGUEUR_DES_MESSAGES_ENVOYES_AU_DISQUE)
,FICHIER_VIDE
)
)
# Eifndef BUG_SYSTEME_PAL_BETA_IMPOSSIBLE_DE_PURGER_LE_BUFFER_DES_CARACTERES_EN_ATTENTE_DANS_IKPopen_disque_video
/* On purge le buffer des caracteres en attente et venant du disque. ATTENTION : il est */
/* evidemment impossible de permuter le 'Tant(...)' qui precede et le 'Test(...)' qui suit, */
/* car en effet, le 'Tant(...)' a un effet sur le buffer (puisqu'il le purge...). */
Bblock
Test(IL_FAUT(IKP_____editer_le_message_des_caracteres_en_attente))
Bblock
PRINT_ERREUR("il y avait des caracteres en attente en provenance du disque");
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETan
FERMETURE_DE_LA_LIGNE_DU_DISQUE;
/* Lorsqu'il n'y a plus de caracteres en attente, on referme la ligne, puis : */
OUVERTURE_DE_LA_LIGNE_DU_DISQUE(OPEN_READ_AND_WRITE);
/* Ouverture de la ligne d'emission et de reception des messages en provenance du disque, */
/* pour le dialogue "normal" cette fois-ci... */
/* */
/* Aux environs du 20090907161922, j'ai tente d'utiliser '$disqueP' sur '$LACT18' (en plus */
/* de '$LACT16'). En fait, cela ne marche pas (ou de facon tres "erratique"). Les tests */
/* ont montre qu'a partir de l'ouverture de la ligne en mode 'OPEN_READ_AND_WRITE' */
/* ci-dessus, les 'Read(...)'s sont bloques. Mais si l'ouverture est faite, comme un peu */
/* avant, en mode 'OPEN_READ_AND_WRITE_SANS_ATTENTE_EN_LECTURE_SI_LE_FICHIER_EST_VIDE', */
/* alors les 'Read(...)'s reviennent immediatement en erreur avec 'errno' donnant le code */
/* erreur 'EAGAIN' (=11) qui signifie qu'il n'y a rien en entree. Il y a peu de raisons */
/* pour que '$disqueP' ne renvoie rien puisqu'en basculant de nouveau sur '$LACT16' tout */
/* marche normalement. On notera que sur '$LACT18' la commande : */
/* */
/* stty -a -F $disqueP */
/* */
/* renvoie la meme chose que sur '$LACT16', avec juste en plus : */
/* */
/* swtch = <undef>; */
/* -iutf8 */
/* */
/* Mais cela ne suffit pas, semble-t-il, a expliquer le probleme puisqu'utiliser : */
/* */
/* stty iutf8 -F $disqueP */
/* */
/* ne change rien. Malgre tout, il convient de rappeler que '-iutf8' signifie la chose */
/* suivante : "assume input characters are UTF-8 encoded", c'est-a-dire implique l'usage */
/* de "Unicode" 32 bits ; "iutf8" quant a lui devrait impliquer l'usage de codes caractere */
/* 8 bits, mais cela marche-t-il correctement ? */
/* */
/* Le 20090911145138, des tests ont ete fait sur 'monotone.polytechnique.fr' qui est une */
/* MACHINE possedant elle-aussi l'option '-iutf8' et le test 'v $xtc/disk_vi_P.21$c' s'est */
/* termine normalement (contrairement a '$LACT18'). On notera malgre tout une difference */
/* importante : '$LACT18' est du type 'SYSTEME_APC_LinuxUbuntu_GCC', alors que la MACHINE */
/* 'monotone.polytechnique.fr' est du type 'SYSTEME_APC_LinuxRedHat_GCC'... */
EGAL(index_du_buffer_des_messages_complets_envoyes_au_disque,PREMIER_CARACTERE);
/* Initialisation du buffer dans lequel seront stockes tous les caracteres envoyes au */
/* disque (introduit le 20030205142434). */
Eblock
ATes
Bblock
PRINT_ERREUR("la programmation de la ligne d'acces s'est mal passee");
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("l'initialisation de la ligne d'acces s'est mal passee");
Eblock
ETes
Eblock
ETes
RETU_ERROR;
Eblock
# undef OUVERTURE_DE_LA_LIGNE_DU_DISQUE
EFonctionI
# undef PARAMETRAGE_DE_LA_LIGNE_D_ACCES_AU_DISQUE
# undef VITESSE_DE_LA_LIGNE_D_ACCES_AU_DISQUE
# undef REINITIALISATION_DE_LA_LIGNE_D_ACCES_AU_DISQUE
# undef COMMANDE_D_ACCES_A_LA_LIGNE_D_ACCES_AU_DISQUE
# undef LIGNE_D_ACCES_AU_DISQUE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F E R M E T U R E D E L A L I G N E D E C O M M A N D E D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(Logical,SINT(IKPclose_disque_video_____editer_les_caracteres_envoyes_au_disque,FAUX)));
/* Pour editer les messages envoyes au disque (introduit le 20030205142434). */
DEFV(Common,DEFV(FonctionI,IKPclose_disque_video()))
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/*..............................................................................................................................*/
Test(IFNE(descripteur_de_la_ligne,CANNOT_OPEN))
Bblock
MEMORISATION_D_UN_CARACTERE_ENVOYE_AU_DISQUE(END_OF_CHAIN);
/* "Fermeture" de la chaine contenant les caracteres qui ont ete transmis au disque */
/* (introduit le 20030205142434). */
FERMETURE_DE_LA_LIGNE_DU_DISQUE;
/* Lorsque la ligne etait ouverte, on la ferme physiquement, */
EGAL(descripteur_de_la_ligne,CANNOT_OPEN);
/* Puis logiquement... */
EGAL(il_y_a_eu_une_erreur_de_transmission,FAUX);
/* Enfin, on reinitialise l'indicateur d'erreurs de transmission... */
Test(IL_FAUT(IKPclose_disque_video_____editer_les_caracteres_envoyes_au_disque))
Bblock
DEFV(Logical,INIT(editer_un_caractere,VRAI));
DEFV(Int,INIT(index_d_edition,PREMIER_CARACTERE));
CAL2(Prin0("\n"));
CAL2(Prin1(" Caracteres envoyes au disque : '%s'\n",buffer_des_messages_complets_envoyes_au_disque));
/* Edition alphanumerique... */
CAL2(Prin0(" soit en hexa-decimal........ : "));
Tant(IL_FAUT(editer_un_caractere))
Bblock
DEFV(CHAR,INIT(caractere_courant_a_editer
,ITb1(buffer_des_messages_complets_envoyes_au_disque,INDX(index_d_edition,PREMIER_CARACTERE))
)
);
Test(IFNE(caractere_courant_a_editer,END_OF_CHAIN))
Bblock
CAL2(Prin1("'%02x'",caractere_courant_a_editer));
/* Edition hexa-decimale... */
INCR(index_d_edition,I);
/* Passage au caractere suivant... */
Eblock
ATes
Bblock
EGAL(editer_un_caractere,FAUX);
/* L'edition s'arrete sur le premier 'END_OF_CHAIN' rencontre... */
Eblock
ETes
Eblock
ETan
CAL2(Prin0("\n"));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("la ligne d'acces au disque video PAL-Beta n'etait pas ouverte, on ne peut donc la fermer");
Eblock
ETes
RETU_ERROR;
Eblock
EFonctionI
# undef FERMETURE_DE_LA_LIGNE_DU_DISQUE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R O C E D U R E S D ' E N V O I D ' U N E C O M M A N D E A U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define LONGUEUR_DE_L_ACQUITTEMENT_DU_DISQUE \
UN \
/* Longueur de la reponse standard du disque lorsque tout s'est bien passe... */
# define ACQUITTEMENT_DU_DISQUE \
K_LF \
/* Reponse standard du disque lorsque tout s'est bien passe... */
# define NON_ACQUITTEMENT_DU_DISQUE \
SUCC(K_LF) \
/* Reponse standard du disque lorsque cela s'est mal passe... */
# define CODE_DE_COMPLETION \
SUCC(K_NULL) \
/* Reponse standard asynchrone du disque pour les commandes : */ \
/* */ \
/* 'PAL_BETA_SEARCH', 'PAL_BETA_REC_STANDBY', 'PAL_BETA_REC' et */ \
/* 'PAL_BETA_BLANK_AREA_SEARCH'. */ \
/* */
# define ERREUR_DE_COMMUNICATION_DU_DISQUE \
SUCC(CODE_DE_COMPLETION) \
/* Message d'erreur de communication entre le disque et le systeme... */
# define LE_DISQUE_A_ETE_EJECTE \
SUCC(ERREUR_DE_COMMUNICATION_DU_DISQUE) \
/* Message 'LID OPEN' envoye apres l'ejection du disque... */
# define ENVOI_D_UN_CARACTERE_AU_DISQUE(caractere_courant) \
Bblock \
Test(EST_FAUX(il_y_a_eu_une_erreur_de_transmission)) \
Bblock \
EGAL(PREMIER_CARACTERE_ITb1(buffer_d_emission),caractere_courant); \
/* Mise du cacactere dans le buffer d'emission. */ \
DODO(IKP_____temporisation_inter_caractere); \
/* On attend un peu avant d'emettre... */ \
CALS(Writ(descripteur_de_la_ligne,buffer_d_emission,LONGUEUR_DES_MESSAGES_ENVOYES_AU_DISQUE)); \
/* Lorsque la ligne est ouverte, on emet le caractere courant, */ \
\
MEMORISATION_D_UN_CARACTERE_ENVOYE_AU_DISQUE(caractere_courant); \
/* "Empilement" du caractere courant... */ \
\
Test(IL_FAUT(un_acquittement_par_caractere)) \
Bblock \
\
LECTURE_DE_LA_REPONSE_DU_DISQUE(caractere_courant \
,ACQUITTEMENT_DU_DISQUE \
,LONGUEUR_DE_L_ACQUITTEMENT_DU_DISQUE \
); \
/* Lecture de l'acquittement synchrone du disque, en general... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("erreur de transmission en cours, rien n'est echange ('ENVOI D'UN CARACTERE AU DISQUE')"); \
PRINT_ERREUR("verifier que la machine correspondante :"); \
PRINT_ERREUR("1-est bien sous-tension,"); \
PRINT_ERREUR("2-est bien en mode 'remote' (et non pas 'local'),"); \
PRINT_ERREUR("3-possede bien un disque charge,"); \
PRINT_ERREUR("sinon, faire 'saneP'"); \
CAL1(Prer1("CODE ERREUR = %d\n",CODE_ERREUR)); \
Eblock \
ETes \
Eblock \
/* Procedure d'envoi d'un caractere (seul...) au disque. */
# ifdef BUG_SYSTEME_PAL_BETA_Read
# define LONGUEUR_DU_BUFFER_INTERMEDIAIRE \
LONGUEUR_DES_MESSAGES_ENVOYES_AU_DISQUE \
/* Longueur du buffer de reception intermediaire mono-caractere. Ce buffer a ete introduit */ \
/* car sinon, la tentative de lecture en un seul 'Read()' des blocs de donnees numeriques */ \
/* se soldait par un echec... */
# define SIMULATION_DU_Read_POUR_LE_DISQUE_PAL_BETA(nombre_de_caracteres_attendus) \
Bblock \
DEFV(CHAR,DTb1(buffer_intermediaire,LONGUEUR_DU_BUFFER_INTERMEDIAIRE)); \
/* Buffer de reception mono-caractere... */ \
DEFV(Int,INIT(index,PREMIER_CARACTERE)); \
/* Index du buffer de reception. */ \
CLIR(longueur_de_la_reponse_du_disque); \
/* Initialisation du compteur des caracteres recus du disque... */ \
Komp(numero_du_caractere_courant,nombre_de_caracteres_attendus) \
Bblock \
Test(IFEQ(Read(descripteur_de_la_ligne,buffer_intermediaire,LONGUEUR_DU_BUFFER_INTERMEDIAIRE) \
,LONGUEUR_DU_BUFFER_INTERMEDIAIRE \
) \
) \
Bblock \
EGAL(ITb1(IKP_____buffer_de_reception,INDX(index,PREMIER_CARACTERE)) \
,PREMIER_CARACTERE_ITb1(buffer_intermediaire) \
); \
INCR(index,I); \
/* Progression de l'index pour le caractere suivant eventuel... */ \
INCR(longueur_de_la_reponse_du_disque,I); \
/* Comptage des caracteres recus du disque. */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("aucun caractere n'a ete lu"); \
Eblock \
ETes \
Eblock \
EKom \
Eblock \
/* Cette procedure simule la lecture de 'N' caracteres a l'aide de 'N' lectures d'un seul */ \
/* caractere. */
# Aifdef BUG_SYSTEME_PAL_BETA_Read
# define SIMULATION_DU_Read_POUR_LE_DISQUE_PAL_BETA(nombre_de_caracteres_attendus) \
Bblock \
EGAL(longueur_de_la_reponse_du_disque \
,Read(descripteur_de_la_ligne \
,IKP_____buffer_de_reception \
,nombre_de_caracteres_attendus \
) \
); \
/* Lecture de la reponse du disque... */ \
Eblock \
/* Cette procedure effectue la lecture de 'N' caracteres un une seule operation... */ \
/* caractere. */
# Eifdef BUG_SYSTEME_PAL_BETA_Read
# define LECTURE_DE_LA_REPONSE_DU_DISQUE(caractere_courant,caractere_attendu,nombre_de_caracteres_attendus) \
Bblock \
Test(EST_FAUX(il_y_a_eu_une_erreur_de_transmission)) \
Bblock \
SIMULATION_DU_Read_POUR_LE_DISQUE_PAL_BETA(nombre_de_caracteres_attendus); \
/* Lecture de la reponse du disque... */ \
Test(IFEQ(nombre_de_caracteres_attendus,LONGUEUR_DE_L_ACQUITTEMENT_DU_DISQUE)) \
Bblock \
Test(IFEQ(PREMIER_CARACTERE_ITb1(IKP_____buffer_de_reception) \
,caractere_attendu \
) \
) \
Bblock \
/* Cas ou tout s'est bien passe... */ \
Eblock \
ATes \
Bblock \
/* Cas ou l'on a recu une reponse autre chose qu'un acquittement... */ \
EGAL(il_y_a_eu_une_erreur_de_transmission,VRAI); \
/* Ainsi, on sait qu'il y a eu au moins un probleme... */ \
CODE_ERROR(COND(IFNE(PREMIER_CARACTERE_ITb1(IKP_____buffer_de_reception),OK) \
,PREMIER_CARACTERE_ITb1(IKP_____buffer_de_reception) \
,ERREUR21 \
) \
); \
/* Enfin, on renvoie le code en temps que code d'erreur (sauf s'il vaut 'OK'...). */ \
Test(IMEQ(PREMIER_CARACTERE_ITb1(IKP_____buffer_de_reception) \
,NON_ACQUITTEMENT_DU_DISQUE \
,ERREUR_DE_COMMUNICATION_DU_DISQUE \
) \
) \
Bblock \
/* Cas des erreurs "prevues" ou "previsibles"... */ \
PRINT_ERREUR("la commande courante au disque PAL-Beta n'a pas ete reconnue"); \
CAL1(Prer1("commande = %02x\n",caractere_courant)); \
/* Et on edite "betement" (c'est-a-dire sans fioritures) le caractere en cause... */ \
Eblock \
ATes \
Bblock \
/* Autres cas... */ \
PRINT_ERREUR("anomalie de fonctionnement (bloc deja -ou pas encore- enregistre,..."); \
CAL1(Prer1("code attendu = %02x\n",caractere_attendu)); \
Test(IFNE(caractere_courant,K_UNDEF)) \
Bblock \
CAL1(Prer1("caractere courant = %02x\n",caractere_courant)); \
/* Et on edite "betement" (c'est-a-dire sans fioritures) le caractere courant s'il ne */ \
/* s'agit pas de 'K_UNDEF'... */ \
/* */ \
/* Voici au passage la liste des codes renvoyes : */ \
/* */ \
/* 0x0a : tout va bien, la commande est acceptee ("ACK"), */ \
/* */ \
/* 0x01 : la commande demandee est terminee ("COMPLETION"), */ \
/* 0x02 : une erreur de communication RS232 (parite,...) est apparue ("ERROR"), */ \
/* 0x03 : le moteur est arrete, et le disque a ete ejecte ("LID OPEN"), */ \
/* 0x05 : la zone recherchee (image ou donnee) est en erreur ("NOT TARGET"), */ \
/* 0x06 : la zone recherchee (image ou donnee) n'existe pas ("NO FRAME NUMBER"), */ \
/* 0x07 : un marquage a ete lu ("MARK RETURN"), */ \
/* 0x0b : la commande demandee ne peut etre executee ("NAK"). */ \
/* */ \
Eblock \
ATes \
Bblock \
CAL1(Prer0("caractere courant indefini\n")); \
Eblock \
ETes \
Eblock \
ETes \
CAL1(Prer1("code recu = %02x\n" \
,PREMIER_CARACTERE_ITb1(IKP_____buffer_de_reception) \
) \
); \
/* Et on edite systematiquement le code renvoye par le disque... */ \
CAL1(Prer1("nombre de caracteres attendus = %d\n",nombre_de_caracteres_attendus)); \
/* Ainsi que le nombre de caracteres attendus... */ \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Test(IFEQ(longueur_de_la_reponse_du_disque,nombre_de_caracteres_attendus)) \
Bblock \
/* Cas ou l'on a recu exactement ce que l'on a demande... */ \
Eblock \
ATes \
Bblock \
EGAL(il_y_a_eu_une_erreur_de_transmission,VRAI); \
/* Ainsi, on sait qu'il y a eu au moins un probleme... */ \
CODE_ERROR(ERREUR21); \
/* Enfin, on renvoie un code d'erreur... */ \
PRINT_ERREUR("il a ete recu moins de caracteres que demande"); \
CAL1(Prer1("attendus = %d\n",nombre_de_caracteres_attendus)); \
CAL1(Prer1("recus = %d\n",longueur_de_la_reponse_du_disque)); \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("erreur de transmission en cours, rien n'est echange ('LECTURE DE LA REPONSE DU DISQUE')"); \
PRINT_ERREUR("verifier que la machine correspondante est bien en mode 'remote' (et non pas 'local')"); \
PRINT_ERREUR("sinon, faire 'saneP'"); \
CAL1(Prer1("CODE ERREUR = %d\n",CODE_ERREUR)); \
Eblock \
ETes \
Eblock \
/* Procedure de lecture de la reponse du disque. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N T R O L E D E S T E M P O R I S A T I O N S : */
/* */
/*************************************************************************************************************************************/
DEFV(Common,DEFV(Positive,ZINT(IKP_____temporisation_inter_caractere,ZERO)));
/* Temporisation effectuee entre chaque caractere envoye au disque. Contrairement au disque */
/* Secam, il ne faut pas attendre... */
DEFV(Common,DEFV(Positive,ZINT(IKP_____temporisation_apres_ENTER,UN)));
/* Temporisation effectuee apres chaque entree de parametres par 'ENTER_PAL_BETA(...)'. */
/* Et oui, a cause de l'envoi des differents parametres des commandes d'enregistrement */
/* (du type 'ENREGISTREMENT_D_UNE_SEQUENCE_PAL_BETA'), il faut entre chacun de ses appels */
/* a 'ENTER_PAL_BETA(valeur_numerique)', faire un petit dodo... */
# ifdef SYSTEME_SG4D20G_IRIX
# if ( (defined(LACT21)))
# define TEMPORISATION_INTER_COMMANDE \
DEUX \
/* Entre chaque commande, il faut attendre un peu (en fait l'ideal serait 1/25eme de */ \
/* seconde), ce qui est du au fait que l'execution des commandes demarre sur les */ \
/* synchronisation trame. De plus, on se met une petite marge de securite afin d'etre */ \
/* sur que tout est bien termine lorsque l'on rend la main. */ \
/* */ \
/* ATTENTION, cette valeur de 'DEUX' est conservee afin d'assurer la compatibilite... */
# Aif ( (defined(LACT21)))
# Eif ( (defined(LACT21)))
# Aifdef SYSTEME_SG4D20G_IRIX
# Eifdef SYSTEME_SG4D20G_IRIX
# TestADef TEMPORISATION_INTER_COMMANDE \
UN \
/* Entre chaque commande, il faut attendre un peu (en fait l'ideal serait 1/25eme de */ \
/* seconde), ce qui est du au fait que l'execution des commandes demarre sur les */ \
/* synchronisation trame. De plus, on se met une petite marge de securite afin d'etre */ \
/* sur que tout est bien termine lorsque l'on rend la main. */ \
/* */ \
/* ATTENTION, cette valeur de 'UN' a ete introduite apres que fut verifie a l'aide du */ \
/* programme 'v $xtc/minute$c' que l'attente 'DODO(TEMPORISATION_INTER_COMMANDE)' avait */ \
/* bien la bonne duree (ce que l'on a vu en verifiant que 60 attentes d'une seconde */ \
/* duraient bien au total une minute, soit 60 secondes...). */
DEFV(Common,DEFV(Positive,ZINT(IKP_____temporisation_inter_commande,TEMPORISATION_INTER_COMMANDE)));
/* Temporisation effectuee entre chaque commande envoyee au disque... */
# undef TEMPORISATION_INTER_COMMANDE
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O N T R O L E D E S L E C T U R E S D E S B L O C S D E D O N N E E S : */
/* */
/*************************************************************************************************************************************/
DEFV(Common,DEFV(Logical,ZINT(IKP_____lecture_des_blocs_de_donnees,LECTURE_DES_BLOCS_DE_DONNEES)));
/* Afin de savoir si la lecture des blocs de donnees est AUTORISEe ou INTERDITe. On notera */
/* que ce dispositif a ete introduit afin d'une part de lutter contre le fameux "bug" */
/* 'BUG_SYSTEME_PAL_BETA_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA' en permettant ainsi de */
/* ne pas faire les lectures de blocs numeriques, mais d'autre part de permettre, malgre */
/* tout, quand ce "bug" est actif de lire les blocs de donnees, ce qui peut etre utile, par */
/* exemple, lorsqu'apres avoir initialise un disque par 'v $xci/disk_vIdeo_P$Z', on souhaite */
/* verifier ce qui a ete fait grace a 'v $xci/disk_vidEo_P$Z'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* E N V O I D ' U N E C O M M A N D E A U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IKPenvoi_d_une_commande_au_disque_video(commande
,longueur_de_la_commande
,un_acquittement_par_caractere
,attendre_une_reponse_multiple
,lire_des_donnees_numeriques
,longueur_des_donnees_numeriques
)
)
)
DEFV(Argument,DEFV(CHAR,DTb0(commande)));
/* Chaine argument correspondant a une commande a envoyer au disque video. */
DEFV(Argument,DEFV(Positive,longueur_de_la_commande));
/* Longueur de la chaine argument ; en effet, on ne peut utiliser le 'END_OF_CHAIN', */
/* puisque des caracteres 'NULL's peuvent apparaitre dedans... */
DEFV(Argument,DEFV(Logical,un_acquittement_par_caractere));
/* En general, on attend un caractere d'acquittement ('ACQUITTEMENT_DU_DISQUE') par */
/* caractere ecrit, sauf lorsqu'on ecrit des donnees numeriques, auquel cas, ils sont */
/* ecrits a la volee... */
DEFV(Argument,DEFV(Logical,attendre_une_reponse_multiple));
/* En general, on attend uniquement un caractere d'acquittement ('ACQUITTEMENT_DU_DISQUE') */
/* par caractere transmis ; malgre cela, pour certaines commandes, un acquittement */
/* asynchrone doit etre attendu : c'est le cas entre autre des commandes : */
/* 'PAL_BETA_SEARCH', 'PAL_BETA_REC_STANDBY', 'PAL_BETA_REC' et */
/* 'PAL_BETA_BLANK_AREA_SEARCH'. Mais ATTENTION, la logique de tout cela est assez */
/* complexe : par exemple, le 'CODE_DE_COMPLETION' renvoye par 'PAL_BETA_REC_STANDBY' */
/* n'apparait qu'apres la derniere fonction 'PAL_BETA_ENTER' qui doit suivre... Il est */
/* donc pratiquement impossible de provoquer cette attente automatiquement, d'ou cet */
/* argument "supplementaire". Enfin, dans le cas de 'PAL_BETA_EJECT', c'est le code */
/* 'LE_DISQUE_A_ETE_EJECTE' qui est recu... */
DEFV(Argument,DEFV(Logical,lire_des_donnees_numeriques));
/* Indique si un bloc de donnees numeriques est a lire ; on notera que l'on a alors de */
/* plus pour 'LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA(...)' : */
/* */
/* un_acquittement_par_caractere = VRAI, et */
/* attendre_une_reponse_multiple = VRAI. */
/* */
/* et pour 'ETAT_PAL_BETA' : */
/* */
/* un_acquittement_par_caractere = FAUX, et */
/* attendre_une_reponse_multiple = FAUX. */
/* */
DEFV(Argument,DEFV(Positive,longueur_des_donnees_numeriques));
/* Indique la longueur des reponses numeriques (lorsqu'il faut les lire...). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
DEFV(CHAR,INIT(commande_courante,PREMIER_CARACTERE_ITb0(commande)));
/* Le premier caractere de la chaine 'commande' est le code de la commande... */
DEFV(Int,INIT(index,PREMIER_CARACTERE));
/* Index de la chaine argument de commande. */
DEFV(CHAR,DTb1(buffer_d_emission,LONGUEUR_DES_MESSAGES_ENVOYES_AU_DISQUE));
/* Buffer d'emission du caractere courant d'une commande, */
DEFV(Positive,INIT(longueur_de_la_reponse_du_disque,UNDEF));
/* Nombre de caracteres renvoyes par le disque video ; en general, il n'y en a qu'un */
/* lorsque tout c'est bien passe. */
/*..............................................................................................................................*/
Test(IFNE(descripteur_de_la_ligne,CANNOT_OPEN))
Bblock
Test(EST_VRAI(il_y_a_eu_une_erreur_de_transmission))
Bblock
CODE_ERROR(ERREUR21);
/* Dans le cas ou il y a deja en entrant dans 'IKPenvoi_d_une_commande_au_disque_video(...)' */
/* une erreur de transmission, il faut forcer le code d'erreur (qui de toute evidence avait */
/* du etre positionne par une appel de 'IKPenvoi_d_une_commande_au_disque_video(...)' ayant */
/* precede celui-ci) afin de pouvoir le tester au retour... En effet, cette fonction est */
/* relayee par la procedure : */
/* */
/* COMMANDE_QUELCONQUE_PAL_BETA(...) */
/* */
/* qui peut etre appelee plusieurs fois par certaines commandes, et en particulier par : */
/* */
/* INITIALISATION_MINIMALE_PAL_BETA */
/* INITIALISATION_MAXIMALE_PAL_BETA */
/* ENREGISTREMENT_D_UNE_SEQUENCE_PAL_BETA */
/* ENREGISTREMENT_D_UN_BLOC_DE_DONNEES_PAL_BETA */
/* */
/* Il est donc imperatif de pieger les defauts, ou qu'ils arrivent... */
Eblock
ATes
Bblock
Eblock
ETes
Tant(IFLE(index,LSTX(PREMIER_CARACTERE,longueur_de_la_commande)))
Bblock
ENVOI_D_UN_CARACTERE_AU_DISQUE(ITb0(commande,INDX(index,PREMIER_CARACTERE)));
/* Envoi du caractere courant au disque et attente d'acquittement... */
INCR(index,I);
/* Puis passage au caractere suivant... */
Eblock
ETan
Test(IL_FAUT(attendre_une_reponse_multiple))
Bblock
LECTURE_DE_LA_REPONSE_DU_DISQUE(PREMIER_CARACTERE_ITb0(commande)
,COND(IFEQ(commande_courante,PAL_BETA_EJECT)
,LE_DISQUE_A_ETE_EJECTE
,CODE_DE_COMPLETION
)
,LONGUEUR_DE_L_ACQUITTEMENT_DU_DISQUE
);
/* Lecture d'un acquittement supplementaire sous forme d'un code asynchrone. */
Eblock
ATes
Bblock
Eblock
ETes
Test(IL_FAUT(lire_des_donnees_numeriques))
Bblock
Test(IFGT(longueur_des_donnees_numeriques,LONGUEUR_MAXIMALE_DES_REPONSES_DU_DISQUE_PAL_BETA))
Bblock
PRINT_ERREUR("la reponse numerique attendue est trop volumineuse");
Eblock
ATes
Bblock
Eblock
ETes
LECTURE_DE_LA_REPONSE_DU_DISQUE(K_UNDEF
,K_UNDEF
,MIN2(longueur_des_donnees_numeriques
,LONGUEUR_MAXIMALE_DES_REPONSES_DU_DISQUE_PAL_BETA
)
);
/* Lecture d'un bloc de donnees numeriques, mais ATTENTION : avec le "check-sum"... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("la ligne d'acces au disque video PAL-Beta n'est pas ouverte, la communication est donc impossible");
Eblock
ETes
RETU_ERROR;
Eblock
EFonctionI
# undef LECTURE_DE_LA_REPONSE_DU_DISQUE
# ifdef BUG_SYSTEME_PAL_BETA_Read
# undef LONGUEUR_DU_BUFFER_INTERMEDIAIRE
# undef SIMULATION_DU_Read_POUR_LE_DISQUE_PAL_BETA
# Aifdef BUG_SYSTEME_PAL_BETA_Read
# undef SIMULATION_DU_Read_POUR_LE_DISQUE_PAL_BETA
# Eifdef BUG_SYSTEME_PAL_BETA_Read
# undef ENVOI_D_UN_CARACTERE_AU_DISQUE
# undef LE_DISQUE_A_ETE_EJECTE
# undef ERREUR_DE_COMMUNICATION_DU_DISQUE
# undef CODE_DE_COMPLETION
# undef NON_ACQUITTEMENT_DU_DISQUE
# undef ACQUITTEMENT_DU_DISQUE
# undef LONGUEUR_DE_L_ACQUITTEMENT_DU_DISQUE
# undef LONGUEUR_DES_MESSAGES_ENVOYES_AU_DISQUE
# undef MEMORISATION_D_UN_CARACTERE_ENVOYE_AU_DISQUE
# undef LONGUEUR_MAXIMALE_DES_MESSAGES_COMPLETS_ENVOYES_AU_DISQUE
#Aifdef __VERSION__COMPILER_LA_GESTION_DU_DISQUE_PAL_BETA /* Common,DEFV(Fonction,) : compiler la gestion du disque PAL-Beta. */
#Eifdef __VERSION__COMPILER_LA_GESTION_DU_DISQUE_PAL_BETA /* Common,DEFV(Fonction,) : compiler la gestion du disque PAL-Beta. */
_______________________________________________________________________________________________________________________________________