24V DC Motor aansturen

Hallo allemaal,

Dit is mijn idee. Ik wil door middel van de Arduino Uno in combinatie met een 2voudig relais een 24V DC motor aansturen. Hiermee wil ik namelijk de tv ''uit het plafond laten komen'' en wanneer je geen tv kijkt deze weer ''laten verdwijnen''. Het motor-aansluitschema is als volgt:

Rood: Altijd 24V
Zwart: Altijd 24V
Blauw: 5V signaal voor aan / uit
Wit: 0 of 5V om de draairichting te bepalen.

Het relais aansturen met de arduino is me al gelukt. Ik gebruik hiervoor een IR signaal. Alleen nu komt mijn probleem. Ik wil gebruik maken van eindschakelaars. 2 stuks om precies te zijn. Ik zou het als volgt willen programmeren:

if eindschakelaar1 = high en ik geef het gewenste ir signaal
then 5V op blauw. Net zo lang totdat eindschakelaar2 hoog word.

if eindschakelaar2 = high en ik geef het gewenste ir signaal
then 5V op blauw en 5V op wit om de draairichting te wisselen.

Dit vervolgens ook net zo lang totdat eindschakelaar1 weer wor geraakt.

Het lukt me echter niet om de voorwaarden er in te programeren. Heb al van alles geprobeerd en gezocht maar zit nu toch echt op een dood spoor.

Mijn probleem is dus eigenlijk vrij simpel. Is het mogelijk om voorwaarden aan een actie te hangen?
De eindschakelaars die ik gebruik hebben geen COMMON, kan dit het probleem zijn? Of bedraad ik handmatig iets verkeerd? Ik zou graag jullie ideeën en hopelijk ook oplossingen horen.

Alvast bedankt,

Stijn

Tv_lift3.0.ino (1.22 KB)

Hoi StijnNijhuis, welkom.

Natuurlijk is dat mogelijk.
Maar om dat goed te doen, zou je eigenlijk eens mo9eten bekijken hoe je het zelf zou doen, en wat de code die je gebouwd hebt nu eigenlijk precies doet.

Ik lees je code als volgt:

  • Kijk of er iets via IR binnen komt.

  • Kijk wat er dan binnenkomt, en besluit wat je daar dan wat mee zal gaan doen.

  • Kijk ook of er een eindschakelaar goed staat om te kunnen doen wat jij wilde doen.

  • Voer de actie uit.

  • Kijk of er een eindschakelaar in een bepaalde stand staat, en wanneer dat zo is, voer dan een actie uit.

  • Kijk of een andere eindschakelaar in een bepaalde stand staat, en voer dan weer een andere actie uit.

Je blijft dit heel erg snel na elkaar doen, en de laatste 2 acties zijn niet afhankelijk van iets anders dan de eindschakelaars.

Uiteindelijk resulteert dit er in dat je het IR commando moet blijven uitzenden, en dat wanneer je een eindwaarde hebt bereikt, er altijd weer terug gegaan zal worden.
Sterker nog, eens er een eindwaarde is bereikt, zal je tv heen en weer gaan jojo'en.

Wat je volgens mij wilde bereiken, is dat je ziet dat er een afstandbedienings-signaal binnen komt, en je dan kijkt of je een bepaalde beweging mag gaan maken.
Tot nog toe doe je dat ook.
Maar als je eenmaal hebt gezien dat je kunt gaan bewegen, hoef je niet meer te controleren of er op een knop word gedrukt.
Wel moet je kunnen zien of je het einde al bereikt hebt.
En dat doe je nu dus niet helemaal goed.

Ik raad je aan om te kijken of je kunt gaan bewegen zoals je dat nu al doet, en dan te onthouden dat de betreffende beweging uitgevoerd kan worden.
Vervolgens voer je de beweging ook uit zolang de eindstand niet bereikt is.

Misschien denk je dat je dat nu doet, maar zo lees ik je code dus niet.

Hallo MAS3,

Oké, de fout zit dus echt in het programmeren. Ik ga proberen te doen wat je zegt. Maar ik zou dus geen Loop moeten gebruiken?

