Er is ook een Rotary encoder library voor de arduino waarbij ook een acceleration functie is ingebouwd. Dus als je meer pulsen geeft in een bepaalde tijd worden de stappen groter. Werkt erg goed, heb hem laatst nog gebruikt
Library
Hierbij een sketch die 2 potmeters gebruikt om een digitale waarde in te stellen. Was wel even puzzelen, maar werkt wel leuk.
// Potmeter uitlezen om een digitale waarde in te stellen.
#define Baudrate 19200
#define Interval 300
class Potmeter
{
public:
// Constructor function.
// - Wordt automatisch aangeroepen asl een nieuw object van class Potmeter wordt aangemaakt.
// - Hiermee worden parameters voor het nieuwe object ingevuld.
// - PortNr : Analog Pin nr waar de echte potmeter is aangesloten.
// - Minimum : Minimum waarde voor m_Value.
// - Maximum : Maximum waarde voor m_Value.
// - StepSize : Kleinste stap per update.
// Updates worden berekend vanuit analoge spanning en kunnen 10 of 100 keer groter zijn.
Potmeter(int PortNr, unsigned int Minimum, unsigned int Maximum, unsigned int StepSize)
{ m_PortNr = PortNr;
m_Minimum = Minimum;
m_Maximum = Maximum;
m_StepSize = StepSize;
}
// Deze variable wordt aangepast. Dus hierin staat de actuele ingestelde stand.
// - Kan door de rest van het programma worden uitgelezen.
// - Wordt bijgewerkt door de Update() funktie, afhankelijk van de analoge input spanning.
unsigned int m_Value; // Possible range 0..65531
// Update() funktie moet elke 300 milliseconden worden uitgevoerd.
// - Hier word m_Value aangepast, afhankelijk van de analoge input.
bool Update()
{ // Eerst lezen we de analoge input naar NewPosition.
int NewPosition = analogRead(m_PortNr);
// Hier vergelijken we de nieuwe analoge waarde met de vorige waarde om te zien of er verandering is en in welke richting
// - Dan kunnen we m_Value stabiel houden als de potmeter in de richting van de middenstand gaat.
// - We laten +/- 5 counts als ruis toe.
if( ((m_OldPosition < 512) && (NewPosition > ( m_OldPosition + 5)))
|| ((m_OldPosition > 512) && (NewPosition < ( m_OldPosition - 5))))
{ m_OldPosition = NewPosition; //< Altijd de nieuwe positie registreren
return false; //< Geen wijziging in m_Value
}
// Ook hier de nieuwe stand registreren.
// - Hebben we de volgende keer nodig.
m_OldPosition = NewPosition;
// De analoge waarde heeft een bereik van 0 - 1023.
// Hier wordt het analoge waarde verdeeld in 7 gelijke stappen door te delen door 1024/7.
// Het resultaat staat in x, range 0 .. 6, maar tgv afrond fouten komt 7 ook voor.
unsigned char x = NewPosition / (1024/7); // Range 0 .. 6
// Deze switch bekijkt in welke range we zitten.
// - Dan kunnen we kiezen tusen Increment, decrement, niks, en een schaalfactor 1, 10 of 100.
switch(x)
{ case 0 : return Decrement(100);
case 1 : return Decrement( 10);
case 2 : return Decrement( 1);
case 3 : return false; // Potmeter in the middle: No change
case 4 : return Increment( 1);
case 5 : return Increment( 10);
case 6 :
case 7 : return Increment(100);
}
}
// Decrement funktie gebruiken we om de waarde te verlagen
// - Delta = 1, 10 of 100 afhankelijk van de analoge potmeter.
bool Decrement(unsigned int Delta)
{ // Eerst vergroten we Delta met de Step size.
// - Dan kunnen we de Stroom instellen in stappen van 1 mA, en Spanning in stappen van 10 mV
Delta *= m_StepSize;
// Dan gaan we afronden.
// - Als we grotere cijfers gaan aanpassen dan kunnen de kleinere cijfers naar 0
m_Value = ((m_Value + Delta - 1) / Delta) * Delta; // Rounding Up before decrement
// Vervolgens testen we of de update nog binnen het bereik past
if (m_Value >= (m_Minimum + Delta)) //< Room for update?
{ m_Value -= Delta; //< Then update
return true;
}
else
{ // Grens bereikt. Geen update meer mogelijk.
return false;
}
}
// Een increment funktie is net een beetje anders.
// - Afronding is anders.
// - Andere range check.
// - Stap size wordt bijgeteld
bool Increment(unsigned int Delta)
{ Delta *= m_StepSize;
m_Value = (m_Value / Delta) * Delta; //< Rounding Down before increment
if (m_Value <= (m_Maximum - Delta)) //< Room for Update?
{ m_Value += Delta; //< Then update
return true; //< Indicate that value was changed
}
else
{ return false; //< Buiten bereik: Geen update.
}
}
private:
// Hier houden we de administratie van het Potmeter object.
// Iedere Potmeter object heeft een eigen copie
// - Zit in de private sektie, dus is niet bereikbaar van buiten het object.
unsigned int m_PortNr;
unsigned int m_Minimum;
unsigned int m_Maximum;
unsigned int m_StepSize;
int m_OldPosition;
};
// Hier doen we niet meer dan de Serial poort opstarten.
// - Wordt gebruikt om te testen.
void setup()
{ // put your setup code here, to run once:
Serial.begin(Baudrate);
}
// ===========================================================================================
// Hier maken we een tweetal Potmeter objecten
// TargetVoltage op AnalogePin 0, Bereik 0..30000 (mv), 10 mV per stap.
// - Object van Type Potmeter, genaamd "TargetVoltage".
// - Analog Port : 0
// - Minimum waarde : 0
// - Maximum waarde : 30000 (mV)
// - Stap grootte : 10 (mV)
Potmeter TargetVoltage(0, 0, 30000, 10);
// TargetCurrent op AnalogPin 1, Bereik 0.. 3000, 1 mA per stap.
// - Using an object of class Potmeter, Named TargetCurrent
// - Defined in Global scope
Potmeter TargetCurrent(1, 0, 3000, 1);
// ===========================================================================================
// - En de Arduino loop funktie. Die wordt in rap tempo steeds weer uitgevoerd.
void loop()
{
// Hier gebruiken we een static variabele om de tijd bij te houden.
// - Is static zodat de waarde behouden blijft tussen opeenvolgende loop() 's.
static unsigned long Timer = millis();
// Hier testen we hoeveel tijd er verstreken is sinds vorige loop()
// - We gaan binnen de if na 300 milliseconen (zoals gedefinieerd in Interval).
if((millis() - Timer) > Interval)
{ Timer += Interval; //< Update Timer for next interval
bool Report = false; // Hier zetten we een vlag, te beginnen op false.
if(TargetVoltage.Update()) // Hier lezen we de Potmeter voor Spanning.
{ Report = true; // Vlag wordt true als Spanning is veranderd.
}
if(TargetCurrent.Update()) //< Hier lezen we de potmeter voor stroom
{ Report = true; //< Vlag wordt true als stroom is veranderd.
}
if(Report) //< Hier testen we de vlag om te zien of er iets is veranderd.
{ // Zo ja, dan sturen we de nieuwe waarden naar de PC.
// - Dan kunnen we met de arduino "Tools -> Serial Monitor" zien wat er gebeurt.
char Buffer[50];
snprintf(Buffer, sizeof(Buffer), "Voltage = %5d mV, Current = %5d mA",
TargetVoltage.m_Value, //< Dit geeft de waarde voor Spanning.
TargetCurrent.m_Value); //< Dit geeft de waarde voor Stroom.
Serial.println(Buffer);
}
}
}
EricP
mét CE
Uhm....
Dus om Bram meteen een beetje op te voeden in 'safe programming'
Opvoeden... daar is deze aap toch te oud voor *grin*
De mythbusters hebben ooit aangetoond dat je ook een oude hond nieuwe kunstjes kunt leren, dus 
Maar goed, je snapt het concept. snprintf is vaak best netjes. Maar C is nou typisch een taal waarbij je na moet denken over wat je doet. In ruil daarvoor krijg je grote flexibiliteit. Iets minder dan met assembly, maar je komt een eind. En dat nadenken, dat moet je ff doorhebben. Ofwel: als je snapt hoe het werkt (en waar het fout kan gaan), dan is de oplossing ook niet zo moeilijk.
@deKees
sketch effe geprobeerd,werkt leuk.
Zal eens kijken wat het bedienings gemak in de voeding geeft.
Misschien beter een nieuw topic hiervoor starten ?
blackdog
Golden Member
Daar de mens het noodzakelijke niet kan volbrengen, streeft hij naar het overbodige (Goethe)
Hi!
MOOI!
Een nieuw topic lijkt me een goed Plan.
Voor de indruk wat ik bedoel kijk even naar de de twee onderstaande video's.
Mooie NAGRA met meerdere versies van "shuttle control"
https://www.youtube.com/watch?v=t-DZnwQiHJY
Kijk vanaf 4:20 er zijn twee "shuttle modes" bij deze Studer recorder
https://www.youtube.com/watch?v=jtidyF3X1ns
Goed bezig deKees.
Ik denk om het mooie analoge gevoel te benaderen, dat er misschien nog wat meer stapjes in snelheid nodig zijn.
Ook dat de stapjes dan niet in decaden gaan maar iets van een log functie.
Wat het precies moet worden in de code weet ik niet, te weinig kennis, maar ik weet wel wat prettig werkt
Wat ik nu is de code zie, is dat de stapjes makkelijk aanpasbaar zijn, maar weet niet of dit zo blijft bij b.v. als er b.v. 16 cases zijn.
Wat mij betreft moet het zo worden dat je met plezier en snel je voeding kan instellen bij een hogere resolutie van zeg een 16 bit DA.
Ik maak zo een nieuw topic aan hierover, want dit topic is eigenlijk klaar wat mij betreft.
Bedankt voor de input en het mee werken.
Gegroet,
Bram
hardbass
PE2BAS
Aha,
Ik snap nu pas wat je bedoelt. Wat je beschrijf heeft inderdaad geen betrekking tot een regelaar. Ik dacht dat je met een potmeter de setpoint wou instellen, en de uitgang daar naar ging regelen.
blackdog
Golden Member
Daar de mens het noodzakelijke niet kan volbrengen, streeft hij naar het overbodige (Goethe)
Hi,
Het heeft even geduurd, maar heb net mijn potmeter gevonden waar ik mee wou testen.
Ik ben niet bij mijn LAB in de buurt vandaar.
In heb de code van deKees geladen en er wat mee gespeeld.
Ik begrijp het nog niet helemaal maar dat vind ik niet zo vreeemd
Ik heb met de waarde "interval" gespeeld en met de stapgrote.
Ik ben vergeten een knop mee te nemen voor mijn potmeter en het instellen van de waarde is hierdoor niet echt confortabel.
Maar door regelmatig een willekeurige waarde te kiezen waarop ik de code wou instellen kreeg ik toch handigheid er in.
De 300mSec vind ik te lang duren voor het soepel te kunnen instellen van de waarde.
Met mijn nu gebruikte potmeter zonder knop zit ik op een waarde van 150mS.
Wat betreft stapgrote zit ik nu op 1, 20 en 200 dat is dan voor de 30V en 3A bereik.
Mijn vraag aan deKees is deze, is het mogelijk nog twee of vier stapjes per kant toe te voegen?
En ik denk dat het zinnig ik als er ook twee drukknopjes bij komen zodat je in de kleinste waarde het makkelijker in kan stellen.
Misschien is een andere oplossing de "interval" waarde dynamisch te maken.
Dus bij bitjes langzamer dan bij de grote stapjes, goed plan , wat vinden jullie?
Om de code wat universeler te maken, is het mogelijk net als de "interval" ook de bitwaarde vana de gebruikte DA boven in de code te defineren?
Dan wil ik het eens proberen met de MCP4725 DAC die ik bij me heb.
Ik heb nog niet ingezien welke variabele ik nu in mijn stukje code voor de kan opnemen.
Hieronder het stukje code dat ik heb gebruikt voor de eerste test met een Rotary encoder.
#include <Wire.h>
#include <Adafruit_MCP4725.h>
Adafruit_MCP4725 dac; // constructor
#define ROTARYPA 2
#define ROTARYPB 4
long rotaryCount = 0;
long lastRotaryCount = 0;
void setup(void) {
Serial.begin(9600);
dac.begin(0x60); // The I2C Address: Run the I2C Scanner if you're not sure
pinMode(ROTARYPA, INPUT);
pinMode(ROTARYPB, INPUT);
attachInterrupt (0, rotaryTurn, RISING); // interrupt 0 is pin 2, For rotary encoder
}
void loop(void) {
if (lastRotaryCount != rotaryCount) {
Serial.println(rotaryCount);
lastRotaryCount = rotaryCount;
uint32_t dac_value;
dac.setVoltage(rotaryCount, false); // Deze heb ik geplaatst om de uitgangswaarde van de DAC aan te passen
}
}
void rotaryTurn()
{
// Interrupt Service Routine for a change to Rotary Encoder pin A
if (digitalRead (ROTARYPB))
rotaryCount--; // Turn it Down!
else
rotaryCount++; // Turn it Up!
}Het rammeld natuurlijk aan alle kanten vooral door het ontbreken van "debounce"
Ik heb geen 4066 of 4093 bij me, ik gebruik liever geen software debounce.
Maar dat is voor nu niet belangrijk, met dit stukje code plaats ik een waarde in de DAC en dit werkt: dac.setVoltage(rotaryCount, false);
Dus de waarde die in "rotaryCount" wordt naar de DAC gestuurd.
Welke variabele van de code van deKees heb ik nu nodig, om mijn DAC te kunen aansturen?
Is dit "Buffer"
Mijn dank weer en gegroet,
Bram
Dac aansturen gaat met "TargetVoltage.m_Value".
Dus
...
if(TargetVoltage.Update()) // Hier lezen we de Potmeter voor Spanning.
{ Report = true; // Vlag wordt true als Spanning is veranderd.
dac.setVoltage(TargetVoltage.m_Value, false);
}
...
Maar het kan zijn dat je nog een schaalfactor moet toepassen. Want TargetVoltage.m_Value is in millivolt, en je DAC waarschijnlijk niet.
Op dezelfde manier kun je een 2e dac aansturen voor de stroom instelling, nu met "TargetCurrent.m_Value"
...
if(TargetCurrent.Update()) // Hier lezen we de Potmeter voor Spanning.
{ Report = true; // Vlag wordt true als Spanning is veranderd.
dac2.setVoltage(TargetCurrent.m_Value, false);
}
...
blackdog
Golden Member
Daar de mens het noodzakelijke niet kan volbrengen, streeft hij naar het overbodige (Goethe)
Hi,
Dank je deKees, ga ik van de week even testen, eerst wat potmeters op stukjes print monteren met verschillende knop grote's omgoed te kunen testen.
Jammer genoeg heb ik hier op het ogenblik geen i2c 15 a 16 bit DAC in huis.
Wat er wel is, is een redelijk aantal mooie parallel mode converters van Analog, Linear, Brooktree en Burr Brown
Nix in i2c en ik heb ook even gekeken of de vrienden van REW iets in 15 of 16 bit DAC hebben, maar jammer genoeg niet.
12bit is geen probleem omdat ik deze wel heb, dus ik zal van de week even kijken of ik snel wat betaalbare 16 bit DAC's kan scoren die snel geleverd kunen worden.
Om aan te geven dat ik serieus er mee bezig ben heb ik wat materiaal besteld en dat lag bijna allemaal klaar toen ik terug kwam van mijn vakantie
Helmaal rechts, verschillende mini/Micro Arduino's in 5 en 3,3V.
Drie maten display's, twee verschillende printjes met de mooie hoge resolutie, BMP280 luchtdruk/Temperatuur sensor.
dan ook twee verschillende printjes met de 16 bit ads1115 ADC.
Twee verschillende FTDI 232 converter printjes en nog wat i2c level converters 3,3/5V
En ik heb twee display's van Electronic Assembly gekocht van de DOGS serie in de resolutie van 102x64.
De rede is dat ik iets wou hebben zoals de Nokia 5110 maar dan een iets hogere resolutie met de zeer lage vermogens opname.
Als het goed is zijn er een aantal library's voor en mijn eerste projectje met de u8glib labrary zou het ook meten ondersteunen.
Van de week hang ik hem even in dat projektje om te zien hoe deze displays er uit zien.
Hier wat foto's van deze display's, je koopt ze in modules, dus display appart vande achtergrond verlichting en de printpennen.
Dit zijn de drie onderdelen, het witte deel is de Aber achtergrond verlichting.
Rechtsboven is het Display van achter gezien, beetje lasting de stickers er af te krijgen...
Hier kunnen jullie zien hoe je het display op de achtergrond verlichting monteerd.
De display verlichting van achteren gezien, de pennen nog niet gesoldeerd.
De display's worden met duidelijke documentatie geleverd, daar kunen de Chinesen nog wat van leren
Nu hangt het aleen nog af van mijn inzet en leervermogen (laten de de beschikbare tijd niet vergeten) om iets leuks/moois te maken.
Twee zaken staan op het lijstje van komende week, wat ik al aangaf het testen van de nieuwe versie van deKees software
en het frontje maken van mijn ruismeet systeem waarin ik dus een mini Arduino wil hangen voor het aansturen van de relais en een paar LED's, vandaar dat ik het hier meld.
Gegroet en ik laat snel weten hoe het met de nieuwe versie software gaat.
Bram
blackdog
Golden Member
Daar de mens het noodzakelijke niet kan volbrengen, streeft hij naar het overbodige (Goethe)
Hi,
Nog geen tijd gehad om met de nieuwe software te spelen 
Maar wel tussendoor wat kleinere zaken gedaan waaronder het testen van de DOGS displsay's.
Hier wat plaatjes hoe het display er uit ziet tijdens het gebruik met en zonder verlichting.
Wat je hier ziet is de code die ik had gemaakt voor het Nokia 5110 display.
De enige aanpassing van de code zijn de lijntjes op het diaplay.
Dit display heeft een hogere resolutie dan het Nokia display.
Nokia = 84x48 en het DOGS display dat ik hier heb = 102x64 pixels.
Ik heb de tekst nog niet mooi op het display gezet, dit was met opset zodat ik goed het verschil kon zien met de indeling voor het Nokia display
Dit is het plaatje met achtergrond verlichting aan.
Wat valt nu volgens mij op bij dit display, ik vind het "vrouwelijk geslachtdeel"!
Slecht contrast, erg kleine kijkhoek en in verhouding met het Nokia display is het duur.
Mooi dat je het in modules kan opbouwen zoals diverse kleuren achtergrond verlichting,
touch moduul wat ik onzin vind voor dit veel te kleine display.
Oja, je mag ook nog drie vrij grote condensatoren van 1uF plaatsen, anders gaat het display niet werken!
Waarom voor is voor mij het display toch nog bruikbaar, het verbruikte vermogen zonder verlichting is erg laag en het heeft dus meer pixels zodat ik het wat mooier in beeld kan brengen.
Dit is de weergave met daglicht, dit lijkt heel aardig,
maar is zo vastgelegt op de foto zodat er maximaal contrast was.
De achtergrond verlichting is in twee groepen LED's opgedeeld, zodat je meer keuze hebt voor 3,3 en 5V voeding.
De twee display's die ik heb gekocht zijn zeker bruikbaar voor mij, maar die 16 Euro per stuk zijn ze niet waard.
Als je kijkt wat Philips heeft gedaan met het Nokia display, hoe goed dat wel niet is,
dan verwacht ik van een modern product dat het minstens de zelfde eigenschappen zou hebben, duidelijk een verkeerde aanname.
Nog een tip voor de eventuel DOGS display gebruikers, de contrastwaarde voor dit display is heel anders dan de waarde in de code voor het Nokia display.
De optimale waarde voor het Nokia display geeft een zwart beeld op het DOGS display.
Wat betreft de door mij gebruikte library, de U8GBLIB was het alleen de regel voor het DOGS display aanzetten.
En natuurlijk worstelen met de vele benamingen betreffende de datalijnen,
ik blijf nog steeds van mening dat de meeste coders/fabrikanten te veel blowen.
Hoe kan je anders voor de paar data lijnen steeds andere namen verzinnen...
Mar goed, dit werkt en daar kan ik dan verder mee aan de slag
Gegroet,
Blackdog
blackdog
Golden Member
Daar de mens het noodzakelijke niet kan volbrengen, streeft hij naar het overbodige (Goethe)
Hi,
Het leren van Arduino coderen heeft even stil gelegen en ik ga weer starten hiermee.
Als eerste wil ik wat open eindjes oplossen, en de eerste is de opmerking van fcapri dat ik niet efficient bezig ben met het gebruik van de U8glib library omdat de manier hoe ik de data in beeld breng,
Bij gebruik van een ander scherm van die van Nokia flikering kan geven.
Nu wil ik fcapri zijn voorstel gaan proberen maar ik loop tegen dit aan bij zijn post van 4 juli 10:57:
void setup(){
...
printLayout();
...
void printLayout (){
u8g.setFont(u8g_font_5x7);
u8g.drawStr(2, 7, "Oven = \260C");
u8g.setFont(u8g_font_5x7);
u8g.drawStr(2, 15, "Trafo = \260C");
u8g.setFont(u8g_font_5x7);
u8g.drawStr(2, 23, "Kast = \260C");
u8g.setFont(u8g_font_5x7);
u8g.drawStr(2, 31, "LM317 = \260C");
u8g.setFont(u8g_font_5x7);
u8g.drawStr(2, 39, "Accu = V");
u8g.setFont(u8g_font_5x7);
u8g.drawStr(2, 47, "H= %");
}
De "printLayout" beging en wordt afgesloten met drie puntjes zoals dit ...
Heeft dit een bepaalde betekenis, is het een andere manier om aan te geven dat het commentaar is enz?
Ene stukje verderop staat het volgende tussen de drie puntjes:
void loop(){
...
printData();
...
Ik kan dit gebruik van puntjes niet snel terug vinden...
Kan fcapri of anderen mij dit uitleggen?
Gegroet,
Bram
De puntjes hebben geen functie in C++ Bram.
Is alleen bedoeld om de rest van de code even te "maskeren". Je kan het dus dan lezen als:
void setup(){
printLayout();
void printLayout (){
u8g.setFont(u8g_font_5x7);
u8g.drawStr(2, 7, "Oven = \260C");
u8g.setFont(u8g_font_5x7);
u8g.drawStr(2, 15, "Trafo = \260C");
u8g.setFont(u8g_font_5x7);
u8g.drawStr(2, 23, "Kast = \260C");
u8g.setFont(u8g_font_5x7);
u8g.drawStr(2, 31, "LM317 = \260C");
u8g.setFont(u8g_font_5x7);
u8g.drawStr(2, 39, "Accu = V");
u8g.setFont(u8g_font_5x7);
u8g.drawStr(2, 47, "H= %");
}
Ben er ook mee bezig geweest om C++ met de arduino aangeleerd te krijgen. Je bent al een aardig stukje onderweg, ik ben er even mee gestopt (teveel dingen tegelijkertijd willen 
)
die puntjes willen idd gewoon andere code zeggen.
zoals het initaliseren van je meet apparatuur (temp sensor, humidity,...)
blackdog
Golden Member
Daar de mens het noodzakelijke niet kan volbrengen, streeft hij naar het overbodige (Goethe)
Hi,
Ik heb de laatste paar dagen toen ik een beetje tijd had gespeeld met het voorstel van fcapri om de u8glib library efficienter toe te passsen.
Ik krijg dit niet goed werkend...
Ik heb bij de makers gekeken, Olikraus en bij "Henry's Bench"
om de manier goed te doorgronden, het kwartje gaat echter niet vallen.
Ik zal met een simpeler stukje code moeten gaan werken om goed inzicht te gaan krijgen en daar is nu de tijd niet voor.
Ik laat het hier even bij wat de optimalisatie betref van de code voor deze toepassing.
Ik heb nu op twee display (LCD typen) geen last van flikker en zal het weer oppakken als ik de u8glib library ga gebruiken met een LED display.
Nu de overgebleven tijd spanderen aan de code voor de potmeters.
Kijken of ik dit zo kan krijgen dat het goed werkbaar wordt.
Verder had ik wat testjes gedaan met de Rotary Encoder van HP, wat werkt dat ding mooi!
256 pulsjes per omwenteling en gewoon TTL uitgangen, nix PullUp weerstanden gebruiken.
Prachtig hoe hij werk, een echt analoog gevoel, mooi soepel gevoel ook van het draaien van de as door het goede lager.
Deze encoder is al lang niet meer te verkrijgen (HEDS-7500) en was toen ik hem aanschafde voor een digitaal gestuurde voeding midden 80 jaren, net geen 200 florijnen als ik dit goed onthouden heb.
Om toch wat meer vergelijking's materiaal te hebben, heb ik op e-bay twee Rotary Encoders besteld met 600 pulsjes per omwenteling.
Deze zijn met 12 Euro een stuk betaalbaarder.
Deze zijn met een 12 bit DAC goed te gebruiken, dat zijn bijna 7 volle omwentelingen voor 4096 stapjes.
Misschien is de 300 pulsjes zelfs beter voor de 12 bit DAC, dat is 14 omwentelingen.
Dat is iets meer dan 2V per omwenteling bij een 30V voeding.
Eerst maar eens mee spelen en dan de keuze maken hoe ik er mee verder ga.
Ik heb nog wat DAC ic's binnen gekregen en moet nu nog wat verloop printjes bestellen.
Ik soms wel een beetje moe van al die verschillende type IC behuizingen
Jammer genoeg is mijn tijd een beetje versprokkeld en dat haalt de efficiëntie een beetje uit het leren en testen, het zij zo
Verder ook nog testjes gedaan met een tweede zending klok ic's printjes.
Deze kwamen van DealExtreme, GEEN DS3231 printjes bij hun kopen!!!
Dit is eerste klas bagger, er zitten geen orginele ic's op.
De printjes hebben een 32Khz klok frequentie en die hang ik dan aan mijn teller.
Die frequentie van de DealExtreme printjes zwabberen als een dronken hoer op de fiets...
Net zo stabiel als b.v. een JostyKit FM zender. (voor de ouderen onder ons )
Verder kan je deze printjes ook niet corrigeren op de klok frequentie.
De drie printjes die ik hier heb van Banggood kan ik met software en twee pulsdrukkers precies op 32,7000000KHz zetten zoals ik al eerder vertelde.
Met deze DealExtreme printjes is dit niet mogelijk, het is net de schakelaars niet aangesloten zijn.
Na een e-mail aan DealExtreme te hebben gestuurd vragen ze mij een video te maken van hun niet werkende produkt!!!
Ik ga dit trouwens wel doen, alleen al om te kijken wat voor oplossing zij gaan aandragen
Dat was het voor nu.
Gegroet,
Blackdog
blackdog
Golden Member
Daar de mens het noodzakelijke niet kan volbrengen, streeft hij naar het overbodige (Goethe)
Hi,
Ik ben een beetje druk en weinig tijd om hier zaken te laten zien.
Ik heb wel een vraag, voor mijn ruismeetsetje die ik met een Arduino ga aansturen wat betreft een aantal LEDjes en relais heb ik een pulstijd nodig.
Het zijn bipolaire relais en ga er vanuit dat deze een stroompuls nodig hebben van 0,3 seconde.
Dit is natuurlijk heel simpel op te lossen door de desbetreffende uitgang 1 te maken en na .3 seconde weer laag te maken.
Maar al je een aantal van deze opdrachten hebt dan blok je het programma op zo'n manier dat het onwerkbaar wordt door alle wait state statements.
Ik heb al een manier gevonden met een library van Jack Christenson "Timer" die simpel doet wat ik wil.
En dan nu de vraag, als ik geen library wil gebruiken is dit dan ook simpel op te lossen met de functies die al in de Arduino/EDE zitten.
Dank en gegroet,
Blackdog
Dat kan met de millis() funktie. Die is niet-blocking en geeft het aantal milliseconden sinds programma gestart is. De waarde is 32 bits, dus die gaat na 49 dagen in een overflow (dan springt hij weer terug naar 0).
Voor zo een puls relais moet je dan administratie bijhouden, die aangeeft of het relais aktief is en wanneer die gestart was. Dan kun je regelmatig een funktie gebruiken die test of het al tijd is om het relais uit te schakelen.
Gaat ongeveer zo:
// Declaratie van een type PulseRelais
class PulseRelais
{
public:
// Constructor funktie. Om vast te leggen welke pin wordt gebruikt
// - Voor dit Pulse relais
PulseRelais(int PinNr)
{ m_PinNr = PinNr;
m_Active = false;
pinMode(m_PinNr, OUTPUT);
digitalwrite(m_PinNr, LOW);
}
// Deze funktie wordt gebruikt om het relais te starten
void Start()
{ m_Timer = millis(); //< Hier wordt de start-tijd geregistreerd
m_Active = true; //< Hier wordt het relais aktief gezet
digitalWrite(m_PinNr, HIGH); //< En hier wordt de pin geschakeld
}
// Deze funktie moet in de loop() regelmatig aangeroepen worden.
void Check()
{ if(m_Active) //< Alleen als het relais aktief is
{ if ((millis() - m_Timer) > 300) //< En alleen als er an 300 millis voorbij is
{ m_Active = false; //< Dan vlag uitzetten
digitalWrite(m_PinNr, LOW); //< en de pin uitschakelen
}
}
}
unsigned long m_Timer; //< Hier wordt de startTijd vastgelegd
bool m_Active; //< Deze vlag geeft aan of het relais aktief is
int m_PinNr; //< En deze pin wordt voor het relais gebruikt.
};
// Dus nu kunnen we variabelen aanmaken van het type PulseRelais.
// - Relais1 op Pin 12, Relais2 op pin 13, Relais3 op pin 14
PulseRelais Relais1(12);
PulseRelais Relais2(13);
PulseRelais Relais3(14);
void loop()
{
...
if( ... ) //< Testen wanneer Relais1 aan moet.
{ Relais1.Start(); //< En daadwerkelijk aanzetten
}
...
Relais1.Check(); //< Testen of Relais1 al uit moet
Relais2.Check(); //< En ook voor Relais2
Relais3.Check(); //< en Relais3
...
}
PS: Deze code is niet getest, dus er kan nog een typefoutje inzitten.
[Edit]: Typefouten verwijderd.