[Discussie] Arduino-topic

[kitao]

Mogge,
dubbele post maar er zitten twee dagen tussen

Ik heb de volgende vraag :
Zijn er lcd-schermpjes van 16x2 die zowel serieel als parallel aan te sturen zijn ?

En ik zeg erbij, voor een tientje extra is dit probleem opgelost want dan koop ik er gewoon 2 maar misschien dat heel toevallig iemand met veel meer ervaring als ik met die dingen hier direkt een antwoord op weet.
Ga dus vooral niet zoeken want dat is echt niet nodig

Ik zal het (kort) toelichten.
Ik heb een arduino uno en een basicstamp en van beiden volg ik bepaalde educatieve voorbeelden.
Nu viel mij op dat ook de arduino veel voorbeelden heeft die gebruik maken van parallax sensoren zoals de ping en de memsic 2125 accelerometer. (zie onder 6 sensors http://arduino.cc/en/Tutorial/HomePage maar dat terzijde.
Voor de basicstamp heb ik deze lcd nodig :
Parallax 2x16 Serial LCD (Backlit)
http://www.parallax.com/S...ProductID/50/Default.aspx
Voor de arduino heb ik deze nodig :
LiquidCrystal Library

The LiquidCrystal library allows you to control LCD displays that are compatible with the Hitachi HD44780 driver.

zoals ook deze bijvoorbeeld

Qua uiterlijk zijn de lcd's zowat identiek maar zover ik kan nagaan is de ene dus serieel en de ander parallel.
Vandaar mijn vraag of ik kan volstaan met de lcd van parallax en of ik die met de gegeven voorbeelden op deze pagina van arduino kan gebruiken zonder kennis van C of dat ik dan een geheel ander programma moet gaan zoeken.
Alvast bedankt voor de tip.

edit:
ps, op dit moment geeft de parallax-link een error op DotNetNuke
Geen idee wat dit is maar zal me niet verbazen als dit een smerige virus is dus ik zou er maar niet op door gaan klikken

[ Voor 7% gewijzigd door kitao op 17-10-2012 09:33 ]

[Demo]

HD44780 lcd's zijn de meest voorkomende, goedkoopste dingen die je op het internet vindt. Dat kan veel goedkoper dan bij Sparkfun Uiteindelijk zijn die serieel aangestuurde dingen vaak niet veel meer dan een HD44780 met een converter (die niet zelden op een PIC of AVR is gebaseerd )

[ Voor 28% gewijzigd door Demo op 17-10-2012 09:30 ]

[kitao]

Zowel voor Sparkfun als voor Parallax is Antratek de distributeur, een bedrijf in Nederland
Dat maakt het dus wel makkelijker om te bestellen hoewel ik nog geen losse componentjes bij hun heb besteld dus ik weet nog niet hoe ze daar op gaan reageren.
Ook zie ik eigenlijk nog niet of er nu zowel serieel als parallele lcd's in één behuizing bestaan ?

[ Voor 16% gewijzigd door kitao op 17-10-2012 09:41 ]

[Verwijderd]

http://iprototype.nl/prod...cd/128x64-Graphic-SPI-LCD

[kitao]

Dat ziet er heel goed uit borroz,
ik ga dat gewoon eens proberen
heel veel dank.

[Verwijderd]

Ik ben aan het proberen om via infrarood 4 bits data door te sturen van de ene arduino naar de andere. Ik wil gewoon 1 getal doorsturen.

1 arduino heeft een IR led en de ander heeft een TSOP1738 ontvanger die is aangesloten volgens de datasheet.

Maar bij de ontvanger komt de informatie heel laat. Er komt vrijwel meteen te staan nieuw getal ontvangen maar het duurt vervolgens best lang voor de informatie wordt weergegeven (ik test met 2 computers de arduino via de serial monitor). Ook zijn de ontvangen nummers helemaal niet constant. Er zit de hele tijd een groot verschil in de puls lengtes. Ook komt er niet elke keer als ik iets zend informatie binnen.

Als ik met een afstandsbediening test dan komen er de hele tijd constanste waarden binnen. Ook de IR led lijkt te werken als ik het bekijk met camera en als ik hem vervang door een gewone led

Zender:

code:

int ir_pin = 10;                        //IR LED 
int led_pin = 13;                       //"Ready to Send" LED
int button_pin = 4;                     //button
int button;                             //check if button is pushed
boolean pressed;                        // to remember if button has already been read
int start_bit = 2400;                   //Start bit threshold 
int one = 1200;                         //Binary 1 threshold 
int zero = 600;                         //Binary 0 threshold 
int dataOut = 0;
int waitTime = 700;

void setup() {
  pinMode(led_pin, OUTPUT);             
  pinMode(ir_pin, OUTPUT);
  pinMode(button_pin, INPUT);
  digitalWrite(led_pin, LOW);           //not ready yet
  digitalWrite(ir_pin, LOW);            //not sending yet
  Serial.begin(9600);
}

void loop() {
  button = digitalRead(button_pin);
  
  if (button == LOW && pressed == false) {
    Serial.println("knop losgelaten");
    pressed = true;
    int dataOut = 13;
    sendIRKey(dataOut);          //Fetch the key
    Serial.print("Getal verstuurd");
   
 
  }else if (button == HIGH && pressed == true){
      pressed = false;
      Serial.println("knop ingedrukt");
  }
}
int sendIRKey(int dataOut) {
  int data[4];
  digitalWrite(led_pin, HIGH);     //Ok, i'm ready to send
  for (int i=0; i<4; i++) {
    data[i] = bitRead(dataOut, i);   //encode data as '1' or '0'
    }
    
  oscillationWrite(ir_pin, start_bit);    // send startbit
  
  digitalWrite(ir_pin, HIGH);    // send separation bit
  delayMicroseconds(waitTime);
  
  for (int i=3; i>=0; i--) {      // send the whole binary code
    if (data[i] == 0){
      oscillationWrite(ir_pin, zero);
    }else{
      oscillationWrite(ir_pin, one);
    }
    digitalWrite(ir_pin, HIGH);  // send separation bit
    delayMicroseconds(waitTime);
  }
  delay(20);                         //Return key number
}

// this will write an oscillation at 38KHz for a certain time in useconds
void oscillationWrite(int pin, int time) {
  for(int i = 0; i <= time/26; i++) {
    digitalWrite(pin, HIGH);
    delayMicroseconds(13);
    digitalWrite(pin, LOW);
    delayMicroseconds(13);
  }
}

Ontvanger:

code:

int ir_pin = 7;                         //Sensor pin OUT
int led_pin = 13;                       //"Ready to Receive" flag
int one = 1000;                         //Binary 1 threshold (Microseconds)
int zero = 400;                         //Binary 0 threshold (Microseconds)


void setup() {
 pinMode(led_pin, OUTPUT);             //This shows when we're ready to receive
 pinMode(ir_pin, INPUT);
 digitalWrite(led_pin, LOW);           //not ready yet
 Serial.begin(9600);
}

void loop() {
 getIRKey();                            //Fetch the key
}


int getIRKey() {
  int data[4];
  digitalWrite(led_pin, HIGH);           //Ok, i'm ready to recieve
  while(pulseIn(ir_pin, LOW) < 2200) {   //Wait for a start bit
  } 
  Serial.println();
  Serial.print("Nieuw getal ontvangen:");
  data[0] = pulseIn(ir_pin, LOW);       //Start measuring bits, I only want low pulses
  data[1] = pulseIn(ir_pin, LOW); 
  data[2] = pulseIn(ir_pin, LOW);
  data[3] = pulseIn(ir_pin, LOW);

  digitalWrite(led_pin, LOW);

  for(int i=0;i<=3;i++) {               //Parse them
    Serial.print(data[i]);
    if(data[i] > one) {                 //is it a 1?
       data[i] = 1;
       Serial.print("=  1 \n");
    }else if(data[i] > zero){           //is it a 0?
       data[i] = 0;
       Serial.print("=  0 \n");
    }else{
       data[i] = 2;                     //Flag the data as invalid; I don't know what it is!
       Serial.print("=  error \n");
    }
  }
}

Bij mijn ontvanger geeft hij ook vaak een error aan omdat de ontvangen pulsen heel kort zijn.

Heeft iemand een idee waardoor ik van die vreemde waardes ontvang?

[mcDavid]

Als ik mag gokken zou ik zeggen die oscilation functie. Zo nauwkeurig timen is nogal veel gevraagd voor een microcontroller. Mijn eerste gedachte is een hardware-timer te gebruiken met deze library: http://www.arduino.cc/playground/Code/FrequencyTimer2

Maar zelfs dat schijnt maar tot ca. 30kHz. te gaan. dat lees ik verkeerd.
ah here it is, 13uS gaat dus lastig worden:

Note well: If your period is too fast you will lock up just handling interrupts. A simple counter incrementor will lock up somewhere under 15uS.

[ Voor 27% gewijzigd door mcDavid op 17-10-2012 20:11 ]

[Fuzzillogic]

Regel 63 doe je keer op keer de deling. Nou kan een optimizer dat wegoptimaliseren, maar of dat gebeurt bij Arduino weet ik niet.

En inderdaad wat mcDavid zegt, maar dan nog beter: gebruik de PWM-functie van Arduino. Ik doe hetzelfde in het WiicooZ-projectje. PWM één keer instellen en vervolgens simpel de output connecten en disconnecten op de snelheid van de daadwerkelijke bitrate.

[Verwijderd]

toevallig kwam ik gisteravond nog iets tegen van een infrarood zender die ook via PWM werkt.

Toch vind ik het vreemd, alles wat ik heb gevonden komt eigenlijk uit voorbeelden die ook via infrarood data verzenden met een arduino. Dus het lijkt me dat er een manier is dat het zou kunnen werken.

Maar nu eerst maar eens gaan kijken naar PWM

[mcDavid]

Fuzzillogic schreef op donderdag 18 oktober 2012 @ 07:44:
Regel 63 doe je keer op keer de deling. Nou kan een optimizer dat wegoptimaliseren, maar of dat gebeurt bij Arduino weet ik niet.

En inderdaad wat mcDavid zegt, maar dan nog beter: gebruik de PWM-functie van Arduino. Ik doe hetzelfde in het WiicooZ-projectje. PWM één keer instellen en vervolgens simpel de output connecten en disconnecten op de snelheid van de daadwerkelijke bitrate.

De PWM-puls van de arduino is maar 500Hz, daar ga je het dus ook niet mee redden. Wat die frequencytimer2 library doet is trouwens de timer van PWM-pin 3 en 11 (uit mijn hoofd) kapen om functies uit te voeren.
Als je er over nadenkt is het gewoon schier onmogelijk om dit met de arduino te timen. De microseconds() functie heeft al een resolutie van 4 microsecondes, en je wilt timen op 13. Dat kan gewoon simpelweg niet.

Verwijderd schreef op donderdag 18 oktober 2012 @ 15:24:
toevallig kwam ik gisteravond nog iets tegen van een infrarood zender die ook via PWM werkt.

Toch vind ik het vreemd, alles wat ik heb gevonden komt eigenlijk uit voorbeelden die ook via infrarood data verzenden met een arduino. Dus het lijkt me dat er een manier is dat het zou kunnen werken.

Maar nu eerst maar eens gaan kijken naar PWM

Waarschijnlijk wordt de PWM timer dan gebruikt om het signaal te timen, niet om de 38kHz draaggolf te timen. De oplossing is om een hardware oscilator te gebruiken daarvoor. Even googlen leert dat de 555 ic hier veel voor gebruikt wordt.

Een andere oplossing kan zijn gewoon een IR photodiode te gebruiken, die dus zonder draaggolf werkt. Nadeel is dat die veel meer hinder zal ondervinden van strooilicht.

[Verwijderd]

Maar in dit voorbeeld van Ken shirrif's IRremote library wordt toch ook PWM gebruikt om 38 kHz te timen?

code:

#include <IRremote.h>

#define PIN_IR 3
#define PIN_DETECT 2
#define PIN_STATUS 13

IRsend irsend;
void setup()
{
  pinMode(PIN_DETECT, INPUT);
  pinMode(PIN_STATUS, OUTPUT);
  irsend.enableIROut(38);
  irsend.mark(0);
}

void loop() {
  digitalWrite(PIN_STATUS, !digitalRead(PIN_DETECT));
}

dit is een infrarood lichtsluis waarbij het signaal getimed moet worden naar 38kHz zodat de ontvanger het anders niet oppikt.

Dit heb ik zojuist getest en dit werkt. Helaas heb ik nu niet veel tijd meer dus wordt pas weer in het weekend voor ik tijd heb om me er verder in te verdiepen.

[Sissors]

Uiteraard kan een arduino dat prima. Dat de standaard arduino libs het niet kunnen is een ander verhaal, maar de microcontroller erachter kan het prima. Die lukt het ook nog een draaggolf op 8MHz te maken, 38kHz is geen enkel probleem daarvoor.

Wat verder het probleem is, is lastig te zeggen. Sowieso zal het een lagere frequentie dan 38kHz zijn, maar zo heel exact zijn die ontvangers vaak ook niet. Met PWM wordt die frequentie wel netter. Wat voor een tijden meet hij dan nu?

En ik zou eens die serialprint eruit halen tijdens ontvangen. Het zou niet uit moeten maken omdat die tegenwoordig als het goed is non-blocking is, maar iig een poging waard.

[mcDavid]

Ah, weer wat geleerd over microcontrollers. Wat die library dus doet is de PWM-frequentie (standaard 490 Hz), veranderen naar 38KHz. Dat vermindert dan de mogelijke keuzes in duty-cycles maar dat boeit niet, die moet gewoon ongeveer 50% zijn.
Het kan dus wel, maar niet op de klassieke manier met interrupts of delays.

[Verwijderd]

ik heb nu ff vlug iets getest met PWM via de IRremote Library.

code:

#include <IRremote.h>

int PIN_IR = 3;
int testpin = 7;         // also connected to IR pin for setting high without PWM
int startBit   = 9000;   // This pulse sets the threshold for a transmission start bit
int waitTime = 700;      // The amount of time to wait between pulses
int buttonPin = 4;                     //button
int button;                             //check if button is pushed
boolean pressed;                        // to remember if button has already been read
int one = 9000;                         //Binary 1 threshold 
int zero = 5000;                         //Binary 0 threshold 

IRsend irsend;

void setup()
{
  pinMode(buttonPin, INPUT);
  pinMode(testpin, OUTPUT);
  irsend.enableIROut(38);
  Serial.begin(9600);
}

void loop() {

  button = digitalRead(buttonPin);
  if (button == LOW && pressed == false) {
    Serial.println("knop losgelaten");
    pressed = true;
    int dataOut = 13;
    sendIRKey(dataOut);          //Fetch the key
    Serial.println("Getal verstuurd");
   
 
  }else if (button == HIGH && pressed == true){
      pressed = false;
      Serial.println("knop ingedrukt");
  }
}
int sendIRKey(int dataOut) {
  int data[4];
  for (int i=0; i<4; i++) {
    data[i] = bitRead(dataOut, i);   //encode data as '1' or '0'
    }
    
  digitalWrite(PIN_IR, HIGH);    // send startbit
  delayMicroseconds(startBit);
  
  digitalWrite(PIN_IR, LOW);    // send separation bit
  digitalWrite(testpin, HIGH);
  delayMicroseconds(waitTime);
  digitalWrite(testpin, LOW);
  
  for (int i=3; i>=0; i--) {      // send the whole binary code
    if (data[i] == 0){
      digitalWrite(PIN_IR, HIGH);
      delayMicroseconds(zero);
    }else{
      digitalWrite(PIN_IR, HIGH);
      delayMicroseconds(one);
    }
    digitalWrite(PIN_IR, LOW);    // send separation bit
    digitalWrite(testpin, HIGH);
    delayMicroseconds(waitTime);
    digitalWrite(testpin, LOW);
    }
  delay(20);                         //Return key number
}

De grote waarden van de startbit, one en zero zijn alleen om te testen of dat een verschil zou maken.

maar dit ontvang ik op de andere arduino:

code:

Nieuw getal ontvangen:
1881=  error 
2114=  error 
600=  error 
4930=  0 

Nieuw getal ontvangen:
1009=  error 
6919=  1 
4659=  error 
8201=  1 

Nieuw getal ontvangen:
4815=  0 
553=  error 
1213=  error 
7499=  1 

Nieuw getal ontvangen:
6923=  1 
548=  error 
8689=  1 
5476=  0 

Nieuw getal ontvangen:
24110=  1 
581=  error 
0=  error 
0=  error

De receiver code is nog hetzelfde, bij de sender heb ik de IR LED ook aangesloten op pin 7 zodat ik die hoog kan zetten zonder modulatie om dezelfde soort datastring te krijgen als ik bij de vorige code verstuurde.

Het lijkt alsof het random tijden zijn die het ontvangt, in ieder geval niet fouten die die hele tijd terug komen.

[Sissors]

Het zal met interrupts ook nog wel lukken, maar het is beter/netter/sneller om het met PWM units te doen. De standaard PWM frequentie heeft ook nog dingen zoals prescalers die het daarop vast zetten.

Als je kijkt naar je maximale PWM frequentie waarbij je geen resolutie inlevert (uitgaande van 8-bit), dan is dat 16M/256 voor fast PWM, en 16M/512 voor phase correct PWM. Als je nog hoger wilt dan dat moet je wel resolutie gaan inleveren. Om precies om 38kHz te komen zal dat misschien ook moeten, maar zoals je zelf zegt, als het maar ergens rond de 50% zit is het prima.


@vorige post, nu kan hij zijn startbit natuurlijk niet meer eruit halen met deze tijden. Maar het is inderdaad wel heel erg random wat er terug komt. En als je niks stuurt, ontvangt hij dan ook random troep of gaat dat wel goed?

[ Voor 16% gewijzigd door Sissors op 18-10-2012 21:03 ]

[Verwijderd]

die grote waarden waren ff om ui te proberen maar met de gewone waarden krijg ik precies dezelfde waarden terug.

Wat bedoel je met niks sturen?
want als ik niks stuur ontvang ik ook niks, of begrijp ik het niet helemaal?

[Sissors]

Dat was de vraag dus, of je ook niks ontvangt wanneer je niks stuurt.

[kitao]

Ik vat het ook niet helemaal hoor furby, als ik geen postkaartje opstuur dan ontvangt mijn familie ook geen vakantiekiekje.
Of bedoelde je soms dat er misschien ergens stoorvelden aanwezig waren ?

[Mattie112]

D-Three schreef op zondag 14 oktober 2012 @ 23:52:
Uiteraard moeten de grounds verbonden zijn. Het signaal is gerefereerd ten opzicht van zijn ground. Dus als de arduino 5V op een pin zet, is dat ten opzichte van de min van de 9V batterij. Maar je hebt er geen idee van hoe groot dat signaal is ten opzichte van de andere batterijen zolang de grounds niet verbonden zijn. De grounds zweven ten opzichte van elkaar.

Thx, nu ik er dat zo lees is het eigenlijk wel heel logisch

Vandaag maar ff kijken hoe ik alle "losse" stukjes (servo, led, lcd) kan combineren tot 1 programmatje.

[Sissors]

kitao schreef op vrijdag 19 oktober 2012 @ 08:55:


Ik vat het ook niet helemaal hoor furby, als ik geen postkaartje opstuur dan ontvangt mijn familie ook geen vakantiekiekje.
Of bedoelde je soms dat er misschien ergens stoorvelden aanwezig waren ?

Dat dus. Als hij hele korte pulsen gaat ontvangen is het een redelijke gok dat het door troep uit de omgeving komt. Kan ook nog zijn dat er slecht contact is, al zou ik dan verwachten dat bij een afstandsbediening hij het ook niet netjes doet.
Sowieso in elk elektronisch circuit ontvang je altijd wat: ruis is altijd aanwezig. (Maar dat zal bij deze modules niet het probleem zijn).

Anyway: bij je laatste tijden kom je wel erg ruim buiten de specs van die TSOP modules. Als je gewoon verstuurt met de irsend library, doet hij het dan wel beter? Ik zie sowieso even niet bij je laatste code hoe daar nu een 38kHz signaal uit komt. Bij je eerste code staat de output standaard op high, staat dan ook de IR led aan?

[mcDavid]

furby-killer schreef op vrijdag 19 oktober 2012 @ 15:17:
[...]

Ik zie sowieso even niet bij je laatste code hoe daar nu een 38kHz signaal uit komt. Bij je eerste code staat de output standaard op high, staat dan ook de IR led aan?

Ik denk dat die IR library dat afvangt door het PWM signaal op PIN_IR 38kHz te maken.

heb geen documentatie gelezen maar... irsend.enableIROut(38); kan haast niet missen

-edit-

code:

int testpin = 7;         // also connected to IR pin for setting high without PWM

Zit hier wel een diode tussen ofzo? Anders heb je gewoon kortsluiting tussen pin 3 en pin 7 op het moment dat de een hoog is en de ander laag.
Een andere oplossing is de pin die je niet gebruikt tijdelijk als input in te stellen.

[ Voor 36% gewijzigd door mcDavid op 19-10-2012 15:31 ]

[Verwijderd]

mcDavid schreef op vrijdag 19 oktober 2012 @ 15:23:
[...]

Ik denk dat die IR library dat afvangt door het PWM signaal op PIN_IR 38kHz te maken.

heb geen documentatie gelezen maar... irsend.enableIROut(38); kan haast niet missen

-edit-

code:

int testpin = 7;         // also connected to IR pin for setting high without PWM

Zit hier wel een diode tussen ofzo? Anders heb je gewoon kortsluiting tussen pin 3 en pin 7 op het moment dat de een hoog is en de ander laag.
Een andere oplossing is de pin die je niet gebruikt tijdelijk als input in te stellen.

Die irsend.enableIROut is inderdaad de om het signaal 38 kHz te maken.

Er zaten wel diodes tussen maar ben ondertussen alweer andere dingen aan het proberen. Alle examples van de IRremote library werken gewoon, inclusief de standaard signalen die in de IR library zitten. Maar om een eigen signaal te versturen krijg ik tot nu toe nog niet voor elkaar. Tenminste geen signaal wat over komt zoals ik het wil.

[Sissors]

Moet je dan niet die enableIROut (en een disable) callen voor elk bitje dat je wilt versturen? Nu zet je hem 1x aan, en ga je daarna iets met een digitalWrite doen, echter dan lijkt het mij niet dat je je 38kHz houdt.

[kitao]

Duration van Tone maakt geen klap verschil ...

Oorspronkelijke code :
http://arduino.cc/en/Tutorial/Tone4

code:

void setup() {
}
void loop() {
   // turn off tone function for pin 11:
   noTone(11);          
  // play a note on pin 6 for 200 ms:
  tone(6, 440, 200);
  delay(200);
  // turn off tone function for pin 6:
  noTone(6);
  // play a note on pin 7 for 500 ms:
  tone(7, 494, 500);
  delay(500);  
  // turn off tone function for pin 7:
  noTone(7);  
  // play a note on pin 11 for 500 ms:
  tone(11, 523, 300);
  delay(300);
}

Opgebouwd en werkt prima
Maar als ik regel 7 verander in :

code:

tone(6, 440, 5000);

dan blijft gewoon hetzelfde deuntje spelen terwijl ik had verwacht dat pin6 dan toch ipv 200ms naar 5000ms zou gaan, dus dat pin6 op de speaker 5 seconden zou aanblijven.
Ik heb al gezocht op Tone maar zie daar geen verklaring ervoor.
http://arduino.cc/en/Reference/Tone
---------------------------------------------------------------------------
@borroz

Verwijderd schreef op woensdag 17 oktober 2012 @ 10:07:
http://iprototype.nl/prod...cd/128x64-Graphic-SPI-LCD

Ik ben laf, ik weet het, maar heb toch maar 2 lcd's besteld, :deze en deze.
Reden daarvoor is dat ik dan kan beginnen met de voorbeelden precies volgens het boekje zoals die aangereikt worden in de tutorials en er dus weinig kans is dat ik ergens vastloop.
Maar mocht ik dit eenmaal onder de knie hebben dan kan ik altijd nog 'jouw' lcd bestellen.

[ Voor 29% gewijzigd door kitao op 20-10-2012 15:19 ]

[Sissors]

Op regel 8 heb je een delay van 200ms, waarnaar je hem weer uitschakelt. Gezien dat tone waarschijnlijk non-blocking is (dus je code runt gewoon door, hij wacht niet totdat hij klaar is), schakelt hij hem na 200ms weer uit. (Dat is in het oorspronkelijke voorbeeld nogal idioot, dat ze zowel de toon 200ms lang maken, en hem na 200ms uitschakelen, beetje dubbelop).

[kitao]

code:

tone(6, 440, 5000);
  delay(5000);

Nu doet die het wel.
Ik snap het, bedankt furby

[Verwijderd]

YouTube: Arduino mega with 128x64 graphic LCD

[kitao]

Ok, nog eentje voor de liefhebbers
Hier staat een programmaatje hoe je een fotocel kan calibreren maar ik had iets heel anders verwacht.
Zelf zou ik dan schrijven :

"Maak alles donker en meet de minimumwaardewaarde van de fotocel en bevestig einde van de meting"
"Maak fel licht en meet de maximumwaarde van de fotocel en bevestig einde van de meting".

Het gegeven programma doet dat niet en lijkt mij dat zonder iets te veranderen de minimum en maximumwaarde dan gelijk blijven ?

[Mattie112]

Het klinkt wel een beetje vreemd. Meet je op die manier niet het "gemiddelde"? Zodat je dus weet of het lichter dan "normaal" of juist donkerder dan "normaal" is?

[kitao]

Ik heb geen idee Mattie, jij bent de C-expert en ik ben er nog maar een week mee bezig.
Dit is de code zonder veel commentaar :

code:

// These constants won't change:
const int sensorPin = A0;    // pin that the sensor is attached to
const int ledPin = 9;        // pin that the LED is attached to

// variables:
int sensorValue = 0;         // the sensor value
int sensorMin = 1023;        // minimum sensor value
int sensorMax = 0;           // maximum sensor value

void setup() {
  // turn on LED to signal the start of the calibration period:
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);

  // calibrate during the first five seconds 
  while (millis() < 5000) {
    sensorValue = analogRead(sensorPin);

    // record the maximum sensor value
    if (sensorValue > sensorMax) {
      sensorMax = sensorValue;
    }

    // record the minimum sensor value
    if (sensorValue < sensorMin) {
      sensorMin = sensorValue;
    }
  }

  // signal the end of the calibration period
  digitalWrite(13, LOW);
}

