Politique

Eric Videlier
Eric Videlier, EA

En savoir plus......

Eric Videlier (Echallens Autrement)

Journaux de campagne

2020, une prise de conscience

Cette année a été propice aux réflexions sur ce qu'était ma vie dans le monde d'avant la pandémie, à tous les changements qu'il a fallu faire pour s'adapter à la crise sanitaire dans de nombreux domaines (personnel, associatif et professionnel), et à faire le point sur quelles seraient mes priorités dans le monde d'après la pandémie, qui voyait déjà se profiler une suite de crises financières, économiques, sociales, climatiques... et même d'autres crises sanitaires.

Crise... un mot qui peut être angoissant, car synonyme de bouleversements, de changements drastiques, mais aussi d'insécurité vis-à-vis de nos revenus et de notre avenir. Mais toute crise est avant tout à voir comme une opportunité de changer.

Echallens, depuis des années, a commencé à perdre son âme, les différentes autorités appliquant comme tout le monde les bonnes vieilles recettes qui ne visaient qu'à une croissance sans fin: fermes remplacées par des habitats collectifs; mobilité relativement modérée virant à une sur-mobilité frénétique et revendiquée comme un droit divin; chemin de fer n'offrant plus qu'un service minimum réduit à déplacer des masses de pendulaires; sans oublier les terres agricoles sacrifiées sur l'autel d'une urbanisation subie. Enfin, le constat que les autorités successives non seulement mettaient la population devant le fait accompli sur de gros projets destinés à changer radicalement la commune, mais qu'en plus d'être sourdes aux inquiétudes des citoyens impactés, elles décrédibilisaient ceux qui avaient l'outrecuidance de penser différemment. Les oppositions croissantes et le référendum concernant le site du futur gymnase en ont été le révélateur: L'Entente ne voulait pas entendre les citoyens...

La volonté de reprendre mon avenir citoyen en mains m'a décidé à m'engager plus en avant dans la vie de ma commune: Echallens. Raison pour laquelle j'ai décidé de me présenter aux élections pour le Conseil communal en 2021.

Des convictions

Tout d'abord, je crois que nous devons évoluer et en venir à une vraie démocratie directe. Aux niveaux cantonal, fédéral et européen, les jeux de pouvoirs et les lobbies sont puissants et refusent fortement tout changement qui les affaibliraient; c'est au niveau communal qu'il faut agir, partant du principe qu'il est plus facile de faire changer le cap à une barque qu'à un paquebot.

Nous avons besoin d'une démocratie directe et donc participative. Dans nos structures légales actuelles, nous sommes contraints à une démocratie représentative: le citoyen n'est libre que le jour du vote ou de l'élection, signant quasiment un chèque en blanc à ses représentants; or, je considère qu'un élu se voit déléguer un pouvoir qui ne cesse d'appartenir en dernière instance à l'ensemble des citoyens.

La priorité doit être d'atteindre ou d'approcher une résilience aussi forte que possible: approvisionnement en eau potable, productions vivrières, productions matérielles nécessaires à l'économie locale, environnement naturel protégé et réhabilité... Cela passe par le soutien communal aux fermes en production BIO et aux producteurs pratiquant la permaculture, par la réhabilitation de cours d'eau naturels et de haies, la protection des sources contre toute pollution, la favorisation des PME et commerces locaux par rapport aux grandes entreprises et grands distributeurs, la facilitation des déplacements piétonniers et cyclistes en réduisant les surfaces allouées au transport motorisé individuel et aux camions et en organisant les transports publics. Ici aussi, la liste est longue, et elle fera l'objet dans les semaines à venir d'une liste détaillée des problèmes que j'ai déjà relevé et des solutions que j'envisage pour y remédier.

Les changements sont nécessaires et même indispensables. Par contre, je ne pense pas qu'on puisse le faire dans des structures partisanes telles que nous les connaissons aujourd'hui. Les partis ont pour habitude de diffuser leurs mots d'ordre et s'organisent autour de doctrines généralement impossibles à changer tant elles les caractérisent, et à leur tête les responsables ont opté pour une carrière politique. Or, je considère que dans une démocratie, le choix permanent et final doit appartenir aux citoyens et non aux appareils partisans qui sont influençables par la puissance des lobbies. Je préfère de loin un mouvement citoyen à l'échelle communale et ne devoir rendre des comptes qu'aux citoyens.

