Même si cela devient de plus en plus rare aux fils des années, il existe encore des appareils dans le domaine de l’audiovisuel pro qui se pilotent via un port série (RS-232, 422, 485). Cela permet un contrôle très fin et efficace des appareils, et la gestion éventuel des états par les retours des appareils, ce qui permet une automatisation efficace et stable.
La principale problématique va être d’avoir une interface permettant de communiquer physiquement en série avec les appareils concernés. Une solution évidente est d’utiliser un ESP, qui permet de faire beaucoup de choses aisément en terme d’interface avec des appareils. Malheureusement les ESP fonctionnent avec une logique à 3V3 alors que les ports série type RS-232 entre autres communiquent avec une tension variant entre -25V et +25V pour les cas plus extrêmes, ce qui est totalement incompatible avec l’ESP. La connexion directe d’un port RS-232 à des ports GPIO de l’ESP entraînerait immédiatement la destruction de l’ESP ! Il est indispensable recourir à un interfaçage entre l’ESP et le port série avec un circuit intégré type MAX232 de chez Maxim qui s’occupe de « convertir » les niveaux logiques. Une autre solution plus pratique est d’utiliser un circuit tout fait, comme par exemple, le Tuya Adapter (moins de 20€ sur Internet) de Kincony.
 |
 |
