DIY Cornering lights motorfiets

[nodri2000]

Hallo allemaal,

Op de huidige motoren zitten tegenwoordig cornering lights, dat zijn lampen die bij het ingaan van een bocht aangaan en na de bocht al fadend weer uitgaan.

Op mijn fiets van 2001 zit dat er niet op, wat ik wel heb is 2 mooie led mist / DRL lampen aan beide zijden van de motor.

Nu wil ik dmv een M5stack, 6DOF IMU en LED driver deze lampen aan en uit laten schakelen als ik een bocht in- uitga. Misschien later een automatisch remlicht programeren zodat deze ook werkt bij gas loslaten.

Zijn er mensen die zoiets al eerder aan de hand gehad hebben, of dat er mensen zijn die hier ervaring mee hebben? Ik ben namelijk benieuwd hoe zo'n IMU omgaat met trillingen.

Alvast bedankt voor de feedback.

[Zyk]

Ik heb met het merendeel hiervan ervaring, behalve de motorfiets.

Mijn eerste vraag is of je niet beter draaiing van de stuurkolom kunt meten met bijvoorbeeld een hall sensor. Dat lijkt mij een eenvoudigere oplossing, en komt softwarematig neer op het instellen van een threshold voor de linker en rechter lamp.

Meten met een IMU kan uiteraard ook. Heb je er al een op het oog wellicht?
Mijn ervaring hiermee is dat de amplitude van hoger frequente trillingen absurt hoog kan zijn (een schroefje tikken op een houten tafelblad is bijvoorbeeld zomaar 200 g-krachten op de sensor). De mechanische ophanging van de sensor is de eerste plaats om dat aan te pakken, liefst met een massa-veersysteem. Praktisch kan dat bijvoorbeeld met balgjes zoals men gebruikt om dronecamera’s mee op te hangen in het frame. Let hierbij op de orientatie. Bij drones zijn de trilling in het horizontale vlak, maar bij een motor verwacht ik deze in het verticale vlak parallel aan de rijrichting.

Qua software pas je voor bochtdetectie een longpassfilter toe voor signaal met periodes langer ongeveer 1 seconden. (Een FFT zou ook kunnen, of analoge filters). Het signaal op de links-rechts richting (laten we dit X noemen) gebruik je om de richting van de bocht te bepalen, en de Z-as om te meten of de motor nog steeds een bocht maakt en ook in dezelfde richting. De g-krachten in Z moeten namelijk door het 1 g punt (normale zwaartekracht) gaan bij een verandering van de richting van een bocht, maar door het hellen van de motor is de g-kracht in X-richting niet per se richting de buitenbocht. Dit is een leuk stukje algoritme om te schrijven.

Bij afremmen verwacht ik dat de motor op de Y-as signaal geeft. Dat zou voldoende moeten zijn met een simpele threshold voor het inschakelen van het remlicht. Sprekend als automobilist zou je me wel verrassen als je remlicht al aanstaat, en je dan daadwerkelijk (hard) remt, ter beoordeling aan jezelf.

LED’s dimmen en aansturen kan met een PWM controller. Afhankelijk van het gewenste knutselniveau kun je dat helemaal zelf doen of wat meer met off-the-shelf onderdelen opbouwen. Heb je hier zelf al een idee over?

[squashedraven]

Zyk schreef op woensdag 17 juli 2024 @ 14:51:

Mijn eerste vraag is of je niet beter draaiing van de stuurkolom kunt meten met bijvoorbeeld een hall sensor. Dat lijkt mij een eenvoudigere oplossing, en komt softwarematig neer op het instellen van een threshold voor de linker en rechter lamp.

probleem hierbij is dat motoren op lage snelheden nog wel eens counter steering toepassen. Dan gaat in deze opstelling de verkeerde lamp branden dus.
Ik zou het eerder zoeken in de gyroscopische hoek dat het licht aan gaat bij een bepaalde hellingshoek

[AlphaRomeo]

Zyk schreef op woensdag 17 juli 2024 @ 14:51:
Mijn eerste vraag is of je niet beter draaiing van de stuurkolom kunt meten met bijvoorbeeld een hall sensor.

Het stuur van een motorfiets draait nauwelijks wanneer eenmaal op snelheid, en dan ook nog eens de verkeerde kant op (bij het ingaan van de bocht). Dit meten is kansloos, en dit is bijvoorbeeld ook de reden dat knipperlichten op de oudere motoren niet vanzelf uitgaan. Modernere motoren doen dit ook met acceleratiesensoren en ABS informatie, bij oudere motoren blijft het knipperlicht aan totdat de motorrijder in kwestie het doorheeft.