void loop() {
  // read the sensor:
  sensorValue = analogRead(sensorPin);

  // apply the calibration to the sensor reading
  sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255);

  // in case the sensor value is outside the range seen during calibration
  sensorValue = constrain(sensorValue, 0, 255);

  // fade the LED using the calibrated value:
  analogWrite(ledPin, sensorValue);
}

regel 16 t/m 28 is volgens mij een loop die 5 seconden lang de min en max opmeet, maar zoals ik het lees zou dan als tijdens die 5 seconden de lichtsterkte verandert dan ook meteen de min en max veranderen en volgens mij allebei hetzelfde worden ?
Anyway, het is niet zo belangrijk, ik heb net Processing gedownload en dat lukt ook nog niet zo best dus ik heb dit alweer achter me gelaten.
Dat komt vanzelf in de loop der tijd, dat ik al die { } -haakjes ga snappen.

(Het lukt niet zo best omdat ik bij ieder voorbeeld onder hoofdstuk 4 op deze pagina de foutmelding : 'serial does not run in 64-bit mode' krijg.
Nou ja, dat download ik dat hele programma maar weer opnieuw in 32 bits

Edit: Dat is nu dus verholpen daarmee; dit werkt nu prima gelukkig.

[ Voor 8% gewijzigd door kitao op 21-10-2012 20:32 . Reden: toevoeging ]

[Sissors]

Die worden simpelweg gebruikt om stukken code te groeperen, dus als je een if-statement hebt, hoort alles tussen accolades die daarna komen bij dat statement.

Over die 'calibratie' techniek, ja die slaat eigenlijk nergens op op die manier. Je zal dan iig zelf moeten zorgen dat in die 5 seconden je je maximum en minimum aanbiedt. Echter max en min zullen wel degelijk verschillend zijn van elkaar (zolang je input wat varieert). Min wordt enkel bij een nieuw minimum geupdate, max enkel bij een nieuw maximum.

[kitao]

Dat eerste wist ik wel maar er staan erzoveel dat ik gewoon de samenhang kwijt raak.

En toch vreemd eigenlijk dat binnen een dag er nu al 2 voorbeelden zijn die eigenlijk nergens op slaan. Dat was gisteren ook al zo met die speakertjes. Ook zie ik steeds tekenfouten in die tutorials, waarmee ik maar wil zeggen dat de kwaliteit van het platform volgens mij niet al te best is.
Geeft verder niet hoor, de grote lijnen zijn wel te volgen en ik ben in ieder geval opgelucht dat Processing nu wel werkt al was het dan via een omweg van hier tot Tokio en dat ik tenminste nog iets zelf heb opgelost.

Morgen maar weer verder en bedankt voor de tips.

[WVL_KsZeN]

Welke multiplexer zouden jullie aanraden om +- 64 LED's aan te sturen? Ik ben aan het zoeken voor de makkelijkste manier om alles aan te sturen..

Het beste lijkt me om altijd alle LED's te scannen met de multiplexer en een output pin op te zetten als de LED moet gaan branden, ipv alleen de LED's te scannen die moeten branden. Op die manier zijn de LED's altijd even helder (doordat de scantijd hetzelfde is), ongeacht het aantal brandende LED's.

Ik wil de multiplexer aansturen met een IRQ, zodat deze buiten mijn applicatie kan lopen.

Ik merk wel dat het aantal IO pins echt beperkend is, 14 stuks I/O en ik wil ook nog 8 inputs kunnen lezen.. (nu ik erover nadenk, misschien nog 6 extra inputs..)

Ik zit even stuk, ik wil dus :

- 64 outputs aansturen met 10mA per output. Als ik deze ga multiplexen met een constante scansnelheid waarbij ik altijd alle 64 LED's bezoek, dan moet ik dus een uitgangssignaal met 640mA (!!!) laten scannen. Gaan mn LED's dan niet stuk (ondanks dat ik ze natuurlijk maar voor 1/64e van de tijd aanstuur)?

Kan ik misschien beter gaan voor meerdere multiplexers zodat ik de LED's per 4 of 8 tegelijk aanstuur?

Stel ik neem multiplexers met 8 uitgangen, ik heb dan 3 pins nodig om een LED te selecteren en 1 pin om de LED aan/uit te sturen. Ik heb dan 8 multiplexers nodig, dus 3 pinnen + 8 om LED's in/uit te schakelen = 11 pinnen.. (ik stuur dan 8 LED's tegelijk aan)

