IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Arduino Discussion :

Connecter un Arduino sur nappe existante


Sujet :

Arduino

  1. #61
    Membre habitué
    Homme Profil pro
    Inscrit en
    Juillet 2012
    Messages
    275
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Juillet 2012
    Messages : 275
    Points : 152
    Points
    152
    Par défaut
    Bonsoir,

    Je me permet de revenir vers vous car le projet avance mais je reste bloqué sur l'analyse de code.

    Quand j'analyse le code récupérer. Il y a plusieurs ports de déclarés.

    D'un coté, Il y a PORTA et PortD:

    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
    void write_color(){
        addr_select(DVS8000_ME_COLOR1);
     
        PORTA = color & 0x3F;
        DDRA = 0xFF;
        PORTD &= ~(1 << 2); //WR
        _delay_us(1);
        PORTD |= (1 << 2); //WR
        DDRA = 0x00;
        _delay_us(2);
     
        addr_select(DVS8000_ME_COLOR2);
        PORTA = (color>>6) & 0x1F;
        DDRA = 0xFF;
        PORTD &= ~(1 << 2); //WR
        _delay_us(1);
        PORTD |= (1 << 2); //WR
        DDRA = 0x00;
    }
     
    void set_row_red(uint8_t row){
        color &= ~(1 << row);
        write_color();
    }
    Et d'un autre coté, il y a DDRB, DDRC et DDRD

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
        DDRB |= 0x07; // address bits for chip selection 0b00000111
        DDRC = 0xFF;  // address bits for board
     
        DDRB |= (1<<3); // A0 out 0b00111000
     
        DDRD |= (1 << 5); //clk out (to 422)
     
     
        // RD & WR lines
        DDRD |= (1 << 3) | (1 << 2);
        PORTD |= (1 << 3) | (1 << 2);
     
        PORTC = (1 << 1);
    Je ne vois pas la différence en entre port C et Port A, peut-on le savoir sans le câblage?

    Je souhaiterais allumer une led dans un premier temps, mais je ne vois quoi changer pour être cohérent avec mon tableau précédent :

    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
    #include "Arduino.h"
     
     
    void setup() {
        // Supply 422 Driver
        DDRD |= (1 << 6) | (1 << 7);
        PORTD |= (1 << 7);
     
        _delay_ms(10);
     
        DDRB |= 0x07; // address bits for chip selection 0b00000111
        DDRC = 0xFF;  // address bits for board
     
        DDRB |= (1<<3); // A0 out 0b00111000
     
        DDRD |= (1 << 5); //clk out (to 422)
     
     
        // RD & WR lines
        DDRD |= (1 << 3) | (1 << 2);
        PORTD |= (1 << 3) | (1 << 2);
     
        PORTC = (1 << 1);
     
        setup_clk_out();
        set_row_yellow(0);
     
    }
     
    void loop() {
    }
     
    void setup_clk_out(){
        TCCR1A = (0<<COM1A1)|(1<<COM1A0);
     
        TCCR1A |= (0<<WGM11)|(0<<WGM10);
        TCCR1B |= (0<<WGM13)|(1<<WGM12);
     
        TCCR1B |= (0<<CS12)|(1<<CS10);
        OCR1A = 15;
    }
     
    void set_row_yellow(uint8_t row){
        color |= (1 << row);
        write_color();
    }
     
    void write_color(){
        addr_select(0x26);
     
        PORTA = color & 0x3F;
        DDRA = 0xFF;
        PORTD &= ~(1 << 2); //WR
        _delay_us(1);
        PORTD |= (1 << 2); //WR
        DDRA = 0x00;
        _delay_us(2);
     
        addr_select(0x27);
        PORTA = (color>>6) & 0x1F;
        DDRA = 0xFF;
        PORTD &= ~(1 << 2); //WR
        _delay_us(1);
        PORTD |= (1 << 2); //WR
        DDRA = 0x00;
    }
    Je suis un peu perdu sûr cette partie.

    Ne pas oublier encore le condo de découplage sur le AM26LS31CN (100nF céramique au plus proche des alimentations du circuit)
    Sauf si je me trompe, je le met entre le 5V du AM26LS31CN et le 5v de l'arduino?

    Cordialement,

    Vincent

  2. #62
    Modérateur

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    Septembre 2008
    Messages
    1 267
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : Septembre 2008
    Messages : 1 267
    Points : 4 829
    Points
    4 829
    Par défaut
    Bonsoir Vincent

    J'ai supposé que c'était une puce 40 pattes, est-ce que cela peut-être validé?
    Dans ce cas c'est 4 ports complets (A, B, C, D) plus un ou deux partiels pour ce qui reste y compris les pattes pour le ou les quartz et celle du reset quand elles sont utilisées en E/S au lieu de leur fonction d'origine.

    Chaque port est géré par trois registres: DDRx pour le sens, PORTx pour l'état en sortie ou la pull-up en entrée, et PINx pour la lecture de l'entrée ou qui inverse PORTx si écrit à 1. "x" dans cette écriture est à remplacer par la lettre du port.

    Je ne suis pas certains de toutes mes déductions précédentes. Il n'y a pas une explication sur les raccordement dans les fichiers de l'autre projet?
    J'ai probablement fait une erreur dans mon message #59. Car pour les 4bits d'adresse cela devrait être DDRx = 0x0F; et non DDRx = 0x0/;La seule chose vraiment certaine de part les commentaires c'est le IOWR qui est sur PORTD2 et IORD sur PORTD3.
    Ensuite sur la base des photos du schéma que tu as présenté je suis parti du principe que seules les lignes A1 à A4 étaient utilisées. Mais s'il y a une autre partie du schéma, les lignes supérieures pourraient aussi être nécessaires. Ce qui pourrait expliquer que l'autre projet utilise plus de lignes. Si tout est raccordé, il faut 11 lignes pour le bus A donc 8 + 3 bits et qui pourrait correspondre à
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
        DDRB |= 0x07; // address bits for chip selection 0b00000111
        DDRC = 0xFF;  // address bits for board
    On met bien 11 bits en sorties, par contre dans quel ordre car deux logiques sont possibles.

    Condensateur de découplage c'est trop difficile ? Et en plus c'est même décrit dans la doc de l'AM26LS31CN
    Non c'est entre l'alim et la masse de chaque puce au plus près. En cas de plan de masse c'est au plus près de la patte d'alimentation + de la puce. Sur les photos des platines du pupitre en début de projet on les voit très bien, identifiés en Cxx. (Par contre ils ressemblent plus à des résistances qu'aux condensateurs que je connais.)
    La quantité c'est 1 par puce. Par contre à l'achat c'est généralement 50 ou 100 pièces.

    Bonne suite

    Delias

  3. #63
    Membre habitué
    Homme Profil pro
    Inscrit en
    Juillet 2012
    Messages
    275
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Juillet 2012
    Messages : 275
    Points : 152
    Points
    152
    Par défaut
    Bonsoir Delias,

    Merci de votre réponse rapide.

    J'ai supposé que c'était une puce 40 pattes, est-ce que cela peut-être validé?
    De quelle puce parlez-vous? Si c'est de la nappe, il y a 60 pins.

    Chaque port est géré par trois registres: DDRx pour le sens, PORTx pour l'état en sortie ou la pull-up en entrée, et PINx pour la lecture de l'entrée ou qui inverse PORTx si écrit à 1. "x" dans cette écriture est à remplacer par la lettre du port.
    Il y a des PINx seulement pour le fichier shell, sinon il y en a pas, voici le fichier bus.h:

    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
    void write(uint8_t data){
        DDRA = 0xFF; // bus direction: output
        PORTA = data;
     
        PORTD &= ~(1 << 2); //WR
        _delay_us(1);
        PORTD |= (1 << 2); //WR
     
        DDRA = 0;
        PORTA = 0;
    }
     
    void read(uint8_t * dest){
        _delay_us(0.2);
        DDRA = 0; //Bus direction: input
        PORTD &= ~(1 << 3); //read pin
     
        _delay_us(0.5);
        *dest = PINA;
        PORTD |= (1 << 3); //end read
     
        // Bus direction to output
        PORTA = 0xFF;
        DDRA = 0xFF;
    }
     
    void addr_select(int addr){
        PORTB &= ~(0x1 << 3);
        PORTB |= (addr & 0x1) << 3;
     
        PORTB &= ~0x7;
        PORTB |= (addr & 0xe)>>1;
     
        PORTC = (addr & 0x1F0)>>4;
    }

    Je ne suis pas certains de toutes mes déductions précédentes. Il n'y a pas une explication sur les raccordement dans les fichiers de l'autre projet?
    Il y a aucune explication sur le raccordement, je me suis permis de le contacter par mail pour savoir mais sans réponse.


    Ensuite sur la base des photos du schéma que tu as présenté je suis parti du principe que seules les lignes A1 à A4 étaient utilisées. Mais s'il y a une autre partie du schéma, les lignes supérieures pourraient aussi être nécessaires. Ce qui pourrait expliquer que l'autre projet utilise plus de lignes.
    Effectivement les A4-A11 servent bien à quelques choses. ME1, ME2 et PP. Je pourrais envoyer le schéma si besoin.

    Merci pour les condensateurs, j'ai compris l'utilité et le branchement.


    Vincent.

  4. #64
    Modérateur

    Homme Profil pro
    Ingénieur électricien
    Inscrit en
    Septembre 2008
    Messages
    1 267
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 41
    Localisation : Suisse

    Informations professionnelles :
    Activité : Ingénieur électricien

    Informations forums :
    Inscription : Septembre 2008
    Messages : 1 267
    Points : 4 829
    Points
    4 829
    Par défaut
    Bonjour Vincent

    Citation Envoyé par vins86 Voir le message
    De quelle puce parlez-vous? Si c'est de la nappe, il y a 60 pins.
    De l'ATMega quelque chose qui est utilisé par l'autre projet. Comme je l'ai déjà indiqué le STK500 permet de recevoir presque toute la famille au format DIL.

    Citation Envoyé par vins86 Voir le message
    Il y a des PINx seulement pour le fichier shell, sinon il y en a pas, voici le fichier bus.h:
    Du PINx, il doit y en avoir lorsque l'on veut lire le bus (D0-D7), à la lecture de l'état des boutons au minimum.

    Citation Envoyé par vins86 Voir le message
    Effectivement les A4-A11 servent bien à quelques choses. ME1, ME2 et PP. Je pourrais envoyer le schéma si besoin.
    Donc ils ne peuvent pas être reliés fixe à Vcc et GND, mais sur des sorties de l'Arduino.

    Un projet de ce type (ce que tu fais actuellement ou la conception du pupitre à l'époque) se réfléchi en premier globalement !
    - Lister toutes les fonctionnalités souhaitées (du point de vue des interfaces extérieurs, comme l'utilisateur)
    - Découper en modules (la carte que tu remplaces est un module, la carte avec les 7 TMP est un module, les panneaux de leds + boutons est un module, etc.)
    - Définir grossièrement l’architecture et les interfaces entres les modules. Dans le cadre du pupitre c'est un bus parallèle avec data et adresse. 8 bits de data une fois fixé cela ne va pas changer, mais le bus d'adressage va croitre à chaque ajout de module. Le module TMP nécessite 16 adresses (donc 4 bits), si je commence la conception avec 4 bits d'adresse, je pourrais tout modifier lors de l'ajout du module suivant...
    - Ensuite seulement on va développer les modules, les uns après les autres avec la possibilité de tester après chaque module réalisé et en l'absence des suivants.

    Pour le remplacement du module coeur par l'Arduino c'est pareil, il faut d'abord déterminer l'ensemble des interfaces nécessaires (il faut réserver les capacités matérielles nécessaires), puis seulement après, on peut progresser fonction par fonction (pour le code)

    Bonne journée

    Delias

  5. #65
    Membre habitué
    Homme Profil pro
    Inscrit en
    Juillet 2012
    Messages
    275
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Juillet 2012
    Messages : 275
    Points : 152
    Points
    152
    Par défaut
    Bonjour à tous,

    Après un moment de silence, je me permet de revenir vers vous avec quelques éléments d'avancer sur le projet.

    Un projet github a été fait et il est consultable à l'adresse suivante : https://github.com/DPCLive/pupitre


    En faisant les différents tests avec le code suivant, nous arrivons bien à sélectionner et à communiquer avec le TMP82c79P (IC80 sur le schéma: https://www.developpez.net/forums/at...30_162858.jpg/).


    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
    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
     
    /////////////////////////////////////////////////////////////////////////////////////
    // D0-D7 Port A (0-7)
    // A1-A8 Port C (0-7)
    // A9-A11 Port L (0-2)
    // CLK PWM 11
    // WR Port G (0)
    // RD Port G (1)
    // Reset Port B (0)
    /////////////////////////////////////////////////////////////////////////////////////
     
     
    int blinkPin = 11;
    int wr_pin = 41;
    int rd_pin = 40;
    int reset_pin = 53;
     
    int test_input_pin = 7;
     
    void TimerOne_setPeriod(long OCRValue)
    {
     TCCR1B = (1 << WGM12) | (1 << CS10); 
     
     TCCR1A = bit(COM1A0);                      //  or use TCCR1A = 0x40;            // Toggle mode 0C1A  
     OCR1A = OCRValue;                          // set the counter
    }
     
    void TMP_Select(uint8_t a0)
    {
      delayMicroseconds(100);
        PORTL = 0x00; // A9..A11
     
    /*
     * Sélection du TMP IC80
     
    Bus adresse sur la nappe
     
      A7..A11  : 0
      A6: 1
      A5: 0
      A4: 1 (C)74 HC138 numéro IC6
      A3: 1 (B)74 HC138 numéro IC6
      A2: 1 (A)74 HC138 numéro IC6
      A1: a0 du TMP (sélection du registre)
     
      */  
        if (a0)
        {
          //  A8  ... A1
          PORTC = B00101111;
        }
        else
        {
          //  A8  ... A1
          PORTC = B00101110;
        }
        delayMicroseconds(100);
    }
     
     
     
    void TMP_WriteCommand(uint8_t data)
    {
      digitalWrite(rd_pin, HIGH);
      digitalWrite(wr_pin, LOW);
     
      delayMicroseconds(1000);
     
      TMP_Select(1);
     
      PORTA = data;
     
      delayMicroseconds(1000);
     
      digitalWrite(wr_pin, HIGH);
     
      delayMicroseconds(1000);
    }
     
     
    void TMP_WriteData(uint8_t data)
    {
      digitalWrite(rd_pin, HIGH);
      digitalWrite(wr_pin, LOW);
     
      delayMicroseconds(1000);
     
      TMP_Select(0);
     
      PORTA = data;
     
      delayMicroseconds(1000);
     
      digitalWrite(wr_pin, HIGH);
     
      delayMicroseconds(1000);
    }
     
    uint8_t TMP_ReadData()
    {
      digitalWrite(rd_pin, LOW);
      digitalWrite(wr_pin, HIGH);
     
      delayMicroseconds(1000);
     
      uint8_t data = PINA;
     
      delayMicroseconds(1000);
      digitalWrite(rd_pin, HIGH);
     
      delayMicroseconds(1000);
     
      return data;
    }
     
    void setup() {
      // put your setup code here, to run once:
     
      DDRC = B11111111;  // 1 == outputs, 0 == input
      DDRL = B11111111;  // 1 == outputs, 0 == input
     
    // Bus de données
      DDRA = 0;  // 1 == outputs, 0 == input
     
    // Configuration du bus de contrôle
      pinMode(wr_pin, OUTPUT); 
      pinMode(rd_pin, OUTPUT); 
      pinMode(reset_pin, OUTPUT);
      pinMode(test_input_pin, INPUT);
     
      // On place le bus de contrôle à un état stable
      digitalWrite(rd_pin, HIGH);
      digitalWrite(wr_pin, HIGH);
      digitalWrite(reset_pin, HIGH);
     
       delayMicroseconds(1000);
     
       TMP_WriteCommand(B00000100); // Configure TMP en mode "Encoded Scan Sensor matrix", le reste par défaut
     
       TMP_WriteCommand(B00100101); // clock divided by 5
     
      // PARAMETRAGE HORLOGE 
       pinMode(blinkPin, OUTPUT);                 // alternately use DDRB = 0xa0;      // turn on the timer ouput pin;
      TimerOne_setPeriod(6);                 // set up and start Timer1 to blink at the same rate as the blink sketch
     
        // open the serial port at 9600 bps:
      Serial.begin(9600);
    }
     
    void loop() {
      uint8_t data = 0;
     
      TMP_Select(1); // status 
      /*data = TMP_ReadData();
      Serial.println("STATUS");
      Serial.println(data, BIN);  // print as an ASCII-encoded binary*/
     
    /*
      TMP_WriteData(B01000000);
      TMP_Select(0); // data
      data = TMP_ReadData();
       Serial.println("DATA");
      Serial.println(data, BIN);  // print as an ASCII-encoded binary
    */
     
      delay(200);
     
    }

    Avec : Le TMP (IC80), nous retour "0" en permanence en console quand on appuie sur un bouton rien ne change pas.


    Avec : Le TMP (IC80), nous retour "101000" en permanence en console quand on appuie sur un bouton rien ne change pas.

    Voici le datasheets du TMP en question : https://static6.arrow.com/aropdfconv...0/tmp82c79.pdf

    Nous avons vérifié les différents câblages et ils sont bon.

    Nous aimerions savoir si les informations envoyées au TMP sont bien juste et si notre code semble plutôt cohérent avec la datasheets du TMP?

    Dans l'attente de votre expertise.

    Cordialement,

    Vincent.

  6. #66
    Membre habitué
    Homme Profil pro
    Inscrit en
    Juillet 2012
    Messages
    275
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations forums :
    Inscription : Juillet 2012
    Messages : 275
    Points : 152
    Points
    152
    Par défaut
    Bonjour,

    Nous essayons toujours de pouvoir communiquer avec notre TMP.

    L'ancien processeur envoyait une clock à 100hz.

    Avec notre code avec une clock à 100khz et un analyseur logique, nous obtenons ce graphe (je ne sais pas si cela peut aider, mais on sait jamais):


    Nom : frequence.PNG
Affichages : 140
Taille : 38,0 Ko

    Je souhaite dans un premier temps récupérer les colonnes des boutons : (S0, S1, S3) quand j'appuie sur un bouton. Les lignes je le ferais après (D0-D7).

    Je suis preneur de toute réponse pour espérer avance avec ce TMP.

    Merci d'avance de votre aide précieux.

    Cordialement,

    Vincent.

Discussions similaires

  1. connecter 2 logiciel sur une webcam
    Par breton51 dans le forum Windows
    Réponses: 6
    Dernier message: 06/07/2006, 13h25
  2. [MySQL] Connection à une bdd sur serveur distant
    Par papyphp dans le forum PHP & Base de données
    Réponses: 4
    Dernier message: 07/03/2006, 21h13
  3. Ajouter en TSQL l'autoincrémentation sur colonne existante
    Par [DreaMs] dans le forum MS SQL Server
    Réponses: 3
    Dernier message: 15/12/2005, 18h13
  4. [VB6]Comment se connecter à une BD sur serveur distant?
    Par Chess0 dans le forum VB 6 et antérieur
    Réponses: 13
    Dernier message: 27/10/2005, 21h11
  5. Savoir si une connection est établie sur un port
    Par Malone dans le forum Web & réseau
    Réponses: 3
    Dernier message: 06/12/2003, 08h22

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo