| Mijn joystick / simpit project | Blog | Elite Dangerous CMDR Cataclysm72
Verwijderd
nou lees ik ' Mobile operating systems including iOS, Android, Windows Phone and BlackBerry, as well as OS X and Windows 8, natively support Bluetooth low energy. '
en die goedkope Bluetooth printjes HC 05/06 hebben 'Bluetooth Specification v2.0+EDR
kan je daarmee niet communiceren dan met IOS
Op de terminal gaat het goed.
Nu kan ik wel lcd.clear() gaan gebruiken of voor lcd.print(cny70) eerst een stel spaties op het display zetten om de boel op te ruimen, maar dat is een workaround.
Kan iemand dit gedrag verklaren?
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
Welke LCD/Oled is dat...?inquestos schreef op dinsdag 18 februari 2014 @ 19:58:
"battery time is about 7 hrs at a normal status." , maar toch erg knap gedaan voor zo'n zelfbouw-smartwatch op klein formaat.
Er staat er ook een met ge-3d-printe case, kan nog wel een beter ontwerp gebruiken. Dit lijkt me niet draagbaar
[afbeelding]
MT Venus E 5KW (V151) P1 HomeWizard | Hackerspace Brixel te Hasselt (BE) - http://www.brixel.be | 9800X3D, 96GB DDR5 6000MHZ, NVIDIA GEFORCE 4090, ASRock X670E Steel Legend, Seasonic GX1000
/me heeft eindelijk ook een icoontje.. woef.. boeien..
Ja, er staan karakters op het display, jij schrijft er minder, de resterende blijven staan.Raven schreef op donderdag 20 februari 2014 @ 17:45:
Ik heb een HD44780 display en een CNY70 aan een Nano hangen. Display werkt prima, de CNY70 sensor die via A0 wordt uitgelezen ook. Maar als ik de waarde van A0 op het display laat zetten, en de waarde bestaat ineens uit minder cijfers, dan blijft het meest rechtse cijfer van de vorige waarde staan. Bijv. als de waarde eerst 1013 was en daarna 802, dan staat er 8023 op het display. Gaat het van 802 maar 63, dan staat er 632. Gaat het van 1013 maar 42, dan staat er 4213.
Op de terminal gaat het goed.
Nu kan ik wel lcd.clear() gaan gebruiken of voor lcd.print(cny70) eerst een stel spaties op het display zetten om de boel op te ruimen, maar dat is een workaround.
Kan iemand dit gedrag verklaren?
Als je echt per sé geen spaties of een clear wilt doen zou je op lengte kunnen checken (>999 is een leading spatie), maar doe liever het volgende ;
Gewoon netjes de print methode nalezen en dan zie je dit;
(number) Minimum number of characters to be printed. If the value to be printed is shorter than this number, the result is padded with blank spaces. The value is not truncated even if the result is larger.
Oftewel %4i in jouw geval. i staat voor integer.
Resultaat: printf(%4i, mijn_getal);
[ Voor 43% gewijzigd door foekie01 op 20-02-2014 19:02 . Reden: typo ]
In dit geval adviseer ik:Resultaat: printf(%4i, mijn_getal);
1
2
3
| char buffer[32]; //lengte aanpassen sprintf(buffer, "%4i", mijn_getal); lcd.print(buffer); |
| Mijn joystick / simpit project | Blog | Elite Dangerous CMDR Cataclysm72
Maar dit gedrag is dus normaal?
edit:
1
| lcd.print(cny70); |
vervangen door
1
2
3
| char buffer[32]; sprintf(buffer, "%4i", cny70); lcd.print(buffer); |
Dat lijkt te werken, thanks
[ Voor 36% gewijzigd door Raven op 21-02-2014 15:07 ]
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
Als het goed is zal dit werken.
1
| lcd.printf("%4i", cny70); |
edit/
Ik had eerst even moeten google.

http://playground.arduino.cc/Main/Printf#.UwkONYUlhuY
Dan doen we het zo, dat zal als het goed is wel werken zonder enige aanpassingen.
1
| lcd.print(printf("%4i", cny70)); |
[ Voor 28% gewijzigd door mad_max234 op 22-02-2014 22:00 ]
Misschien is het handig om je display buffer in ieder geval even te calloceren.
1
2
3
4
5
6
| int row = 2; // 2x16 int col = 16; char * displaybuf = (char*)calloc(sizeof(char) * row * col , sizeof(char)); ... free(displaybuf); |
Volgende keer even doorgooglen:mad_max234 schreef op zaterdag 22 februari 2014 @ 21:54:
Dan doen we het zo, dat zal als het goed is wel werken zonder enige aanpassingen.
C:
1 lcd.print(printf("%4i", cny70));
1
| int printf ( const char * format, ... ); |
printf returnt een int (het aantal karakters dat naar de console is gestuurd), en die stuur je nu naar de lcd.print(). Niet wat je wilde hebben denk ik.
| Mijn joystick / simpit project | Blog | Elite Dangerous CMDR Cataclysm72
mad_max234 schreef op zaterdag 22 februari 2014 @ 21:54:
Kan ook direct met printf dan heb je geen extra buffer nodig om je string in op te slaan. Al weet ik niet wat de compiler optimization ermee doet, kan goed zijn dat ze beide dezelfde code genereren, zal je even moeten testen.
Als het goed is zal dit werken.
C:
1 lcd.printf("%4i", cny70);
edit/
Ik had eerst even moeten google.![]()
http://playground.arduino.cc/Main/Printf#.UwkONYUlhuY
Dan doen we het zo, dat zal als het goed is wel werken zonder enige aanpassingen.
C:
1 lcd.print(printf("%4i", cny70));
1
| lcd.print(printf("%4i", cny70)); |
In hoeverre is dat handig?Oyster schreef op zaterdag 22 februari 2014 @ 22:11:
[...]
Misschien is het handig om je display buffer in ieder geval even te calloceren.
C:
1 2 3 4 5 6 int row = 2; // 2x16 int col = 16; char * displaybuf = (char*)calloc(sizeof(char) * row * col , sizeof(char)); ... free(displaybuf);
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
Heel stom want gebruik het heel vaak, heb zelfs blog post overgemaakt tijdje terug.
Xmega blog: USART part 1, schrijven naar usart. (Xmega)
Heb dus deze macro er bij voor het streamen van bytes via stdout.
1
| static FILE mystdout = FDEV_SETUP_STREAM (uart_putchar, NULL, _FDEV_SETUP_WRITE); |
Edit/
Er zit vast wel een lcd.clear(); functie in jou arduino library, kan iets anders genoemd zijn maar zal er vast en zeker inzitten
[ Voor 13% gewijzigd door mad_max234 op 22-02-2014 22:31 ]
Is dit gedrag nou een ontwerpfout of feature? Daar ben ik nog wel benieuwd naar.
Vooralsnog lijkt
1
2
3
| char buffer[32]; sprintf(buffer, "%4i", cny70); lcd.print(buffer); |
[ Voor 15% gewijzigd door Raven op 22-02-2014 22:37 ]
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
Je moet het zo zien, elke pixel heeft geheugen adres(in de HD44780 controller chip), jij schrijft naar dat geheugen als je iets wilt weergeven en niet naar de lcd zelf, lcd controller stuurt de lcd aan niet de arduino, die schrijft alleen data naar het geheugen van de hd44780 controller. LCD controller weet niet wat jij wilt en kan alleen maar domweg weergeven wat er in zijn geheugen is gezet. Jij moet dus zorgen dat juist data in het geheugen staat, zoals je dus al hebt gemerkt als je eerst 4 cijfers gebruikt en vervolgende maar drie nieuwe in geheugen zet de vierde gewoon blijft bestaan.
Wil je alleen deel van je lcd refreshen dan overschrijf je alles wat je wilt aanpassen, dus alle oude cijfers die aangepast moeten worden moeten overschreven worden, betekend dus ook dat je geheugen moet leegmaken als er lege plek moet komen.
Hier staan bijv. de hd444780 instructies en meeste libs hebben die ook netjes allemaal geïmplanteerd.
http://dawes.wordpress.co.../hd44780-instruction-set/
Edit/
LCD.clear was niet als vervangen voor de sprintf, mocht je dat denken, want dat kan ik niet helemaal uit je post halen. Gaf dat als alternatief op Oyster zijn oplossing, legen door 0x01 te schrijven is heel efficient overigens, veel sneller dan alles overschrijven, hoeft dan maar 1 byte te sturen ipv 16, HD44780 doet de rest door geheugen vrij te geven. Het helemaal opnieuw beschrijven daarin tegen is inefficiënt tegenover dat je maar deel aanpast, als je maar 4 bytes veranderen en je hebt rest van je lcd in gevuld met data die niet veranderd dan is het veel sneller om die 4 bytes te overschrijven dan hele lcd schoon te vegen en alles opnieuw te moeten verzenden.
Je gebruik ze dus voor verschillende situaties, bijv. wil je leeg lcd, dan is lcd.clear veel sneller dan 16 keer byte schrijven om plekken leeg te maken, wil je andere data weergeven kan je beter overschrijven.
[ Voor 29% gewijzigd door mad_max234 op 22-02-2014 23:29 ]
Op de shield zit een L298P, zelf gebruik ik altijd een L298N om een motor aan te sturen en ik heb die voltage drop niet: ik meet een keurige 9V aan de output. Kan dat verschil in de P- en N-versie zitten? Ik kan hier niets over vinden in de datasheet. Je zou toch kunnen aannemen dat het interne van zo'n chip toch gelijk is en dat alleen de package verschilt?
In dit draadje wordt er gespeculeerd over een circa 3V voltage drop bij de L298P: klopt dit verhaal. Ik kan die "total drop" wel terugvinden in de datasheet, maar ik vind het nogal veel?
Verder zou ik er maar grotendeels ervan uitgaan dat zo'n datasheet toch wel redelijk moet kloppen en anders zit er wrs niets anders op als toch een multi erop aan te sluiten.
Iets anders, een vraagje over een programma. Niet echt belangrijk maar goed, ben toch benieuwd
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
| /* * Debounce sketch * a switch connected to pin 2 lights the LED on pin 13 * debounce logic prevents misreading of the switch state */ const int inputPin = 2; // the number of the input pin const int ledPin = 13; // the number of the output pin const int debounceDelay = 10; // milliseconds to wait until stable // debounce returns true if the switch in the given pin is closed and stable boolean debounce(int pin) { boolean state; boolean previousState; previousState = digitalRead(pin); // store switch state for(int counter=0; counter < debounceDelay; counter++) { delay(1); // wait for 1 millisecond state = digitalRead(pin); // read the pin if( state != previousState) { counter = 0; // reset the counter if the state changes previousState = state; // and save the current state } } // here when the switch state has been stable longer than the debounce period return state; } void setup() { pinMode(inputPin, INPUT); pinMode(ledPin, OUTPUT); } void loop() { if (debounce(inputPin)) { digitalWrite(ledPin, HIGH); } } |
regel 17: previousState = digitalRead(pin); // store switch state
Ik zie ( pin) helemaal nergens toegewezen staan zoals bijvoorbeeld wel bij
const int inputPin = 2; // the number of the input pin
het geval is.
Hoe weet de uC dan welke pin er moet worden gedigitalRead ?
Programma compileert maart heb het nog niet opgebouwd. Dit voorbeeld komt uit Cookbook en die is gratis slechts per paragraaf te lezen. Hieronder de betreffende begeleidende tekst:
https://www.inkling.com/r...-2nd/chapter-5/recipe-5-3
r12: boolean debounce(int pin)
r40: if (debounce(inputPin))
r7: const int inputPin = 2;
Als er niet gemeten en verteld wordt hoe de motor aangestuurd wordt, is het nogal lastig natuurlijk. Je vraagt jezelf af of een Vdrop van 3V mogelijk is terwijl er geen zekerheid is dat het werkelijk om 3V gaat. Nu begrijp ik wel dat het spanningsverschil is gegokt aan de hand van draaisnelheden en stuurspanning op een regelbare voeding ofzo. Maar voor hetzelfde geld wordt de motor op het shield aangestuurd met PWM. Kan allemaal, maar wordt niet verteld.almightyarjen schreef op dinsdag 04 maart 2014 @ 21:02:
Iemand heeft mij een vraag gesteld over de Arduino Motor Shield en eerlijk gezegd heb ik daar geen antwoord op.
...
[ Voor 95% gewijzigd door Oyster op 05-03-2014 22:37 ]
Ik snap het nu
r12 had ik gezien en r7 ook maar hoe regel40 werkt heb ik blijkbaar niet begrepen.
Tnx
Zojuist bedacht ik me dat ik in principe een standaard relais zou kunnen gebruiken met een optocoupler maar dan zit ik weer met het probleem dat ik een tweede 5v systeem gescheiden van de arduino moet hebben, puur om de relais te schakelen. En dan is die optocoupler weer zinloos.
Is er een mogelijkheid om een phototriac ssr aan te sluiten op een manier waardoor er een normally closed situatie word behaald?
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Dat dacht ik dusmad_max234 schreef op zaterdag 22 februari 2014 @ 23:15:
Edit/
LCD.clear was niet als vervangen voor de sprintf, mocht je dat denken, want dat kan ik niet helemaal uit je post halen. Gaf dat als alternatief op Oyster zijn oplossing, legen door 0x01 te schrijven is heel efficient overigens, veel sneller dan alles overschrijven, hoeft dan maar 1 byte te sturen ipv 16, HD44780 doet de rest door geheugen vrij te geven. Het helemaal opnieuw beschrijven daarin tegen is inefficiënt tegenover dat je maar deel aanpast, als je maar 4 bytes veranderen en je hebt rest van je lcd in gevuld met data die niet veranderd dan is het veel sneller om die 4 bytes te overschrijven dan hele lcd schoon te vegen en alles opnieuw te moeten verzenden.
Je gebruik ze dus voor verschillende situaties, bijv. wil je leeg lcd, dan is lcd.clear veel sneller dan 16 keer byte schrijven om plekken leeg te maken, wil je andere data weergeven kan je beter overschrijven.
Van 't weekend maar eens de Nano in de meterkast plaatsen, heb een sketch geschreven dat de tijd tussen het voorbijkomen van de markering op de draaischijf meet, dan het verbruik in watt berekend en dat weergeeft op het display. Later maar eens kijken hoe ik dat ga vastleggen, via APC220 naar pc of ENC28J60 aan de Nano hangen. Had laatst een stel van die netwerk modules via Ebay gehaald, moet ze alleen nog testen...
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
Misschien is dit een mogelijkheid ? Gaat om een zogenaamde IO-powermodule
Kost wel 20 euro
http://www.power-io.com/l...losed-ssr-application.htm
http://nl.mouser.com/Prod...=DS9oLa/318Vh1LiMjKRfSQ==

Iemand anders melde daarna een wellicht eenvoudigere oplossing, SPST schakelaar over de geschakelde pinnen. Als 't geheel dan uitvalt kun je 't met 1 knop handmatig bedienen.
Ik zit nu echter met een heel ander probleem. Ik heb afgelopen week een Sparkfun Rotary Encoder (RGB) (link) besteld en ik probleem dat ding nu al de hele dag enigsinds uit te lezen en ik snap d'r geen bal van (pardon my french). Via de productpagina van Sparkfun ben ik wel weer op een Bildr artikel uitgekomen maar ook daar word ik niet heel veel wijzer.
Met de code uit het Bildr artikel (link) krijg ik wel een respons maar bij lange na niet wat ik verwacht. Het lijkt erop dat er tussen de posities van de knop in 4 states zitten die alle 4 (in volgorde lijkt het) getriggered worden. Ik wilde daarna gaan isoleren en heb de tweede regel vergelijkingen in de encoderUpdate() functie gecomment. Ik verwachtte toen dat er alleen activiteit in 1 richting zou worden waargenomen maar op een of andere manier word er evengoed opgeteld en afgetrokken. Erg vreemd. Suggesties?
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Wikipedia: Gray code
Not everybody wins, and certainly not everybody wins all the time.
But once you get into your boat, push off and tie into your shoes.
Then you have indeed won far more than those who have never tried.
Is je rotary encoder fatsoenlijk gedebounced in H/W, S/W?
Toevallig was ik ook bezig met zo'n encoder vandaag. Alles opgebouwd en aan de praat gekregen. Alleen het instellen van de tijd ging erg waardeloos.
Blijkt dat die schrijver er ook zelf last van had :
After watching that clip you can soon see that there is an issue with the encoder. As a normal switch can bounce (turn on and off very very quickly in the latter part of operation), so can a rotary encoder. That is why it would sometimes return a result of clockwise, instead of anti-clockwise. Furthermore, they are right little pains when trying to use in a breadboard, so if you were going to use one in greater lengths, it would pay to make up your own little breakout board for it. Therefore at this stage we will leave the encoder for a while.
http://tronixstuff.com/20...h-arduino-chapter-twelve/
In hoofdstuk 11 staat nog meer info
Ik weet niet of het enkel aan bouncen ligt. Altijd makkelijk als iets niet werkt om dan dat de schuld te geven ipv de code werkend te maken. Ik heb die van mij op ebay gekocht en daar krijg je amper nooit info erbij.
http://www.ebay.com/itm/2..._trksid=p3984.m1439.l2649
Bij mij zijn 3 weerstanden alvast ingebouwd, er zit een A-pin voor omhoog, een B-pin voor omlaag en een drukknoppin. Plus een gnd en vcc aansluiting. Verder heb je verschil per encoders hoeveel stappen die doorloopt per omwenteling zoals 12, 24 en nog veel meer.
Dat is volgens mij ook van invloed op de code die gebruikt moet worden.
Ik zal morgen nog eens verder kijken naar jouw links.
Niet als je dat voordeel in software negeert.Sissors schreef op zondag 09 maart 2014 @ 22:07:
Hele voordeel van Gray code is dat debouncen niet heel belangrijk is. Je wilt er nog wel wat rekening mee houden, maar het zou niet echt foutieve posities moeten veroorzaken, enkel dat hij paar keer switched voordat hij bij definitieve is.
@C.44: Heb je de comments gelezen? Het staat daar helemaal vol met jouw probleem.
kitao schreef op zondag 09 maart 2014 @ 22:15:
Ik weet niet of het enkel aan bouncen ligt. Altijd makkelijk als iets niet werkt om dan dat de schuld te geven ipv de code werkend te maken.

