Ce ne serait pas plus simple si tu arrives à les acquérir, de te greffer en sortie du lecteur de bande, en envoyant les octets tels qu'ils sont sur la bande, au bon rythme, après avoir neutralisé dans le lecteur les sécurités genre couvercle ouvert, absence de bande ... ?
Seuls les faucons volent. Les vrais restent au sol.
Si ça serait plus simple, mais il faut que je respecte le cahier de charge donc je dois enlever toutes ces anciennes carte à l'ntérieur de cette machine et essayer de l'informatiser donc la machine devra être contrôler juste avec le pc.Envoyé par f6exb
A quoi sert un incerseur de type 74L04?
Comme son nom l'indique : inverser la polarité du signal 0 ===>1 ; 1 ===> 0
Eventuellement à permettre d'alimenter aussi plus d'entrées en provenance d'une sortie. (Buffer).
Mais si tu parles du schéma #97, ils inversent juste les signaux.
Seuls les faucons volent. Les vrais restent au sol.
Ouii je parle du schema #97.C'est un inverseur Hexadécimal donc les inputs de 74L04 seront en hexadécimal.
C'est un inverseur logique.
Pour de l'hexadécimal, il faut 4 bits et ce n'est pas le cas ici.
Chaque sortie d'un phototransistor de la tête de lecture est inversée par ce circuit. Il y en a un sur chaque fil de data, + un double en série sur le fil correspondant aux trous, de manière à fonctionner comme un trigger de schmitt et d'avoir des fronts avant et arrière bien nets pour le strobe (appelé ici spkt).
Seuls les faucons volent. Les vrais restent au sol.
Je veux connecter les 8 pins de data du DB25 avec ma carte Arduino uno pour visualiser le contenu de la bande perforée. j'ai réalisé le programme et je veux savoir et ce qu'il y a des mesures de sécurité pour ne pas abîmer la carte genre utiliser des autocoupleurs.
Ton lecteur sort en TTL. Si l'Arduino accepte le TTL en entrée, il ne devrait pas y avoir de problème.
Seuls les faucons volent. Les vrais restent au sol.
Mais, il y a toujours, en test, le risque de faire une fausse manip..... et de griller le port LPT1 qui se trouve sur la carte mère.
Par prudence, je conseille d'utiliser un LPT2 à 20€ sur une carte d'extension PCI
J'aime pas le Grec
T'as pas dû suivre tout le film, il ne s'agit pas de relier un PC à l'Arduino, mais un lecteur de bande perforée antédiluvien à l'Arduino.
Schéma #97.
Dernière modification par f6exb ; 24/03/2014 à 16h27.
Seuls les faucons volent. Les vrais restent au sol.
Exact .... 15 jours d’absence ! J'étais toujours sur le port PC
J'aime pas le Grec
Est-ce que je peux visualiser les données sortant de mon connecteur 25 sur le moniteur série de la carte Arduino avec la vitesse 96àà bps ou bien je dois la chager??
Pour lire les données de l'EPROM est-ce que j'aurais intérêt à connecter en plus des pins des datas, les pins des adresses (A0,...,A10)?
9600bd correspondent à environ 90 -100 caractères par second. Tant que le lecteur ne débite pas plus, ça doit aller.
Concernant l'eeprom, je pense qu'elle doit être associée à un micro et c'est loin d'être gagné.
Je ne sais pas si tu fais ça pour ton plaisir, ou si une boite a les moyens de payer la transformation, mais il existe des émulateurs de bande perforées actuellement destinés à remplacer les bandes dans les machines CNC.
Seuls les faucons volent. Les vrais restent au sol.
Euh .... non. Ce que tu dis est vrai pour une transmission série, mais pas en tranmission parallèle (ou bus en général); ici 1 baud = 1 caractére/s (du moins pour des caractère dont le nombre de bits est <= au nombre de canaux parallèle - ici avec de l'ASCII parallèle sur 7 bit + parité c'est le cas).
Donc ici : 9600 Baud = 9600 caractères/seconde.
1 Baud est un changement d'état de la ligne par seconde. En parallèle 8 bits chaque changement d'état correspond au passage de 8 bits contre 1 en transmission série.
Il parle bien de transmission série en sortant de l'Arduino ?sur le moniteur série de la carte Arduino avec la vitesse 96àà bps
Seuls les faucons volent. Les vrais restent au sol.
Pour la vitesse de transmission, ça va surtout dépendre de la vitesse moyenne de défilement de la bande perforée, dont on n'a aucune idée jusque maintenant.
Quant aux broches d'adresse A0...A10 de l'EPROM, je t'avais demandé à quoi celles qui ne recevaient pas données du lecteur étaient reliées, et on n'a pas non plus d'informations là-dessus.
L'analyse de la conception et du fonctionnement de l'appareil est un préalable nécessaire à toute investigation. Intercepter les signaux qui transitent sur les cartes de l'appareil n'est pas une fin en soi, et n'est même pas forcément utile. ll faut avoir une raison valable pour se lancer dans l'enregistrement de tel ou tel signal.
Pour ne parler que des signaux A0...A10, il n'est par exemple pas utile de lire ceux dont le niveau logique serait fixé électriquement à une valeur constante. En revanche, si tous ces signaux sont effectivement variables, il n'est pas dit que toutes les combinaisons possibles se présentent. Il serait beaucoup plus efficace de se concentrer d'abord sur la recherche d'informations permettant de comprendre la fonction et le principe de réalisation de cette partie du circuit, parce que les signaux intéressants peuvent se situer beaucoup plus en aval, ou parce que les états logiques possibles peuvent être pour la plupart évidents à déterminer et ne nécessiteraient donc pas d'être lus après avoir été générés.
Dernière modification par PA5CAL ; 25/03/2014 à 15h18.
Aurais je raté une occasion de la fermer ? sans doute .....
En plus des 4 eproms, y a-t-il un micro et de la RAM dans la boite ?
Seuls les faucons volent. Les vrais restent au sol.
En fait, avec 8 bits de données, 1 bit de start et un bit de stop (soit 10 bits par octet de donnée), la liaison série entre le µC de l'Arduino et son circuit de communication USB avec le PC peut transmettre jusqu'à 960 caractères par seconde pour une vitesse de 9600 bauds.
En utilisant la librairie Arduino standard, cette liaison série utilise un tampon circulaire de 64 octets par défaut, qui autorise provisoirement l'envoi d'un nombre de caractères plus important que celui correspondant à la vitesse de transmission moyenne. Mais la vitesse moyenne reste quoi qu'il en soit une limite pour des durées considérées supérieures au dixième de seconde.
Il est possible d'augmenter la vitesse de cette liaison, à condition de paramétrer celle du circuit de communication USB à partir du PC, simplement en spécifiant la vitesse du port COM virtuel correspondant sous Windows, ou du TTY correspondant sous Mac OS ou sous Linux. En ce qui me concerne, j'ai pu réaliser des transmissions jusqu'à 500 000 bauds sans problème, et jusqu'à 1 MBaud avec quelques erreurs de transmission.
Toutefois, il faut aussi que les données reçues du côté PC soient lues et traitées assez rapidement pour ne pas en perdre, la liaison USB ayant elle aussi un tampon limité.
Dernière modification par PA5CAL ; 25/03/2014 à 15h47.
La carte perforée contient sans doute des codes de commandes, mais peut être aussi les paramètres variables.
Exemple : (chiffres donnée au hasard pour juste meubler l'exemple)
Position X ; 2300
Position y ; 320
descendre (pas de paramètre ordre direct)
wrapper
couper
remonter
etc...
chaque ligne correspondant à une action à faire.
Et les paramètres seraient les octets suivants, peut être même qu'un bit détermine le type data/code
Cette action devant se faire en plusieurs étapes qui sont calculées par le processeur et la eprom
Car pour déplacer vers X il faut calculer le déplacement relatif puis le nombre de pas correspondant.
Peut être que la commande déplacement relatif existe aussi , dans mon exemple je sous entendait "position absolu"
d'ailleur l eprom est peut être un programme mais peut aussi contenir des datas ou des routines sous forme d'automate.
Je pense que dans un premier temps, il faut espionner ce qui se passe sur le DB25.
Il doit y avoir un signal pour latcher la commande et en retour un ack qui dit au lecteur de carte de passer au code suivant, car s'il s'agit de commandes et ou de datas, comme décrit plus haut, elles sont sans doute de longueurs différentes
à partir de là un simple port peut permettre de lire, par contre au niveau arduino la mémoire est un peut juste... On pourrait donc transmettre vers un PC pour mémoriser... ou ajouter des EEPROM sur l'arduino.
A+, pat
Effectivement. Je ne sais plus diviser par 10.
Seuls les faucons volent. Les vrais restent au sol.
J'ai connecter les 8bits de datas du connecteur 25 broches avec les 8 pins digital de l'ARDUINO uno.j'ai réalisé le premier test en pédalant une seule fois et sur le moniteur série il y avait les 8 bits de x0 à X7 qui s'affiche 25 fois maintenant je me demanse est-ce que je dois aussi brancher le pin du signal SPKT (SPKT= les petits trous d'entraînement de la bande ce signal génère des impulsions de synchronisation.) et le pin du clock ? si oui comment les intégrer dans mon programme ???
je ne vois pas ce que tu enregistre de valable sans les signaux de synchro
il faut attendre la monté du signal
puis enregistrer
puis attendre la descente du signal
et boucler (avec une issue de sortie tout de même donc) si bouton <> on
Je considère là une impulsion positive de synchro, ça pourrait être négatif.
A+, pat
Et si la machine renvoie un ack
A la restitution il faudra le gérer pour ne pas sauter d'instruction.
ou alors débiter à la vitesse escargot, c est à dire la vitesse la plus lente de toutes les opérations
A+, pat
Donc c'est le signal Spkt qui est responsable de la synchronisation ou bien c'est le signal Step (CLK) ?????
voile le code que j'ai fait sur la carte Arduino .
*************************
int x1,x2,x3,x4,x5,x6,x7,x8;
void setup ()
{
pinMode (2,INPUT);
pinMode (3,INPUT);
pinMode (4,INPUT);
pinMode (5,INPUT);
pinMode (6,INPUT);
pinMode (7,INPUT);
pinMode (8,INPUT);
pinMode (9,INPUT);
Serial.begin(9600);
}
void loop()
{
x1=digitalRead(2);
x2=digitalRead(3);
x3=digitalRead(4);
x4=digitalRead(5);
x5=digitalRead(6);
x6=digitalRead(7);
x7=digitalRead(8);
x8=digitalRead(9);
Serial.print("\t x1=");
Serial.print(x1);
Serial.print("\t x2=");
Serial.print(x2);
Serial.print("\t x3=");
Serial.print(x3);
Serial.print("\t x4=");
Serial.print(x4);
Serial.print("\t x5=");
Serial.print(x5);
Serial.print("\t x6=");
Serial.print(x6);
Serial.print("\t x7=");
Serial.print(x7);
Serial.print("\t x8=");
Serial.print(x8);
delay(10000);
}
*****************
A priori, comme il y a un bit de parité et que tu ne le gères pas encore, les bits 1 à 7 sont à utiliser.
Sur un autre port, ou par interruption, tu utilises la montée du signal spkt pour valider à ce moment les 7 bits en entrée.
Chaque fois que spkt présente un front montant, tu lis la donnée correspondante que tu transformes en ascii.
Seuls les faucons volent. Les vrais restent au sol.
pourquoi lire bit à bit
il faut lire le port entier...
et une attente de 10 secondes on doit rater 99% LOL
A+, pat
il faut vérifier ou est câbler le PORTD entier
j ai gardé 2 à 0 mais c est surement faux
j ai le synchro sur 10
notez aussi que la transmission à 9600 bd n'est pas instantané donc on part du principe que les codes arrivent plus lentement que l'émission du message
Code:// the setup routine runs once when you press reset: void setup() { unsigned int i; // initialize the digital pin as an output. for (i=0; i<9; i++) pinMode(i, INPUT); Serial.begin(9600); } // the loop routine runs over and over again forever: void loop() { char MyRd; while (digitalRead(10)==0) { MyRd = PORTD; Serial.print("\t x="); Serial.print(MyRd); while (digitalRead(10)==1); }
A+, pat
Voici un exemple de programme réalisant la lecture des caractères avec un signal de validation (strobe) en accédant directement aux ports du microcontrôleur (ports B et D sur l'Arduino Uno, et ports A et C sur l'Arduino Mega 2560).
(Le programme a été écrit sur un coin de table, et comme je n'ai ni Arduino ni source de données parallèle sous la main, je ne l'ai pas testé).
Ne pas oublier de régler la vitesse de réception du moniteur série sur le PC à 115200 bauds.Code:/* LECTURE DE PORT PARALLELE 7 BITS + PARITE * * ATTENTION : ce programme est spécifique à l'Arduino Uno et à * l'Arduino Mega 2560. Il peut nécessiter des adaptations pour * fonctionner sur d'autres modèles. * * * FONCTIONNEMENT : * * Lit chaque caractère (avec parité sur le bit 7) présenté sur * les entrées de l'Arduino et validé par un signal strobe, pour * l'envoyer au PC via le port série/USB. * * La polarité du signal strobe est détectée automatiquement * d'après les changements des signaux de données. * * * BRANCHEMENTS : * * Sur l'Arduino Uno, utiliser les entrées #2 à #9 pour les * bits de données 0 à 7, et l'entrée #10 pour le signal strobe. * * Sur l'Arduino Mega 2560, utiliser les entrées #22 à #29 * (situées en haut sur le connecteur double) pour les bits de * données 0 à 7, et l'entrée #30 (située au-dessous) pour le * signal strobe. * * * FORMAT : * * Par défaut, les caractères sont envoyés sous forme ASCII. * * Pour les envoyer sous forme de codes hexadécimaux, décommenter * la ligne suivante, puis re-compiler et re-téléverser le * programme dans l'Arduino. */ //#define _format_hexadecimal_ unsigned char inPortB, data, oldData; unsigned char strobe, oldStrobe, strobeInactiveState; unsigned char rotate, parity; void setup() { // Fixe la vitesse de transmission à 115200 bauds Serial.begin(115200); // Les pins sont déjà configurées en entrée par défaut // Enregistre l'état initial des entrées #if defined(__AVR_ATmega2560__) // Arduino Mega 2560 data = PINA; // data = inputs #22...#29 strobe = PINC&0x80; // strobe = input #30 #else // Arduino Uno inPortB = PINB; data = (PIND>>2)|(inPortB<<6); // data = inputs #2...#9 strobe = inPortB&0x04; // strobe = input #10 #endif oldData = data; oldStrobe = strobe; strobeInactiveState = strobe; } void loop() { // Lit les 8 bits de données et le bit de strobe #if defined(__AVR_ATmega2560__) // Arduino Mega 2560 data = PINA; // data = inputs #22...#29 strobe = PINC&0x80; // strobe = input #30 #else // Arduino Uno inPortB = PINB; data = (PIND>>2)|(inPortB<<6); // data = inputs #2...#9 strobe = inPortB&0x04; // strobe = input #10 #endif // Si les données ont changé depuis la dernière lecture, alors // on considère que le signal strobe est dans son état inactif, // et on recommence la lecture if (oldData!=data) { strobeInactiveState = strobe; oldStrobe = strobe; oldData = data; return; } // Si le strobe n'a pas changé, alors on recommence la lecture if (oldStrobe==strobe) return; oldStrobe = strobe; // Si le strobe est inactif, alors on recommence la lecture if (strobeInactiveState==strobe) return; // Calcule le bit de parité rotate = data; parity = rotate; // b7 rotate <<= 1; parity ^= rotate; // b6 rotate <<= 1; parity ^= rotate; // b5 rotate <<= 1; parity ^= rotate; // b4 rotate <<= 1; parity ^= rotate; // b3 rotate <<= 1; parity ^= rotate; // b2 rotate <<= 1; parity ^= rotate; // b1 rotate <<= 1; parity ^= rotate; // b0 parity &= 0x80; // Envoie le caractère lu au PC #if defined(_format_hexadecimal_) // version hexadécimale Serial.print(data^parity, HEX); Serial.write(' '); #else // version ASCII Serial.write(data^parity); #endif }
Dernière modification par PA5CAL ; 26/03/2014 à 21h21.
J'ai pu tester le programme ci-dessus sur un Mega 2560, et j'ai fait une petite erreur au niveau de la prise en compte de la parité. À la fin, il faut lire :
Code:... // Envoie le caractère lu au PC #if defined(_format_hexadecimal_) // version hexadécimale Serial.print((data&0x7f)|parity, HEX); Serial.write(' '); #else // version ASCII Serial.write((data&0x7f)|parity); #endif }
Dernière modification par PA5CAL ; 27/03/2014 à 01h41.
