interface 868mhz panSTamp pour Crouzet Millenium 3 wireless

[panMillenium]

Bonjour,
Sur les conseils de Fred j'ouvre un nouveau topic pour le partage et la collaboration autour d'un projet d'interface sans fil pour nos M3.

l'idée de base:
utiliser l'emplacement de l'interface serie-PC pour loger un composant 868mhz qui ouvre des possibilités de communication sans fils entre un automate M3 et d'autres peripheriques sans fils, ou d'autres automates, ainsi qu'un PC avec superviseur, ou pour la programation à distance.

le module/le protocole:
Il y a plusieurs alternatives dispo sur le marché et utilisé dans la comunauté DIY. soit du 2.4ghz (zigbee, blutooth...) soit du 868 ou 433.
- le 2.4ghz ne permet pas de tres longues distances et il faut quand meme envisager de pouvoir communiquer entre le sous sol et le toit ou l'extremité du jardin.
-le 433 fonctionne très bien à travers les murs notament.
-le 868 est la frequence recomandée pour les appareils utilisés en europe.
J'ai choisi le module panSTamp qui est tres compacte et contient un chip atmega328p et un chip texas instrument CC1101 qui prend en charge tout le protocole de transmission entre les appareils sans fil. Le module est 100% compatibe avec l'environement de devlopement Arduino.
L'alternative d'utiliser un RFM12B notament tres populaire dans les "jeenode" etait aussi interressante mais demandais un effort d'integration (HW+SW) baucoup plus important et difficilement à la porté du bricoleur que nous sommes.

une petite image pour attiser la curiosité:


les capteurs déjà existant et le site pour les modules panSTamp:
http://www.panstamp.com/

je tiens a préciser que je n'ai aucun accord commercial ou quelconque avec le fondateur (qui se nomme Daniel) mais que j'apprécie la qualité du produit, des idées, et que ce soit une start up européenne (basé en Espagne).

le circuit d'interface:
le module panSTamp tient dans un format "DIL24" (donc 12 pins de chaque cotées espacées de 2.54mm) et mesure 18x31mm.
il faut le loger dans l'emplacement du M3 qui est de 22x38mm.
donc ca rentre.
coté epaisseur, nous disposons de 9mm, et on fera avec :)

Une vue technique coté composant du circuit (double face épaisseur 1mm, couleur noir et pastille dorées), avec un connecteur 6 points à droite pour la liaison avec l'automate, et un connecteur 16 points a gauche (+6 en dessous optionel) pour l’interfaçage avec le monde extérieur si nécessaire, et la programmation du module.


et coté composants:


il faudra prévoir le soudage manuel de 5 résistances CMS (0805) et une capa (0805) ainsi qu'une led (1206) et un régulateur 3V3 (SOT23).
Les pattes du panSTamp et des 2 connecteurs devront etre racourcies un petit peu pour garantir le bon positionnement dans le logement M3 ....

un fil d'antenne d'environ 8cm doit etre soudé directement sur le module panSTamp.

je viens de lancer 20 circuits en fabrication (printed.cz) donc le projet est tout chaud, ou plutot juste enfourné.
le produit créé autour du circuit, du panstamp avec antenne et des connecteurs s'apelle PanMillenium (pan=personnal area network)