Natuurlijk moet je wel de loop blijven gebruiken, maar je moet het verloop ervan beïnvloeden.
Dat betekent dat je niet bij elke iteratie (elke keer als de loop weer opnieuw begint), precies hetzelfde moet doen.
Jouw loop word elke seconde duizenden en nog eens duizenden malen doorlopen.
Das best vaak, vind je niet.

Als er eenmaal een afstandbedienings-signaal is binnengekomen, en je hebt gezien dat de beweging ook gemaakt kan worden, dan hoef je niet meer naar dat IR signaal te kijken totdat de beweging ten einde is.
Tenzij je wil dat de beweging alleen gemaakt word zolang er op het knopje gedrukt word, maar daarvoor heb je dan weer een andere extra handeling nodig.
En als de beweging ten einde is, dan hoef je ook niet meer een beweging in de andere richting te starten.

Je zou het misschien niet verwachten, maar ook dit is iets wat je gaat begrijpen als je je verdiept in Blink Without Delay .

ik zou de eindschakelaars hard in het elektrisch schema zetten en dan kun je met diodes de motor wel in de goede richting laten lopen, maar niet in de verkeerde.
werkt zeker en altijd ipv code.

Hallo allemaal,

Ik heb geprobeerd het programma aan te passen zoals jullie hebben voorgesteld. Maar ik heb het idee dat de eindschakelaars niet binnen komen. Ik heb het als volgt aangesloten. Vanaf de 5v van de arduino naar de eindschakelaars en vanaf de andere kant van de eindschakelaars naar pootje 3 en 7. Wat kan hiervan de oorzaak zijn?

Alvast bedankt.

TV_lift3.1.ino (1.41 KB)

Hoi.

Je hebt nu wel de eindschakelaar aan een vast nivo gehangen (5 volt), maar die 5 volt staat alleen aan de andere kant van de schakelaar als de schakelaar aan staat.
Weet jij wat er aan de andere kant van de schakelaar staat wanneer de schakelaar niet aan staat ?
Want ik weet het niet, en je Arduino ook niet.
Die zit er naar te kijken en ziet van alles voorbij komen.
Soms zal ie daaruit de conclusie trekken dat de ingang hoog is, en soms (iets minder vaak) dat die laag is, maar het blijft maar een beetje gokken.

Daarom moet je in dit soort gevallen zorgen dat de ingang een gedefinieerd nivo ziet, wanneer er geen ander nivo aangeboden word.
In dit geval zou je dan de ingangspin van je Arduino via een weerstand (van een relatief hoge waarde) aan GND hangen.
Nu word je ingang naar nul getrokken door de weerstand tenzij de schakelaar een sterkere 5 volt aan die ingang brengt, waardoor die 5 volt gezien zal worden.

Maar dan moet je een weerstand gaan toevoegen en das lang niet altijd gewenst.
Jouw Arduino biedt daarom de mogelijkheid om een ingang omhoog te trekken (pull up), jij moet er met je schakelaar dan harder aan trekken om 'm omlaag te krijgen.
Met andere woorden, de schakelaar moet dan aan GND en jij moet op zoek gaan naar een LOW in plaats van een HIGH.
En je moet de ingang definiëren als INPUT_PULLUP in plaats van alleen als INPUT.
In de voorbeelden bij je IDE zit ook een voorbeeld dat hier over gaat, zodat je het gebruik er van kunt bestuderen.

Ik zie trouwens erg weinig verschil tussen versie 3.0 en 3.1 van jouw code, maar ik heb ze niet echt naast elkaar gelegd,

Hallo,

Als ik het goed begrijp moet ik dus in plaats van 5V de GND gebruiken om naar de eindschakelaars toe te gaan. En een kleine aanpassing in het programma. Dit heb ik geprobeerd maar het werkt nogsteeds niet. Iemand nog tips...? Of ziet iemand misschien wat ik fout doe?

Alvast bedankt

TV_lift3.2.ino (1.43 KB)

Hoi.

