Panoramic Arduino

Non non. c'est bien un CAN 10 bits que j'attaque avec un potar et qui me fournit un entier < 1024.
je l'ai divisé par 4 pour obtenir un char (< 256), mais je n'arrive pas à le faire revenir à Panoramic.

Pire encore... Quan je fais une boucle, la valeur lue n'est pas stable. Elle varie de 53 à 10 !!!
ce résultat est le même si je n'effectue pas la division par 4.
Et je réitère mon affirmation, si j'utilise le moniteur série du logiciel Arduino ça marche sans problème...
Peut on imaginer un protocole série(Usb) qui n'aurait pas la même parité et le même nb de bits de stop dans les 2 sens ?
Moi ça me paraitrait aberrant...

Jicehel a écrit:

Merci Klaus, il pleut sur Paris et je dois aller manger... J'ai pris 5 mn pour ce sujet

Seulement 5 mn ?
Tu vas faire des jaloux parmi les membres et je ne parle pas seulement de moi !
Alors, bénit soit la pluie qui tombe sur Paris !
Et bon appétit !

Effecctivement, c'est aberrant. Est-ce que tu as essayé le programme DemoIoCom.exe fourni dans le ZIP téléchargeable dont tu as fourni l'URL ? Le bouton "Rec" fait exactement ça: appel de la fonction ComGetDataIn. Vérifie avec ça et tiens-moi au courant !

pour info




Description

La librairie Serial est utilisée pour les communications par le port série entre la carte Arduino et un ordinateur ou
d'autres composants. Toutes les cartes Arduino ont au moins un port Série ( également désigné sous le nom de UART ou USART)
: Serial. Ce port série communique sur les broches 0 (RX) et 1 (TX) avec l'ordinateur via le port USB. C'est pourquoi,
si vous utilisez cette fonctionnalité, vous ne pouvez utiliser les broches 0 et 1 en tant qu'entrées ou sorties numériques.

Vous pouvez utiliser le terminal série intégré à l'environnement Arduino pour communiquer avec une carte Arduino.
Il suffit pour cela de cliquer sur le bouton du moniteur série dans la barre d'outils puis de sélectionner
le même débit de communication que celui utilisé dans l'appel de la fonction begin().


Serial.print(données)
Description

Affiche les données sur le port série.

Affiche les données sous le port série sous forme lisible pour les humains (texte ASCII).
Cette instruction peut prendre plusieurs formes.

Les nombres entiers sont affichés en utilisant les caractères ASCII pour chaque chiffre.
Les nombres à virgules (float) sont affichés de la même façon sous forme de caractères ASCII
pour chaque chiffre, par défaut avec 2 décimales derrière la virgule.
Les valeurs de type byte sont affichés sous la forme d'un caractère ASCII.





Serial.println(data)
Description

Affiche les données sur le port série suivi d'un caractère de "retour de chariot" (ASCII 13, or '\r') et un caractère de "nouvelle ligne" (ASCII 10, or '\n'). Cette instruction a par ailleurs la même forme que l'instruction Serial.print():

Serial.println(b) affiche b en tant que nombre décimal sous la forme d'une chaîne de caractères ASCII suivi d'un retour de chariot et d'un saut de ligne.

Serial.println(b, DEC) affiche b en tant que nombre décimal sous la forme d'une chaîne de caractères ASCII suivi d'un retour de chariot et d'un saut de ligne.

Serial.println(b, HEX) affiche b en tant que nombre hexadécimal sous la forme d'une chaîne de caractères ASCII suivi d'un retour de chariot et d'un saut de ligne.

Serial.println(b, OCT) affiche b en tant que nombre octal sous la forme d'une chaîne de caractères ASCII suivi d'un retour de chariot et d'un saut de ligne.

Serial.println(b, BIN) affiche b en tant que nombre binaire sous la forme d'une chaîne de caractères ASCII suivi d'un retour de chariot et d'un saut de ligne.