Une candidature

Tout ce qui précède, conjugué au fait que 2021 voit s'ouvrir une nouvelle législature qui se doit d'être celle des grands changements, m'ont convaincu qu'il était plus que temps que je consacre une part croissante de mon temps à cela. Je le dois pour mon propre avenir, mais aussi pour celui de l'ensemble des citoyens composant notre commune et, au-delà, de notre district et région du Gros-de-Vaud; je le dois surtout pour les générations montantes à qui nous nous devons de laisser un environnement qui leur permette non seulement un avenir mais aussi d'avoir eux-mêmes des moyens pour aller plus loin vers un monde si possible meilleur.

Restait à déposer ma candidature dans une structure qui correspond à ma vision de la politique communale. Cela exclut tout groupe politique affilié à un parti, quel que soit son bord, considérant ces entités comme ayant toutes plus ou moins participé à ce qui nous a mené à la situation actuelle, soit par leurs décisions, soit par leurs absences de décisions. En clair: pour régler les problèmes actuels et à venir, ne pas s'appuyer sur ceux qui nous ont mené dans ces problèmes! Exit donc le SVI (Socialistes, Verts et Indépendants) et le parti UDC-PAI (Paysans, Artisans et Indépendants)...

L'Entente communale? Assurément pas. Les votations sur le futur gymnase d'Echallens ont révélé la volonté affichée de poursuivre sur la voie de l'augmentation de la population pour passer au statut rêvé de ville, comme s'il s'agissait d'un Graal à forcément atteindre... Incompatible avec le but d'atteindre la résilience au niveau de notre commune. Une politique de la mobilité ne desservant que les intérêts de la métropole lausannoise et les rêves de grandeur du canton, au détriment des besoins des habitants et de l'économie du Gros-de-Vaud, tout en appliquant des mesurettes pour ne pas égratigner le droit quasi divin accordé aux adeptes du transport motorisé individuel et aux sociétés de camionnage...

Restaient donc d'autres groupes, portés sur les fonds baptismaux par quelques citoyens engagés, et dont j'ai étudié les projets et idées pour y trouver celui qui correspondait le mieux à l'image de mon engagement. Au final, c'est auprès des membres de Echallens Autrement que j'ai trouvé ce qui me convenait: des personnes provenant d'horizons divers à tous points de vue, y compris politiquement; des gens animés par une culture du dialogue et des débats, et considérant que le bien-vivre de l'ensemble des citoyens est prioritaire par rapports aux volontés de croissances dites maîtrisées prônées par certains milieux économiques et les pouvoirs politiques cantonaux et fédéraux. Un mouvement politique, et non un parti politique; nuance importante...

Une nouvelle étape

Le dimanche 7 mars 2021, le mouvement Echallens Autrement se voit offrir par le vote des citoyens challensois 9 places au Conseil communal. Une nouvelle étape pleine d'espoirs peut commencer. De nombreux défis nous attendent durant les 5 prochaines années, pour assumer les décisions prises par les législatures précédentes et, surtout, tenter de réorienter les choix de la commune vers un avenir durable et aussi agréable que possible... autrement!

District & Région du Gros-de-Vaud

L'année 2020 a vu la société de consommation néo-capitaliste et néo-libérale s'arrêter brutalement. La crise sanitaire et le confinement qui en a été la conséquence m'a permis de prendre le temps de reprendre intégralement le présent site.

Dans cette section District & Région du Gros-de-Vaud, mon but est de faire connaître ce qui fait de ma région un endroit encore agréable à vivre malgré la pression croissante de la métropole lausannoise et celle non moins croissante des autorités vaudoises, et du Grand Conseil en particulier (mais ceci est une autre histoire...).

Ainsi seront traités ici l'histoire de la région, les voies de communication qui l'ont structurée, les producteurs qui ont fait la richesse du tissu économique local dans toute sa variété, les endroits à découvrir par celles et ceux qui voudraient venir visiter le Gros-de-Vaud, les bonnes tables, les sites et le patrimoine particulier de la région, les associations qui enrichissent la vie locale, etc.

Le fil conducteur à tout cela? Ne seront publiés ici que ce qui permet en priorité à la commune d'Echallens et à la région du Gros-de-Vaud d'avoir un avenir durable et ce qui favorise la résilience de ce petit coin de notre fragile planète...

