Generation signaux Chacon-RF avec un AVR

De MicElectroLinGenMet.

(Retour Accueil ou Liste des articles)

Sommaire

Description

Suite à l'article Generation signaux X10-RF avec un AVR, voici une variante pour piloter les récepteurs CHACON RF.

Il faut savoir que CHACON a proposé différents appareils utilisant des protocoles RF différents.

  • Des appareils programmable comme en X10 avec des contacteurs HOUSE/UNIT (gamme REF.540xx)
  • D'autres utilisant un système d'auto-apprentissage de code. (gamme REF 545xx, plus de contacteur présent)

Mon programme pour AVR était destiné aux anciens modèles CHACON de la gamme REF.540xx mais il s'avère que les nouveaux modèles de la gamme REF 545xx soient compatibles avec l'ancien codage.
Il permet aussi de piloter une sonnette sans fils de nom Carillon ML-8300 de IDK Multimedia avec une commande "O8-BELL"


Pour les non bidouilleurs en électronique, il existe dans le commerce un émetteur RF 433.92MHz abordable sous forme de clef USB et pouvant commander les appareils Chacon: le TellStick.

Décodage

Je n'ai pas trouvé de documentation concernant le protocole utilisé par les appareils Chacon, mais j'ai pu retrouvé le codage gràce à un programme disponible gratuitement: Protocol Analyzer disponible sur http://wiki.nethome.nu/doku.php/analyzer/start.

C'est un programme Java permettant d'analyser des codages utilisés dans les télécommande IR ou RF. Il suffira de relier un récepteur HF 433.92MHz avec son adaptateur de niveau sur l'entrée micro d'un PC pour pouvoir afficher les trames de codage d'une réception HF.

Interface entre un module récepteur 433.92MHz, genre RF_290_A-5S et l'entrée micro du PC (Source: http://wiki.nethome.nu):

Fichier:Protocol_Analyzer_Interface.png


Graphes obtenus pour une commande M1-ON


Réception de plusieurs trames M1_ON
Détail d'une trame


Le décodage est facilité en inversant l'image

En regardant le graphes inversé, il st possible de déterminer le codage utilisé.
Codage signal RF Chacon:

Entête de ~10ms à '0' entre trame.

|                      +-------+                        +------------------------+       +---
|                      |       |                        |                        |       |
|          10ms        | 370us |         1000us         |           1000us       | 370us |
| ---------------------+       +------------------------+                        +-------+
| |<----- Entete ---- >|<------------- 0 -------------->|<-------------- 1 ------------->|

m1-on	E|0000-0101|0000-0000|0001-0101|1	0x05, 0x00, 0x15
m1-off	E|0000-0101|0000-0000|0001-0100|1	0x05, 0x00, 0x14


Pour une commande M1_ON, il suffira d'envoyer ces 3 octets 0x05, 0x00, 0x15 en respectant le codage des bits ci-dessus.
Ci-dessous la table montrant la correspondances avec les différents codes HOUSE/UNIT déduite par essais successifs:

Protocole X10 Chacon:

  Bits 3210	 0 1  2 3 Code	House	Unit	 
 
00	0000	0000-0000 0x00	A	1
01	0001	0100-0000 0x40	B	2
02	0010	0001-0000 0x10	C	3
03	0011	0101-0000 0x50	D	4
04	0100	0000-0100 0x04	E	5
05	0101	0100-0100 0x44	F	6
06	0110	0001-0100 0x14	G	7
07	0111	0101-0100 0x54	H	8
08	1000	0000-0001 0x01	I	9
09	1001	0100-0001 0x41	J	10
0A	1010	0001-0001 0x11	K	11
0B	1011	0101-0001 0x51	L	12
0C	1100	0000-0101 0x05	M	13
0D	1101	0100-0101 0x45	N	14
0E	1110	0001-0101 0x15	O	15
0F	1111	0101-0101 0x55	P	16
 