Lees mijn antwoorden altijd meerdere malen door, want ik probeer er zoveel mogelijk informatie in te stoppen.
Schijnbaar heb je nog niet alle informatie uit mijn vorige bericht ontvangen, want in onderstaande code is inderdaad wat veranderd (ik heb ze nu wel naast elkaar gelegd), maar niet alles dat nodig is.
Alleen pinmode aanpassen is niet voldoende.

#include <IRremote.h>
 
const int RECV_PIN = 4;
const int eindschakelaarboven = 3;
const int eindschakelaarbeneden = 7;
const int blauwhigh = 2; //Blauwe draad van 10 hier naar toe op een input, 
const int withigh = 5; //Witte draad van 11 hier naar toe op een input
const int blauw = 10;
const int wit = 11;

IRrecv irrecv(RECV_PIN);
decode_results results;

 
void setup(){
  Serial.begin(9600);
  irrecv.enableIRIn();

  pinMode(blauw, OUTPUT);
  pinMode(wit, OUTPUT);
  pinMode(voeding, OUTPUT);
  pinMode(eindschakelaarboven, INPUT_PULLUP);
  pinMode(eindschakelaarbeneden, INPUT_PULLUP);
  pinMode(blauwhigh, INPUT);
  pinMode(withigh, INPUT);

  digitalWrite(blauw, HIGH);
  digitalWrite(wit, LOW);

}
 
void loop(){
    
  if (irrecv.decode(&results)) {
    switch(results.value) {
      case 0xFFA857: 
         if(eindschakelaarboven == HIGH && blauwhigh == HIGH){
              digitalWrite(wit, HIGH);
              digitalWrite(blauw, LOW);
         }
      break; 
      case 0xFF629D:
         if(eindschakelaarbeneden == HIGH && blauwhigh == HIGH){
              digitalWrite(blauw, LOW);
         }
      break;
      }
      Serial.println(results.value, HEX); 
      irrecv.resume();
  }
  if(eindschakelaarboven == HIGH && withigh == LOW && blauwhigh == LOW){
    digitalWrite(blauw, HIGH);
  }
  
  if(eindschakelaarbeneden == HIGH && withigh == HIGH && blauwhigh == LOW){
    digitalWrite(blauw, HIGH);
    digitalWrite(wit, LOW);
  }
}

Hallo iedereen. Ik heb volgensmij alle tips van MAS3 geprobeerd. Maar het wil me nog steeds niet lukken. Ik heb de inputs veranderd tesamen met de code. Heeft iemand misschien een stuk code en aansluit schema over hoe ik een eindschakelaar moet gebruiken. Het wil me gewoon echt niet lukken.

Alvast bedankt.

Hoi Stijn.

Laat de code zien die je nu hebt.
Dan kunnen we ook zien hoe jij bedacht hebt het te doen en je wijzen op problemen die in die code te zien zijn zodat jij dat op kunt lossen.
Op die wijze kun je leren.
Je zult erg weinig leren van code die iemand anders voor jou maakt, en die jij vervolgens nog steeds niet snapt.
Wanneer je de volgende keer de code wil uitbreiden of op andere wijze wil wijzigen, loop je meteen weer vast.
Dus dat schiet dan niet op.

Hallo,

Dit is hoe ik het programma nu heb. Ik heb geprobeerd met 5v en een weerstand op de eindschakelaars. En ik het het geprobeerd met de eindschakelaars aan GND, toen had ik in de code een klein beetje anders en ging ik op zoek naar een LOW. Toch ''ziet'' de arduino de eindschakelaars nog niet..
Iemand nog een oplossing..?

TV_lift3.3.ino (1.38 KB)

Hoe weet je dat de eindschakelaars niet gezien worden ?

Ik zie dat je nu eerst de waarde van de eindschakelaars binnenhaalt, en dan gaat verwerken.
Maar ik vraag me af hoe jij weet wat de Arduino wel en niet kan zien.
Misschien kun je iets maken waardoor je, om te testen, kunt meekijken met wat de Arduino kan zien.
Daar kun je vast wel meerdere oplossingen voor bedenken.
Sterker nog, in je code doe je al iets soortgelijks.