Dan heb ik nog 3 pinnen over, dus te weinig om inputs te lezen..

Waar zouden jullie voor kiezen?

Ik wil het aantal componenten ook een beetje beperkt houden.. 8 multiplexers is niet zo tof. Ook vind ik het een goed idee om de stroomsterkte zoveel mogelijk te beperken.

In het kort zijn de mogelijkheden volgens mij :

- 1 grote multiplexer met 64 uitgangen (bestaan die wel?) -> stroomsterkte is dan 640mA!
- 8 multiplexers met 8 uitgangen die ik kan aansturen met 3 pinnen (zelfde pinnen voor alle multiplexers), vervolgens stuur ik 8 LED's tegelijk aan met 8 pinnen. Ik gebruik dan 11 pinnen en een stroomsterkte van 80mA.
- 9 multiplexers met 8 uitgangen. De eerste multiplexer stuurt de stroom naar 1 van de 8 multiplexers (3 pinnen nodig), en de 8 overige multiplexers scannen over 8 LED's (3 pinnen). Dan heb ik nog 1 pin nodig om de LED's aan/uit te zetten. Totaal 7 pinnen, stroomsterkte 640mA.

prrft.

[ Voor 21% gewijzigd door WVL_KsZeN op 21-10-2012 21:39 ]