Installation fixe - Passage à niveau (PN)

Code en développement pour une installation fixe, le PN (Passage à Niveau).

Article en cours de développement !

Commande par un seul bouton sur la platine de développement (commande "fermer", puis commande "ouvrir").

Le programme est conçu pour simuler un système multi-tâches, bien que le microcontrôleur Arduino ne gère pas le multi-tâches. Voici le code actuel:

#include <Servo.h>

/******************
* Class InstFixe : Installation fixe > PN (passage à niveau)
******************
*/
class InstFixe {
// Variables de la classe
int instID; // numéro ID de l'installation fixe
int instEtat; // état de l'installation fixe
/* 0 - PN ouvert, en attente
* 1 - PN activé, feux routiers activés (feux + sonnerie)
* 2 - PN activé, débuter descente des barrières (feux + sonnerie)
* 3 - PN activé, descente des barrières (feux + sonnerie)
* 4 - PN protégé, barrières fermées (feux)
* 5 - PN désactivé, remontée des barrières (feux)
* 6 - PN désactivé, barrières ouvertes > info au pupitre
*/
int instAvertir; // durée avertissement avant activation barrières
unsigned long instTempo; // temporisation max de l'installation
unsigned long instHorlogeAct; // horloge au moment de l'activation
// Constructeur
public:
InstFixe (int id, int avertissement, unsigned long int tempo) {
instID = id; // ID unique pour communiquer
instEtat = 0; // par défaut, PN en attente
instTempo = tempo; // temporisation de l'installation
instAvertir = avertissement;
instHorlogeAct = 0; // initialisation
}

// Fonction EtatActuel
int instEtatActuel() {
if ((instEtat == 1) && ((instHorlogeAct + instAvertir) <= millis())) {
// si PN activé et délai avertissement expiré
Serial.println("Fin avertissement > descente des barrières");
++instEtat; // passage à la phase suivante
} else if (instEtat == 7) {
// si le PN a été désactivé et les barrières relevées
instEtat = 0; // retour à l'état d'attente
Serial.println("PN en attente d'activation");
}
return(instEtat);
}

// Fonction Activation
void Activation() { // activation du PN
instHorlogeAct = millis(); // enregistre le moment de l'activation
}

// Fonction EtatSuivant
void EtatSuivant() { // changement d'état de l'installation
instEtat = ++instEtat; // incrémente l'état de 1'installation
}
};




/******************
* Class BtnCmde : Bouton de commande
******************
*/
class BtnCmde {
// Variables de la classe
int btnPin; // pin du bouton
int btnState; // état du bouton
// Constructeur
public:
BtnCmde (int pin) {
btnPin = pin; // pin du bouton créé
pinMode(btnPin, INPUT); // bouton en mode entrée
btnState = LOW; // bouton en mode non pressé
}

// Fonction de lecture: Etat
int Etat() { // état retourné comme entier
int btnEtat = digitalRead(btnPin); // lecture du bouton
delay(10); // délai de 10ms
return(btnEtat); // retourne l'état du bouton
}
};




/******************
* Class SignalLC (Lampe de Contrôle pour le train)
******************
*/
class SignalLC {
// Variables de la classe
int lcFreq; // fréquence clignotement LC
int lcLed; // pin de commande LC
int lcEtat; // état de la lampe LC
unsigned long horlogeAvant; // dernière mise à jour des feux
// Constructeur
public:
SignalLC (int pin, int freq) {
lcLed = pin; // Lecture du PIN de la LC
lcFreq = freq; // Lecture de la fréquence de clignotement
pinMode(lcLed, OUTPUT); // LED en mode sortie
lcEtat = LOW; // Le feu est éteint à son initialisation
horlogeAvant = 0; // valeur à l'initialisation
}

// Fonction de clignotement
void Clignoter() {
// relever l'horloge actuelle
unsigned long horlogeActuelle = millis();
if ((horlogeActuelle - horlogeAvant) >= lcFreq) {
// inverser l'état de la lampe LC
lcEtat = !lcEtat;
horlogeAvant = horlogeActuelle; // enregistrer la nouvelle base temps
// envoi de la commande aux feux
digitalWrite(lcLed, lcEtat);
}
}

// Fonction de désactivation de la LC
void Eteindre() {
lcEtat = LOW;
digitalWrite(lcLed, lcEtat);
}
};