Er zijn een aantal manieren om te gaan debuggen.
Vaak word bijvoorbeeld vergeten hoe snel de code uiteindelijk zal worden uitgevoerd.
Maar dat kun je voor jezelf wel duidelijker maken door de boel te gaan vertragen.
Dan zet je op bepaalde punten een pauze neer en als je alle problemen hebt opgelost haal je dat natuurlijk weer weg.
Dit is 1 van de zeldzame gevallen waar delay() wel nuttig is.
Doe je delay(1000), dan word er een seconde lang niets meer gedaan.
Dat is meer dan genoeg om te kunnen zien of er een relais ineens word ingeschakeld.
Want die heeft geen seconde nodig voor dat inschakelen, maar wel heel veel meer tijd dan 1 iteratie.
En als je telkens tegengestelde signalen zou gaan geven, dan doet je relais dus niets.
Je code word dan ineens heel traag uitgevoerd, maar jij kunt dan elke stap precies volgen.

Volgens mij is het slimmer om, wanneer je eenmaal het afstandbedieningssignaal hebt gezien, je gaat onthouden dat dat signaal er was.
Pas als je klaar bent met de afhandeling van wat je daar ook mee wil doen, kun je vergeten dat je dat signaal gezien hebt.

Ik snap nog steeds niet waarvoor de regels 51 tot en met 58 nodig zijn.

Verder vind ik de namen die je aan je variabelen geeft, niet de slimste.
Want wat wit en blauw is dat ga ik niet voor jou onthouden.
Ja, dat dat de kleuren van de draden zijn die je gebruikt hebt dat weet ik wel.
Maar waar ze voor zijn, geen idee.
Wanneer je over 2 jaar deze code nog eens opduikt, dan word het best lastig om uit te vinden wat je er ook al weer mee bedoelde.
Uiteraard maakt dit voor de Arduino niets uit (de Arduino zelf weet zelfs helemaal niet van de namen die je er aangegeven hebt), zolang de juiste namen maar worden gebruikt.

De belangrijkste informatie in dit antwoord, heb ik je eerder al gegeven

Hallo, het heeft even geduurd maar het is me gelukt. Wanneer ik een van de eindschakelaars bedien te samen met de afstandsbediening schakelt mijn relais. Alleen nu het volgende probleem. Wanneer ik alles aansluit blijft het motortje maar draaien terwijl dit eigenlijk niet moet. Ik heb het aangesloten zoals op de foto te zien is. Iemand misschien een idee waar de fout zit? Alvast bedankt.

TV_LIFT_WERKEND_____.ino (1.63 KB)

Hoi.

StijnNijhuis:
Rood: Altijd 24V
Zwart: Altijd 24V
Blauw: 5V signaal voor aan / uit
Wit: 0 of 5V om de draairichting te bepalen.

De beschrijving in de quote komt volgens mij niet helemaal overeen met wat je in het plaatje getekend hebt.
Die 5 volt waar je het over hebt, worden die door de motor-controller geleverd ?
En wanneer zijn die signalen actief ?
Wanneer de 5 volt word geleverd, is dat signaal dan actief als de 5 volt er nog is, of als die naar nul volt word getrokken ?

In je tekening zijn de relais met GND verbonden en kunnen dus alleen een signaal activeren door het naar nul volt te trekken.
Wanneer jij je relais inschakelt door er een HIGH heen te sturen, dan word de kleur draad die je daar aan gehangen hebt, dus naar nul getrokken.
En wanneer je je relais niet hebt ingeschakeld, dan heeft die draad dus 5 volt (ofzo).
Als je blauwe draad de motor laat draaien wanneer daar 5 volt op staat, en stopt wanneer daar 0 volt op staat (en dat is wel het meest logische), dan moet je de blauwe draad niet op de NO aansluiting van je relais aansluiten, maar op de NC aansluiting.
Heb je dat al geprobeerd ?

Dan kan het nog zo zijn dat die motor controller zelf helemaal niets met de ingangen doet, en gewoon een externe 5 volt verwacht.
Geen idee,want ik weet niet waar je precies mee werkt.
Kun je me vertellen waar het niet aangesloten gele draadje voor is ?