coté soft
il s'agit de développer une application Arduino qui permettra de positionner le M3 comme un "noeud SWAP" sur le reseau, il sera donc compatible avec les autres capteurs panSTamp et pourra communiquer des infos ou recevoir des ordres.
le module communiquera en modbus ascii avec le M3 et utilisera les fonction SLin et SLout qui permettent d'echanger jusqu'à 48 mots de 16bits (maxi) avec l'application FBD.
l'application sera paramétrable (variables en debut de code) et permetra de configurer l'adresse de l'automate sur le reseau, les mots SLin et SLout utilisés et comment ils seront transmis/recu sur le reseau, sous forme de "registres SWAP".
une fois compilée, l’application doit etre téléchargée dans le module grâce à un adaptateur USB/Serie standard FDTI232 (en +5Volts) qui est pluggé sur le connecteur avant (le panMillenium doit etre déconnecté de l'automate)



coté PC
il est prevu aussi de pouvoir communiquer avec le module grace à un autre module panSTamp.
On pourra soit utiliser un deuxieme circuit panMillenium avec un FDTI232 ou tout simplement acheter un PanStick+PanStamp sur le site de Daniel.
dans ce deuxieme cas, le panStick pourra etre utilisé pour la programmation du panMillenium en pluggant une des rangées du connecteur 16 points.

l'application coté PC sera une sorte de "modem" avec un jeu de commande type "AT", permettant d'echanger des infos avec les panSTamp et notament le panMillenium.
en plus, l'application devrait reconaitre les trames type modbus ascii commencant par ":" et terminée par CRLF, et elles seront redirigées vers le panMillenium (dans les deux sens bien sur :) ), ce quidevrait permetre dutiliser cette solution comme un moyen de comunication sans fils entre le PC et le millenium !
il faudra juste faire des essais pour verifier que le taux d'erreur sur la transmission reception des paquest est compatible avec la suite de programmation M3 / AC7 .... croisons les doigts, a defaut il faudra rendre le protocole d'echange un peux plus compliqué, avec des accusés de reception intermediare, ou des demande de repetition.

voila pour ce premier post. Je voudrais vous encourager à creuser l’environnement panStamp, et surtout à partager vos idées ou contributions sur ce fil, pour que ce projet soit utile au plus grand nombre. de plus tout est opensource, meme si vous avez des projets commerciaux.
Je pourrai fournir quelques circuits vierges pour les membres du forum (10€ fdpin) qui voudraient participer activement au développement.

a+

[cyril.64]

Perso je te crois sur parole!!!

[panMillenium]

hello,
ca accélère un peu, 20 circuits en provenance de printed.cz recu en une semaine. cool.
Encore quelques composants passifs a attendre et on va pouvoir passer aux chose serieuses :)

[moriss]

un peu comme cyril, très compliqué mais tellement interressant

si je pige bien, on pourra ajouter tout type de composant sans fil, voila qui est fort interressant

reste à voir la complexité de programmation de ces nouveaux modules

[panMillenium]

oui, c'est ca : une fois le module en place dans l'automate, il pourra envoyer ces infos (registre SLout) vers d'autres modules similaires, ou il pourra recevoir des infos "brodcastées" par d'autres modules et les donner a l'automate via les registres SLin.

Une application de base ecrite sous forme d'un sketch arduino pourra etre telechargée dans le module, pour permettre ce type de communication.
quelques variables en entete de l'application devraient permettre de parametrer la communication avec les autres capteurs sans avoir a modifier l'application. en tout cas au minimum..

N'importe quel capteur contenant le chip CC1101 de texas instrument , et utilisant (plus ou moins) le protocole SWAP des modules panSTamp devrait etre compatible. il y a deja quelques modules panSTamp assez sympa pour pas cher. Ca devrait aussi etre compatible avec le rfbee vendu sur seedstudio.

[panMillenium]

ca avance, tranquilement :)
2 premiers PCB soudés. pas facile les CMS. comptez 30' par carte.
1 avec juste les composants passifs, cela permet de programer le Millenium sans le cable crouzet.
1 avec son panSTamp raccourci.


et ca tient pile poil dans l'emplacement, il y a juste l'antenne et le connecteur (optionel) qui depasse!


une petite photo pour monter le raccordement du PanMillenium sur le panStick, pour la programation du sketch arduino.
possibilité aussi d'utiliser un FTDI232.


il reste a faire un peu de soft.
ah au fait, la bonne nouvelle du jour c'est que le panMillenium est technicquement compatible avec les modules RFM12B en mode FSK,
ce qui veux dire que nous pourrons interfacer le Millenium avec les "jeenode". ce n'est qu'une question de soft (...)

si quelqu'un veux se lancer, m'envoyer un MP, je dispose de quelques panstamp et de tout ce qu'il faut pour monter une quinzaine de panMillenium.
j'ai aussi quelques FTDI232, l'ensemble permetant de remplacer le cable USB/serie Crouzet

voila voila

[Samounet]

Bonsoir,

Tous ces Panpan, ça fait pas un peu Bambi, non ?

[panMillenium]

ou PeterPan :)

[Samounet]

Bonjour,

Ou sinon, moi ça m'intéresse toujours, d'une part pour remplacer le câble, mais surtout pour permettre de faire communiquer les deux M3 que j'ai actuellement.

A+++

[panMillenium]

Salut

un petit update avant le week end de Pacques :)

ca yest enfin, j'ai implementé une couche de lecture ecriture modbus maitre ascii pour le panStamp (donc en arduino).

aucun probleme pour lire et ecrire les SLin et SLout soit 48 mots.

il me reste a faire une "recopie" reguliere vers les regsitres "panSTamp" et la c'est la magie, ca part sur le reseau 868mhz tout seul ... :)

bon, il y a encore du taf pour rendre les choses super simples, mais le principe est dejà clair sur papier, et la ca avance correctement.