Ik heb wel een beetje ervaring met electronica op en aan motorfietsen, en mijn ervaring is vooral dat er elke connector en elk boutje dat niet echt goed vast zit los gaat trillen uiteindelijk. Wat het effect is van de trillingen op een acceleratiesensor weet ik niet, maar ik verwacht dat dit zeker waarneembaar is. Met een low-pass filter zouden die er ook weer relatief makkelijk uit te filteren moeten zijn (in theorie).

[Zyk]

@squashedraven Duidelijk. Ik had een vermoeden dat er mogelijk een reden zou zijn.

Overigens is een accelerometer bruikbaar als een hellingshoekmeter als je de vectoren tussen de assen berekent. Een gyrometer meet daarentegen uitsluitend verandering van orientatie. Als je deze scheef neerzet, geeft deze na plaatsing een uitgangswaarde 0 als de orientatie niet daarna niet meer verandert.

[naarden 4ever]

Is dit ongeveer wat je wilt bereiken?

Ik heb geen uitgebreide en specifieke ervaring met IMU's, en heb zelf ook geen ervaring met een motorfiets. Maar wat je wilt bereiken zal niet zozeer moeilijk zijn w.b.t. het maken ervan, maar het betrouwbaar laten werken is vooral een uitdaging.

Ten eerste is dit een vrij ideale opstelling: in stilstand, en redelijk zuivere en vloeiende bewegingen (voor zover mijn hand dat toelaat). Dan krijg je ook redelijk mooie, zuivere resultaten uit je accelerometer. Daarnaast kan ik de richtingsassen ook toepassen zoals ze in de IMU zijn ingericht, dus geen complexe berekeningen om een eventuele verdraaiing t.o.v. 'de normaal' te compenseren.

Op een motor is dat zeker niet het geval. Er zijn legio factoren die dit signaal gaan verstoren, maar de belangrijkste zullen (oscillerende) trillingen, schokken, en middelpuntvliedende krachten zijn.

Om even een voorbeeldje te geven:


Hier zien we het signaal van twee van de assen van de accelerometer in de IMU. Aangezien ze beiden in rust rond de nulwaarde hangen, zal dit niet de Z-as zijn ('verticaal'), want daar meet je in rust 1G, de gravitatiekracht. Dus blauw is de voor/achter as, en oranje is de links/rechts as.

Als eerste heb ik de sensor gekanteld zoals in het filmpje, maar dan tot -90° tot 90°. We zien een redelijk geleidende lijn tot ongeveer ±16000. Dat is ongeveer 1G, en dat is logisch, want op de uitersten werkt er 1G aan gravitatiekracht op die as. Je ziet wel iets meer rimpelingen op de blauwe as, maar het mag eigenlijk geen naam hebben.

Vervolgens tik ik een paar keer met het breadboard op de tafel. We zien dan behoorlijke uitschieters op de voor/achter as. Waarschijnlijk omdat ik het breadboard niet perfect horizontaal op de tafel smijt, maar de voorkant iets eerder de tafel raakt dan de achterkant, of vice versa. Je ziet hier enorm hoge, maar smalle pieken. Ook op de oranje as (waarschijnlijk was ik ook niet links/rechts loepzuiver), met uitschieters tot wel 10000. Dat soort pieken kan je zeker verwachten als je een keertje een kuiltje in de weg tegenkomt, en waarschijnlijk nog aanzienlijk hogere waardes ook.

De trillingen in de zijwaartse richting zullen meevallen zolang je rechtdoor rijdt (lichtgroen hierboven), maar zodra je in een bocht zit zal dat veranderen. Ik kantelde het bordje ongeveer 20° heen en weer in het roze deel, en je ziet daar al dat de pieken hoger zijn dan het maximale waarde in het groene deel. Er is wel een verband tussen de kanteling die je maakt met het voertuig en de gemiddelde waarde van de oranje grafiek van, zeg, de laatste 10 metingen, maar dat zal geen direct verband zijn.

Tot slot zal vooral de middelpuntvliedende kracht een behoorlijk lastige factor zijn (die kan ik niet simpel voor je simuleren). Een IMU is in principe een gewichtje dat hangt aan veren, en de waarde die je meet is de mate van compressie/uitrekking van die veertjes. Net zoals je in een auto in de bocht naar buiten wordt geslingerd, zal ook het gewichtje in de IMU naar de buitenkant van de worden geslingerd: het gewicht wilt immers rechtdoor, terwijl de motor links-/rechtsaf beweegt. Dus op snelheid en in een bocht zal er een factor middelpuntvliedende kracht bijkomen die juist tegenovergesteld is gericht aan de richting waarin je beweegt.