Tijdens het testen heb ik gemerkt dat als ik de 0V van de 24V voeding aan blauw of wit hang dat de motor stopt/ draai richting wisselt. Als er "0V", dus relais geschakeld, op de blauwe draad staat stopt de motor. Als deze 0V, wederom relais geschakeld, relais 2 in dit geval, op de witte draad staat dan zal de draai richting van de motor veranderen. Dus vandaar dat ik het op die manier heb aangesloten. Nu het probleem, als ik handmatig de com en het no contact van het relais overbrug, stopt de motor met draaien. Of de draairichting wisselt. Ligt aan het relais natuurlijk. Ik zou het kunnen proberen met een externe voeding van 5V denk ik? Misschien dat dit het probleem oplost. Maar de conclusie;

Het relais schakelt wel maar ik heb het idee dat dit niet het geval is omdat de motor er niet op reageert, handmatig relais overbruggen reageert de motor wel op.

Alvast bedankt

P.s. de gele draad is om de snelheid te regelen, wanneer deze niet gebruikt word is vol aan/ vol uit het geval.

Hoi.

Ik voeg hier even 2 snippets samen:

  pinMode(10, OUTPUT); //blauw
  pinMode(11, OUTPUT); //Wit
 
void loop()
{
  
    switch(results.value) 
    {
      case 0xFFA857: 
         if(eindSchakelaarBoven == 0)
         {
              Serial.println("Naar beneden");
              digitalWrite(11, HIGH);               // Hier zet je WIT aan LAAG
              digitalWrite(10, LOW);                // HIer zet je BLAUW aan HOOG
              omLaag = 1;
         }
         break; 
      
      case 0xFF629D:
         if(eindSchakelaarBeneden == 0)
         {
              Serial.println("Naar boven");
              digitalWrite(11, HIGH);             // Hier zet je WIT aan LAAG
              digitalWrite(10, HIGH);             // Hier zet je BLAUW aan LAAG
              omHoog = 1;
         }
         break;
    }
  

}

Ik heb er ook wat commentaar aan toegevoegd.
Als jij schakelt, werkt een en ander precies achterstevoren.
Dat maakt niet uit, maar daar moet je wel rekening mee houden, en volgens mij heb je dat in je code niet gedaan.
Je kunt nu de code aanpassen, maar je kunt ook de draden op het andere contact van de relais aansluiten.
Het blijft natuurlijk wel vreemd dat je eerst iets getest hebt en het dna op de ene manier werkt, en als je het via relais gaat bedienen, dat het dan precies andersom werkt als je eerder hebt vastgesteld.
Daarom lijkt het me wel verstandig eerst te zien of je gegevens van die motor (-driver) kunt vinden, en anders je test met de draden nog eens over doet om er zeker van te zijn dat je het niet verkeerd opgeschreven of onthouden hebt.

De code lijkt me goed. Want om de motor te laten werken moet relais 2 (Blauw) uit zijn. Als vervolgens er een eindschakelaar word geraakt zal relais 2 inschakelen zodat de motor stopt met draaien. We gaan er even van uit dat de televisie nu van de hoogste positie naar de laagste positie is gegaan hierboven. Vervolgens om weer omhoog te gaan moet de draairichting worden verwisselt. Nu zal relais 1 (wit) inschakelen, net zo lang tot er weer een eindschakelaar word geraakt. Als dit het geval is zal relais 1 uitschakelen en relais 2 inschakelen. Hier nog wat gegevens van de motor:

Machifit GM4058-BLDC3650 DC 24V

BLDC3650 vijfregelige verbindingsmodus:
1- zwarte lijn: vermogen - (blauwe lijn is verbonden met de negatieve poolmotor onmiddellijk te remmen)
2- rode draad: kracht +
3- witte lijn: CW / CCW-communicatielijn, de witte lijn en zwarte lijnverbinding om de besturing te veranderen.
4- gele lijn: FG-signaallijnuitgang Holzer-signaal, gebaseerd op de uitslag van een belsignaal.
5- blauwe lijn: PWM pauze-breedtemodulatielijn kan worden aangesloten op de 0-5V pulsbreedtegeleider.