[kitao]

Ik heb hier niet veel verstand van maar ik zou kiezen voor een demultiplexer waarschijnlijk als je 64 leds onafhankelijk van elkaar wil aansturen.
Dan heb je 1x een X-ingang nodig, 1x een Enable ingang, en een A,B,C,D,E,F ingang nodig, totaal 8 ingangen en op de demultiplexer zitten dan 64 uitgangen. (2^6).

(ps, dit is theorie en hoe dit in de praktijk moet uitpakken is een ander verhaal, vooral als die 64 leds tegelijk gaan branden zal er flink stroom gevraagd worden)

Hier nog een foto om het iets duidelijker te maken)

(klik)

[mcDavid]

64 led's aansturen doe je toch gewoon met één MAX7221 en verder niets? Of zie ik iets over het hoofd?

-edit-
@hieronder:
http://www.arduino.cc/playground/Main/MAX72XXHardware

[ Voor 27% gewijzigd door mcDavid op 21-10-2012 22:03 ]

[kitao]

Ja Mac,
Je vergeet een linkje

[franssie]

f(google) arduino + MAX7221 = http://www.arduino.cc/playground/Main/LEDMatrix

en dan http://arduino.cc/playground/Main/MultiplexMAX72xx lijkt op wat je wilt?

[ Voor 34% gewijzigd door franssie op 21-10-2012 22:07 ]

[kitao]

Zoiets ?



http://arduino.cc/forum/index.php?topic=50074.0

[WVL_KsZeN]

Ja! Die 7221 is wat ik wil

Nu ik erover nadenk ik is een andere oplossing om 8x 8-bit SIPO shift registers te gebruiken..74HC164 ofzo. Dat zou misschien nog beter zijn, want ik hoef de LED's maar 10x per seconde aan te passen... (nadeel is dan weer dat je vast zit aan 8 14pins chips.. )

[ Voor 11% gewijzigd door WVL_KsZeN op 21-10-2012 22:42 ]

[Verwijderd]

http://www.instructables.com/id/Led-Cube-8x8x8/?ALLSTEPS

[Mattie112]

kitao schreef op zondag 21 oktober 2012 @ 19:51:
Ik heb geen idee Mattie, jij bent de C-expert en ik ben er nog maar een week mee bezig.
Dit is de code zonder veel commentaar :

code:

// These constants won't change:
const int sensorPin = A0;    // pin that the sensor is attached to
const int ledPin = 9;        // pin that the LED is attached to

// variables:
int sensorValue = 0;         // the sensor value
int sensorMin = 1023;        // minimum sensor value
int sensorMax = 0;           // maximum sensor value

void setup() {
  // turn on LED to signal the start of the calibration period:
  pinMode(13, OUTPUT);
  digitalWrite(13, HIGH);

  // calibrate during the first five seconds 
  while (millis() < 5000) {
    sensorValue = analogRead(sensorPin);

    // record the maximum sensor value
    if (sensorValue > sensorMax) {
      sensorMax = sensorValue;
    }

    // record the minimum sensor value
    if (sensorValue < sensorMin) {
      sensorMin = sensorValue;
    }
  }

  // signal the end of the calibration period
  digitalWrite(13, LOW);
}

void loop() {
  // read the sensor:
  sensorValue = analogRead(sensorPin);

  // apply the calibration to the sensor reading
  sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255);

  // in case the sensor value is outside the range seen during calibration
  sensorValue = constrain(sensorValue, 0, 255);

  // fade the LED using the calibrated value:
  analogWrite(ledPin, sensorValue);
}

regel 16 t/m 28 is volgens mij een loop die 5 seconden lang de min en max opmeet, maar zoals ik het lees zou dan als tijdens die 5 seconden de lichtsterkte verandert dan ook meteen de min en max veranderen en volgens mij allebei hetzelfde worden ?
Anyway, het is niet zo belangrijk, ik heb net Processing gedownload en dat lukt ook nog niet zo best dus ik heb dit alweer achter me gelaten.
Dat komt vanzelf in de loop der tijd, dat ik al die { } -haakjes ga snappen.

