Carte Servomoteurs DCC + CAN

[Dominique]

je pense qu'il vaut mieux alimenter la carte par le port K1 de toute façon.

Pour les servos, c'est sûr que les servos ne sont pas alimentés si K1 n'a rien.

[Dominique]

Je viens de refaire des essais avec et sans alim sur K1 :
- avec alim sur K1 on a du 5V correct partout
- sans alim sur K1, l'alim du 2515 et du 2551 est plutôt vers 2V

C'est comme si le circuit était alimenté par les signaux SPI, ce qui n'est pas sain du tout (ça peut même l'endommager, peut-être, mais le mien marche toujours) = donc il faut éviter de ne pas alimenter K1 : alimenter K1 avant de connecter la prise USB !

[Jean-Luc]

 Si tu charges un sketch vide qui ne programme pas les broches SPI en sortie, il y a toujours 2v ?

[Thierry]

Merci à tous. Avec le programme de Dominique ça marche. C'est sans doute le numéro de broche SPI que j'avais laissé à 9, sa valeur par défaut dans l'exemple de la biblio... J'y ai repensé dans la nuit, et je pensais bien que c'était ça.
Et effectivement, ça marche aussi pour moi avec seulement l'USB branché... Cela pose t-il un problème d'avoir à la fois l'alimentation extérieure via K1 et un câble USB branché ? Parce que pour vérifier ce qui passe avec la liaison série, c'est quand même plus pratique...

[Jean-Luc]

Non ça ne pose pas de problème car le Nano est alimenté via VIN et pas par le 5V. C'est fait pour.

Le Nano intègre un dispositif un peu rudimentaire mais fonctionnel pour sélectionner la source d'alimentation (une diode schottky qui empêche que le régulateur envoie du jus dans l'USB) :
- Si VIN n'est pas alimenté le régulateur embarqué dans le Nano ne délivre pas de 5V et c'est VUSB qui est appliqué via la diode schottky.
- SI VIN est alimenté, le +5V du Nano est fourni par le régulateur, celui venant de l'USB ne sert pas.

[Thierry]

Après divers essais, je n'arrive à rien. Si maintenant l'initialisation est correctement faite, la carte de réception ne reçoit rien !
J'ai connecté par un câble RJ11 droit (vérifié, au cas où...) les prises côté Nano de chacune des cartes, alimentées toutes deux par l'extérieur, plus des câbles USB en place.

Code émetteur :

Code: [Sélectionner]

// demo: CAN-BUS Shield, send data
#include <mcp_can.h>
#include <SPI.h>

// the cs pin of the version after v1.1 is default to D9
// v0.9b and v1.0 is default D10
const int SPI_CS_PIN = 10;

MCP_CAN CAN(SPI_CS_PIN);                                    // Set CS pin

void setup()
{
    Serial.begin(115200);

    while (CAN_OK != CAN.begin(CAN_125KBPS))              // init can bus : baudrate = 500k
    {
        Serial.println("CAN BUS Shield init fail");
        Serial.println(" Init CAN BUS Shield again");
        delay(100);
    }
    Serial.println("CAN BUS Shield init 125K ok!");
}

unsigned char stmp[8] = {0, 1, 2, 3, 4, 5, 6, 7};
void loop()
{
    // send data:  id = 0x00, standrad frame, data len = 8, stmp: data buf
    Serial.println("send data!");
    CAN.sendMsgBuf(0x00, 0, 8, stmp);
    delay(1000);                       // send data per 100ms
}
Code récepteur :

Code: [Sélectionner]

// demo: CAN-BUS Shield, receive data with interrupt mode
// when in interrupt mode, the data coming can't be too fast, must >20ms, or else you can use check mode
// loovee, 2014-6-13

#include <SPI.h>
#include "mcp_can.h"

// the cs pin of the version after v1.1 is default to D9
// v0.9b and v1.0 is default D10
const int SPI_CS_PIN = 10;

MCP_CAN CAN(SPI_CS_PIN);                                    // Set CS pin

unsigned char flagRecv = 0;
unsigned char len = 0;
unsigned char buf[8];
char str[20];