[ Voor 21% gewijzigd door Oyster op 09-03-2014 22:25 ]
@kitao, ik had dat stukje inderdaad nog niet gelezen, spreekt boekdelen inderdaad. Voor zover ik weet zijn de meeste goedkopere rotary encoders vaak modellen die geen Gray code, maar quadrature doorgeven. Bij Gray code kun je in principe zelfs nog de absolute positie van de encoder achterhalen maar bij quadrature moet je 't doen met de relatieve positie.
@Oyster, die comments had ik inderdaad ook al gezien ja, er word veel geklaagd maar ik kan er weinig data uit halen waarmee ik zelf een oplossing voor 't probleem kan bedenken.
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Ik weet niet wat je hiermee precies bedoelt Oyster maar ik dacht dat het toch wel mogelijk was om softwarematig te debouncen. Zelf ben ik niet zo'n programmeur maar de schrijver had er blijkbaar ook geen zin meer in vandaar mijn opmerking.
@C.44
hier nog een linkje
http://perhof.wordpress.c...ry-encoders-with-arduino/
Tip: google op rotary encoder arduino en dan afbeeldingen
dan kom je nuttige sites tegen
ps. Op een cap staat meestal een getalcode al dan niet leesbaar
[ Voor 5% gewijzigd door kitao op 09-03-2014 22:45 . Reden: ps ]
YouTube: Rotary Encoder Tutorial with Arduino Code
@Kitao, ik ga die pagina dadelijk ook eens even doorlezen. Ik heb uiteraard al wel gegoogled maar heb me in eerste instantie proberen te beperken tot de encoder die ik hier heb, wat werkt met veel encoders werkt namelijk blijkbaar vaak niet met dit ding
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Er zijn ook veel verschillenden. Zoals ik schreef zit er bij mij weerstanden ingebouwd en met een plus-min aansluiting. Bij jou zit er zelfs een lamp in. Bij veel voorbeelden zie je dan andere schakelingen, soms zelfs zonder voeding zoals hierC.44 schreef op zondag 09 maart 2014 @ 22:45:
@Kitao, ik ga die pagina dadelijk ook eens even doorlezen. Ik heb uiteraard al wel gegoogled maar heb me in eerste instantie proberen te beperken tot de encoder die ik hier heb, wat werkt met veel encoders werkt namelijk blijkbaar vaak niet met dit ding

http://tronixstuff.com/20...h-arduino-chapter-eleven/
. Ik ben er dan maar gewoon vanuit gegaan dat ik die weerstanden kon weglaten en voeding moest aansluiten
Probeer gewoon wat, zo snel blaas je het niet op.
Ik heb op dit moment wel de hele RGB meuk nog niet aangesloten, zelfs de drukknop niet. Ik houd me liever even bezig met de dingen die nog nieuw voor me zijn in plaats van dingen aan te gaan sluiten waarvan ik weet hoe ze werken.
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
er zijn 2 pinnen A en B (die op de mijne trouwens anders heten namelijk DT en CLK)
de ene is voor ClckWise en de ander voor CCW
Dat ding weet welke kant erop gedraaid wordt volgens dit schema :