dici 8 jours (j'ai aussi un vrai boulot et une famille) on devrait avoir une solution "clé en main" pour échanger des registres panSTamp automatiquement entre automates, et entres capteurs et automates, SANS programation juste un parametrage de table. je vais detailler le principe sur le site/forum panSTamp.

ah, j'ai aussi fait un compresseur de trames pour faciliter les echanges entre un PC et l'automate en 868 . ca avance vraiment pas mal.

coté devoir de vacances, je ne peux que vous encourager a lire le wiki sur le protocole panstamp et notament les concept de "mote" et "enpoints" et "registre" avec leur XML associés
a+

[Samounet]

'suis impatient...

[moriss]

[quote="panMillenium"]Salut


ca yest enfin, j'ai implementé une couche de lecture ecriture modbus maitre ascii pour le panStamp (donc en arduino).
[/quote]

salut
pourrais tu partager la partie modbus maitre pour arduino ?
je souhaite aussi utiliser ce protocole

merci

[panMillenium]

oui bien sur,
voila un extract de la class modbusMaster et un exemple d'utilisation.
c'est assez primaire comme code pour l'instant mais c'est deja exploitable tel quel.

j'ai utilisé la librairie SCOOP pour permettre un multitache ulterieurement et pour definir un timer. mais il est tres simple de remplacer le timer par un "x - millis()".

Code : Tout sélectionner

#include <SCoop>
/*
#include <IOFilter>
Output led(LED_BUILTIN);
*/

HardwareSerial Uart = HardwareSerial();
// light implementation, compatible RTU ASCII for further dev
#define mbport Uart	// choose Serial for Arduino and Uart for Teensy
#include "util/crc16.h"
class modbusMaster  
{ public: 
  enum  rtu_ascii { ASCII=0, RTU=1  };
  rtu_ascii mode;
  
  modbusMaster(rtu_ascii m) : mode(m) { } ;
  
  uint8_t   slave;
  uint8_t   command;
  uint16_t  address;
  uint8_t   Nmax; 
  uint16_t  crc;
  uint8_t   lastCh;
  uint8_t   lastByte;
  uint16_t  lastWord;
  uint8_t   buff[48]; // temporary buffer for receiving/sending to PLC
  uint16_t * ptr;     // source/dest of data
  
  void initCrc() {
    if (mode == ASCII) crc = 0; else crc = ~0; 
  }

  void addCrc(uint8_t c) {
    if (mode == ASCII) crc += c; 
	else crc = _crc16_update(crc, c); 
  }

  
//////////////////////////////////////////////////  

  void write(uint8_t c) { mbport.write(c); }

  void writeHEX8(uint8_t val) {
     uint8_t x;
	 x = val >> 4; if (x>=10) x = x - 10 +'A'; else x = x + '0';
	 write(x); 
	 x = val & 0x0F; if (x>=10) x = x - 10 +'A'; else x = x + '0';
	 write(x); 
  }
  
  void writeByte(uint8_t val) {
    if (mode == ASCII)  {
	  writeHEX8(val); 
	} else { write(val);  }
	addCrc(val);
	yield(); // if output buffer is too small...we dont want to block
  }
  
  void writeWord(uint16_t val) {
    writeByte(val >> 8); writeByte(val); 
  }
  
  void writeCrc() {
    if (mode == ASCII) {
	  writeByte((~crc+1)&0xFF); write(0x0D); write(0x0A); 
	} else { writeByte(crc & 0xFF); writeByte(crc >> 8); }
  }
  
  void startFrame() {
    if (mode == ASCII) write(':'); 
  }
  
  void writeHeader(uint8_t s, uint8_t c, uint16_t ad, uint8_t n) {
	uint8_t ch;
	while (mbport.available()) ch= mbport.read(); // flush receive buffer
	initCrc(); startFrame();
	writeByte(slave = s); 
	writeByte(command = c);
	writeWord(0); writeWord(address = (ad-1));
	writeByte(Nmax = (n*2)); 	
  }
  
  void writeRegisters(uint8_t s, uint16_t ad, uint8_t n, uint16_t * p) {
	writeHeader(s,16,0xFF00+ad,n);
	for (uint8_t i = 0; i<n>0) {
	   if (mbport.available()) {
	      lastCh = mbport.read(); 
	      if (mode == ASCII) lastCh &= 0x7F;
	      return 1; }
	   yield(); }
	return 0;
  }	
	
  uint8_t waitStart() {
  timeout = 200;
  retry:
    if (!waitAvailable()) return 0; // nothing available
	if (mode == ASCII) {
	   if (lastCh != ':') goto retry; }    
	initCrc(); 
	return 1;	   
	}
			
  uint8_t waitByte() {
    timeout=50; // timeout inter - characters
	if (!waitAvailable()) return 0; 
	if (mode == ASCII) {
	   if (lastCh==':') return 0;
	   if (lastCh==0x0A) return 0; // end of line should not happen here
	   if (lastCh >= 'A') lastCh = lastCh-'A'+10; else lastCh = lastCh -'0';
	   lastByte = lastCh <<4>= 'A') lastCh = lastCh-'A'+10; else lastCh = lastCh -'0';
	   lastByte |= lastCh;
	} else {
       lastByte=lastCh; }
	return 1;
  }
	
  uint8_t waitWord() {
	if (!waitByte()) return 0;
	lastWord = (lastByte <<8);
	if (!waitByte()) return 0;
	lastWord |= lastByte;
	return 1;
  }
	
  uint8_t waitAnswer() { // wait a complete answer during 200ms
  start:  
	if (!waitStart()) goto stop; 
	if (mode == ASCII) { 
	   if (!waitByte()) goto stop; }
	else lastByte = lastCh;
	addCrc(slave = lastByte);
	if (!waitByte())  goto stop; addCrc(command = lastByte);
	switch (command) {
	  case 3: // read registers
    	if (!waitByte())  goto stop; addCrc(Nmax = lastByte);
	    for (uint8_t i=0; i<Nmax; i++) {
	       if (!waitByte()) goto stop;
	       if (i<sizeof>>8); addCrc(lastWord);
    	if (!waitWord())  goto stop; address = lastWord; addCrc(lastWord >>8); addCrc(lastWord); 
    	if (!waitByte())  goto stop; addCrc(Nmax = lastByte);
		break;
	 }
	if (mode == ASCII) {
	   if (!waitByte()) goto stop; // check sum
	   uint8_t sum = lastByte; 	   
	   if (!waitAvailable()) goto stop; // CR
	   if (!waitAvailable()) goto stop;	// LF
	   if (lastCh != 0x0A)   goto stop;
	   crc = (~crc+1)&0xFF;
	   if (crc != sum) goto stop;
	 } else {
	   if (!waitByte()) return 0; addCrc(lastByte); 
	   if (!waitByte()) return 0; addCrc(lastByte); 
	   if (crc != 0) return 0;
	 }
	 return 1; // buff contains result
	stop:
	  if (mode == ASCII) {
	    if (lastCh==':') goto start; }
      return 0;
	}
};

modbusMaster MB(modbusMaster::ASCII);

// BEGINING OF THE TASK (class) in charge of PLC pooling and update
defineTaskBegin_Size(PLC,200)

uint16_t tab[48]; // user storage area for modbus frames

void setup() {  // caled automatically by the Scheduler.start()
  mbport.begin(115200); 
  UCSR1C = (UCSR1C & 1) | B00100100; // 7bit Even parity 1 stop Assync
  
  }


uint16_t sorties;
  
void loop() { 

MB.readRegisters(4,25,8,tab);
if (MB.waitAnswer()) { // treat received data here
  // treat received data here, by extracting MB.buff[]
  Serial.println("<good>");
} else { Serial.println("<bad>");} // just treat problems here

MB.writeRegisters(4,1,1,&sorties); sorties ^= 0x03;
if (MB.waitAnswer()) {
  // everything ok here
} else { Serial.println("<bad>");}
sleep(500);
 }

defineTaskEnd(PLC) // END OF THE TASK RELATED TO PLC

void setup() {  // Standard Arduino Setup()
Serial.begin(115200); // usb port on Teensy+2
Scheduler.start();
pinMode(LED_BUILTIN, OUTPUT);
//serialOut.begin(4,&PORTD, B00010000, F_CPU/64/4800); // D4 sur teensy+2
}

void loop() { // user code to do something here :)

Scheduler.sleep(500);
digitalWrite(LED_BUILTIN, HIGH);
Scheduler.sleep(500);
digitalWrite(LED_BUILTIN, LOW);
}

ci joint aussi le fichier qui peut directement etre compilé et utilisé avec une carte Teensy2 ou +2, ou probablement arduino leonardo.
j'ai utilisé cette carte pour devlopper car c'est tres pratique d'avoir le port USB pour monitorer ce qu'il se passe.

voila

[panMillenium]

fichier a renomer en .ino.
je p'appercois que la balise "code" dans le post precedent change certaines lignes de codes ! quelque ++ ont disparus :)

[Samounet]

c'est sympa, merci.