Jasper’s blog is verplaatst

Hallo allemaal, Voor iedereen die op zoek is naar het blog over mijn zoon Jasper - die is verplaatst naar de website van mijn vrouw (http://www.mar...

Arduino Uno

I2C LCD scherm 2×16 karakters ...

Eerder schreef ik al dat het I2C LCD schermpje werkte met een Arduino Uno. Op dat moment had ik 'm nog niet werkend met een Arduino Mega 2560. Dat is ...

Arduino Uno

Knop met led ring

De knop met de lichtgevende LED-ring bestaat in principe uit twee aparte delen. Het eerste deel is de knop (pushbutton, momentary switch) en het tweed...

Arduino Uno

Softpot potentiometer (ribbon contr...

Het is een fragiel uitziende sensor moet ik zeggen, die softpot potentiometer. Het lijkt voor tachtig procent zelfklevend materiaal. Hij is buigzaam e...

Jasper’s blog is verplaatst

Hallo allemaal,

Voor iedereen die op zoek is naar het blog over mijn zoon Jasper – die is verplaatst naar de website van mijn vrouw (http://www.maritslinger.nl). Onder “Persoonlijk” kun je daar op één pagina het hele verhaal teruglezen.

I2C LCD scherm 2×16 karakters met Arduino Mega

Eerder schreef ik al dat het I2C LCD schermpje werkte met een Arduino Uno. Op dat moment had ik ‘m nog niet werkend met een Arduino Mega 2560. Dat is me nu wel gelukt.

Ik weet niet precies waarom hij de vorige keer raar deed, maar dezelfde sketch werkte nu op het moment dat ik 5v en GND had aangesloten, en pin 20 en 21 (SDA en SCL respectievelijk) van de Mega. Het enige probleem was dat er regelmatig rare tekens op het scherm verschenen die ik niet zag op de Uno. Ik dacht eerst misschien dat er een clock probleem was (verkeerde baud-rates geven ook rare tekens op je serial output), maar toen ik een andere sketch uitprobeerde werkte deze wel zoals het hoort (zie sketch hieronder).

Uno en Mega 2560: een verschil in troep
Ik dacht dat er bij het plaatsen van mijn eerste sketch (die van de Uno) op mijn blog iets verkeerd was gegaan met de opmaak en dat dat de reden was dat de Mega troep weergaf – maar toen ik onderstaande Mega sketch zojuist op mijn Uno uitprobeerde, toen gaf deze juist de troep. Kortom – de Uno sketch werkt goed op de Uno maar geeft troep op de Mega – terwijl onderstaande Mega sketch goed werkt op de Mega 2560 maar troep weergeeft op de Uno. Ik heb nog geen tijd gehad om uit te zoeken waarom precies, maar ik vind het erg frappant.

De code een aangepaste versie van deze sketch omdat de pinnen niet overeen kwamen:


/* YourDuino.com Example Software Sketch
terry@yourduino.com */
/*-----( Import needed libraries )-----*/
#include
#include
#include // F Malpartida's NewLiquidCrystal library

/*-----( Declare Constants )-----*/
#define I2C_ADDR 0x20 // Define I2C Address for the PCF8574A

#define BACKLIGHT_PIN 3
#define En_pin 2
#define Rw_pin 1
#define Rs_pin 0
#define D4_pin 4
#define D5_pin 5
#define D6_pin 6
#define D7_pin 7

#define LED_OFF 0
#define LED_ON 1

/*-----( Declare objects )-----*/
LiquidCrystal_I2C lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);

void setup() /*----( SETUP: RUNS ONCE )----*/
{
lcd.begin (16,2);

// Switch on the backlight
lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
lcd.setBacklight(HIGH);
lcd.home (); // go home

lcd.setCursor ( 0, 0 ); // go to the 1st line
lcd.print("Momentje... ");
lcd.setCursor ( 0, 1 ); // go to the 2nd line
lcd.print("Initialiseren... ");

}

void loop() /*----( LOOP: RUNS OVER AND OVER AGAIN )----*/
{

// Reset the display
lcd.clear();
delay(1000);
lcd.home();

// Print our characters on the LCD
lcd.backlight(); //Backlight ON if under program control
lcd.setCursor(0,0); //Start at character 0 on line 0
lcd.print("Hello, world!");
delay(1000);
lcd.setCursor(0,1); //Start at character 0 on line 1
lcd.print("16 by 2 Display");
delay(8000);
} // END Loop

Knop met led ring

De knop met de lichtgevende LED-ring bestaat in principe uit twee aparte delen. Het eerste deel is de knop (pushbutton, momentary switch) en het tweede deel is een simpel LED lampje.

Op de achterkant van de knop vind je vijf pootjes. In het midden zitten er drie op een rij, en aan de beide buitenkanten een pootje dat iets lager geplaatst is. Bij het ene pootje staat een + en bij het andere pootje een -.
Deze twee pootjes gebruik je om de LED-ring te laten oplichten. Het pootje bij de plus is het het ‘lange’ pootje van een LED-lampje en het pootje bij de min het korte pootje. Dat is handig om te weten als je zo naar het filmpje kijkt onder het kopje “De basis”. Sluit je ‘m verkeerd om aan, dan gebeurt er niks.

De andere drie pootjes zijn dus voor de knop – maar je hebt er maar twee nodig. Voor de sketch die ik gebruikt heb in mijn filmpje hoef je het middelste pootje niet aan te sluiten.

De basis
Hier wordt precies beschreven hoe je de knop kan aansluiten. Je moet alleen het ledje vervangen door de LED ring (buitenste twee pootjes) en het knopje door de pootjes in het midden (minus degene precies in het midden).
https://www.youtube.com/watch?v=XUuXq4J4u14

Filmpje

Hier kun je ‘m kopen:
http://floris.cc/shop/en/knobs-buttons-joysticks/861-metal-pushbutton-latching-16mm-red.html

Softpot potentiometer (ribbon controller / slider)

Het is een fragiel uitziende sensor moet ik zeggen, die softpot potentiometer. Het lijkt voor tachtig procent zelfklevend materiaal. Hij is buigzaam en de standaard prototype pinnetjes blijven er niet lekker aanzitten. Maar eenmaal aangesloten werkt ‘ie meteen, en je hebt maar drie pinnetjes nodig.

Bij het bovenste pinnetje (of links, ligt eraan hoe je ‘m hebt liggen) staat een driehoekje. Sluit dat pinnetje aan op ground (GND) van je Arduino. De middelste pin is je analoge data pin – sluit die dus aan op een analoge ingang op je Arduino (de pinnen die A0, A1, A2, etc gelabeled zijn). De sketch die hieronder staat maakt gebruik van pin A0.

Filmpje

Sketch
Gebaseerd op deze sketch.

int softpotPin = A0; //analog pin 0
int lastValue = 0;

void setup(){
digitalWrite(softpotPin, HIGH); //enable pullup resistor
Serial.begin(9600);
}

void loop(){
int softpotReading = analogRead(softpotPin);
if (softpotReading < 1001) { lastValue = softpotReading; } Serial.println(lastValue); delay(100); }

De softpot potentiometer heb ik gekocht bij iPrototype.

IR Afstand sensor 30cm

Na een middag van uitzoeken is het ook wel eens lekker als er iets in één keer werkt. Met de IR afstand sensor 30 cm (https://www.iprototype.nl/products/components/sensors/ir-sensor-4-30) werkte alles vrijwel meteen. Dat kan ook bijna niet anders – er zitten maar drie pinnen op – 5v, ground en een data pin. Ik ga dan ook niet laten zien hoe je ‘m moet aansluiten, dat is een eitje. Het enige dat van belang is, is dat je de pin aansluit op een analoge ingang, niet een digitale. In het geval van deze sketch, op A3.

In deze sketch heb ik een drempelwaarde ingevoerd van 40. Bij mij fluctueerde de waarde nogal daaronder, dus die gooi ik gewoon weg (de waarde is nul voor alles lager dan 40). Alles erboven wordt gewoon doorgegeven.


int analogPin = 3; // Infrared Sensor (Right lead) connected to analog pin 3
// outside leads to ground and +5V
int val = 0; // variable to store the value read

void setup()
{
Serial.begin(9600); // setup serial
}

void loop()
{
val = analogRead(analogPin); // read the input pin
if (val < 40) { Serial.println(0); // debug value } else { Serial.println(val); // debug value } delay(80); }

5-way selector switch

De vijf-positie schakelaar (“5-position switch”) is voor mij één van de moeilijkst aan te sluiten objecten gebleken. Tenminste, het aansluiten is niet zo moeilijk, maar de informatie die ik nodig had om uit te zoeken hoe ik met drie draadjes vijf standen op de Arduino moest aansluiten, bleek voor mij moeilijk te vinden. Een typisch geval dus van een post die andere mensen hopelijk een hoop tijd kan besparen!

Ik snap nog steeds niet honderd procent hoe het werkt maar je vindt hier in ieder geval de informatie om deze switch werkend aan te sluiten op een Arduino, inclusief een sketch die via de serial output laat zien welke stand je geselecteerd hebt. Het heeft me een complete middag gekost. Het antwoord vond ik uiteindelijk op het SparkFun forum, hoewel ik een melding kreeg dat deze site niet per definitie als veilig te beschouwen is, dus ik heb de informatie hierheen gekopiëerd – met bronvermelding.

Het principe van de vijf-positie schakelaar is dat je maar drie data-pinnen nodig hebt om vijf standen uit te lezen. Dat heeft er mee te maken dat er eigenlijk maar drie contact-punten zijn, maar dat deze ook per paar actief kunnen zijn. Je hebt dus als het ware stand 1, stand tussen 1 en 2 in, stand 2, et cetera.

Er zitten acht pootjes op de schakelaar (ik heb zelf deze versie), waarvan je alleen de linker vier gebruikt. Op de vierde van links (degene het meest bij de rand vandaan) sluit je de 5v output van je Arduino aan.

Voor de andere contacten doe je drie keer hetzelfde.

Dit is je breadboard:


3 6 9
2 5 8
1 4 7

Verticaal maken de cijfers contact (1, 2, 3).

Punt 1 sluit je met een 10K weerstandje aan op Ground
Punt 2 sluit je aan op het meest linker contact punt van je vijf-positie schakelaar
Punt 3 sluit je aan op Digital Pin 4 van je Arduino.

Punt 4 sluit je met een 10K weerstandje aan op Ground
Punt 5 sluit je aan op het op een na meest linker contact punt van je vijf-positie schakelaar
Punt 6 sluit je aan op Digital Pin 3 van je Arduino.

Punt 7 sluit je met een 10K weerstandje aan op Ground
Punt 8 sluit je aan op het op twee na meest linker contact punt van je vijf-positie schakelaar
Punt 9 sluit je aan op Digital Pin 2 van je Arduino.

Ik heb geprobeerd (zoals je zal zien in de sketch) om de interne pull-up op de Arduino zelf te gebruiken, maar bij mij ontstond er toen een lek waardoor de Arduino uitschakelde, dus ik heb uiteindelijk gewoon drie aparte weerstandjes gebruikt.

Hier leg ik alles nogmaals uit in een filmpje.

Hieronder de originele forum-post inclusief verhelderend plaatje.

Post op een forum die alles duidelijk beschrijft:
There are 2 separate switches in this one switch. Let me call them L and R for left and right. Looking at the picture the pin names would be (going from left to right in the pic) L1, L2, L3, LCom, RCom, R3, R2 and lastly R1. The L and R #1 pins are the outermost and have a dot above them. The L and R common pins are the innermost. The white lines show which pins are connected to which for each lever position.

I think the sketch only used one side, L or R (you pick) of the switch and has that side wired with Com connected to the Arduino 5V and each of the switch pins 1, 2 and 3 to a 10K pulldown resistor connected to Arduino ground. Pins 1, 2 and 3 of the switch are then also connected to the Arduino digital inputs pins 4, 3 and 2 respectively.

I’ve not looked too much at the sketch (included below) so I can’t comment on it but you should be able to figure it out from the pic below and the wiring above. See if it makes sense to you now.
EDIT : Looking at the code below I believe they used the left side pins so:
pinState1 = L3
pinState2 = L2
pinState3 = L1

5way_labeled

Sketch:
(bron: https://ec2-67-202-61-130.compute-1.amazonaws.com/viewtopic.php?f=14&t=31542)


//First we declare our pins
#define pin1 2
#define pin2 3
#define pin3 4

//These variables will hold our digital read values
int pinState1 = 0;
int pinState2 = 0;
int pinState3 = 0;

//This will keep the last number sent to the terminal
//in this way we'll keep from cramming the terminal
//with a continuous stream of numbers.
int lastvalue = 0;

//And finally, this variable will hold the current switch position
int switchpos = 0;

void setup() {
// And... Serial
Serial.begin(9600);
// Now we set up our pinModes

// Set input pins
pinMode(pin1, INPUT);
pinMode(pin2, INPUT);
pinMode(pin3, INPUT);
// Set internal pull-ups (20K)
digitalWrite(pin1, HIGH);
digitalWrite(pin2, HIGH);
digitalWrite(pin3, HIGH);

}

void loop() {
//First we read the pins:
pinState1 = digitalRead(pin1);
pinState2 = digitalRead(pin2);
pinState3 = digitalRead(pin3);

// Now we'll use a list of if then conditions to determine the switch position
// because that's a nice transparent way of doing it. You could also
// use switch case or other methods. Basically, with each sweep we check to
// see if each pin is high, if a pin is high, we check the surrounding pins.
// with a little logic, we can deduce from that information which position the
// switch is in.

if(pinState1 == HIGH){
if(pinState2 == HIGH){switchpos = 2;}
else {switchpos = 1;}}
else if(pinState2 == HIGH){
if(pinState1 == HIGH){switchpos = 2;}
else if(pinState3 == HIGH){switchpos = 4;}
else {switchpos = 3;}}
else if(pinState3 ==HIGH){
if(pinState2 == HIGH){switchpos = 4;}
else {switchpos = 5;}}

//Now that we know which position our switch is in, let's print it to the terminal.
//But first, we'll make sure the switch has moved

if(switchpos != lastvalue){
Serial.print("Switch Position:");
Serial.println(switchpos);
Serial.println(""); //make some room
}

//Now remember that for the next sweep.
lastvalue = switchpos;

}

7-segment led bar

Een tijdje geleden was er op mijn werk een ‘mafia-of-drooglegging-themed’ kerstfeest en er werd van je verwacht dat je in kostuum zou komen. Mijn idee was om als een ‘klassieke’ huurmoordenaar te komen, met een vioolkist met daarin allemaal kleine flesjes whiskey en een aflopende led-timer (via Arduino), alsof er drank en wapens in de kist verstopt zaten.

Ik was al zover dat ik hoed, pak, vioolkist, whiskeyflesjes en de 7-segment led bar al had, maar mijn vrouw was net bevallen na eerst langere tijd in het ziekenhuis te hebben gelegen, dus ik heb het nooit in de praktijk kunnen brengen.

Echter, ik had toen dus wel al de aftellende led-bar al aan de praat. En omdat ik zeker weet dat ik dat ding nog wel weer een keer ga gebruiken, zou het zonde zijn als ik de sketch kwijt raak. Mocht je deze sketch zelf willen gebruiken, realiseer je dan wel dat de timer niet nauwkeurig is en dus niet overeenkomt met daadwerkelijke seconden. Dit was voor mij geen enkel issue, maar dat kan het voor jou natuurlijk wel zijn.

Ik weet niet zeker meer waar ik de 7-segment bar gekocht heb*, maar het was ergens in het buitenland. Ik weet dat nog, omdat de post erg lang op zich liet wachten en ik me afvroeg of het verstandig was geweest om een eng uitziend elektronisch apparaat (een of andere shield) tegelijk te kopen met die zeven segment led bars die er toch uitzien als de klassieke film-aflopende-timer. Ik zal dus wel ergens op een lijst staan nu ergens – maar NSA, het was allemaal voor het kerstfeest!

*Het was bij DFRobot: http://www.dfrobot.com/index.php?route=product/product&path=53_133&product_id=374#.UpsYzeInKSp

Aangesloten via Interface shield:

Aangesloten zonder Interface shield:

In dit filmpje sluit ik per ongeluk de 5v pin aan op Vin. Dat kun je beter niet doen! Als je een te hoog voltage aansluit op de Arduino, reguleert deze het zelf naar 5v of 3.3v – maar de pin Vin is gelijk aan dit ongereguleerde voltage! In dit geval maakte het niet uit omdat ik de stroom via USB binnenkreeg (USB levert in principe ongeveer 5 volt stroom), maar als je je Arduino op batterijen of een accu aansluit, kun je je led bar slopen.

Hier de wiki-pagina met het aansluit diagram waarnaar verwezen wordt in het tweede filmpje:
http://www.dfrobot.com/wiki/index.php?title=SPI_LED_Module_%28SKU:DFR0090%29

Sketch:


//Pin connected to latch pin (ST_CP) of 74HC595
const int latchPin = 8;
//Pin connected to clock pin (SH_CP) of 74HC595
const int clockPin = 3;
////Pin connected to Data in (DS) of 74HC595
const int dataPin = 9;
int firstdigit = 9;
int seconddigit = 9;
int thirddigit = 9;
int fourthdigit = 5;
int fifthdigit = 9;
int sixthdigit = 5;

byte Tab[]={0xc0,0xf9,0xa4,0xb0,0×99,0×92,0×82,0xf8,0×80,0×90,0xff};
byte Tap[]={0xff,0x7f}; //”space”,”.”
void setup() {

//set pins to output because they are addressed in the main loop
pinMode(latchPin, OUTPUT);
pinMode(dataPin, OUTPUT);
pinMode(clockPin, OUTPUT);
Serial.begin(9600);
Serial.println(“reset”);
}

void loop() {
int bitToSet = 9;
// write to the shift register with the correct bit set high:
digitalWrite(latchPin, LOW);
// shift the bits out:
shiftOut(dataPin, clockPin, MSBFIRST, Tab[firstdigit]);
shiftOut(dataPin, clockPin, MSBFIRST, Tab[seconddigit]);
shiftOut(dataPin, clockPin, MSBFIRST, Tab[thirddigit]);
shiftOut(dataPin, clockPin, MSBFIRST, Tab[fourthdigit]);
shiftOut(dataPin, clockPin, MSBFIRST, Tab[fifthdigit]);
shiftOut(dataPin, clockPin, MSBFIRST, Tab[sixthdigit]);
shiftOut(dataPin, clockPin, MSBFIRST, Tap[0]);
shiftOut(dataPin, clockPin, MSBFIRST, Tap[0]);
// turn on the output so the LEDs can light up:
digitalWrite(latchPin, HIGH);
delay(10);
firstdigit = firstdigit – 1;
if (firstdigit < 0){
firstdigit=9;
seconddigit = seconddigit – 1;
}
if (seconddigit < 0){
seconddigit=9;
thirddigit = thirddigit – 1;
}

if (thirddigit < 0){ thirddigit=9; fourthdigit = fourthdigit – 1; } if (fourthdigit > 5){
fourthdigit=5;
}

if (fourthdigit < 0){
fourthdigit=5;
fifthdigit = fifthdigit – 1;

}

if (fifthdigit < 0){ fifthdigit=9; sixthdigit = sixthdigit – 1; } if (sixthdigit > 5){
sixthdigit=5;

}

}

Arcade joystick aansluiten op de Arduino

Zodra je eenmaal door hebt hoe een arcade joystick werkt, wordt het een vrij simpel verhaal. Je kunt een joystick zien als vier afzonderlijke knoppen (normally open). Je kunt ze dus zowel qua aansluitingen als in je Arduino sketch op deze manier behandelen. Als je de joystick omhoog beweegt, wordt er beneden een circuit gesloten. Hier een filmpje:

 

Handige links:

https://www.iprototype.nl/products/components/buttons-switches/arcade-joystick

Dit is de versie die ik heb gekocht. Maar ik vermoed dat alle arcade-modellen op deze manier werken.

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

Hier vind je een duidelijke breadboard foto

http://arduino.cc/en/Tutorial/Button

Hier vind je een aansluitschema en de sketch die je nodig hebt. Hij maakt gebruik van pin 13 om een LEDje te laten branden. De meeste Arduino’s hebben dit LEDje, zo niet dan zul je er eentje moeten aansluiten (inclusief 220 ohm weerstandje als die er ook nog niet bij zit, anders sloop je je LEDje binnen de kortste keren).

 

I2C LCD scherm 2×16 karakters

In tegenstelling tot de fader was het 2×16 karakter LCD scherm een stuk moeilijker aan de praat te krijgen. Uiteindelijk is het wel gelukt – en ik heb er een filmpje van gemaakt:

De volgende informatie zal je een hoop tijd schelen.

Het gebruikte LCD scherm:

https://www.iprototype.nl/products/components/led-lcd/lcd16x2-I2C-BL

Het topic waarin belangrijke problemen worden aangekaart en opgelost:

http://forum.arduino.cc/index.php/topic,128635.0.html

Met deze sketch kun je zien welke poort je LCD scherm gebruikt:

http://playground.arduino.cc/Main/I2cScanner

Vergeet niet de benodigde libraries te installeren. Gebruik hiervoor niet de libraries op de site van iPrototype maar de deze:

https://bitbucket.orghttps://bitbucket.org/fmalpartida/new-liquidcrystal/wiki/Home

Een update over de Mega 2560 vind je hier.

En uiteindelijk de sketch zoals te zien in het filmpje.


/*
** Example Arduino sketch for SainSmart I2C LCD2004 adapter for HD44780 LCD screens
** Readily found on eBay or http://www.sainsmart.com/
** The LCD2004 module appears to be identical to one marketed by YwRobot
**
** Address pins 0,1 & 2 are all permenantly tied high so the address is fixed at 0x27
**
** Written for and tested with Arduino 1.0
** This example uses F Malpartida's NewLiquidCrystal library. Obtain from:
** https://bitbucket.org/fmalpartida/new-liquidcrystal
**
** Edward Comer
** LICENSE: GNU General Public License, version 3 (GPL-3.0)
**
** NOTE: TEsted on Arduino NANO whose I2C pins are A4==SDA, A5==SCL
*/
#include <Wire.h>
#include <LCD.h>
#include <LiquidCrystal_I2C.h>

#define I2C_ADDR    0x20  // Define I2C Address where the PCF8574A is
#define BACKLIGHT_PIN     3
#define En_pin  2
#define Rw_pin  1
#define Rs_pin  0
#define D4_pin  4
#define D5_pin  5
#define D6_pin  6
#define D7_pin  7

int n = 1;

LiquidCrystal_I2C    lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);

void setup()
{
lcd.begin (16,2);

// Switch on the backlight
lcd.setBacklightPin(BACKLIGHT_PIN,POSITIVE);
lcd.setBacklight(HIGH);
lcd.home ();                   // go home

lcd.setCursor ( 0, 0 );        // go to the 1st line
lcd.print("Lucas van Tol");
lcd.setCursor ( 0, 1 );        // go to the 2nd line
lcd.print("Arduino n00b");

}

void loop()
{
// Backlight on/off every 3 seconds
//lcd.setCursor (14,1);        // go col 14 of line 3
//  lcd.print(n++,DEC);
//  lcd.setBacklight(LOW);      // Backlight off
lcd.setCursor ( 0, 0 );        // go to the 1st line
lcd.print("info@           ");
lcd.setCursor ( 0, 1 );        // go to the 2nd line
lcd.print("lucasvantol.nl");
delay(3000);
lcd.setBacklight(HIGH);     // Backlight on
lcd.setCursor ( 0, 0 );        // go to the 1st line
lcd.print("Lucas van Tol");
lcd.setCursor ( 0, 1 );        // go to the 2nd line
lcd.print("Arduino n00b  ");
delay(3000);
}

Supersimpele sensor: de fader

Ik ben een sound designer, dus voor mij is het een ‘fader’, deze “Slider 60 Analog Slide Position Sensor” van DF Robots.

Ik ben gewend om nogal wat te moeten zwoegen om sensoren en dergelijke aan de praat te krijgen, maar dit was echt letterlijk aansluiten en gaan.

Hier staat alles duidelijk beschreven, inclusief aansluitschema:

http://www.dfrobot.com/wiki/index.php?title=Analog_Slide_Position_Sensor_%28SKU:_DFR0053%29

Stekkertje erin, drie draadjes in 5v (rood), grnd (zwart) en signal (blauw) en je kunt deze sketch uploaden. Dan werkt het meteen.

// # Editor     : Lauren from DFRobot
// # Date       : 30.12.2011
// #
// # Editor     : Lauren from DFRobot
// # Date       : 17.01.2012
// # Product name: Rotation Sensor v1/v2 or Analog Slide Position Sensor
// # Product SKU : DFR0054/DFR0058/DFR0053
// # Version     : 1.0
// # Description:
// # the sample to drive some analog sensors
// # Connection:
// #        Signal output pin  -> Analog pin 0
// #
void setup()
{
  Serial.begin(9600);     //Set serial baud rate to 9600 bps
}
void loop()
{
  int val;
  val=analogRead(0);      //Read slider value from analog 0
  Serial.println(val,DEC);//Print the value to serial port
  delay(100);
}