http://playground.arduino...taryEncoders#.UxzlRfl5PbQ
Afhankelijk van de sketch gaat die dan op- of aftellen of een menu doorlopen etc.
De drukknop is dan meestal om in een submenu te komen
Bijv. je hebt een klok met uren, min, en sec
je drukt de knop in, de uren gaan knipperen, je draait de knop, je kunt de uren verstellen
nogmaals knop indrukken, uren staan ingesteld, minuten gaan knipperen ..... etc. etc.
Bij jouw encoder is dat niet anders enkel er zit een rgb ledje ingebouwd.
[ Voor 32% gewijzigd door kitao op 09-03-2014 23:19 ]
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Dat heeft dan misschientoch te maken met het aantal klikken dieer zijn per omwenteling. Hoe meer standen per omwenteling des te meer - hoe noem je dat - (resolutie?) zoals bij een adc.C.44 schreef op zondag 09 maart 2014 @ 23:20:
Klopt, en wat ik juist heb begrepen uit 't filmpje van Kevin Darrah is dat 't quadrature heet juist omdat er 4(!) pulsen zijn per "klik". Eens kijken of ik zelf een sketch kan maken naar aanleiding van de info uit 't filmpje want ik heb 't vage vermoeden dat ik op 1 of andere manier zijn 4 functies (falling en rising voor 2 kanalen) toch moet kunnen veranderen naar 2 of zelfs 1 functie. Maar eerst maar eens de basics.
Maar dit zou ik weer op moeten zoeken, en dat wou ik morgen eens bekijken.
Mijn encoder ligt hier toch op tafel.
Oh, ik had niet gezien dat het een reply was op dat artikel. Ik dacht dat de opmerking op zichzelf stond.kitao schreef op zondag 09 maart 2014 @ 22:38:
[...]
Ik weet niet wat je hiermee precies bedoelt Oyster maar ik dacht dat het toch wel mogelijk was om softwarematig te debouncen. Zelf ben ik niet zo'n programmeur maar de schrijver had er blijkbaar ook geen zin meer in vandaar mijn opmerking.
Geeft niet, was idd opmerking op dat artikel
Dat opbouwen met tig jumpers, weerstanden, transistors, 2 ic's, R.E en DS1307 is aardig projectje.
En dan bounct t alle kanten op ...
was daar niet echt blij mee.
De sketch is echter ook niet mals om daar zelf even aan wat te veranderen
dan zou ik toch liever gaan voor de schmitt-triggeroplossing in mijn vorige post
tenminste, als ik graag die schakeling permanent zou willen maken maar dat is niet het geval
Ik ben op dit moment aan 't zoeken naar alternatieve manieren om een rise of fall te detecteren.
M'n huidige code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
| int counter; byte lastA = 1, lastB = 1; void setup(){ Serial.begin(115200); attachInterrupt(0, CHANNEL, CHANGE); attachInterrupt(1, CHANNEL, CHANGE); } void loop(){} void CHANNEL(){ byte curA = digitalRead(2); byte curB = digitalRead(3); if (curA != lastA){ if (curA == 1){ // Rising if (lastB == 0){ // Forwards counter++; } else { // Backward counter--; } } if (curA == 0){ // Falling if (lastB == 1){ // Forwards counter++; } else { // Backwards counter--; } } lastA = curA; } if (curB != lastB){ if (curB == 1){ // Rising if (lastA == 1){ // Forwards counter++; } else { // Backwards counter--; } } if (curB == 0){ // Falling if (lastA == 0){ // Forwards counter++; } else { // Backwards counter--; } } lastB = curB; } Serial.println(counter); } |
Ik heb er al flink aan gesleuteld om zo dicht mogelijk in de buurt van de originele 3030 bytes te komen en zit op dit moment op 3046 bytes, maar die twee digitalRead's zitten me nog even dwars.
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Ik heb er nog even naar gekeken vandaag. Om te beginnen jouw link :
http://www.circuitsathome...rotary-encoder-on-arduino
Ik heb dit aangesloten en werkt zoals in die site vermeld. Ik weet jouw programmeerkennis niet - die van mij is belabberd - maar als je niks in beeld krijgt komt dat misschien omdat je de ser.mon. niet op 115200 baud heb gezet (helemaal rechtsonder)
Verder staat er dit in de site vermeld :
If you’re using Sparkfun encoder, you’ll notice that it gives 4 increments per click and it’s impossible to make it hold position between clicks. Therefore, to count clicks you will need to divide counter variable by 4.
Staat verder niet bij hoe dit precies gedaan moet worden
Mijn encoder geeft dit beeld met A op pinA0 en B op pinA1 :

klik
Zoals de schrijver vermeld is dit voor bijv een volumeregeling niet storend maar voor een display wel (waar ik dus zelf erg last van had bij mijn klokje)
Dan de andere link vanuit de sparkfunpagina; die van Bildr
http://bildr.org/2012/08/rotary-encoder-arduino/
Merk op dat ze daar een 12pulser gebruiken en geen 24 zoals die van jou met Led.
(ben er trouwens nog niet helemaal uit of en welk verschil dit dan geeft aangezien die toch eindeloos kan ronddraaien
Ook deze aangesloten en afgezien van een klein foutje in het 2e programma (encoderSwitchPin2 ; die 2 moet weg) werkt dit naar behoren maar nu wordt er per 4 geteld : 4,8,12,16....etc maar ook nu af en toe met verspringende tussenwaarden.
Op de drukknop lijkt er niks te gebeuren, komt wrs omdat dit niet is aangegeven in de sketch. Er staat enkel in de voidloop : //Do stuff here
Dit zal dan zelf verder uitgewerkt moeten worden zo te zien.
Ik hoop dat dit enigzins behulpzaamis geweest en lijkt er sterk op dat zo'n encoder toch degelijk een anti-dender schakeling erachter nodig heeft.
Zeker bij displays
Ok, jouw post werd gezet toen ik de mijne aan het schrijven was. Blijkbaar is je programmeerkennis ruim voldoende en was mijn opmerking over de baudrate volkomen onnodig.C.44 schreef op maandag 10 maart 2014 @ 10:43:
Ik heb vannacht en vanmorgen de rotary encoder aan de praat gekregen met hulp van 't filmpje van Darrah. Ik heb ook zijn 4 funties (falling en rising functies over 2 channels) weten te combineren in 1 enkele functie.
Ik begin nu ook enigzins te begrijpen wat je bedoelt met die 4 functies hoewel ik de video nog moet bekijken.
Wat wil je eigenlijk doen met die functies, dat begrijp ik nog niet helemaal ?
De code op CircuitsAtHome heb ik geprobeerd, wat de precieze output was kan ik me alleen even niet herinneren. Baudrate merk je vanzelf als die niet goed is, je krijgt dan wat aparte tekens in je SerialMonitor, afgezien daarvan kijk ik er zelf ook altijd naar in sketches van anderen, scheelt weer een paar seconden ergernis haha.
Die link van Bildr is inderdaad voor een andere encoder maar dat is ook een manier van quadrature lezen. Het aantal pulsen per volledige revolutie maakt voor de code niets uit zo lang je een relatieve positie wil bepalen. Als je een absolute positie wil weten dan is dat wel belangrijk uiteraard, maar dan zul je of de encoder elke keer moeten instellen of de laatste waarde in de eeprom zetten anders begint je counter toch steeds weer bij 0.
De drukknop van Bildr heb ik zelf niet eens geprobeerd, daarvan weet ik hoe ik em kan interfacen dus dat boeit me totaal niet, ditto voor de RGB led.
Wat Darrah doet is een interrupt koppelen aan de twee pinnen (A en C) van de encoder, net als op Bildr. Alleen bij Bildr word de interrupt getriggerd bij CHANGE (dus hoog naar laag of laag naar hoog), Darrah's interrupt kijkt naar de afzonderlijke RISING en FALLING momenten en heeft daar voor elke pin dus ook 2 functies voor.
In eerste instantie kijkt hij naar RISING bij beide pinnen
1
| attachInterrupt(0, functie, RISING); |
Dan word de interrupt direct vervangen door de FALLING variant omdat je van hoog alleen maar naar laag kunt.
1
| attachInterrupt(0, functie, FALLING); |
Die twee regels zijn in principe de RISING functie, omgekeerd bestaat er een functie voor de FALLING state van een pin. En omdat er 2 pinnen zijn heb je dan 4 functies, RISING en FALLING voor pin A en RISING en FALLING voor pin B.
Wat betreft die 4 posities per detent / klik, je zou inderdaad eenvoudig de output of counter door 4 kunnen delen maar persoonlijk vind ik dat bad BAD practice. Ik wil dadelijk (als ik erachter ben hoe ik m'n sketch kleiner krijg
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Ben zelf bezig met programmeren te leren en dit is nog een stapje te ver voor mij. Ik weet wel wat je met interrupts, falling en rising bedoelt en over die 4 signalen daarmee verbonden kan ik me ook iets bij voorstellen.
Ik dacht eigenlijk dat je wat moeite had om waardes in beeld te krijgen en misschien ook met het aansluiten van dat ding. Blijkt nu dus dat je aan het stoeien bent met de sketch zelf.
Daarmee kan ik je weinig verder mee helpen maar ben wel benieuwd wat het eindresultaat wordt.
Op dit moment zit ik inderdaad een beetje met de sketch zelf in m'n maag. Ik heb zojuist wel gezien dat door 't combineren van Darrah's manier van rising en falling detectie en mijn vereenvoudigde functie ik de sketch kleiner heb kunnen krijgen, al heb ik 't idee dat dat ook te maken heeft met 't feit dat hij integers gebruikt voor sommige waarden waar ik byte's gebruik (een 0 of 1 opslaan in een integer vind ik een beetje onzin...).
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya

Pulldown: als de schakelaar open staat vloeit er geen stroom, er staat geen spanning over R10K en die weerstand verbindt of trekt de pin naar GND en de pin zal dus een 0 zien.
Wordt de schakelaar gesloten dan komt er 5V spanning op de weerstand te staan en dus ook op de pin; die wordt 1.
Pullup: als de schakelaar open staat dan staat daar 5V spanning overheen. Omdat de pin daarmee verbonden is zal die een 1 zien. Sluit de schakelaar dan staat er op de pin geen spanning meer en zal die 0 worden.
Ze zijn dus elkaar tegenovergestelde logica
PD :schakelaar sluit , ingang wordt 1
PU:schakelaar sluit, ingang wordt 0
pullups kun je trouwens ook softwarematig aanroepen heb ik begrepen
http://www.roguescience.o...-add-a-switch/exercise-6/
Ik ben weer een beetje verder gekomen met m'n encoder. Ik ben erachter gekomen dat bij elke klik of detent van de encoder beide pinnen HIGH zijn. Ik gebruik wel nog steeds 4 functies voor de detectie maar ik denk niet dat ik daar omheen kom zonder digitalRead's en die plakken er gewoon dik 300 bytes bovenop. In een realworld sketch zul je sowieso wel te maken hebben met digitalReads en dan is de impact van 2 extra digitalRead's in de code voor de sketch wellicht een stuk minder.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
| int counter; byte curA = 0, curB = 1; void setup(){ Serial.begin(115200); attachInterrupt(0, A_RISE, RISING); attachInterrupt(1, B_RISE, RISING); } void loop(){} void A_RISE(){ curA = 1; if (curB == 1){ // detent detected, backwards motion counter--; updateCounter(); } attachInterrupt(0, A_FALL, FALLING); } void A_FALL(){ curA = 0; attachInterrupt(0, A_RISE, RISING); } void B_RISE(){ curB = 1; if (curA == 1){ // detent detected, forwards motion counter++; updateCounter(); } attachInterrupt(1, B_FALL, FALLING); } void B_FALL(){ curB = 0; attachInterrupt(1, B_RISE, RISING); } void updateCounter(){ Serial.println(counter); } |
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
http://www.budgetronics.e...condensator_codes&lang=NL
http://www.esdsite.nl/elektronica/kleurcodecap.html
kleurcodes van die laatste zie ik trouwens niet veel
Ps, nog iets over die pulldown
Het wordt nog duidelijker misschien als je erbij bedenkt dat een inputpin een erg hoge ingangsweerstand heeft.
Dus stroom zal er niet makkelijk invloeien.
Pins configured this way are said to be in a high-impedance state. Input pins make extremely small demands on the circuit that they are sampling, equivalent to a series resistor of 100 megohm in front of the pin.
http://arduino.cc/en/Tutorial/DigitalPins#.Ux2_wfl5PbQ
Maak je een software pullup dan kun je de uitwendige weerstand weglaten maar daar heb ik zogauw even geen link van
[ Voor 40% gewijzigd door kitao op 10-03-2014 14:38 . Reden: Ps ]
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya

Volgens de Arduino geeft de analoog aangesloten sensor een waarde van rond de 390 wanneer de markering op de draaischijf gedetecteerd wordt en rond de 330 wanneer dat niet het geval is. Met behulp van die gegevens kwam ik tot dit:
Als ik de sketch zo bekijk, dan zou het moeten doen wat ik verwacht: De sensor lezen, bij de eerste 2 detecties van de markering moet ie in de 2e if uitkomen, bij "puls" 3 en verder moet ie in de eerste if uitkomen waarin ie het verbruik in watt berekend.
Voor de duidelijkheid, dit is wat zou moeten gebeuren (op het display):
Start Arduino:
1
2
| Watt: Pulsen: |
Na 1e detectie:
1
2
| Watt: Pulsen: 1 |
Na 2e detectie:
1
2
| Watt: Pulsen: 2 |
Na 3e/4e/5e/etc detectie:
1
2
| Watt: 1234 Pulsen: 3 |
Wat gebeurt er: De eerste detectie wordt gezien en er wordt zoals verwacht een 1 geplaatst naast "Pulsen: ", maar daarna verandert het display niet, er lijkt niks gedaan te worden met andere detecties

Iemand enig idee waar het fout gaat?
Edit: never mind, denk dat ik het al zie. de waarde van cny70 verandert niet in de while loop

Na eten maar ff testen.
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
We do what we must because we can.
Verwijderd
- http://www.nu.nl/economie...er-van-start-in-2015.html
Zoals je onderaan in de edit kan zien had ik dat (lekker laat) ook gezienResuCigam schreef op maandag 10 maart 2014 @ 16:48:
Om te beginnen: Ik ben geen programmeur maar ik wil toch een poging wagen: Volgens mij is regel 49 altijd waar, hij is om te beginnen waar (je if op regel 44) en je checkt niet in de tussentijd. Dus ik gok dat hij in die while lus blijft hangen.
1
| cny70 = analogRead(analogPin); |
Helaas zie ik de pulsecount soms ineens 2 keer omhoog gaan (ipv telkens 1 keer), daarnaast gaat de watt waarde soms ineens op 0 staan en ook gehad dat de pulsecount ineens héél hard omhoog ging. Werkt dus nog niet helemaal 100%, maar het begin is er
[ Voor 3% gewijzigd door Raven op 10-03-2014 17:53 ]
After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
Inmiddels de antidender uit de video in gebruik genomen :

Ik moet zeggen dat bij het programma van deze site dit enorm veel verschil maakt
http://www.circuitsathome...rotary-encoder-on-arduino


zonder debounce ----------------------------- met debounce
In plaatje 2 zie je dat er geen verspringende getallen voorkomen en hij print ook precies 4 countergetallen af per klik. Bij plaatje 1 zonder debounce was dit vaak 8 getallen.
Dus ik kan je wel aanraden om de caps en weerstanden erbij te zetten.
Wat betreft mijn klokje van deze site is het effect minder maar wel beter.
Het instellen van de tijd met deze schakeling

gaat nu stuk beter maar niet 100%. Ik laat het er maar bij, heb al genoeg klokjes.
Voor de gein maar weer eens een fotootje gemaakt, is al tijdje geleden

klikbaar
Breadboardje linksonder zit de debounce van de video op.
Die hardwarematige debounce had ik inderdaad ook al overgenomen. Dat verschil merk je inderdaad heel erg goed. Voor andere knoppen heb ik een eigen libje geschreven dat o.a. ook debounced.
Ik ben nu alleen even aan 't kijken hoe ik m'n ledjes aan de praat krijg. Ik heb namelijk een 5v ingang op 't ding die ik direct op de 5v van de Arduino zet. Daarna kan ik dmv weerstanden tussen de afzonderlijke pinnen van de losse kleuren 't voltage omlaag krijgen en 't veilig op de GND / Aarde / 0v / - aansluiten van de Arduino en dat gaat 't lampje ook aan.
Nu ben ik alleen een beetje roestig met 't aansluiten van dat ding via een PWM pin. In principe kan ik alleen de afzonderlijke ledpinnen aansluiten op de GND of op een PWM poort. Alleen moet ik die poort dan LOW zetten om er daadwerkelijk iets mee te kunnen. En 't geheel stuitert ontiegelijk.
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Er zijn verschillende manieren om te ontklapperen, gisteren had ik het over een schmitt-trigger die beschreven werd in een site

http://perhof.wordpress.c...ry-encoders-with-arduino/
maar het kan ook met een flipflop
In principe zou dat volgens mij beter moeten werken als met een RC-kringetje
Maar ja, je moet zo'n IC maar net in huis hebben en het kost zowieso meer aansluitingen
[ Voor 13% gewijzigd door kitao op 10-03-2014 21:50 ]
Ben nu bezig om 3 verschillende levels te maken zodat ik met een druk op de encoderknop de verschillende kleuren in de led hoger of lager kan zetten dmv een pwm signaal.
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
maar je gebruikt ook interrupts
Nu was het volgens mij zo dat SW-debouncing vaak gebruik maakt van delays van circa 20
Maar ik dacht gelezen te hebben dat delays niet werken in een interrupt ?
Dus hoe gaat dan dan eigenlijk als je dan toch wil debouncen terwijl er een interrupt wordt aangeroepen om de rotary encoder uit te lezen ?
Zou groot voordeel zijn om dat in de SW te kunnen regelen want zoals je zag had ik al spaghetti genoeg
EDIT:
Ok, ik zie nu je post pasC.44 schreef op maandag 10 maart 2014 @ 22:21:
Nop, 't gaat om de RBG led in de encoder. Heb 't geheel ondertussen aangesloten. Aangezien de poorten standaard laag staan moet ik ze in de setup even hoog zetten en dan is ie in eerste instantie uit. Beetje omslachtig maar voor en proof of concept werkt 't.
Ben nu bezig om 3 verschillende levels te maken zodat ik met een druk op de encoderknop de verschillende kleuren in de led hoger of lager kan zetten dmv een pwm signaal.
Ik heb die rec niet
heb wel gelezen over dat onderdeel
is eigenlijk geen rgb maar een gr dacht ik
oftewel maar twee kleuren , rood en groen, ipv diverse kleuren zoals bij een rgb kunnen ontstaan
[ Voor 56% gewijzigd door kitao op 10-03-2014 22:29 ]
In principe kun je op 2 manieren debouncen, over hardware en over software. Als je een rotary encoder gebruikt via interrupts (omdat je anders de kans loopt stukken quadrature te missen). In principe heb je dan geen softwarematige debounce meer nodig. Daarnaast werkt het met een rotary encoder alleen maar tegen omdat je met die delays of timers zit (zoek 't maar es op, debouncen met delay is bad practice en zet je hele script stil en je kunt slechts 1 knop tegelijk debouncen).kitao schreef op maandag 10 maart 2014 @ 22:22:
Je hebt het trouwens over softwarematige debouncing
maar je gebruikt ook interrupts
Nu was het volgens mij zo dat SW-debouncing vaak gebruik maakt van delays van circa 20
Maar ik dacht gelezen te hebben dat delays niet werken in een interrupt ?
Dus hoe gaat dan dan eigenlijk als je dan toch wil debouncen terwijl er een interrupt wordt aangeroepen om de rotary encoder uit te lezen ?
Zou groot voordeel zijn om dat in de SW te kunnen regelen want zoals je zag had ik al spaghetti genoeg
Voor de rotary encoder gebruik ik dan ook alleen maar hardware debouncing via de methode uit 't filmpje. Vor de drukknop in de encoder gebruik ik dan weer m'n eigen libje om te debouncen, via software dus want die doe ik niet via hardware.
Hardware debouncen mag dan in 't script wel eleganter zijn maar op je PCB / breadboard maakt 't er een zootje van imho.
Er bestaan 2 versies van die encoder, RG (met 2 leds idd) en de RGB, met een RGB led. Ik heb die laatste dan ben ik iets vrijer in 't maken van kleurtjesEDIT:
[...]
Ok, ik zie nu je post pas
Ik heb die rec niet
heb wel gelezen over dat onderdeel
is eigenlijk geen rgb maar een gr dacht ik
oftewel maar twee kleuren , rood en groen, ipv diverse kleuren zoals bij een rgb kunnen ontstaan
[ Voor 16% gewijzigd door C.44 op 10-03-2014 22:33 ]
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Oh, dat wist ik nietC.44 schreef op maandag 10 maart 2014 @ 22:30:
Er bestaan 2 versies van die encoder, RG (met 2 leds idd) en de RGB, met een RGB led. Ik heb die laatste dan ben ik iets vrijer in 't maken van kleurtjes
8 kleuren kun je er mee maken meen ik, was er laatst nog mee bezig maar geen idee waar
trouwens nog bedankt voor de uitleg en hoewel ik best geloof dat debouncing softwarematig kan verminderen zie ik toch weinig concreet resultaat ervan zoals bij dat klokje.
Dan zit er weinig anders op als extra meuk aan te sluiten ...
en beetje offtopic misschien....maar bestel jij rechtstreeks bij Sparkfun en hoeveel verz, kosten betaal je dan ?
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Tnx,C.44 schreef op maandag 10 maart 2014 @ 22:52:
Met een RG versie kun je R, G, en combinaties van die twee maken dmv PWM. Zelf bestel ik meestal meerdere onderdelen en dan ga ik gewoon kijken wie in nederland of duitsland het meeste van m'n lijstje op voorraad heeft. Direct bij Sparkfun bestellen zou financieel gezien interessant zijn maar dan zit je wel weet met een levertijd van een paar weken en meestal heb ik daar 't geduld niet voor
Ik ben namelijk bezig met wat gratis eboeken en dit is er 1 van :
http://it-ebooks.info/book/2320/
Lijkt er echter sterk op dat sparkfun dat boek sponsort want alle genoemde onderdelen komen daar vandaan
tijdje wachten vind ik geen probleem als het toch betaalbaar blijft zonder 6 euro verz. kosten o.i.d.
zo zat ik al 3 weken te wachten op een cc-7-seg voor mijn klokje en zit ik nu al via ebay een maand te wachten op een paar Three 74HC4066 quad bilateral switch ICs om de rest van dat hoofdstuk af te kunnen maken.
maar ik heb geen haast en zal proberen bij sparkfun een bestelling proberen te plaatsen.
Ik heb zojuist m'n encodertje bounce-vrij aan de praat gekregen met kleurtjes en al. Ik kan nu dmv het drukken op de knop wisselen tussen de R, G en B kleuren en die dan dmv de encoder zelf de waardes voor R, G en B omhoog of omlaag draaien.
* C.44 tevreden is
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Groot voordeel denk ik als je zelf kunt programmeren en je eigen libs kunt schrijven.
Over dat bestellen, bij DX of Ebay zie ik weinig sparkfun onderdelen
zoals zo'n rec 2,50 kost en je betaalt dan 6 euro verz. kosten dan haak ik af
mijn uno staat ook sparkfun op, die komt van antratek uit nl.
tja, beetje crisis hier en dan let je daar op
bovendien, als het niet volledig omschreven is in tutorials met vaste onderdelen dan moet je wel improviseren
en dat kan geen kwaad
als ik die rec had die jij hebt dan had ik graag de sketch en lib willen zien trouwens
helaas heb ik toch geen rgb erin zitten
De complete code voor 't uitlezen van de quadrature heb ik al gepost, beetje omhoog scrollen
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
ik heb jouw geposte sketches nog niet geprobeerd
het breadboard staat er nog dus morgen maar even uploaden
Edit/
Om nog even terug te komen op gisteravond, ik had het over een paar ebooks, dit is er 1 van.

Misschien ook wel handig voor jou om wat 'roestige' dingen snel terug te vinden in de basicuitvoering. Ik heb daar een pdf van en zit goede index bij met een onderdelenlijst en toevallig was ik vandaag op pagina 100 en dat gaat over een Sparkfun RGB module
Verzondkosten met economy shipping zijn $2,95 dus die maar besteld.
[ Voor 71% gewijzigd door kitao op 11-03-2014 11:04 ]
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Ik heb jouw sketch van 10:43 en 14:02 getest en gaat goed. De 1e geeft 4 getallen per klik en de 2e 1 getal/klik.C.44 schreef op maandag 10 maart 2014 @ 23:51:
De lib staat eigenlijk compleet los van de encoder, dat is een algemene lib voor buttons. Nog niet helemaal productiecode. Als dat ding zover af is en van commentaar voorzien is maak ik een post op m'n blogje erover.
De complete code voor 't uitlezen van de quadrature heb ik al gepost, beetje omhoog scrollenIn principe kun je daar (met wat aanpassingen) alle 4 de state-changes mee detecteren per "klik" maar ik heb ervoor gekozen om alleen de statechange op de klik te gebruiken.
Knap hoor als je dat zelf even schrijft en de 2e sketch bewaar ik, kan altijd van pas komen. Van begin af aan had ik me al voorgesteld dat er maar 1 getal per klik zou verschijnen maar ik begrijp nu waarom het er ook 4 kunnen zijn. Overigens zie ik jouw blog niet, ik heb geprobeerd jouw onderschrift aan te klikken maar dat werkt niet of ik zie iets over het hoofd
Dat is wel zo. Maar ja, ik wou daar toch eens wat bestellen en dat boek is goed te volgen vandaar dat ik me maar aan de tekst probeer te houden. Echt goedkoop is het idd niet voor 1 ledje te laten verkleurenC.44 schreef op dinsdag 11 maart 2014 @ 11:04:
Over die RGB module, dat is dus een RGB led die via een I2C interface word aangestuurd, imho is dat een beetje over the top voor 1 enkele RGB led.

Eigenlijk is 't gewoon een aanpassing van de code van Darrah, weinig bijzonders van mijn kant haha. M'n blogje staat bij wordpress (klik). Moet wel zeggen dat er qua Arduino nog niet veel te vinden is daar maar daar gaat binnenkort wel verandering in komen.kitao schreef op dinsdag 11 maart 2014 @ 14:46:
Ik heb jouw sketch van 10:43 en 14:02 getest en gaat goed. De 1e geeft 4 getallen per klik en de 2e 1 getal/klik.
Knap hoor als je dat zelf even schrijft en de 2e sketch bewaar ik, kan altijd van pas komen. Van begin af aan had ik me al voorgesteld dat er maar 1 getal per klik zou verschijnen maar ik begrijp nu waarom het er ook 4 kunnen zijn. Overigens zie ik jouw blog niet, ik heb geprobeerd jouw onderschrift aan te klikken maar dat werkt niet of ik zie iets over het hoofd
Ik heb nog niet echt gekeken naar de mogelijkheid van de led maar is het mogelijk om kleuren te mixen met die led? Dat zou namelijk betekenen dat er ergens op dat pcb'tje pwm pinnen zitten of pinnen die dat emuleren. Klinkt allemaal interessant =)Dat is wel zo. Maar ja, ik wou daar toch eens wat bestellen en dat boek is goed te volgen vandaar dat ik me maar aan de tekst probeer te houden. Echt goedkoop is het idd niet voor 1 ledje te laten verkleuren
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Ik zou idd denken met PWM maar die module heeft zn eigen micro die mij onbekend is. Dit staat er bijvoorbeeld : BlinkM is a Smart LED and knows how to turn 24-bit RGB or HSB color values into the corresponding high-frequency PWM signals needed to drive its super-bright RGB LED.
De datasheet bevat geen moeilijke grafieken ofzo en is makkelijk door te bladeren. Groot deel bestaat uit uitleg commando's.
HSB kon ik trouwens nog niet maar wordt hier toegelicht. En ik weet niet of zomaar het volgende rekensommetje mag worden toegepast maar met 24 bit zou je dus uitkomen op 2^24=16.8 miljoen kleuren.
Dat lijkt veel maar er schijnt zelfs al een tv-scherm te zijn met 1 biljoen kleuren. Toevallig is daar een GOT-artikel van: nieuws: Scherm met biljoen kleuren in ontwikkeling
Of je daar veel aan hebt, geen idee, menselijk oog kan 7.5 miljoen kleuren ontvangen en volgens deze wiki
kunnen we in totaal tussen de 120 en 160 zuivere kleuren van elkaar onderscheiden, mits we ze naast elkaar kunnen zien.
Dus dat loopt nogal uiteen.
Anyway, dit plaatje uit de datasheet zegt misschien meer:

klikbaar
Mocht je toch in de toekomst interesse hiervoor hebben dan zou ik ook overwegen of de MaxM misschien niet beter ligt bij je gewenste toepassing. Kost $25 maar is wel geschikt om een Led_array met 24V/2A aan te sturen: BlinkM MaxM Features : Three high-power 5-24VDC @ 2A PWM outputs to drive large common-anode LED arrays. (zie bijv. foto pagina 11 datasheet)
Zelf heb ik tot nu toe nog niet veel interesse gehad in Ledstrips maar je kunt er leuke effecten mee krijgen. Deze video met slechts 1 MinM ledje is best geinig
YouTube: BlinkM Smart LED
Ps: leuke en mooi ontworpen blog trouwens, hoewel ik laatste tijd meer lipton en pickwick nuttig als supra
[ Voor 10% gewijzigd door kitao op 12-03-2014 04:44 ]
linkje: klik
Staat iig op m'n todo list om dat eens te proberen.
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Dus tenzij je veel goedkope losse rgb's wil gebruiken heb je volgens mij aan die link voldoende om het principe te kunnen achterhalen. Zelf is dat vaak mijn beweegreden, het principe proberen te begrijpen en de praktische toepassing is voor mij heel vaak een bijkomende zaak. Maar dat ligt bij iedereen anders natuurlijk.
Gedeeltelijk door jouw posts en omdat het ook in mijn eboek wordt behandeld ben ik nu het pwm-gebeuren aan het herhalen. Veel meer als een paar jumpers, ledje, fan, transistor, pot,weerstandjes en ldr gebruik ik dan niet om toch het begrip te krijgen.
Anyway, veel tekst, maar ik wou je eigenlijk gewoon die link laten zien en wellicht heb je er iets aan.
Het enigste wat me op dit moment dwars zit is dat een encoder eigenlijk alleen via een interrupt 't beste werkt. Dat heet dat de Arduino alles laat vallen waar hij mee bezig is op 't moment dat je aan de knop komt... Ik kan me voorstellen dat dat niet in alle situaties handig is.
De enigste manier waarop je dat zou kunnen oplossen is door de encoder simpelweg in de loop constant te pollen voor veranderingen. Het probleem daarin is echter dat, wanneer een loop iets arbeidsintensiever is voor de processor, je de kans loopt om bepaalde input / signalen van de encoder te missen waardoor je of gewoon geen reactie krijgt op de input of de tegenovergesteld reactie die je verwachtte.
Toyota Supra 3.0i Turbo Targa in Panther Black Mica - 300D || 30D || 10-20 || 50mm 1.8 mk1 || 18-55 || 17-85 || 75-300 || Giottos || Manfrotto || Cullmann || Kenko || Hoya
Ik heb wel gegoogled op "interrupts and programflow rotary encoder arduino" want daar heb je het in feite over in je post. Ik heb een paar links gevonden waar je misschien wat aan hebt. Of niet.
http://0xfebytes.blogspot...er-with-pwm-and-isrs.html
http://www.tigoe.com/pcomp/code/misc/1187/
http://www.circuitsathome...ce-routine-for-avr-micros
http://www.jeremyblum.com...-and-hardware-debouncing/
Je kan niet beide hebben, waarbij je geen interrupt hebt en geen loop die continue polled als je altijd de locatie wilt hebben van je encoder.C.44 schreef op woensdag 12 maart 2014 @ 21:44:
Ik was al wel bekend ermee, het RGB ledje in m'n rotary encoder kan ik nu ook de kleur laten weergeven die ik met de encoder bij elkaar mix. Per default is het rode kanaal geactiveerd en daar kun je de PWM cycle van aanpassen, druk je de encoder in kun je 't groene kanaal bedienen, nog een keer indrukken bedient het blauwe kanaal en als je nog een keer drukt kom je weer bij rood terecht. Leuk proof of concept.
Het enigste wat me op dit moment dwars zit is dat een encoder eigenlijk alleen via een interrupt 't beste werkt. Dat heet dat de Arduino alles laat vallen waar hij mee bezig is op 't moment dat je aan de knop komt... Ik kan me voorstellen dat dat niet in alle situaties handig is.
De enigste manier waarop je dat zou kunnen oplossen is door de encoder simpelweg in de loop constant te pollen voor veranderingen. Het probleem daarin is echter dat, wanneer een loop iets arbeidsintensiever is voor de processor, je de kans loopt om bepaalde input / signalen van de encoder te missen waardoor je of gewoon geen reactie krijgt op de input of de tegenovergesteld reactie die je verwachtte.
Normaal wil je simpelweg een zo simpel mogelijke interrupt routine, zodat wat je onderbrak zo snel mogelijk weer door kan gaan. Als dat echt niet onderbroken mag worden dan is die code zelf ervoor verantwoordelijk om interrupts uit te schakelen.
Dedicated cores instead of interrupts
The design philosophy of the Propeller is that a hard real-time multi-core architecture negates the need for dedicated interrupt hardware and support in assembly. In traditional CPU architecture, external interrupt lines are fed to an on-chip interrupt controller and are serviced by one or more interrupt service routines. When an interrupt occurs, the interrupt controller suspends normal CPU processing and saves internal state (typically on the stack), then vectors to the designated interrupt service routine. After handling the interrupt, the service routine executes a "return from interrupt" instruction which restores the internal state and resumes CPU processing.
To handle an external signal promptly on the Propeller, any one of the 32 I/O lines is configured as an input. A cog is then configured to wait for a transition (either positive or negative edge) on that input using one of the two counter circuits available to each cog. While waiting for the signal, the cog operates in low-power mode, essentially sleeping. Extending this technique, a Propeller can be set up to respond to eight independent "interrupt" lines with essentially zero handling delay. Alternately, a single line can be used to signal the "interrupt" and then additional input lines can be read to determine the nature of the event. The code running in the other cores is not affected by the interrupt handling cog. Unlike a traditional multitasking single-processor interrupt architecture, the signal response timing remains predictable,[10] and indeed using the term "interrupt" in this context can cause confusion, since this functionality can be more properly thought of as polling with a zero loop time.
Wikipedia: Parallax Propeller
Is zo te zien dus een heel ander type uC
Verwijderd
- http://www.arduino.cc/en/Reference/AttachInterrupt
- http://www.nongnu.org/avr...oup__avr__interrupts.html
- http://www.gammon.com.au/forum/?id=11488
[ Voor 33% gewijzigd door Verwijderd op 13-03-2014 11:07 ]
Bovenstaande sketch maakt gebruik van "smoothing" in de hoop dat dat de false positives opvangt. Zo op het eerste gezicht lijkt dat te werken
Zag echter net wel wat vaags. Verbruik lag volgens de Arduino op zo'n 170 watt. Toen zette ik de oven aan, die volgens een Voltcraft Energy Logger 4000 zo'n 2200 watt verbruikte, waarna het verbruik volgens de Arduino ineens exact 3200 watt zou zijn.
170 + 2200 is bij mijn weten geen 3200 watt, geen idee hoe dat kan
Blijkbaar zit er dus toch nog ergens een vautje

After the first glass you see things as you wish they were. After the second you see things as they are not. Finally you see things as they really are, and that is the most horrible thing in the world...
Oscar Wilde
Ik dacht uit C.44's post te kunnen opmaken dat hem dat wel bekend is. De vraag was volgens mij meer of hij een interrupt kon maken wat totaal geen invloed heeft op de rest van het programma. Volgens Scissors is dat dus niet mogelijk, 'Je kan niet beide hebben, waarbij je geen interrupt hebt en geen loop die continue polled als je altijd de locatie wilt hebben van je encoder'.
Een andere uC zoals de propeller zou volgens de interne architectuur dit misschien beter mogelijk maken vandaar dat ik die naar voren heb gehaald.
Twee zinnen uit mijn vorige post laten dit wellicht zien:
1) In traditional CPU architecture when an interrupt occurs, the interrupt controller suspends normal CPU processing.
2) A Propeller can be set up to respond to eight independent "interrupt" lines with essentially zero handling delay,
this functionality can be more properly thought of as polling with a zero loop time.
Afbeelding van die micro :

http://www.parallax.com/microcontrollers/propeller
Nadeel is dan wel dat dit zover ik weet geen C gebruikt maar o.a. wel Spin wat volgens de fabrikant er erg op lijkt. Andere nadelen zijn al eens eerder vermeld maar die ben ik vergeten.
Overigens beweer ik hiermee niet dat jouw links van onpas komen; ik kan ze goed gebruiken.
@Raven,
sorry voor de onderbreking
Verwijderd
oh.. ik dacht te lezen dat jij niet helemaal begreep wat een interrupt is en hoe eea werkt vandaar mijn uitleg arduino linkjes in dit arduino topic .. sorry dankitao schreef op donderdag 13 maart 2014 @ 13:59:
[...]
Ik dacht uit C.44's post te kunnen opmaken dat hem dat wel bekend is. De vraag was volgens mij meer of hij een interrupt kon maken wat totaal geen invloed heeft op de rest van het programma. Volgens Scissors is dat dus niet mogelijk, 'Je kan niet beide hebben, waarbij je geen interrupt hebt en geen loop die continue polled als je altijd de locatie wilt hebben van je encoder'.
Een andere uC zoals de propeller zou volgens de interne architectuur dit misschien beter mogelijk maken vandaar dat ik die naar voren heb gehaald.
Twee zinnen uit mijn vorige post laten dit wellicht zien:
1) In traditional CPU architecture when an interrupt occurs, the interrupt controller suspends normal CPU processing.
2) A Propeller can be set up to respond to eight independent "interrupt" lines with essentially zero handling delay,
this functionality can be more properly thought of as polling with a zero loop time.
Afbeelding van die micro :
[afbeelding]
http://www.parallax.com/microcontrollers/propeller
Nadeel is dan wel dat dit zover ik weet geen C gebruikt maar o.a. wel Spin wat volgens de fabrikant er erg op lijkt. Andere nadelen zijn al eens eerder vermeld maar die ben ik vergeten.
Overigens beweer ik hiermee niet dat jouw links van onpas komen; ik kan ze goed gebruiken.![]()
@Raven,
sorry voor de onderbreking![]()
Ik weet er inderdaad weinig vanaf en zeker is dat ik het niet even zelf programmeer, dus daarom bedankt voor je linkjes. Ik ben zeg maar 'het aan het bestuderen'. Maar het was C.44 die dit draadje eigenlijk begonnen is met deze vraag :Verwijderd schreef op donderdag 13 maart 2014 @ 14:48:
oh.. ik dacht te zien dat jij niet helemaal begreep wat een interrupt is en hoe eea werkt vandaar mijn uitleg arduino linkjes in dit arduino topic .. sorry dan
Toevallig was ik zelf bezig met een rec en heb ik ingehaakt op zijn posts hoewel ik minder bezig was met interrupt. Met een korte attachinterupt moet je volgens mij wel heel snel ronddraaien wil die het niet bijhouden. Maar goed, dat durf ik niet met zekerheid te zeggen omdat ik weinig programmeerkennis heb.C.44 schreef op woensdag 12 maart 2014 @ 21:44:
Het enigste wat me op dit moment dwars zit is dat een encoder eigenlijk alleen via een interrupt 't beste werkt. Dat heet dat de Arduino alles laat vallen waar hij mee bezig is op 't moment dat je aan de knop komt... Ik kan me voorstellen dat dat niet in alle situaties handig is.
De enigste manier waarop je dat zou kunnen oplossen is door de encoder simpelweg in de loop constant te pollen voor veranderingen. Het probleem daarin is echter dat, wanneer een loop iets arbeidsintensiever is voor de processor, je de kans loopt om bepaalde input / signalen van de encoder te missen waardoor je of gewoon geen reactie krijgt op de input of de tegenovergesteld reactie die je verwachtte.
Verwijderd
Kan de arduino wat anders doen tot dat die een verandering detecteert aan een ingang(draai aan de knop), dan springt die naar een speciaal stukje code, voert die uit en springt weer terug in zijn normale loop.
Voor 99.9999% van de gevallen snel genoeg allemaal.. alleen bij de nasa denken ze daar anders over
je kan dus die rotary uitlezen op verschillende manieren benaderen
- in een loop.. dus telkens pollen of er een verandering is.. meestal niet zo handig want dan kan je eigenlijk niks anders doen.
geld btw ook voor schakelaars uitlezen in het algemeen.
- interrupt gestuurd, de processor detecteert een verandering en springt naar een stukje code die de nieuwe stand in leest
- ook een interrupt maar een soort combinatie, een timerinterrupt, je stelt een klokje in en laat die 100 x per seconde een interrrupt genereren die vervolgens de stand van de knop uitleest.
[ Voor 44% gewijzigd door Verwijderd op 13-03-2014 15:15 ]
Verwijderd schreef op donderdag 13 maart 2014 @ 15:06:
Voor 99.9999% van de gevallen snel genoeg allemaal.. alleen bij de nasa denken ze daar anders over

Ja, dat dacht ik ook eigenlijk. Die atm328 rekent in milloseconden
enkel oppassen dat er geen delay 5000 in de code terecht komen e.d.
Maar blijft een uitdaging om dit goed in code om te zetten.
Verwijderd
verder, het feit dat je last kan hebben van bounce, geeft al aan hoe snel die processor is.
- http://forum.arduino.cc/index.php?topic=62026.0
[ Voor 63% gewijzigd door Verwijderd op 13-03-2014 15:25 ]
Precies en geen interrupt in een interrupt etc.Verwijderd schreef op donderdag 13 maart 2014 @ 15:16:
je zet nooit een delay() in een interrupt routine.
verder, het feit dat je last kan hebben van bounce, geeft al aan hoe snel die processor is.
- http://forum.arduino.cc/index.php?topic=62026.0
Daarom denk ik dat het wel mogelijk is om zo'n rec goed uit te lezen maar voorwaarde is dan wel dat de sketch goed in elkaar gesleuteld zit. En daar kan ik helaas C.44 niet mee helpen.
Feit blijkt echter wel dat zo'n interrupt altijd de lopende sketch onderbreekt. Daar kun je niet omheen tenzij je dus een totaal anders ingedeelde micro daarvoor gebruikt. Tenminste, zo heb ik het begrepen.
Verwijderd
dat is nu eenmaal een basis principe van een microprocessor.
de atmega328 (die vb op de nano / mini zit) kent 28 interrupt typen
de ene heeft voorrang boven de andere ( interrupt priority )
- http://www.gammon.com.au/forum/?id=11488
- http://www.fiz-ix.com/201...ega328-analog-comparator/
[ Voor 21% gewijzigd door Verwijderd op 13-03-2014 15:46 ]
Klopt. een interrupt triggert een ISR (Interrupt Service Routine), welke code uit voert als deze interrupt op treedt.kitao schreef op donderdag 13 maart 2014 @ 15:31:
[...]
Precies en geen interrupt in een interrupt etc.
Daarom denk ik dat het wel mogelijk is om zo'n rec goed uit te lezen maar voorwaarde is dan wel dat de sketch goed in elkaar gesleuteld zit. En daar kan ik helaas C.44 niet mee helpen.
Feit blijkt echter wel dat zo'n interrupt altijd de lopende sketch onderbreekt. Daar kun je niet omheen tenzij je dus een totaal anders ingedeelde micro daarvoor gebruikt. Tenminste, zo heb ik het begrepen.
Je microcontroller springt dus uit de huidige routine naar de andere routine. Je processor is dus even niet meer met het ene bezig, maar gaat zich met de code bezig houden wat in je ISR staat. Zoals je zelf ook al weet mag een interrupt nooit "veel" code bevatten, mag deze geen delay bevatten en mag deze geen andere interrupt triggeren.
Nadat je processor klaar is met de ISR uit te voeren gaat de processor weer verder met waar hij mee bezig was.
Zoals borroz zegt maakt dit ook helemaal niks uit. Dit afhandelen gaat super snel en merk je, normaal gezien, niks of weinig van (daarom moet je aan de voorwaarden voor een ISR voldoen).
Hier een plaatje;

In dit plaatje zie je ook de vectoren staan. Deze wijzen naar de uit te voeren ISR voor een bepaalde interrupt.
Ik gebruik de ethercard lib om een enc28j60 mee aan te sturen. Omdat dit bedoeld is om ledstrips mee te sturen, wil ik graag de commando's via een udp broadcast versturen. Ik krijg het echter niet voor elkaar om de broadcast packets op de avr te krijgen.
In de lib zit een commando verstop om de enc de broadcast packets niet te laten filteren, maar als ik dit commando aanroep veranderd er niets. Het commando zit in enc28j60.h/.cpp en is daar enc28j60.enableBroadcast(). In mijn eigen code roep ik die opdacht aan via de ethercard lib als volgt: ether.enableBroadcast().
Ziet een van jullie wat ik fout doe? De compiler geeft namelijk geen fouten, geen melding van een niet bestaande functie oid.
Verwijderd
- http://www.mikroe.com/dow....htm#spi_ethernet_userudp
wellicht kan je daar iets vinden ?
Tnx, maar blijkbaar telt dit niet voor iedere micro. Lijkt erop dat er ook micro's zijn die dat effect niet hebben en een interrupt gewoon naast het al lopende hoofdprogramma tegelijkertijd weten te verwerken.foekie01 schreef op donderdag 13 maart 2014 @ 17:36:
Je microcontroller springt dus uit de huidige routine naar de andere routine. Je processor is dus even niet meer met het ene bezig, maar gaat zich met de code bezig houden wat in je ISR staat.
Soort spineffect wat de hub met 0 delay langs de cogs rond laat suizen

Zo'n propellerspin schijnt goed te zijn in video's vga e.d.
Ben voorlopig nog niet klaar met mijn uno maar wie weet, misschien stap ik gerust weer over
Wordt al vergeleken met crack-cocaine op deze site :

But the best is yet to come! Parallax, Inc. is less than a year away from releasing the microcontroller equivalent of crack-cocaine: the Propeller 2!
http://forzartos.org/2012...lti-core-microcontroller/
(site anno 2005)
Tja, wie wil dat eigenlijk niet ?

[ Voor 4% gewijzigd door kitao op 13-03-2014 18:28 . Reden: link vergeten ]
Verwijderd
ja dat geld voor iedere microprocessor .. nou kan je natuurlijk wel meerdere micro's in 1 doosje stoppenkitao schreef op donderdag 13 maart 2014 @ 18:23:
[...]
Tnx, maar blijkbaar telt dit niet voor iedere micro.
verder gaat dit soort techniek geheel voorbij aan dit topic en de relatief eenvoudige vraag ' moet ik nou heel snel aan mijn rotaryknop draaien en het antwoord is NEE'
Precies. Een micro is single threaded. Tenzij het een multi core betreft OF een RTOS (Real Time Operating System) aan boord heeft. Maar zelfs dan is het "slechts" semi-threaded.Verwijderd schreef op donderdag 13 maart 2014 @ 18:29:
[...]
ja dat geld voor ieder micro.. nou kan je natuurlijk wel meerdere micro's in 1 doosje stoppen
Overigens bestaan er voor arduino RTOS-en. Heb ik zelf nog niet geprobeerd maar volgens mij moet je er ook niet teveel van verwachten.
[ Voor 17% gewijzigd door foekie01 op 13-03-2014 18:40 ]
oh, neem me niet kwalijk dan dat ik een mogelijk alternatief heb geopperd op een issue wat in dit topic naar voren is gebracht.Verwijderd schreef op donderdag 13 maart 2014 @ 18:29:
verder gaat dit soort techniek geheel voorbij aan dit topic
ik heb geen enkele vraag gesteld. sorryen de relatief eenvoudige vraag ' moet ik nou heel snel aan mijn rotaryknop draaien en het antwoord is NEE'
Verwijderd
Nee dat heb je niet (welk 'alternatief' dan) .. maar het is je vergevenkitao schreef op donderdag 13 maart 2014 @ 18:40:
[...]
oh, neem me niet kwalijk dan dat ik een mogelijk alternatief heb geopperd op een issue wat in dit topic naar voren is gebracht.
Nou jah ... alternatief leek me toch duidelijkVerwijderd schreef op donderdag 13 maart 2014 @ 18:49:
Nee dat heb je niet (welk 'alternatief' dan) .. maar het is je vergeven
Ipv gebruik te maken van een interrupt wat het hoofdprogramma onderbreekt, een 32-bit propeller micro pakken wat totaal geen interrupt kent maar wel een 'polling with virtualy 0 delay''.
edit hierna:
doei

Edit2 volgende dag:
Foekie, Scissors, Borroz bedankt voor de uitleg. Ik heb nu tenminste een beter begrip wat een multi-core betekent.
Op die term gezocht en dit artikel gelezen: Wikipedia: Multi-core processor
Enkele dingen die mij opvielen:
- As of 2010, multi-core network processing devices have become mainstream.
- The extent to which software can be multithreaded to take advantage of these new chips is likely to be the single greatest constraint on computer performance in the future.
- Ambric Am2045, a 336-core Massively Parallel Processor Array (MPPA)
Omdat het idd off-topic gaat daarom maar geen nieuwe post geplaatst en ipv daarvan voor een edit gekozen.
[ Voor 47% gewijzigd door kitao op 14-03-2014 06:50 . Reden: edit2 ]
Verwijderd

maar goed.. ben weer weg terug

goedzo Kitao.. je moet je is niet zo gelijk aangevallen voelen
[ Voor 30% gewijzigd door Verwijderd op 14-03-2014 13:18 ]
Overigens zelfs als je een RTOS draait heb je nog steeds het probleem dat je of moet pollen via de RTOS, of een interrupt moet draaien die op zijn minst de RTOS waarschuwt dat er wat berekent moet worden. Maar de berekeningen zijn zo simpel dat ik niet denk dat het nuttig is die niet in de interrupt handler te doen.
Gelukkig werkt het nu
Scratch that. Mijn probleem bestaat helaas nog steeds.
[ Voor 16% gewijzigd door Bravo51 op 13-03-2014 20:49 ]
Verwijderd
wellicht domme opmerking maar je hebt toch wel de originele Ethernet lib verwijderd ?Bravo51 schreef op donderdag 13 maart 2014 @ 20:42:
Ik heb overigens mijn probleem opgelost. Ik riep de opdracht verkeerd aan, wat ik moest gebruiken was: ether.ENC28J60::enableBroadcast().
Gelukkig werkt het nu
Scratch that. Mijn probleem bestaat helaas nog steeds.
In alle gevallen dat je nog cpu tijd over heb heb je prima de tijd om extra code er doorheen te verwerken.
En lees dat ISR niet veel code mag bevatten, dat is ook maar half waar, je mag gerust veel code uitvoeren in je ISR, je moet daar wel rekening mee houden. Heb wel vaker veel code in ISR staan, moet dan denken een 433Mhz zend code die rits bytes verzend of zo.
Delay is ook geen probleem, is niet 100% accuraat meer, maar is accuraat genoeg om bijvoorbeeld in ISR softwarematig een kaku aan te sturen met delay's om signaal te genereren.
Ik zou zeggen test het eens, speel er eens wat mee, zoek de grenzen eens op en ga er eens overheen en neem vooral niet alles zomaar aan!