Die gegevens van de motor helpen erg veel.

Maar de beschrijving van functies van de draden zijn tenenkrommend door een zeer slechte vertaling, eerst naar Engels en vervolgens naar het Nederlands.

Je stuurt de motor verkeerd aan.
De motor heeft een ingebouwde driver (daar sprak ik eerder ook al over).
Wanneer je de blauwe draad aan GND hangt, dan word er geremd.
Hang je hem aan 5 (!!) volt, dan gaat ie met de maximale snelheid.
De snelheid kun je aansturen middels een PWM signaal (volgens de specificaties met een frequentie van 10 Kilo Hertz).
Zo'n signaal kan je Arduino leveren, maar niet standaard bij die frequentie.
Vaak zal het echter gewoon werken.
Zoals onderaan al mijn berichten te zien, dien je hiervoor wel de GND van de Arduino met die van de motordriver te verbinden.
Dat is dus de zwarte draad.

De witte draad dient inderdaad om de draairichting te veranderen.

De gele draad dient niet direct voor snelheidsregeling.
Het is een terugkoppeling voor de snelheid.
Aan de motor zit een magnetische schijf, en nabij die schijf zit een sensor.
Daardoor kan het toerental gemeten worden.
Als je dat toerental meet (==weet), dan kun je dus de aansturing aanpassen als je van mening bent dat dat noodzakelijk is.
Als je het niet interessant vind hoe snel je motor draait, dan kun je de verwerking van dit signaal uit het gele draadje weglaten en dat doe je in dit geval dan ook.

Overigens kun je die pulsen ook tellen en een aardig eind inschatten hoe ver je lift al onderweg is, zodat je ook andere posities kunt bereiken dan helemaal bovenaan of helemaal naar beneden.

De ingebouwde driver is schijnbaar wel een beetje hufterproof gemaakt, waardoor die niet meteen in de fik vliegt als je er niet exact de juiste signalen op aansluit.
Want anders had je 'm allang opgeblazen.
Maar je moet natuurlijk gewoon het ding op de juiste wijze aansturen.
Omdat de blauwe draad aan GND een functie heeft (remmen), zorgt de driver er voor dat die niet vanzelf aan GND hangt.
Die heeft dus zelf al een pull up weerstand of iets soortgelijks.
Dat is een voordeel, want daardoor is de ingang niet ongedefinieerd als je 'm niet aansluit.
En het is de oorzaak van het draaien van je motor als er geen ander signaal op die draad staat.
Maar het is niet te zeggen hoe sterk die pullup is, wat weer zou kunnen leiden tot minder betrouwbaar werken van het ding indien die weerstand erg hoog is.
Want dan kunnen stoorpulsen worden ontvangen die de werking beïnvloeden.
Je mag dus niet stellen dat als je niet remt, de motor zal draaien.
Maar dat doe je nu wel, want dat is wat je ook hebt geconstateerd.
Als je wil dat de motor betrouwbaar draait, zal je 'm ook op correcte wijze moeten aansturen.
De motor zal remmen als het PWM signaal 10% of lager is.

Wil je de snelheid niet regelen, zet dan een 5 volt signaal op NO, GND op NC en sluit de blauwe draad aan op COM va het relais.
En draai de aansturing in je sketch om.
Dit zodat je standaard de motor uit hebt staan, tenzij de de motor bewust aanstuurt.
Dat is veiliger dan andersom.

Sowieso is het in de meeste gevallen beter om de belasting op COM aan te sluiten, alhoewel er ook wel meerdere redenen voor te bedenken zijn om dat juist niet te doen.

Hallo, ik heb het een en ander aangepast en het is me gelukt. Ten eerste heb ik de voeding van de arduino aangepast. Deze was 5v, dit moet minimaal 7v zijn. Voor de rest heb ik het programma een klein beetje aangepast, verbeterd. Zie de bijlage voor het aansluit schema.

Iedereen bedankt voor de genomen moeite om te reageren, en met me mee te denken.