/******************
* Class FeuRoutier
******************
*/
class FeuRoutier {
// Variables de la classe
int feuFreq; // fréquence d'alternance des 2 feux
int feuLedA; // 1er feu alterné
int feuLedB; // 2e feu alterné
int feuEtatA; // état du feu A
int feuEtatB; // état du feu B
unsigned long horlogeAvant; // dernière mise à jour des feux
// Constructeur
public:
FeuRoutier (int ledA, int ledB, int freq) {
feuLedA = ledA; // Lecture des pins à utiliser
feuLedB = ledB;
feuFreq = freq; // Lecture de la fréquence d'alternance
pinMode(feuLedA, OUTPUT); // LEDs en mode sortie
pinMode(feuLedB, OUTPUT);
feuEtatA = LOW; // Le feu est éteint à son initialisation
feuEtatB = LOW;
horlogeAvant = 0; // valeur à l'initialisation
}

// Fonction de clignotement
void Clignoter() {
// relever l'horloge actuelle
unsigned long horlogeActuelle = millis();
if ((feuEtatA == HIGH) && (horlogeActuelle - horlogeAvant >= feuFreq)) {
// si le feu A est allumé et la fréquence de clignotement est atteinte
feuEtatA = LOW; // extinction du feu A
feuEtatB = HIGH; // allumage du feu B
horlogeAvant = horlogeActuelle; // enregistrer la nouvelle base temps
// envoi de la commande aux feux
digitalWrite(feuLedA, feuEtatA);
digitalWrite(feuLedB, feuEtatB);
}
else if ((feuEtatA == LOW) && (horlogeActuelle - horlogeAvant >= feuFreq)) {
// si le feu A est éteint et la fréquence de clignotement est atteinte
feuEtatA = HIGH; // allumage du feu A
feuEtatB = LOW; // extinction du feu B
horlogeAvant = horlogeActuelle; // enregistrer la nouvelle base temps
// envoi de la commande aux feux
digitalWrite(feuLedA, feuEtatA);
digitalWrite(feuLedB, feuEtatB);
}
}

// Fonction d'extinction du feu routier
void Eteindre() {
feuEtatA = LOW; // extinction du feu A
feuEtatB = LOW; // extinction du feu B
digitalWrite(feuLedA, feuEtatA);
digitalWrite(feuLedB, feuEtatB);
}
};




/******************
* Class Barriere
*******************
*/
class Barriere {
Servo servo; // le servo commandant les barrières
int servoPin; // pin de connexion du servo
int servoPosition; // position actuelle du servo
int servoIntervalle; // intervalle entre les déplacements
int servoIncrement; // pas lors de chaque intervalle
int servoStop; // 0-Non, 1-Oui (informe le process appelant
unsigned long servoDernierIncrement; // dernier changement de position
// Constructeur
public:
Barriere (int pin, int intervalle, int increment) {
// lecture des paramètres fournis
servoPin = pin;
servoIntervalle = intervalle;
servoIncrement = increment;
// initialisation autres variables
servoPosition = 0;
servoStop = 0;
}

// Fonction de liaison pin > servo
void Lier() {
servo.attach(servoPin);
}

// Fonction de libération de la liaison pin > servo
void Liberer() {
servo.detach();
}

// Fonction de mouvement des barrières
int Baisser() {
if ((millis() - servoDernierIncrement) > servoIntervalle) {
// si c'est le moment de bouger les barrières
servoDernierIncrement = millis(); // relever l'horloge
servoPosition += servoIncrement; // calcule le mouvement
servo.write(servoPosition); // mouvement du servo
Serial.print("Position servo (baisser) = ");
Serial.println(servoPosition);
if ((servoPosition >=90) || (servoPosition <= 0)) {
// si les barrières sont entièrement baissées
servoStop = 1; // annoncer barrières fermées
}
else {
servoStop = 0; // annoncer barrières en cours de fermeture
}
return(servoStop); // informe le processus appelant
}
}

// Fonction de relevage des barrières
int Relever() {
if ((millis() - servoDernierIncrement) > servoIntervalle) {
// si c'est le moment de bouger les barrières
servoDernierIncrement = millis(); // relever l'horloge
servoPosition -= servoIncrement; // calcule le mouvement
servo.write(servoPosition); // mouvement du servo
Serial.print("Position servo (relever) = ");
Serial.println(servoPosition);
if ((servoPosition >=90) || (servoPosition <= 0)) {
// si les barrières sont entièrement baissées
servoStop = 1; // annoncer barrières ouvertes
}
else {
servoStop = 0; // annoncer barrières en cours de fermeture
}
return(servoStop); // informe le processus appelant
}
}
};