void setup()
{
    Serial.begin(115200);

    while (CAN_OK != CAN.begin(CAN_125KBPS))              // init can bus : baudrate = 500k
    {
        Serial.println("CAN BUS Shield init fail");
        Serial.println(" Init CAN BUS Shield again");
        delay(100);
    }
    Serial.println("CAN BUS Shield init ok!");

    attachInterrupt(digitalPinToInterrupt(3), MCP2515_ISR, FALLING); // start interrupt
}

void MCP2515_ISR()
{
    Serial.println("Exception raised");
    flagRecv = 1;
}

void loop()
{
    if(flagRecv)
    {                                   // check if get data

        flagRecv = 0;                   // clear flag

        // iterate over all pending messages
        // If either the bus is saturated or the MCU is busy,
        // both RX buffers may be in use and reading a single
        // message does not clear the IRQ conditon.
        while (CAN_MSGAVAIL == CAN.checkReceive())
        {
            // read data,  len: data length, buf: data buf
            CAN.readMsgBuf(&len, buf);

            // print the data
            for(int i = 0; i<len; i++)
            {
                Serial.print(buf[i]);Serial.print("\t");
            }
            Serial.println();
        }
    }
}

Les codes ont été adaptés pour coller au matériel : pin 10 pour le SPI, interruption CAN sur la pin 3 pour la lecture et vitesse réduite à 125K... Mais rien n'y fait. Une idée ?

[Jean-Luc]

Il ne faut pas faire de print dans une routine d'interruption.

Si le buffer d'émission est plein, print fait une attente active sur la disponibilité d'un emplacement dans le buffer d'émission. Comme il est vidé par l'interruption d'envoi de l'UART et que l'ISR correspondante ne peut pas s'exécuter tant que l'ISR du MPC n'est pas terminée...

... Ça fait un deadlock

[Thierry]

Ben, le print je l'ai juste ajouté parce que je ne comprenais pas, et que je voulais savoir si une interruption avait été lancée, mais ça ne marche pas sans non plus !

[Jean-Luc]

Les terminateurs sont en place ? les 2551 dans le bon sens ?

[Thierry]

Je crois que tout est bon :

[Jean-Luc]

Vu d'ici oui.

Tu as un oscillo ?

[Thierry]

J'en ai un petit, mais je ne sais pas m'en servir. Je referais des essais dimanche, lorsque je reviendrais de week-end. Je descend en Bourgogne voir mon beau-frère (youpi...), ça me fera un break en tout cas.
Il faudra aussi que j'essaie avec les cartes CAN d'essai pour voir si ça marche avec elles...

[Jean-Luc]

Je vais m'y mettre également ce week-end. On va déverminer tout ça 

[Dominique]

Après avoir cherché un cable RJ11 pendant 1 heure, j'ai réussi à connecter une carte 8 servos à un moniteur CAN que j'avais réalisé pour voir ce qui s'y passe.

Sketch sur le nano (carte servo) = send_Blink de l'exemple CAN Locoduino, à 500 kb/s, avec SPI_CS_PIN = 10 comme il se doit. Pas d'autre motif.
Ce sketch envoie un message par seconde et 'In loop" sur la console.

Mon moniteur affiche un compteur des messages reçus : il y en a bien un toutes les secondes. Voici ce qu'il affiche sur la console :

Code: [Sélectionner]

CAN Monitor V0.6 du 22/01/2016 copyright Dominique Bultez
CAN bus initialized.
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7
70 1 1 2 3 0 5 6 7

Ca correspond bien à ce qu'envoie send_Blink.

Maintenant, Thierry, il faut décortiquer un peu ce qui se passe de ton coté.
Je vais essayer de faire un programme de test entre 2 cartes servos

[Dominique]

Petit test entre les sketchs receive_check et send_blink pris dans les exemples du Can Locoduino à 500 kb/s = OK 

J'ai inversé les tests pour être sûr que la carte 8 servos joue bien l'un ET l'autre :

Code: [Sélectionner]

CAN BUS Shield init ok!
-----------------------------
get data from ID: 70
1 1 2 3 0 5 6 7
-----------------------------
get data from ID: 70
1 1 2 3 0 5 6 7
-----------------------------
get data from ID: 70
1 1 2 3 0 5 6 7
-----------------------------
get data from ID: 70
1 1 2 3 0 5 6 7
Donc pas besoin de tests plus compliqués pour valider le CAN.
Après, si tu veux, je peux t'envoyer mes programmes, mais il faut ajouter d'autres composants comme des afficheurs lcd.