Commandes
ON  		0001-0101 0x15
OFF 		0001-0100 0x14
BELL		0101-0101 0x55


Modules testés avec ce montage

  • Module Chacon encastrable 1000W ancienne génération 54094


  • Module Chacon variateur 300W ancienne génération 54093


  • Module Chacon encastrable 1000W nouvelle génération 54555

Ce module à auto-apprentissage fonctionne avec les anciens modules émetteur.


  • Sonnette sans fils Carillon ML-8300 de IDK Multimedia


Shéma de base

Les composants principaux sont l'ATtiny2313, microcontroleur AVR économique de 20 broches et un module émetteur à 433.92MHz, le TX-433-SAW, lui aussi trés abordable.

Ce montage de test ne fera rien d'autre qu'emettre une commande ON suivi d'une OFF toutes les 30s pour vérifier le fonctionnement. La réception peut être vérifié sur un récepteur RFXCOM USB sous Linux avec le programme xpl-rfxcom de la librairie xpl-perl.


Programme de l'AVR

Source C à compiler avec avr-gcc avec ce Makefile.
(Modifier la variable DEVICE en fonction du programmateur utilisé).

Le port série de l'AVR n'est utilisé ici que pour vérifier le fonctionnement du programme.
Une évolution de celui-ci pourrai par exemple permettre de piloter directement l'émission de code RF par le PC.


Source du programme main.c:

/* 13/11/2009 								*/
/* Test avec ATtiny2313 avec quartz externe de 11.0592MHz		*/
/* Test émission trame Chacon						*/
/* Message sur port série pour vérifier bon fonctionnement		*/
/* Connexion au PC et test avec: picocom -b 19200 -d 8 /dev/ttyS1	*/
 
/* Rajout fonction rf_sendcmd(House, Unit, Action)			*/
 
// --------------------------------------------------------------------------------------
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
 
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/io.h>
 
// UL (unsigned long)
#define F_CPU 11059200UL
#include <util/delay.h>
 
#define ON  0x15
#define OFF 0x14
#define BELL 0x55
//#define BRI 0x??
//#define DIM 0x??
 
#define RFPIN PD6	// bit du port sur lequel est connectée la pin x10.
#define NBTRAMES 0x08	// Nbre de trames envoyées à chaque commande.
 
// --------------------------------------------------------------------------------------
// Tableaux en mémoire programme (PROGMEM) à relire avec fonction "pgm_read_byte"
// House/Unit codes: A à P / 1 à 16
const unsigned char houseunit_code[] PROGMEM = { 0x00, 0x40, 0x10, 0x50, 0x04, 0x44, 0x14, 0x54, 0x01, 0x41, 0x11, 0x51, 0x05, 0x45, 0X15, 0x55 } ;
 
 
// -------------------------------------- Fonctions série -------------------------------
void initUART(unsigned char baudrate)
{
	UBRRL = baudrate ;
	UCSRB = (1 << RXEN) | (1 << TXEN) ;
	UCSRC = (1 << UCSZ1) | (1 << UCSZ0) ;	// 8N1
}
 
unsigned char ReceiveByte(void)
{
	while ( ! (UCSRA & (1 << RXC)) ) ;
	return	UDR ;
}
 
static void TransmitByte(unsigned char data)
{
	loop_until_bit_is_set(UCSRA, UDRE) ;
	UDR = data ;
}
 
static void TransmitTxt(const char *s)
{
	char c;
	for ( c = pgm_read_byte(s); c; ++s, c = pgm_read_byte(s) )
	{
		TransmitByte(c) ;
	}
}
 
// -------------------------------------- Fonctions X10 ---------------------------------
// Envoi entête:
static void rf_sendpreamble(void)
{
	PORTD &= ~_BV(RFPIN) ;		// RFPIN à 0.
	_delay_ms(10) ;			// Pendant 10ms
}
 