Cette carte prévue au départ pour faire de l’interfaçage avec des équipements Tuya va être détournée pour faire au choix du 232 ou du 485 selon la position d’un jumper sur la carte ! Pour l’alimentation de la carte cela se fait facilement via le bornier à vis ou le connecteur d’alimentation. La connexion en RS-232 se fait via la sub-d9 et le 485 via le bornier à vis.
Il nous suffit alors de préparer un sketch ESPHome pour écraser le firmware d’origine du fabricant et rendre cette carte facilement intégrable dans Home-Assistant.
La configuration sera assez simple et je vais vous partager quelques exemples. On va commencer par le pilotage d’un processeur audio Meridian. Le protocole fourni par le fabricant est disponible sur ce lien. La première chose dont on a besoin c’est les paramètres de communication: pour une liaison série il s’agit de la vitesse en bauds, le bit d’arrêt et la parité. Ici il nous est indiqué 9600 bauds, 1 bit d’arrêt et aucune parité. Cela tombe bien, c’est quasiment les réglages par défaut d’ESPHome donc on aura juste besoin de préciser la vitesse à 9600 bauds.
Pour le câblage il suffira de relier les 3 fils suivants: RX, TX et GND(Masse). Selon les appareils, RX et TX devront être croisés ou non entre le Kincony et l’appareil piloté (aucune règle scientifique à ce niveau là !).
Il est nécessaire maintenant de déterminer les « messages » à envoyer pour piloter cet appareil. Le protocole indique qu’il suffit d’envoyer 2 caractères parfois suivi d’un argument et fini par un « Carriage Return ». On mettra donc simplement la chaine de caractères en question dans le uart.write du code ESPHome. Le Carriage Return est un caractère invisible car il correspond au Retour Chariot et donc il s’encode souvent en CR ou ici pour ESPHome avec le caractère d’échappement: \r Il est courant que les commandes soient terminées par un CR ou un LF (Line Feed ou Saut de Ligne) voire les deux. Ici le programmeur par habitude a mis automatiquement les deux.
On obtient donc tout simplement la commande suivante pour commuter le processeur Meridian sur l’entrée TV: TV\r\n
esphome:
name: esp-meridian
platform: ESP32
board: esp32dev
logger:
web_server:
ota:
wifi:
networks:
- ssid: !secret wifi_ssid
password: !secret wifi_passwd
captive_portal:
api:
reboot_timeout: 10min
button:
- platform: template
name: Meridian CD input
on_press:
- uart.write: "TV\r\n"
- delay: 1s
- uart.write: "VN90\r\n"
- delay: 20s
- uart.write: "VN90\r\n"
- platform: template
name: Meridian DV input
on_press:
- uart.write: "DV\r\n"
- platform: template
name: Meridian Stanby
on_press:
- uart.write: "SB\r\n"
switch:
- platform: template
name: Meridian Audio Direct
id: direct
optimistic: true
restore_mode: restore_default_off
internal: false
on_turn_on:
- uart.write: "PN0\r\n"
- switch.turn_off: cinema
- switch.turn_off: music
- switch.turn_off: thx
- platform: template
name: Meridian Audio Cinema
id: cinema
optimistic: true
restore_mode: restore_default_off
internal: false
on_turn_on:
- uart.write: "PN12\r\n"
- switch.turn_off: direct
- switch.turn_off: music
- switch.turn_off: thx
- platform: template
name: Meridian Audio Music
id: music
optimistic: true
restore_mode: restore_default_off
internal: false
on_turn_on:
- uart.write: "PN1\r\n"
- switch.turn_off: cinema
- switch.turn_off: direct
- switch.turn_off: thx
- platform: template
name: Meridian Audio THX
id: thx
optimistic: true
restore_mode: restore_default_off
internal: false
on_turn_on:
- uart.write: "PN13\r\n"
- switch.turn_off: cinema
- switch.turn_off: music
- switch.turn_off: direct
uart:
tx_pin: GPIO17
rx_pin: GPIO16
baud_rate: 9600
Dans ce nouvel exemple, on va piloter une TV Loewe qui présente un port RS sur une RJ-11 (connecteur assez inhabituel pour de la RS-232). Le protocole tel que fourni par le fabricant est disponible sur ce lien. On va donc reprendre la même logique que précédemment.
Pour les paramètres du port série, on est dans la même configuration que le cas précédent.
Pour les commandes à envoyer, on reste également dans un cas assez similaire. Par contre ici, on va contrôler le volume de la TV ce qui implique d’envoyer une valeur de façon dynamique. Via un lambda, on va pouvoir construire dynamiquement la chaine à envoyer à la TV (« data volume XX » où XX sera la valeur du niveau de volume souhaité). Cette valeur sera stockée dans une variable locale dans ESPHome et cela permettra de faire varier cette variable directement depuis HA pour faire varier le volume comme souhaité (typiquement via un bargraph par exemple).
esphome:
name: esp-tv-loewe
platform: ESP32
board: esp32dev
logger:
web_server:
ota:
wifi:
networks:
- ssid: !secret wifi_ssid
password: !secret wifi_passwd
captive_portal:
api:
reboot_timeout: 10min
button:
- platform: template
name: TV HDMI1
on_press:
- uart.write: "prog -6\r\n"
- platform: template
name: TV HDMI2
on_press:
- uart.write: "prog -7 \r\n"
switch:
- platform: template
name: "TV mute"
optimistic: True
turn_on_action:
- uart.write: "data mute 1\r\n"
turn_off_action:
- uart.write: "data mute 0\r\n"
- platform: template
name: "Power tv"
assumed_state: True
optimistic: True
turn_on_action:
- uart.write: "power tv\r\n"
turn_off_action:
- uart.write: "power off\r\n"
number:
- platform: template
name: "TV Volume"
id: test
optimistic: true
min_value: 0
max_value: 95
step: 1
on_value:
- uart.write: !lambda
char buf[128];
sprintf(buf, "data volume %.1f\r\n", id(test).state);
std::string s = buf;
return std::vector( s.begin(), s.end() );
uart:
tx_pin: GPIO17
rx_pin: GPIO16
baud_rate: 9600
Quelques points importants pour un pilotage série fonctionel:
- le câblage RS-232 entre la carte ESP et l’appareil peut nécessiter d’intervertir RX et TX (selon les appareils il faudra un câblage droit ou croisé !). Le cablage se fera la plupart du temps sur une SUB-D9 sur l’appareil à piloter mais cela peut être sur des connecteurs plus exotiques comme une RJ-11 par exemple dans le cas de notre TV Loewe.
- Faire attention à bien configurer la vitesse voire la parité et la longueur des mots (selon les indications du fabricant de l’appareil à piloter).
- disposer du protocole de pilotage fourni par le fabricant (il est impossible de deviner un protocole de pilotage si vous ne l’avez pas car chaque fabricant décide de la syntaxe de pilotage).
Recent Comments