(Het lukt niet zo best omdat ik bij ieder voorbeeld onder hoofdstuk 4 op deze pagina de foutmelding : 'serial does not run in 64-bit mode' krijg.
Nou ja, dat download ik dat hele programma maar weer opnieuw in 32 bits

Edit: Dat is nu dus verholpen daarmee; dit werkt nu prima gelukkig.

Heb iets gevonden

http://stackoverflow.com/...24/arduino-map-method-why

The analog output only has an acceptable range between 0 and 255.

Therefore, the value has to be mapped within the acceptable range.

maw: 100% licht zou dus "1023" zijn, maar je digitalwrite kan maar "255" aan. Je kan dus delen door 4 heel simpel maar zoals ik het opvat via die map() dat het door arduino zelf berekend wordt en dat je dus in 1x de waarde kan gebruiken.

Zie ook:

http://arduino.cc/en/Reference/map
en
http://arduino.cc/en/Tutorial/AnalogInOutSerial

[kitao]

Bedankt Matti, vooral voor de links, maar map was niet waar ik me over verbaasde want dat begrijp ik wel.
Het ging om dit stukje code :

code:

 // calibrate during the first five seconds 
  while (millis() < 5000) {
    sensorValue = analogRead(sensorPin);

    // record the maximum sensor value
    if (sensorValue > sensorMax) {
      sensorMax = sensorValue;
    }

    // record the minimum sensor value
    if (sensorValue < sensorMin) {
      sensorMin = sensorValue;
    }
}

Gedurende 5 seconden is er een loop gaande - while (millis() < 5000) { - waarin het programma kijkt naar de min en max waarde, maar als de gebruiker dan in die tijd niets verandert aan de omstandigheden dan zal er ook geen min en max-waarde te meten zijn, slechts de waarde waar de sensor op dat moment op staat ingesteld.
Bij een pot moet de gebruiker in die 5 seconden draaien aan het dopje, bij een fotocel moet binnen 5 seconden donker en licht gemaakt worden.
Althans zo komt het op mij over en ik meen dat furby-killer het daar mee eens was.
Maar dat kon je dus nergens in het voorbeeld terugvinden en ook het programma zelf vraagt niet om die handelingen via een monitor en zelfs niet via de comments.
Dus vandaar dat ik het niet helemaal begreep.

[Mattie112]

Ah ok nu snap ik wat je bedoelt

Nee idd, je zou zeggen dat hij dus in 5 sec even helemaal donker én helemaal licht moet "zien" voordat hij optimaal werkt.

Ook nog even over mijn eigen zooi:

Heb zojuist wat shift-register chippies binnen gekregen. Toch wel erg handig om nu met slechts 3 pinnetjes 8 (of zelfs meer) dingen te bedienen

Nu nog kijken hoe ik ga zorgen dat mn LCD op die manier gaat werken......

[kitao]

Mogge,
Zijn dat 595 flipflop's ?
Een hele tijd geleden was ik ook bezig met dat soort dingen maar is allemaal een beetje weggezakt.
Laat me weten hoe het gaat, ik heb gisteren ook 2 lcd's besteld, een 2x16 serieel en parallel en daar zou ik evt. ook zo'n IC voor kunnen gebruiken.

[Dutch Lion]

kitao schreef op maandag 22 oktober 2012 @ 16:08:
Bedankt Matti, vooral voor de links, maar map was niet waar ik me over verbaasde want dat begrijp ik wel.
Het ging om dit stukje code :

code:

 // calibrate during the first five seconds 
  while (millis() < 5000) {
    sensorValue = analogRead(sensorPin);

    // record the maximum sensor value
    if (sensorValue > sensorMax) {
      sensorMax = sensorValue;
    }

    // record the minimum sensor value
    if (sensorValue < sensorMin) {
      sensorMin = sensorValue;
    }
}

Gedurende 5 seconden is er een loop gaande - while (millis() < 5000) { - waarin het programma kijkt naar de min en max waarde, maar als de gebruiker dan in die tijd niets verandert aan de omstandigheden dan zal er ook geen min en max-waarde te meten zijn, slechts de waarde waar de sensor op dat moment op staat ingesteld.
Bij een pot moet de gebruiker in die 5 seconden draaien aan het dopje, bij een fotocel moet binnen 5 seconden donker en licht gemaakt worden.
Althans zo komt het op mij over en ik meen dat furby-killer het daar mee eens was.
Maar dat kon je dus nergens in het voorbeeld terugvinden en ook het programma zelf vraagt niet om die handelingen via een monitor en zelfs niet via de comments.
Dus vandaar dat ik het niet helemaal begreep.

Een sensor geeft in vijf seconden altijd wel iets verschil. Dus je krijgt een min en max waarde. Deze min en max waarde worden gebruikt om te converteren naar het hele bereik.

Het is inderdaad wat vreemd zoals je aangeeft maar wat het als doel heeft zoals ik nu even snel lees is dat je zonder iets te doen dat ledje zal gaan zien veranderen. Er zal dus maar een hele kleine licht variatie nodig zijn om die led te doen veranderen.

In principe calibreer je dus ook wel de sensor, je weet immers wat bij gelijkblijvende omstandigheden de min en max waardes zijn dus je weet de inaccuraatheid (is dat een nederlands woord?) van de sensor.

Alleen waar het nu voor gebruikt wordt is weinig nuttig.

[Mattie112]

kitao schreef op dinsdag 23 oktober 2012 @ 05:42:
Mogge,
Zijn dat 595 flipflop's ?
Een hele tijd geleden was ik ook bezig met dat soort dingen maar is allemaal een beetje weggezakt.
Laat me weten hoe het gaat, ik heb gisteren ook 2 lcd's besteld, een 2x16 serieel en parallel en daar zou ik evt. ook zo'n IC voor kunnen gebruiken.

Jup, dat zijn deze http://cgi.ebay.com/ws/eB...geName=ADME:X:AAQ:US:1123 (lekker goedkoop )

Heb nog even zitten kijken hoe hij precies werkt en je stuurt dus zegmaar een klok-signaal (bijv) _-_-_-_-_-_-_-_- (8x hoog, 8x laag). Terwijl je dat klok-signaal stuurt moet je op de datapin je data meesturen (bijv) ____--___--___ Dat chippie kijkt dan bij "hoog" van je klok-signaal of je datasignaal hoog of laag is en geeft die waarde dan "door" aan de desbetreffende pin.

geeeeeeeeeeeen idee hoe ik dat ga doen icm LCD schermpje aangezien ik daar de standaard library voor gebruik. Denk dat ik daar ook nog even niet mee ga kloten aangezien er nog een i2c-convertor in aantocht is voor mn lcd

Maargoed, het komt er dus op neer dat je in 1 "run" alle 8-waarde door moet geven. Voor zover ik zie is het niet mogelijk om alleen pin 2 HIGH te zetten ZONDER de andere pinnen LOW te zetten (unless je die waarde ergens opslaat (array) en ze daarna weer uitleest....)

Iemand die kan bevestigen wat ik denk?

[Verwijderd]

Lang weekend gehad maar ik ben weer aan het spelen met mijn IR zender.

furby-killer schreef op vrijdag 19 oktober 2012 @ 19:49:
Moet je dan niet die enableIROut (en een disable) callen voor elk bitje dat je wilt versturen? Nu zet je hem 1x aan, en ga je daarna iets met een digitalWrite doen, echter dan lijkt het mij niet dat je je 38kHz houdt.

Daar klopte niet zoveel van dat heb ik voor het weekend nog even vlug gemaakt.

als ik op: http://www.pjrc.com/teensy/td_libs_IRremote.html

kijk lijkt me dat ik met de IRremote library en de irsend.sendRaw functie toch een eigen code kan verzenden.

results.rawbuf: An array of IR pulse times
results.rawlen: The number of items stored in the array

irsend.sendRaw(rawbuf, rawlen, frequency);
Send a raw code. Normally you would obtain the contents of rawbuf and rawlen by using the receiver many times and averaging the results. Some adjustments may be necessary for best performance. The frequency is the expected bandpass filter frequency at the receiver, where 38 is the most commonly used.

Maar ik snap nog niet helemaal hoe dat werkt. Als ik gewoon een array maak met een startbit en een aantal lengtes die overeenkomen met 1 of 0 herkent mijn ontvanger niks.

als ik de irsend.sendSony(IRcode, Numbits) gebruik dan kan ik wel zelf hexadecimale waarden invoeren, maar dan vangt hij ook de signalen van een afstandsbediening op en dat wilde ik eigenlijk voorkomen door helemaal mijn eigen data string te maken waar ik dan uiteindelijk nog een eindbit aan kan toevoegen die herkent wordt door mijn receiver.

weet iemand of ik met die sendRaw op de goede weg ben of heb ik het gebruik daarvan vekeerd begrepen?

[kitao]

@Lion, bedankt voor de uitleg, tzt ga ik dit eens verder uitzoeken.
@Matti, klinkt ingewikkeld en meer als een lichtorgeltje ermee maken heb ik eerlijk gezegd nog nooit bereikt. Hoewel erbij gezegd moet worden dat de cursus(sen) digitale techniek die ik heb gevolgd eigenlijk ook niet meer als dat als voorbeeld gaven. Niet dat ik me kan herinneren althans of het moet bijvoorbeeld het aansturen van een 7-segmentje zijn maar dat is ook niet bepaald high-tech.
Wel is het zo dat de signalen inderdaad boven elkaar getekend werden, zeg maar het signaalschema, dus dat is tenminste niet helemaal nieuw.
Ik heb nog een paar bergje IC's liggen, wordt tijd om die eens te gaan indelen of ze nog van pas kunnen komen.
Een stoffig testbordje heb ik ook nog + iets van 50 100 theorielessen maar die ga ik echt niet meer doorspitten want daar hebben de geleerden juist een micro voor uitgevonden om die dradenspaghetti van losse chips te kunnen vervangen door een compacte opbouw.
Een voorbeeld daarvan is de ADC die ik hier heb behandeld :
kitao in "Micro-controller toegepast."
Nu is me niet helemaal duidelijk of dat de basicstamp geen adc-ingang heeft of dat dit slechts als 'lesmateriaal' naar voren werd gebracht, maar inmiddels weet ik dat de uno dit allang ingebouwd heeft.
Dat scheelt dus weer tig draadjes en een externe ic met een rc-netwerk daaraan gekoppeld.

Om terug te komen op die 100 theorie-lessen, toen ik daar mee bezig was moest je voor een datasheet nog naar de centrale bibliotheek op de blaak, tegenwoordig haal je die simpelweg van internet af.
Dat wil nog niet zeggen dat iemand (ook ik) ze daarmee meteen kan lezen en interpreteren maar het werd tenminste wel een beetje toegelicht.


_klik

En verder, nu ik toch in deze post zit, als jij nu al pinnen tekort komt en je hebt daar nu al perse uitbreiding bij nodig in de vorm van extra ic's dan wordt het volgens mij tijd om iets sterkere koffie te gaan drinken.
Een 32- of 64-bitter micro ofzo en zet de uno dan maar aan de kant.

edit:
dit is mischien wel wat voor jou, 96 vrije pinnetjes
mad_max234 in "De EL-kroeg - Deel 3"

[ Voor 49% gewijzigd door kitao op 23-10-2012 19:37 ]

[kitao]

kitao schreef op woensdag 17 oktober 2012 @ 09:38:

Zowel voor Sparkfun als voor Parallax is Antratek de distributeur, een bedrijf in Nederland
Dat maakt het dus wel makkelijker om te bestellen hoewel ik nog geen losse componentjes bij hun heb besteld dus ik weet nog niet hoe ze daar op gaan reageren.

Ik weet dat nu dus wel
Deze rgb bijvoorbeeld van sparkfun is bij hun niet te bestellen.
Jammer omdat antratek bij sparkfun als distibuteur wordt vermeld maar ook deze lcd was niet te verkrijgen via antratek hoewel ze deze (de 2e) als alternatief boden die ik besteld heb.
(ik bedoel, wat heb je aan een lokale verzender als die de helft of meer van je spullen niet kan leveren

Dus als iemand van plan was om direkt van sparkfun te bestellen wat niet bij antratek op de bestellijst staat, reken dan op extra verzendkosten vanuit de usa of koop via dx, iprototype, of ebay.
(op iprotype kon ik trouwens geen common anode rgb vinden dus dan maar een common kathode
En ik baal er best van want Sparkfun heeft een heel goede zoekmachine waar bijv. Conrad en de rest nog een puntje aan kan zuigen.
Nog afgezien van de extra verzendkosten die ik krijg voor een rgb via iprotype én een lcd via antratek
(4+6 euro respectievelijk)

[ Voor 10% gewijzigd door kitao op 23-10-2012 19:42 ]

[mcDavid]

Waarom zou je perse common anode willen? Over het algemeen werkt common cathode relaxter (al maakt het eigenlijk weinig uit). Ook zou ik je aanraden RGB-leds altijd diffused te bestellen, is veel mooier.

[kitao]

Common anode omdat dat hier wordt gebruikt als voorbeeld.
Nu klopt dat hele programma niet meer natuurlijk
En of het nu mooi of dof is maakt me weinig uit; ik heb dat componentje gewoon niet en nog steeds niet dus

[mcDavid]

Och dat hele programma aanpassen is een kwestie van "255 -" weghalen bij de kleuren. Een beetje eigen inbreng maakt het toch juist leuk?

[darkvortex]

Na het plaatsen in de verkeerde topic zal ik mijn bericht (op aanraden van mcDavid) verplaatsen naar hier.

Heeft hier iemand een idee hoe je de parallelle poort van een pc kan besturen op de meest simpele manier?
We zijn namelijk bezig met een aansturing van een oude robot arm in onze school.
Tot nu toe hebben we het geprobeerd te programmeren met turbo pascal maar dat heeft niet zo'n mooie gui.

Ook heb ik al het internet eens af gesurft en het één en ander gevonden ,maar niet echt concreet wat ik zocht.

Heeft iemand misschien kant en klare oplossingen of mooie ideetjes in vb alle input is welkom.

Als een mod dit leest mag hij het verwijderen.

[ Voor 4% gewijzigd door darkvortex op 23-10-2012 20:33 ]

[kitao]

@mcDavid
Tuurlijk, maar ik ken C nog niet goed genoeg om er op dit moment al teveel aan te kunnen gaan veranderen.
Een beetje programmeur had bijvoorbeeld in het sensor-calibratie gedeelte wat ik hiervoor naar voren bracht de waarden op een monitor kunnen zetten zodat je kunt zien wat het programma doet maar helaas ben ik nog niet zover.

[franssie]

darkvortex schreef op dinsdag 23 oktober 2012 @ 19:57:
<>
Als een mod dit leest mag hij het verwijderen.

De LTP van een PC aanspreken kan wel maar een arduino is een makkelijkere optie. Misschien nog leuker is een Raspberry Pi - heeft ook GPIO (general purpose in/out - pinnen die je makkelijk kan laten doen wat je wilt, meten of aansturen). Arduino is ouder en heeft meer knowledge base/kennis/topics. Raspberry Pi is sterk aan het opkomen en draait linux, kan via HDMI op een monitor , heeft ethernet en kan met een dongle van USD 8 (van DX.com) ook wifi out of the box. Voordeel van de RPi voor mij is dat ie dus draadloos te benaderen is (telnet of SSH, of VNC) en je niet steeds vastgeknoopt aan je project zit (bij de arduino standaard USB, voor te veel geld Ethernet en voor nog meer WIFI).
Wat alleen wel erg belangrijk is, is om te snappen welke logica de robotarm heeft, moet/kan je 'm commando's geven als in stel as S in op stap 34%, of stuur je direct de motoren aan. In het eerste geval moet je het protocol achterhalen. In het tweede zal je je moeten verdiepen in hoe je gaat meten waar dat ding is en hoe ie beweegt. En dat is dus voor alle oplossingen gelijk (arduino, RPi, PC) al kan je voor de PC wellicht nog een driver vinden (voor windows 95 oid - werkt prima zolang je het niet via ethernet/ip aan het internet hangt).

[Sissors]

Tbh imo is een RPB niet geschikt voor zulk soort dingen, vooral als je net wilt beginnen. Er is een reden dat microcontrollers standaard gebruikt worden voor zulk soort taken, ze zijn gewoon veel geschikter ervoor. Als je serieusere signaalverwerking wil doen dan is een RPB een optie, voor een robot armpje maak je het enkel jezelf onnodig moeilijk.

Wanneer je out of the box ethernet wilt hebben zou ik ook eerder dan bijvoorbeeld een mbed aanraden (moet je enkel nog een ethernet socket aankoppelen, de PHY zit er wel op), je kan leuke dingen met de RPB doen, maar alleen al direct een enkele motor aansturen en een potmeter gebruiken om de positie te achterhalen en als feedback te gebruiken zal een RPB nagenoeg niet trekken (En bij twee zal het hem gewoon niet lukken) zonder extra ICs, terwijl zelfs een arduino dat met 3 vingers in de neus doet, om het nog maar niet te hebben over een ARM uC.

[franssie]

@furby-killer daar heb je ongetwijfeld gelijk in (ik heb er allemaal weinig ervaring mee, stuurde vroeger wel dingen aan vanaf mijn ZX spectrum en later op de PC de printerpoort, en daar zat idd altijd wel een transistortje of meer tussen). En voor de arduino is ook gewoon veel meer code beschikbaar.
Voor mij is de RPi wel gebruiksvriendelijker.
Ik ben wel benieuwd naar de robot-arm.
@Darkvortex, heb je er wat gegevens van?

[kitao]

...heb je hier wat gegevens van ?

Ik krijg het idee dat darkvortex de discussie heeft geterminated middels zijn schrappost; wellicht omdat hij zich van kastje naar muur voelde gestuurd ?

[mawi]

Heb sinds deze week ook een Arduino kit en ben nu aan het proberen om een KlikAanKlikUit stopcontact te bedienen, wat nog niet wil lukken.

Ik heb een een 433Mhz zender aangesloten op een breadboard op de volgende manier:

PIN1 GND
PIN2 Digital In port 11
PIN3 5V

De volgende code heb ik ge-upload naar de Arduino:

[code=c]#include <RemoteTransmitter.h>

//Intantiate a new KaKuSwitch remote, use pin 11
KaKuTransmitter kaKuTransmitter(11);

int val;

void setup()
{
}

void loop()
{
if (Serial.available())
{ // if data is available to read,
val = Serial.read(); // read it and store it in val
}
if (val == 'H')
{
//Switch off KaKu-device 10 on address M
kaKuTransmitter.sendSignal('B',1,true);

//wait 2 seconds
delay(2000);
}
if (val == 'L')
{
//Switch on KaKu-device 2 of group 3 on address M (which is the same as device 10 on address M!)
kaKuTransmitter.sendSignal('B',1,false);

//wait 2 seconds
delay(2000);
}
}[/code=c]

Het KAKU stopcontact staat ingesteld op B1 (getest met losse afstandsbediening). De H en L die je in de code ziet staan wordt doorgegeven vanuit een PHP pagina op een webserver (ook dit werkt, getest met een simpele LED).

Het KAKU stopcontact doet helaas nog niets. Iemand een idee hoe dit aan te pakken, is er iets wat ik meten (heb niet zo heel veel electronica ervaring)?

[mcDavid]

gebruik even de [code=c]-tag om je code in te posten, dat maakt het wat overzichtelijker.

Zo te zien mis je de aanroep van de library (misschien niet meegekopieerd?) en ontbreekt de aanroep van Serial.begin() voor de seriele communicatie.

[mawi]

mcDavid schreef op donderdag 25 oktober 2012 @ 09:58:
gebruik even de [code=c]-tag om je code in te posten, dat maakt het wat overzichtelijker.

Zo te zien mis je de aanroep van de library (misschien niet meegekopieerd?) en ontbreekt de aanroep van Serial.begin() voor de seriele communicatie.

Library had ik inderdaad niet meegekopieerd in het voorbeeld, maar wordt wel aangeroepen (#include <RemoteTransmitter.h>)

Serial.begin() ben ik inderdaad vergeten op te nemen in de code (bedankt bij deze), dat verklaart wel het één en ander.

[ Voor 7% gewijzigd door mawi op 25-10-2012 10:53 ]

[Bloemstukje]

Hou je er rekening mee dat schakelaar 1 op je afstandbediening schakelaar 2 bij Arduino is ? Dus om schakelaar 1 te schakelen moet je in je Arduino schakelaar 0 schakelen.

[mawi]

SanderPS3 schreef op donderdag 25 oktober 2012 @ 11:02:
Hou je er rekening mee dat schakelaar 1 op je afstandbediening schakelaar 2 bij Arduino is ? Dus om schakelaar 1 te schakelen moet je in je Arduino schakelaar 0 schakelen.

Dat wist ik niet, ga ik rekening mee houden. Werkte gisteren ook al met een verouderde Library, waardoor het compileren niet wilde lukken. Dat is inmiddels opgelost.

Bedankt voor de tip!

[mcDavid]

als je nog een goeie RC-library zoekt kan ik je deze aanraden: http://code.google.com/p/rc-switch/

[Verwijderd]

Ik ben daar zelf een tijd geleden mee bezig geweest, maar had natuurlijk niet bedacht dat je beter de signalen rechtstreeks met de arduino kon zenden

Ik heb toen mooi een paar relaitjes gebruikt die ik nog had liggen om de knoppen van mijn KAKU afstandsbediening te bedienen.

Maar goed dat heb ik nu dus weer losgehaald en nu werkt het op 1 poort van mijn arduino

wel handig dat dat voorbij komt hier

[kitao]

zie kitao in "[Discussie] Arduino-topic"

Hallo,
ik ben bezig met hfdst.4 communicatie
http://arduino.cc/en/Tutorial/HomePage
met deze oefening:
http://arduino.cc/en/Tutorial/Graph
Ik krijg deze storing :

klik

code:

myPort = new Serial(this, Serial.list()[0], 9600);

Ik heb de 0 al veranderd in 5 (ik gebruik com5) maar dan krijg ik weer een storing.
Iemand enig idee, ik ben al een half uur ermee bezig maar loop vast.
Alvast bedankt.
Ps, de uno monitor geeft wel gewoon waardes door dus dat werkt prima.
Edit:
en ook dit voorbeeld gaat zonder problemen :
http://arduino.cc/en/Tutorial/PhysicalPixel
vreemd
edit2:
De vraag is eigenlijk of dat er nu een simpel schrijffoutje in het programmaatje zit of dat ik te maken heb met een Serial Issue :
http://wiki.processing.org/w/Serial_Issues
Is dat laatste het geval dan wordt het ingewikkeld en hoeft niemand voor mij te gaan zoeken, dan moet ik er alleen meer tijd aan besteden als het vaker optreedt.

[ Voor 34% gewijzigd door kitao op 25-10-2012 18:51 ]

[mcDavid]

heb gisteren de laatste hand gelegd aan het printplaatje voor mijn binaire klok:


RTC, temperatuursensor, en een drukknopje om te wisselen tussen weergaves: uren/minuten/secondes of maand/dag/temperatuur

[kitao]

Mooi gedaan McDavid, heb je al een display ?
En waarom staat die batterij zo vreemd hoog als een helikopterplatform, die had je toch gewoon op de andere helft van de gaatjesprint kunnen zetten ?
Velleman heeft daar overigens ook leuke kits van maar zelf bouwen is natuurlijk leuker

[mcDavid]

andere helft ga ik eraf knippen heb op de RTC-module een female-header gesoldeerd en op het printje een male-header zodat je 'm er op kunt prikken. Alleen ben ik bang dat ik 'm straks toch vast moet solderen omdat hij nu te hoog uitsteekt, maargoed dat is niet zo'n probleem.
Het "display" (praktisch een 6x3 LED matrix) ga ik volgende week in elkaar zetten, nadat ik de behuizing heb (laten) lasersnijden, dan kan ik die led's daar zo indrukken.

[kitao]

Of anders 2 bouten en moertjes erop zetten in de hoekgaten van de batterijprint, dan blijft het wel stevig ?

En mijn vorige post is opgelost trouwens, ik kwam dit tegen :
http://forum.processing.o...inside-serial-init-no-joy
Het valt me wel op dat ik steeds vaker de usb kabel uit mn lap moet trekken (resetten dus) vanwege port-issues.

Edit:
Zo vaak zelfs dat ik er geen moer meer van begrijp.
Even uitleggen : Ik heb 4 usb-aansluitingen op de lap, zeg maar A-linksboven, B-linksonder, C-rechtsonder en D-rechtsboven.
Meestal gebruik ik C voor de uno, die staat ingesteld op Com5, maar vandaag nu al paar keer gehad dat ik D moest pakken en zelfs B voordat het zooitje de poort zag.
Toen ik processing erbij ging koppelen heb ik wel 6 keer moeten switchen tussen B,C,D voordat ze (uno en processing) allebei eindelijk tegelijk contact hadden.

Hoe is dit mogelijk ?!!!
Heb ik soms een zwevende com-poort aan de fiets hangen of hoe zit dat eigenlijk ?
Met dit programma kreeg ik opnieuw de problemen trouwens :
http://arduino.cc/en/Tutorial/VirtualColorMixer
Uiteindelijk werkte het wel, maar het is me een raadsel waar het aan ligt.

[ Voor 56% gewijzigd door kitao op 25-10-2012 19:03 . Reden: Toch niet opgelost ]

[mcDavid]

je kunt toch gewoon bij extra->seriele poort de juiste selecteren
(moet zeggen dat ik het nog nooit met windows geprobeerd heb)

[kitao]

Ja, dat zou je denken.
Nog iets waar ik geen bal van begrijp :

En datzelfde gebeurt ook met processing, met dezelfde foutmelding en ook met een seriele poort in extra waarvan het veldje niet eens is aan te klikken.

[kitao]

Mogge,
Ik las ergens dat bij poort-problemen het programma verwijderd moet worden en opnieuw geinstalleerd maar dan met de usb en het apparaat aangesloten op de poort. Ik heb dat nog niet gedaan maar viel me wel op dat ik vanmorgen nergens last van had toen ik eerst de uno aansloot en pas daarna de programma's arduino en processing opstartte. Probleem is enkel dat iedere keer als je een andere opstelling wil opbouwen dat dan de stroom eraf moet en dus ook de usb-kabel weer verwijderd moet worden want de uno heeft geen aan/uit knop. Helaas.
Ik vraag me trouwens af wie hier nog meer last van heeft (gehad).

Even wat anders, mijn bestelling is binnen :


Nu begrijp ik ook waarom die parallax-lcd (groen) een stuk duurder is, niet alleen omdat die serieel is en de rode sparkfun parallel maar ook omdat er nog een heel extra blokje electronica achter hangt.
Dat verklaart veel.

@MacDavid,
Jij heb zeker een MacIntosh dan ?

[Mr_gadget]

Die parallax is ook parallel alleen dat blokje elektronica maakt er serieel van, past waarschijnlijk ook op de sparkfun lcd. Sparkfun heeft ook zo'n backpack. Heb er zelf een gemaakt met i2c.

[kitao]

Ok, tnx.
Ik had al geprobeerd dat blokje eraf te halen maar zit vastgesoldeerd.

[mcDavid]

kitao schreef op vrijdag 26 oktober 2012 @ 10:29:
Mogge,
Probleem is enkel dat iedere keer als je een andere opstelling wil opbouwen dat dan de stroom eraf moet en dus ook de usb-kabel weer verwijderd moet worden want de uno heeft geen aan/uit knop. Helaas.
Ik vraag me trouwens af wie hier nog meer last van heeft (gehad).

@MacDavid,
Jij heb zeker een MacIntosh dan ?

Als je een prototyping-shield hebt, kun je gewoon dat shield eraf trekken En nee mijn systemen draaien allebei Ubuntu.

[kitao]

mcDavid schreef op vrijdag 26 oktober 2012 @ 13:01:
[...]
Als je een prototyping-shield hebt, kun je gewoon dat shield eraf trekken

Huh, waar heb jij het nou weer over ? Over die lcd of over dat com-poorten gedoe ?
Zo ja, die eerste zit vastgesoldeerd.

En nee mijn systemen draaien allebei Ubuntu.

Van gehoord maar die ken ik niet. Ik 'ken' enkel windows, gewoon meelopen met de meute
Ik ben nu trouwens de rgb ck aan het opbouwen, ik was van plan eerst (zie tekening) de r g en b via 220Ohm apart op een 5V adapter te zetten met de ck op gnd en kijken wat er gebeurt. Is namelijk mijn eerste 4-potige led van mn leven

Je had trouwens gelijk, het stond zelfs in het programma hoewel ik die nog moet gaan proberen als deze testopstelling is gelukt.

// constrain the values to 0 - 255 and invert
// if you're using a common-cathode LED, just use "constrain(color, 0, 255);"

http://arduino.cc/en/Tutorial/ReadASCIIString
Je hoort het nog wel van me.

[kitao]

Geen succes helaas

Ik heb dit opgebouwd volgens http://arduino.cc/en/Tutorial/ReadASCIIString
Maar omdat ik een common cathode heb moest ik wat veranderen tot dit :

Deze code staat in de uno :

code:

// pins for the LEDs:
const int redPin = 3;
const int greenPin = 5;
const int bluePin = 6;

void setup() {
  // initialize serial:
  Serial.begin(9600);
  // make the pins outputs:
  pinMode(redPin, OUTPUT); 
  pinMode(greenPin, OUTPUT); 
  pinMode(bluePin, OUTPUT); 

}

void loop() {
  // if there's any serial available, read it:
  while (Serial.available() > 0) {

    // look for the next valid integer in the incoming serial stream:
    int red = Serial.parseInt(); 
    // do it again:
    int green = Serial.parseInt(); 
    // do it again:
    int blue = Serial.parseInt(); 

    // look for the newline. That's the end of your
    // sentence:
    if (Serial.read() == '\n') {
      // constrain the values to 0 - 255 and invert
      // if you're using a common-cathode LED, just use "constrain(color, 0, 255);"
      red = constrain(red, 0, 255);
      green = constrain(green, 0, 255);
      blue = constrain(blue, 0, 255);

      // fade the red, green, and blue legs of the LED: 
      analogWrite(redPin, red);
      analogWrite(greenPin, green);
      analogWrite(bluePin, blue);

      // print the three numbers in one string as hexadecimal:
      Serial.print(red, HEX);
      Serial.print(green, HEX);
      Serial.println(blue, HEX);
    }
  }
}

Zoals ik de tekst begreep moet je bovenin de monitor 3 waarden invullen en op verzenden sturen :
Bijvoorbeeld : 5,220,70 + verzend.

You'll use the serial monitor to send strings like "5,220,70" to the Arduino to change the lights.

Maar er gebeurt niks en ik ben er al meer dan anderhalf uur mee bezig.
Ik heb dit programma geprobeerd en opgebouwd en dat werkte meteen dus aan de led ligt het niet.
http://www.instructables....-Randomly-Flash/?ALLSTEPS
Iemand een tip ?

[Mattie112]

Wat als je gewoon (in je setup() bijv) dit doet:

code:

analogWrite(redPin, 100);
analogWrite(greenPin, 100);
analogWrite(bluePin, 100);

Werkt je led dan wel?

[kitao]

code:

// pins for the LEDs:
const int redPin = 3;
const int greenPin = 5;
const int bluePin = 6;

void setup() {
  // initialize serial:
  Serial.begin(9600);
  // make the pins outputs:
  pinMode(redPin, OUTPUT); 
  pinMode(greenPin, OUTPUT); 
  pinMode(bluePin, OUTPUT); 
  analogWrite(redPin, 100);
analogWrite(greenPin, 100);
analogWrite(bluePin, 100);

}

void loop() {
  // if there's any serial available, read it:
  while (Serial.available() > 0) {

    // look for the next valid integer in the incoming serial stream:
    int red = Serial.parseInt(); 
    // do it again:
    int green = Serial.parseInt(); 
    // do it again:
    int blue = Serial.parseInt(); 

    // look for the newline. That's the end of your
    // sentence:
    if (Serial.read() == '\n') {
      // constrain the values to 0 - 255 and invert
      // if you're using a common-cathode LED, just use "constrain(color, 0, 255);"
      red = constrain(red, 0, 255);
      green = constrain(green, 0, 255);
      blue = constrain(blue, 0, 255);

      // fade the red, green, and blue legs of the LED: 
      analogWrite(redPin, red);
      analogWrite(greenPin, green);
      analogWrite(bluePin, blue);

      // print the three numbers in one string as hexadecimal:
      Serial.print(red, HEX);
      Serial.print(green, HEX);
      Serial.println(blue, HEX);
    }
  }
}

Nu brandt de led wel.
Maar ik kan nog steeds geen kleur invoeren ?
Zit hier het probleem soms dat dat ding maar blijft wachten en geen serials krijgt ?

code:

void loop() {
  // if there's any serial available, read it:
  while (Serial.available() > 0) {

[ Voor 6% gewijzigd door kitao op 26-10-2012 16:46 ]

[Mattie112]

Nu weet je in elk geval dat je LED's en je analogwrite werken

uhm probeer anders is dit te doen:

if (Serial.read() == '#') {
// constrain the values to 0 - 255 and invert
// if you're using a common-cathode LED, just

Ik heb de "\n" veranderd in een "#". Als je vervolgens "1,12,123#" stuurt zou het moeten werken. Miss heeft ie wat problemen met newline.....

[kitao]

Bedoel je dat ik volgens dat programma 5,220,70/n had moeten intoetsen in de editbox + verzend ?!!

Het werkt nu, ik heb 1,12,123# verzonden en kreeg hex 1C7B terug en de led is blauw.
Goed gedaan Matti !

Sorry dat ik jullie opzadel met dit soort dingen maar die voorbeelden zijn echt niet duidelijk omschreven hoor.
Ik bedoel, is niet helemaal mijn schuld volgens mij.

[ Voor 57% gewijzigd door kitao op 26-10-2012 17:03 ]

[Mattie112]

Naja "\n" is eigenlijk newline maw een "enter". Maarja als dat dus niet (goed) werkt zou ik het gewoon eerst met een "#" of van mij part de letter Z proberen als het dan wel weer weet je dat het daar aan ligt

[kitao]

Ik heb nu 5,220,70n gestuurd, werkt ook prima.
/n is namelijk om te inverteren wat die bij een ck.rgb.led juist niet moet doen.

Ik begrijp echt niet dat ze dit dan niet wat beter vermelden in het voorbeeld, zo schrijf je toch geen programma dat een gebruiker ergens maar wat op een leeg veldje moet gaan intoetsen ?

Bedankt voor je hulp, ik ben bezig C wat beter door te nemen want dit werkt zo niet.

ps, en waarom doet die /n het dan niet ?

[ Voor 5% gewijzigd door kitao op 26-10-2012 17:18 . Reden: edit scratch ]

[mcDavid]

"/n" is sowieso niets, "\n" is een newline karakter. Windows voegt voor een enter "\r\n" in, \r is een carriage-return. Linux voegt alleen \n in. Dik kans dus dat dit sample op een linux-systeem wel werkt.

[kitao]

mcDavid schreef op vrijdag 26 oktober 2012 @ 17:34:
"/n" is sowieso niets, "\n" is een newline karakter.

daar ben ik net ook achter gekomen

Windows voegt voor een enter "\r\n" in, \r is een carriage-return. Linux voegt alleen \n in. Dik kans dus dat dit sample op een linux-systeem wel werkt.

\r\n werkt ook niet.
Maar goed, ik stop hiermee vandaag met dat kerstlampje.
Nu begrijpen jullie misschien wel waarom ik aan programmeren eigenlijk een broertje dood aan heb.
Maar het is wel fijn om support te krijgen en dat het uiteindelijk toch doet wat het moest doen, ook al kost het dan drie uur.

[Sissors]

Het hangt ook van instellingen van terminal programma af, de meeste kunnen beide aan, je zou verwachten dat ze dat gelijk hebben getrokken voor de Arduino terminal.

Voor de duidelijkheid, je moet NIET zelf \n of \r\n tikken, je moet gewoon enter drukken (als het goed werkt), dan voegt hij zelf die \n (of \r\n) toe.

[kitao]

Ik heb alle knopjes geprobeerd die je maar kan bedenken furby.
x,x,x + enter - y,y,y + \n - a,a,a + verzend - g,g,g + \r\n en ga zo maar door.
Er is gewoon iets mis met dat (originele) programma en het is dat Matti het zag anders was ik nu nog knopjes aan het drukken.

Nou ja, genoeg gescholden, zo'n rgb-ledje is idd een mooi gezicht, ik begrijp nu wel waarom leds zo'n hot-topic zijn hier.

[ Voor 42% gewijzigd door kitao op 26-10-2012 18:14 ]

[kitao]

Onderstaande vraag onder de streeplijn kan vervallen : is zo simpel opgelost dat ik het gewoon over het hoofd zag terwijl ik er toch lang mee bezig was.
Dit wordt de decimale code voor een smiley :

code:

byte smiley[8] = {
0,17,0,0,17,14,0,
};

Sorry maar wellicht heeft iemand er wat aan die ook zelfgemaakte karakters wil gebruiken dus vandaar dat ik de post niet verwijder.
Bovendien blijft nog het vraagje openstaan waarom lcd.write(0) niet werkt

============================
Mogge
Ik heb een vraag : werkt createChar() alleen met binaire getallen ??
Ik hou het kort met links :
http://arduino.cc/en/Reference/LiquidCrystalCreateChar
Gegeven voorbeeld werkt overigens niet, dan krijg je de melding : call of overloaded 'write(int)' is ambiguous.
Ik heb dit opgelost door de beiden 0 in 1 te veranderen in onderstaande code :

code:

void setup() {
  lcd.createChar(0, smiley);
  lcd.begin(16, 2);  
  lcd.write(0);

Waar dit aan ligt is me onduidelijk, maar goed dat is eigenlijk een 2e vraag.
Ik heb dit voorbeeld gedraaid en werkt goed (na bovenstaande aanpassing):

code:

#include <LiquidCrystal.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);

byte smiley[8] = {
  B00000,
  B10001,
  B00000,
  B00000,
  B10001,
  B01110,
  B00000,
};

void setup() {
  lcd.createChar(1, smiley);
  lcd.begin(16, 2);  
  lcd.write(1);
}

void loop() {}

Mijn LCD-pixels is 5x8 dus ik zou er nog een lijn aan toe kunnen voegen wat ook zonder problemen ging.
Nu had ik graag die binaire nummers willen vervangen door decimalen dus bijvoorbeeld B10100 door DEC 20 ivm minder typen.
Dit lukt echter niet !
Is dit een beperkende factor op de arduino dat jullie weten of maak ik een syntax-fout ?
Alvast bedankt en hier nog een link naar speciale karakters :
http://www.quinapalus.com/hd44780udg.html

Het bijbehorende schema van de schakeling is hier te vinden.

[ Voor 30% gewijzigd door kitao op 29-10-2012 05:34 . Reden: vraag zelf beantwoord ]

[Mattie112]

haha precies het probleem waar ik ook tegenaanliep

lcd.write(0); werkt niet
maar:
lcd.write(0x0); werkt wel

(en dus ook 0x1, 0x2 enz)

edit: ik zie dat het bij jou ook gewoon werkt met "write(1)"

en hier nog een linkje voor je:

http://mikeyancey.com/hamcalc/lcd_characters.php

[ Voor 34% gewijzigd door Mattie112 op 29-10-2012 09:46 ]

[kitao]

Logish dat we tegen hetzelfde write-probleem aanliepen, zo staat het in het voorbeeld
Maar ik weet nu genoeg van de lcd, ik stap over naar de seriele parallax voordat ik heel pbasic weer vergeten ben. Er zit een begeleidend tekstboek bij van 328 pagina's dus ik ben even weg.
http://www.parallax.com/S...d=ProductName,ProductName
Ps, gelukkig gaat dat boek niet enkel over lcd's en hoef ik dan ook niet alles door te nemen want die andere sensors heb ik toch nog niet.

[Mattie112]

Ik ben nu aan het kloten met mijn i2c convertor chip. Hij doet geen donder helaas
Althans de backlight is aan maar ik zie niks. Er zit ook een potmeter op voor het contrast maar deze ik zolang doordraaien als ik wil, lijkt me niet kloppen? Maar is een mail sturen naar de ebay verkoper.

[kitao]

linkje naar die i2c converter ?

[Mattie112]

http://cgi.ebay.com/ws/eB...eName=ADME:X:eRTM:US:1123

[kitao]

Ok, dus de bedoeling van die i2c is om van een paralelle lcd een seriele te maken ?
Madmax heeft er nog een paar liggen als die van jou niet werkt.
mad_max234 in "De EL-kroeg - Deel 3"
zie edit2

[ Voor 20% gewijzigd door kitao op 29-10-2012 14:47 ]

[Mattie112]

Hm dat is weer een andere oplossing geloof ik

Die i2c zit op de analog pin 5 en 4 van de arduino en dat ding van madmax gebruikt een shiftregister en zit dus (denk) op de digital pins.

Ik ga nog ff verder kloten kijken of het echt niet aan mn code ligt en dan even kijken wat handig is om te doen.

[kitao]

Deze oplossing bevalt me het beste eigenlijk, gewoon kant en klaar maar kost een paar dollars ($28) :

_klik
zie dat groene lcd'tje.
Gisteren wat zitten exp. met die rooie, blijkt er na lang tobben geen overflow op te zitten :

This probably should have been done differently but hey that's what we have to live with.
Hopefully we'll have a future LCD library that is very smart and wraps lines but for now we are stuck.
So when writing long lines to the LCD count your characters and make sure that you dont accidentally overrun the lines!

http://learn.adafruit.com...cds/using-a-character-lcd
En dan ook steeds weer van die idiote irritante fouten in de voorbeelden maakt het er niet plezieriger op.
Vergelijk de parallax met een uitleg van 350 pagina's :

The LCD displays provide basic text wrapping so that your text looks correct on the display.

http://www.parallax.com/P...arallaxSerialLCD-v3.0.pdf

Ok is allemaal iets duurder maar wellicht beter als die china-crap.

[Mattie112]

Mja bij jou is het 2-in-1 en bij mij is het een losse convertor die ik er op prik En ach het is voor school en we moeten alles uit eigen zak betalen dus ik ga echt geen 20 euro betalen voor een LCD scherm wat er alleen voor de "lol" opzit

[kitao]

Gelijk heb je, nu zit je met een i2c converter van 4 dollar die je kan klikoën.

[Mattie112]

Haha dat is het risico, hoewel ze bij ebay vaak wel een nieuwe opsturen als het stuk blijkt te zijn.

Maar ach als ik alle prima werkende ebay producten zou "omrekenen" naar originele dingen dan stelt die 4 dollar niks voor