// --------------------------------------------------------------------------------------
// Envoi bit 0:
static void rf_sendbit_0(void)
{
	PORTD |= _BV(RFPIN) ;		// RFPIN à 1.
	_delay_us(370) ;
	PORTD &= ~_BV(RFPIN) ;		// RFPIN à 0.
	_delay_us(500) ;
	_delay_us(500) ;
}
 
// Envoi bit 1:
static void rf_sendbit_1(void)
{
	PORTD |= _BV(RFPIN) ;		// RFPIN à 1.
	_delay_us(500) ;
	_delay_us(500) ;
	PORTD &= ~_BV(RFPIN) ;		// RFPIN à 0.
	_delay_us(370) ;
}
 
 
// --------------------------------------------------------------------------------------
// Envoi d'un octet Chacon RF
static void rf_sendbyte(unsigned char octet)
{
	unsigned char ptbit, valbit;	
	for (ptbit=0; ptbit<=7; ptbit++)
	{
		valbit=octet & 0x80;
		octet=(octet << 1);
 
		if ( valbit ) rf_sendbit_1() ;
			else rf_sendbit_0() ;
	}
}
 
// --------------------------------------------------------------------------------------
// Envoie trame Chacon X10, House Code / Unit Code / Action (ON/OFF/BELL)
void rf_sendcmd(unsigned char House, unsigned char Unit, unsigned char Action)
{
	unsigned char hc, uc ;
	unsigned char bcle ;
 
	hc = pgm_read_byte( houseunit_code + (House - 0x41) ) ;		// Lit code correspondant dans tableau houseunit_code.
	uc = pgm_read_byte( houseunit_code + (Unit - 0x01) ) ;		// Lit code correspondant dans tableau houseunit_code.
 
	// Envoie commande Chacon X10 hc/uc/action.
	for (bcle = 0; bcle < NBTRAMES; bcle++)			// Envoie la trame NBTRAMES X.
	{
		rf_sendpreamble() ; 
		rf_sendbyte(hc) ;
		rf_sendbyte(uc) ;
		rf_sendbyte(Action) ;
		rf_sendbit_0() ;
	}
}
 
// --------------------------------------------------------------------------------------
// Pause de n secondes
void delay_s(unsigned short sec)
{
	sec*=10 ;
	while(sec > 0)
	{
		_delay_ms(100) ;		// _delay_ms pas précise pour valeur trop grande.
		--sec ;
	}
}
 
 
// --------------------------------------------------------------------------------------
// -------------------------------------- Main ------------------------------------------
int main(void) 
{
	DDRB |= _BV(PB2) ;		// PB2 en sortie.
 
	DDRD |= _BV(RFPIN) ;		// RFPIN en sortie.
	PORTD &= ~_BV(RFPIN) ;		// RFPIN à 0.
 
	initUART(35) ;			// 19200,8N1 avec Qz 11,0592MHz.
	TransmitByte('>') ;
 
	while (1)
	{
		TransmitTxt( PSTR("Test Chacon X10 RF sur ATtiny2313\n") ) ;
 
		PORTB &= ~_BV(PB2) ;	// Led ON sur PB2.
 
		// Envoi commande
		rf_sendcmd('M', 1, ON) ;
 
		delay_s(30) ;
		PORTB |= _BV(PB2) ;	// Led OFF sur PB2.
 
		// Envoi commande
		rf_sendcmd('M', 1, OFF) ;
 
		delay_s(30) ;		
	}
}
// --------------------------------------------------------------------------------------


Réception sous Linux

Vue de la réception avec xpl-rfxcom:

xpl-trig/x10.basic: bnz-rfxcomrx.vesta -> * - on m1
xpl-trig/x10.basic: bnz-rfxcomrx.vesta -> * - off m1


Messages xPL reçus avec xPL_Logger:

09/11/19 18:18:04 xpl-trig {bnz-rfxcomrx.vesta *} x10.basic { command='on' device='m1' }
09/11/19 18:18:34 xpl-trig {bnz-rfxcomrx.vesta *} x10.basic { command='off' device='m1' }


Photos du montage

ATtiny2313 + TX-433