/******************
* Initialisation du programme
******************
*/
// Création objet Installation fixe (ID, avertissement)
InstFixe pn(100,15000,60000); // PN 100, avertir 15 sec., tempo 1 min. TEST
// InstFixe pn(100,15000,300000); // PN 100, avertir 15 sec., tempo 5 min.
// Pin 2 - Objet bouton de commande du pupitre
BtnCmde btnPupitre(2);
// Pin 4 - Objet moteur des barrières (servo)
Barriere barrieres(4,100,1); // barrières sur pin 4, intervalle 100 ms, increment 1
// Pin 5 - Objet signal LC
SignalLC lampeControle(5,700); // LC sur pin 5, clignote à 0,7 sec.
// Pins 7 et 8 - Objet feu routier
FeuRoutier feuRoutier (7,8,500); // pins 7 et 8, alternés à 0,5 sec.

// Variables utiles au programme général (loop)
int mvtBarriere;



/******************
* Setup du programme
******************
*/
void setup() {
Serial.begin(9600); // Ouverture du port série
Serial.println("PN en attente d'activation");
mvtBarriere = 0;
}




/******************
* Boucle principale
******************
*/
void loop() {
// lecture des pins d'activation (ici, bouton)
int etatBouton = btnPupitre.Etat();

if ((etatBouton > 0) && (pn.instEtatActuel() == 0)) {
// Activation du PN
Serial.println("PN activé");
pn.Activation();
pn.EtatSuivant();
// >>> ICI, ajouter message au pupitre (PN activé)
}
else if ((etatBouton > 0) && (pn.instEtatActuel() == 4)) {
// Demande de désactivation du PN
Serial.println("Demande de désactivation > relevage barrières");
lampeControle.Eteindre();
barrieres.Lier(); // activer le moteur des barrières
Serial.println("Servo barrières lié");
pn.EtatSuivant(); // passer à la séquence 5, relevage barrières
}

switch (pn.instEtatActuel()) { // selon la phase en cours de l'installation fixe
case 1: // PN activé, feux routiers clignotent pour avertissement
feuRoutier.Clignoter();
break;
case 2: // PN activé, initier la descente des barrières
feuRoutier.Clignoter();
barrieres.Lier(); // activer le moteur des barrières
Serial.println("Servo barrières lié");
pn.EtatSuivant();
break;
case 3: // PN activé, descente des barrières
feuRoutier.Clignoter();
mvtBarriere = barrieres.Baisser();
if (mvtBarriere == 1) {
// en cas de barrières fermées
barrieres.Liberer(); // libérer le servo
Serial.println("Servo barrières libéré");
Serial.println("Barrières PN fermées");
pn.EtatSuivant();
// >>> ICI, ajouter message au pupitre (PN protégé)
mvtBarriere = 0; // réinitialiser à barrières immobiles
}
break;
case 4: // PN protégé, barrières fermées
lampeControle.Clignoter();
feuRoutier.Clignoter();
break;
case 5: // PN désactivé, remontée des barrières
feuRoutier.Clignoter();
mvtBarriere = barrieres.Relever();
if (mvtBarriere == 1) {
// sitôt les barrières relevées
Serial.println("Barrières PN ouvertes");
pn.EtatSuivant();
mvtBarriere = 0; // réinitialiser à barrières immobiles
}
break;
case 6: // PN désactivé, barrières ouvertes
barrieres.Liberer(); // désactiver le moteur des barrières
Serial.println("Servo barrières libéré");
feuRoutier.Eteindre();
// >>> ICI, ajouter message au pupitre (PN désactivé et ouvert)
pn.EtatSuivant();
delay(10); // histoire de faire quelque chose...

break;
default: // PN en attente d'activation
delay(10);
break;
}
}