Ik kan je niet zeggen hoe groot deze factoren zijn. De eerstvolgende logische stap om te maken nu is data verzamelen. Zet zo'n IMU op je M5stack (of op een Arduino), zet dat ding vervolgens op je motor, en verzamel data (ik zou hiervoor ook een SD-kaart module gebruiken, want in het geheugen van een Arduino ga je maar weinig kunnen opslaan). Ga uitzoeken hoe sterk de trillingen zijn, wat er gebeurt met de waardes in een bocht, enzovoorts. Zodra je die data hebt, kan je een programma schrijven waarin je alle trillingen en storingsfactoren weg filtert.

Edit: Ik zie nu op je profiel dat je expert bent met UAV's. Waarschijnlijk is bovenstaande dan redelijk gesneden koek voor je en had ik het niet in zulk groot detail hoeven omschrijven. Ik laat het wel staan voor de volledigheid.

[ Voor 96% gewijzigd door naarden 4ever op 17-07-2024 16:49 ]

[memphis]

Kan ook simpel met kwikschakelaars.

[nodri2000]

Bedankt allemaal voor de suggesties.

Wat ik wil gebruiken is een M5stick pro met IMU.

V.w.b. expert op drone gebied. Dat was nog ind e tijd dat we WII controllers uit elkaar haalden om daar de IMU's uit te halen. (jaar of 10 geleden), KK bordjes etc. Heel oud dus, zal dat moeten aanpssen denk ik. Ben nog wel bezig met UAV's maar staat op een laag pitje.

De bedoeling is om het op te bouwen met deze componenten:
https://www.tinytronics.n...c-esp32-development-board Deze heeft een ingebouwde IMU en een ingebouwde led aansturing (zal geen driver zijn lijkt mij.

[Illusion]

De door jou voorgestelde imu heeft ook gyroscopen. Die meten de snelheid van rotatie. Door de gyroscoop en versnelling samen in een kalman-filter te stoppen, kan je een redelijke voorspelling doen van de rotatie van de motor in zowel zijdelingse- als rijrichting

[naarden 4ever]

nodri2000 schreef op dinsdag 30 juli 2024 @ 15:15:
De bedoeling is om het op te bouwen met deze componenten:
https://www.tinytronics.n...c-esp32-development-board Deze heeft een ingebouwde IMU en een ingebouwde led aansturing (zal geen driver zijn lijkt mij.

Begin met de code waarmee een twee ledjes aan of uit gaat bij de gewenste kantelhoek. Vanaf dat punt kan je verder uitbreiden met correcties op je model.

Waarschijnlijk werken de lampen die je uiteindelijk wilt gaan gebruiken op 12V. Je kunt dan het signaal dat je gebruikt voor een eenvoudig ledje gebruiken als aansturing voor een MOSFET om de lamp op 12V aan te sturen. Dat is niet zo heel moeilijk om te realiseren.

[nodri2000]

naarden 4ever schreef op woensdag 31 juli 2024 @ 10:19:
[...]


Begin met de code waarmee een twee ledjes aan of uit gaat bij de gewenste kantelhoek. Vanaf dat punt kan je verder uitbreiden met correcties op je model.

Waarschijnlijk werken de lampen die je uiteindelijk wilt gaan gebruiken op 12V. Je kunt dan het signaal dat je gebruikt voor een eenvoudig ledje gebruiken als aansturing voor een MOSFET om de lamp op 12V aan te sturen. Dat is niet zo heel moeilijk om te realiseren.

Tja als ik zo naar jou filmpje kijk is dat wat ik wil bereiken. De spullen besteld maar staan uiteraard op back order.
Kun/ wil jij je code delen die je daarvoor gebruikt hebt?

[naarden 4ever]

nodri2000 schreef op woensdag 31 juli 2024 @ 13:12:
[...]


Kun/ wil jij je code delen die je daarvoor gebruikt hebt?

Zeker:

code:

#include<Wire.h>
#include<stdio.h>

#define LED_LEFT 5                    // Digitale pin waarop de linked LED is aangesloten
#define LED_RIGHT 6                   // Digitale pin waarop de rechter LED is aangesloten

const int MPU=0x68;                   // I2C adres van de IMU
int16_t AcX,AcY,AcZ,Tmp,GyX,GyY,GyZ;  // Hier worden de waardes van de IMU in opgeslagen

uint8_t valLeft = 0;                  // PWM waarde voor de linker LED
uint8_t valRight = 0;                 // PWM waarde voor de rechter LED