Serial.print(b, BYTE) affiche b en tant qu'octet simple suivi d'un retour de chariot et d'un saut de ligne.

Serial.println(str) si str est une chaîne de caractère ou un tableau de caractère, affiche la chaîne de caractère suivie d'un retour de chariot et d'un saut de ligne.

Serial.println() affiche un retour de chariot et un saut de ligne.
Paramètres

data : tous types de données entières incluant les char, chaînes de caractères et floats (nombre à virgule).

Les floats sont supportés avec une précision de 2 à plusieurs décimales. Les caractères et les chaînes sont affichés tels que.


Serial.write()
Description

Ecrit des données binaires sur le port série. Ces données sont envoyées comme une série d'octet;
pour envoyer les caractères correspondants aux chiffres d'un nombre, utiliser plutôt la fonction print().
Syntaxe
serial.write(val)
serial.write(str)
serial.write(buf, len)
[Obtenir le Code]
Paramètres

val: une valeur à envoyer sous forme d'octet simple
str: une chaîne à envoyer sous forme d'une série d'octets
buf: un tableau pour envoyer une série d'octets
len: la largeur du tableau

@ Klaus

Après test avec le logiciel qui va bien (celui fourni à l'origine avec la dll), le résultat est identique à l'ouverture du port et à l’écriture des data. Ca marche
Mais le bouton "Rec" ne donne rien

Avec le programme DemoIoCom.exe, as-tu utilisé la DLL fournie dans le ZIP initial ? Ce programme ne peut pas fonctionner avec la DLL version Panoramic ! Ce serait certainement utilile de garder cela dans un dossier séparé.

J'ai bien réutilisé la dll d'origine. La fenêtre où devrait s'afficher la donnée reste noire

Chez moi, cette petite zone juste à gauche du bouton Rec est blanche.

Sans même connecter ta carte, donc avec un port libre, non occupé;, fais ceci:
- dans ce programme, sélectionne un port physiquement présent mais libre (chez moi, le numéro 3 pour COM3)
- puis, dans le combo à gauche du bouton Emi, place une valeur non nulle
- puis clique sur Emi
- maintenant cliuque sur Rec
==> tu devrais voir apparaître la valeur du combo à gauche du bouton Rec

Ensuite, fais la même chose dans ton programme, avec la DLL récupérée sur mon site:
- sélectionne le même port
- envoie la même donnée
- lis une donnée
- regarde ce que tu reçois
==> et c'est là que ça deviendra intéressant !

Le problème c'est que je n'ai pas de port com sur mon portable...
Je ne peux envoyer et recevoir des données que par l'intermédiaire d'un port virtuel. Et pour ça il faut que je branche ma carte.
Si j'essaye de me connecter malgré tout, il m’engueule, ce que je trouve légitime soit dit en passant. Mais ça ne règle pas le pb

Bon. Puisque tu dois connecter ta carte, fais comme ceci:
- connecte ta carte
- lance ce programme avec la DLL d'origine
- connecte le port avec les paramètres de configuration qui vont bien
- par ta carte, prépare une donnée à envoyer
- par le bouton Rec, lis la donnée

Puis, fais la même chose avec ton programme Panoramic avec la DLL de mon site.

Y a-t-il une différence, et si oui, laquelle ?

STOP !!!

Ca marche

le fonctionnement (avec Panoramic) est un peu instable pour le moment, mais j'arrive à peu près à faire ce que j'attends.
Je vais creuser un peu et je vous tiens tous au courant de mes découvertes.
A noter que le prog de test livré avec la dll d'origine ne fonctionne pas chez moi (Win 7)
A bientôt à suivre

Super ! J'attends tes infos pour éventuellement adapter la DLL, ou la pousser plus loin...

@ Klaus
1er jet sur la chose.

Tout d'abord il faut bien faire attention à la donnée que la carte envoie. Pour ComGetDataIn ça doit être un char sur 8 bits et non pas un int < 255 comme je faisais au début (honte).

J’ai écrit les lignes suivantes (avec le seul soucis du test)

Code:

dim a% ,b%,a$, in% ,b$
b$ = "Ceci est un texte avec des a ou pas"

dll_on "C:\_Données_\Panoramic's projects\_Dll\IO_Acces_COM.dll"

a%=dll_call1("ComUsePort",7)
a% = dll_call4("ComConfig", 9600, 8, 1, 0)



for b% = 1 to len(b$)
  a$ = mid$(b$,b%,1)
  a% = dll_call1("ComSetDataOut",asc(a$))
'  wait 500
  a% = dll_call1("ComGetDataIn",adr(in%))
  print chr$(in%);
next b%

Le "a" et le <> "a" me permettent d’allumer ou d’éteindre une led sur la carte. Par l’intermédiaire du petit programme suivant

Code:

int led = 13;
char a ;
int b ;

void setup() { 
  Serial.begin(9600); 
  pinMode(led, OUTPUT);   
                    }

void loop() {

    if (Serial.available()) {
      a = Serial.read();
      Serial.print(a);
    if  (a == 'a') { 
        digitalWrite(led, HIGH);
                        }
    else {
        digitalWrite(led, LOW); 
            }
                                        }
                  }

La ligne Serial.print(a) permet de recopier la donnée sur le port Usb. Un Serial.println() rajoute CR LF après la donnée.
Tout ça, ça recopie le texte contenu dans b$ au travers de la carte.

Bon ben valà. Nous v'là avec les fonction ComUsePort, ComConfig, ComSetDataOut et ComGetDataIn qui fonctionnent et qui sont dûment testées. Et tout ça sans avoir la carte sous la main ! Fallait oser le challenge. Chapeau bas.
Je m’attèle aux 2 dernières fonctions (celles sur les buffers).
Au fait, la carte peut passer à l'ordi des int et des float...
Y aurait pas moyen ?

Eh bien, dans la DLL telle qu'elle était fournie (et c'est ce que j'ai adapté), elle a les fonctions de "lecture" suivantes:

ComGetDataIn
Cette fonction reçoit un seul octet de 9 bits. Que ce soit un caractère Ascii ou une valeur binaire entre 0 et 255 ne fait pas de différence à ce niveau-là, puisque justement un caractère Ascii est une valeur binaire entre 0 et 255. Dans la fonction d'origine, la valeur était ddéclarée "byte" en Delphi, ce qui est un entier binaire sur 8 bits. Pour cette raison, j'ai gardé cette logique pour retourner un entier à Panoramic, même si en Panoramic,un entier est codé sur 32 bits, dont dans notre cas, seuls les 8 bits inférieurs seront utilisés, les autres étant systématiquement à zéro.

ComGetBlockIn
Cette fonction reçoit une chaîne de caractères. En entrée, on spécifie l'adresse de la chaîne de destination et le nombre maximum de caractères à lire. La chaîne doit exister et contenir au moins autant de caractères que le nombre maxi attendu, sinon on risque un écrasement de mémoire ce qui se traduit par un crash avec violation de mémoire. La fonction lit autant de caractères que possible et les dépose dans la chaîne de sortie, et la lecture se termine, soit lorsque le nombre maxi est atteint, soit lorsu'il n'y a plus de caractères disponibles à l'entrée. Dans ce dernier cas, les caractères éventuellement restantes dans la chaîne de caractères de sortie ne seront pas remplacés.

Maintenant, pour passer un int ou un float, je pourrais faire facilement les fonctions corrspondantes, en me basant sur ComGetBlockIn, et en demandant 2 ou 4 octets pour un int, et 4 octets pour un float. Il suffirait que tu me dises ce que tu entends sous "int" et "float":
int = integer*2 = 16 bits soit 2 octets
int = integer*4 = 32 bits soit 4 octets (format Panoramic)
float = float*4 = 32 bits soit 4 octets (format Panoramic)
float = float*8 = 64 bits sout 8 octets
Qu'est-ce que la carte envoie si tu lui demandes d'envoyer un de ces types de données ? Avec cette information, je pourrai facilement ajouter les deux fonctions supplémentaires dans la DLL.

A tout hasard, j'ai ajouté une fonction
res% = dll_call1("ComGet4ByteBlockIn",adr(float))
ou
res% = dll_call1("ComGet4ByteBlockIn",adr(int%))

La fonction peut être appelée indifféremment pour un résultat integer s'il s'agit de integer 32 bits comme en Panoramic, ou avec un flottant s'il s'agit d'un flottant 32 bits comme en Panoramic. Voir mon message précédent. Si les longueurs sont différentes, je vais adapter la fonction.

Au retour, res%=1 si réussite et si float ou int% ont été chargés, ou res%=0 si la lecture a échoué.

Tout est à jour dans mon WebDav, y compris de programme de test pour Panoramic.

Déjà les int sont au format 32 bits, et les float idem. Comme en panoramic. Il y a aussi d'autres formats mais il faut savoir se limiter... en fait comme il s'agit d'un avatar du C, on a tous les formats possibles unsigned long short etc.. et j'en passe
En ce qui concerne ComGetBlockIn, J'ai un petit souci. Je ne sais pas s'il faut lui passer un adr(n%) ou adr(n$).
Je suis perplexe. Le $ me donne une violation mémoire et je ne vois pas trop comment déclarer une chaine d'entiers. Un tableau ?

j'avais pas fini d'écrire que la solution était déjà là!!!
T'as pas de problème de refroidissement de clavier ? Y doit chauffer à ce train là...

Lorsque je suis devant la machine, en effet, cela peut aller très vite, des fois. Mais sinon, je fais comme tout le monde: je m'interromps pour manger, me promener, jardiner etc.

En ce qui concerne ComGetBlockIn, cette fonction est bien prévue pour lire une chaîne de caractères en NON un tableau de valeurs entières ou flottantes ! En Panoramic, c'est bien une variable avec un $ qu'il faut définir. Mais comme je l'ai dit plus haut, il faut que la place nécessaire pour les données à recevoir soit réservée dans la variable. Or, si tu fais dim buffer$, la longueur allouée est zéro octets - la chaîne est vide ! Voici comment il faut faire:

Code:

dim buffer$, longueur%, res%
longueur% = 8 : ' on attend 8 octets
buffer$ = string$(longueur%," ") : ' on réserve un espace de 8 octets
' maintenant, on passe l'adresse du buffeur et l'adresse de la variable contenant la longueur
res% = dll_call2("ComGetBlockIn",adr(buffer$),adr(longueur%))
if res%=1
  ' ici, on a reçu au moins un caractère.
  'Le contenu de la variable longueur% a été modifié pour représenter le nombre de caractères lus
  buffer$ = left$(buffer$,longueur%) : ' on élimine les éventuels espaces en trop
  message str$(longueur%)+" caractères reçus: "+buffer$
else
  ' ici, on n'a rien reçu du tout
  message "Oups..."
end_if

Tu vois le principe ?

J'ai bien réservé la place nécessaire par b$=" " mais je vois que dans ton prog de tes tu nas pas les mêmes pb.
Je décortique
Edit les espaces entre les "" ont disparu ! Enfer et damnation

Je sais. C'est un problème du forum. Pour poster des sources contenant des chaînes de caractères avec des espaces multiples, il faut mettre string$(n%," ").

D'ailleurs, mon code devrait fonctionner aussi bien ainsi:

Code:

dim buffer$, longueur%, res%
longueur% = 8 : ' on attend 8 octets
buffer$ = string$(longueur%,"x") : ' on réserve un espace de 8 octets
' maintenant, on passe l'adresse du buffeur et l'adresse de la variable contenant la longueur
res% = dll_call2("ComGetBlockIn",adr(buffer$),adr(longueur%))
if res%=1
  ' ici, on a reçu au moins un caractère.
  'Le contenu de la variable longueur% a été modifié pour représenter le nombre de caractères lus
  buffer$ = left$(buffer$,longueur%) : ' on élimine les éventuels espaces en trop
  message str$(longueur%)+" caractères reçus: "+buffer$
else
  ' ici, on n'a rien reçu du tout
  message "Oups..."
end_if

en remplaçant l'espace par un x. L'important, c'est d'occuper l'espace avant l'appel de la fonction DLL.

Bon je commence a avoir les yeux qui se croisent. je vais t'abandonner pour ce soir. Je te remercie de m'avoir aidé, et ce n'est que partie remise. j'ai encore quelques fonctions à tester.
Bonne nuit et à plus tard

Bonne nuit ! Je ne tarderai pas non plus. Mais tu verras - tu apprendras à me connaître. Je suis tenace, et je continuerai jusqu'à ce que ce soit opérationnel pour toi !

Merci a Klaus et a Mumu

un petit programme de test panoramic vers carte arduino

Code:

error_french
label  sp_1,sp_2,sp_3,sp_4,sp_5,sp_15,sp_led
label err
on_error_goto err
dim r,rr,d% ,a,b,c,d,aa,led_retour%,res%,dat%
rem DLL chargée en mémoire
dll_on "IO_Acces_COM.dll":'  ????
r= dll_call1("ComUsePort",8):'  ???
rr= dll_call4("ComConfig",115200,8,1,0):'  ????
button 1: top 1,130: left 1,50:caption 1,"A"
alpha 11: top 11,180: left 11,50:caption 11,"LED 1":color 11,160,160,160
width 11,75:height 11,25
button 2: top 2,130: left 2,150:caption 2,"B"
alpha 12: top 12,180: left 12,150:caption 12,"LED 2":color 12,160,160,160
width 12,75:height 12,25
button 3: top 3,130: left 3,250:caption 3,"C"
alpha 13: top 13,180: left 13,250:caption 13,"LED 3":color 13,160,160,160
width 13,75:height 13,25
button 4: top 4,130: left 4,350:caption 4,"D"
alpha 14: top 14,180: left 14,350:caption 14,"LED 4":color 14,160,160,160
width 14,75:height 14,25
button 5: top 5,330: left 5,450:caption 5,"fin"
alpha 6: top 6,60: left 6,150:color 6,125,125,125
alpha 7: top 7,60: left 7,350:color 7,125,125,125
alpha 8: top 8,30: left 8,150:caption 8,"ComUsePort"
alpha 9: top 9,30: left 9,350:caption 9,"ComConfig"
alpha 17: top 17,60: left 17,270:caption 17,"0"
timer 15:timer_interval 15,90:timer_on 15
if r=1
  color 6,0,255,0
else
  color 6,125,125,125
end_if
if rr=1
  color 7,0,255,0
else
  color 7,125,125,125
end_if
on_click 1,sp_1 : on_click 2,sp_2
on_click 3,sp_3 : on_click 4,sp_4
on_click 5,sp_5 :on_close 0,sp_5
on_timer 15,sp_15
' =============
 end :' ========
' =============
sp_1:
timer_off 15
 a=1-a
 if a=1
  r= dll_call1("ComSetDataOut",65)
  pause 1
 else
  r= dll_call1("ComSetDataOut",97)
  pause 1
 end_if
 caption 1,"A" str$(a)
 timer_on 15
  return
  ' =============
sp_2:
timer_off 15
 b=1-b
 if b=1
  r= dll_call1("ComSetDataOut",66)
  pause 1
 else
  r= dll_call1("ComSetDataOut",98)
  pause 1
 end_if
 caption 2,"B" str$(b)
 timer_on 15
return
 ' =============
sp_3:
timer_off 15
 c=1-c
 if c=1
  r= dll_call1("ComSetDataOut",67)
  pause 1
 else
  r= dll_call1("ComSetDataOut",99)
  pause 1
 end_if
 caption 3,"C" str$(c)
 timer_on 15
return
 ' =============
sp_4:
timer_off 15
 d=1-d
 if d=1
  r= dll_call1("ComSetDataOut",68)
  pause 1
 else
  r= dll_call1("ComSetDataOut",100)
  pause 1
 end_if
 caption 4,"D" str$(d)
 timer_on 15
return
 ' =============
sp_5:
 timer_off_all
 pause 300
 dll_off
 pause 300
 terminate
return
 ' =============
sp_15:
 timer_off 15
 pause 2
 res% = dll_call1("ComGetDataIn",adr(dat%))
 pause 10
 if res%>0
  led_retour%=dat%
  gosub sp_led
 end_if
 aa=1-aa
 if aa=1
  caption 17,1
 else
  caption 17,0
 end_if
 timer_on 15
return
 ' =============
sp_led:

 select led_retour%
  case 87:color 11,0,255,0
  case 119:color 11,160,160,160
  case 88:color 12,0,255,0
  case 120:color 12,160,160,160
  case 89:color 13,0,255,0
  case 121:color 13,160,160,160
  case 90:color 14,0,255,0
  case 122:color 14,160,160,160
 end_select
return
' =============
err:
message "erreur " str$(error_number) " " error_type$ " error_line  " str$( error_line)
 terminate
return

programme Arduino

Code:

String command = "";
void setup(){
    Serial.begin(115200);
    pinMode(3,OUTPUT);
    pinMode(4,OUTPUT);
    pinMode(5,OUTPUT);
    pinMode(6,OUTPUT);
}
void loop()
{
 
      while (Serial.available()>0)
{
    //lecture des commandes envoyées par le port série 0
    command += String(char(Serial.read()));
    // Serial.println(char(Serial.read()));
  delay(1);
}
// lecture du premier caractère
    char letter = command.charAt(0);
//Suppression de ce caractère pour n'avoir que la commande
      command=command.substring(1);

// le premier caractère indique l'appareil destinataire de la commande
  switch(letter)
{
    case 'a' :
          digitalWrite(3,0);
          Serial.print("w");
    break;
    case 'A' :
          digitalWrite(3,1);
          Serial.print("W");
    break;
    case 'b' :
          digitalWrite(4,0);
          Serial.print("x");
    break;
    case 'B' :
          digitalWrite(4,1);
          Serial.print("X");
    break;
    case 'c' :
          digitalWrite(5,0);
          Serial.print("y");
    break;
    case 'C' :
          digitalWrite(5,1);
          Serial.print("Y");
    break;
    case 'd' :
          digitalWrite(6,0);
          Serial.print("z");
    break;
    case 'D' :
          digitalWrite(6,1);
          Serial.print("Z");
    break;
 
  command="";

Bonjour a tous,

Je déterre ce topic ouvert depuis un certain temps pour la carte ARDUINO.

Elle fonctionne parfaitement mais, je n'arrive pas a la faire communiquer avec Panoramic malgré les tests vu ci-dessus.

je ne comprends pas, j'ai une ARDUINO UNO, j'adapte le port en fonction de ma carte.
Je télécharge la partie ARDUINO sur la carte via l'IDE, mais aucun résultat !
Cela dit il n'y a pas de plantage de Panoramic non plus donc il doit juste y avoir un problème sur les valeurs et la manière dont elles sont transmises. enfin je pense...

Auriez vous une idée d'où vient mon erreur. qu'est ce que je fais ou ne fais pas comme il faut ???
J'avoue être un peu perdu.  

D'avance merci pour votre aide.

Bonjour.

@Minibug
Je dois m'absenter ce matin, mais je serai là en début d’après-midi.
Déjà, à la louche, si tu as chargé les prog ci dessus, la partie arduino ne fait RIEN. La fonction loop() est vide, donc...
Je reviens tout à l'heure