void  setup(){                      // Setup (wordt 1x uitgevoerd bij het opstarten)
  pinMode(LED_LEFT, OUTPUT);          // Stel linker LED in als output pin
  pinMode(LED_RIGHT, OUTPUT);         // Stel rechter LED in als output pin
  Wire.begin();                       // Start I2C communicatie
  Wire.beginTransmission(MPU);        // Open de communicatie via I2C naar (het adres van) de IMU
  Wire.write(0x6B);                   // Verstuur 0x6B, het adres van het register dat we willen aanpassen (PWR_MGMT_1 register)
  Wire.write(0);                      // Zet de waarde van het register op 0 (zet de IMU op actief)
  Wire.endTransmission(true);         // Beeindig deze transmissie
  Serial.begin(115200);               // Serieel op 115200 voor het uitlezen in de serial monitor
}
void  loop(){                       // Loop (code wordt herhaaldelijk uitgevoerd)
  Wire.beginTransmission(MPU);        // Open de communicatie via I2C naar (het adres van) de IMU
  Wire.write(0x3B);                   // Verstuur 0x3B, het adres van het eerste register dat we willen lezen (ACCEL_XOUT_H)
  Wire.endTransmission(false);        // Beeindig de transmissie niet, we willen nu namelijk data gaan ontvangen van de IMU
  Wire.requestFrom(MPU,12,true);      // Geef opdracht aan de IMU om de 12 volgende geheugenregisters te versturen (deze worden hiermee ook ontvangen en opgeslagen in het geheugen van de Arduino, waarna je deze met Wire.read() op volgorde kunt ophalen uit het geheugen van de Arduino)
  AcX=Wire.read()<<8|Wire.read();     // Eerst ontvang je ACCEL_XOUT_H, dit zijn de eerste 8 bits (met de hoogste waarde) van de totaal 16 bits aan data die de IMU per as verstuurt. De eerste waarde bitshift je 8 plekken naar links, de tweede waarde (ACCEL_XOUT_L) laat je zoals 't is en deze tel je bij elkaar op. 
  AcY=Wire.read()<<8|Wire.read();     // Zelfde maar dan voor ACCEL_YOUT_H en ACCEL_YOUT_L
  AcZ=Wire.read()<<8|Wire.read();     // enz.
  GyX=Wire.read()<<8|Wire.read();  
  GyY=Wire.read()<<8|Wire.read();  
  GyZ=Wire.read()<<8|Wire.read();  
  
  Serial.print(AcX);                  // Druk de opgehaalde waardes af naar de serial monitor, gescheiden met een komma tussen elke waarde
  Serial.print(",");
  Serial.print(AcY);  
  Serial.print(",");
  Serial.print(AcZ);
  Serial.print(","); 
  Serial.print(GyX);
  Serial.print(",");
  Serial.print(GyY);
  Serial.print(",");
  Serial.print(GyZ);
  Serial.println();                   // Nieuwe regel voor de volgende waarde

  // Voor het kantelen is in mijn voorbeeld de AcY waarde gebruikt
  if (AcY > 3000)                     // Als de waarde voor AcY hoger is dan 3000, dan kantel je naar links
  {
    if (valLeft < 255)                // Zolang de waarde voor valLeft lager is dan 255,
    { 
      valLeft+=5;                     // verhoog valleft met 5 per keer dat de loop() wordt uitgevoerd 
    }
    if (valRight > 0)                 // Tegelijkertijd willen we dat de waarde van valRight afneemt zolang we niet naar rechts kantelen, dus als de waarde van valRight hoger dan 0 is,
    {
      valRight-=5;                    // Verlaag je de waarde voor valRight met 5 per keer dat de loop() wordt uitgevoerd
    }
  }
  else if (AcY < -3000)               // Hetzelfde idee als hierboven maar nu juist als de waarde voor AcY lager is dan -3000, kantel je naar rechts en wil je rechts feller maken en links juist dimmen
  {
    if (valLeft > 0)
    { 
      valLeft-=5;
    }
    if (valRight < 255)
    {
      valRight+=5;
    }
  }
  else {                                // Als je geen van beide kanten op kantelt (dus AcY zit tussen -3000 en +3000 in), dan moeten beide lampen dimmen. 
    if (valLeft > 0)
    {
      valLeft -= 5;
    }
    if (valRight > 0)
    {
      valRight -= 5;
    }
  }

  analogWrite(LED_LEFT, valLeft);       // Schrijf de waarde van valLeft en valRight als PWM waarde van de pins
  analogWrite(LED_RIGHT, valRight);

  delay(10);                            // delay 10 milliseconde om het programma eens per 0.01s uit te voeren (verklein delay voor sneller reageren van de lampen, vergroot delay voor langzamere reactie)
}