10-bits Magnetic Encoder inlezen in Aruino

Je kan ons helpen met een link naar het datasheet. Anders is het voor ons een extra handeling om het typenummer in google in te tikken en dan het juiste datasheet te selecteren.

RS422 is gewoon serieel over een gebalanceerde lijn (differentieel dus). Als je ervoor zorgt dat elk paartje (clk en data) weer gewoon 1 enkel lijntje wordt (single ended), dan kun je het zeker inlezen met een Arduino. Je moet wel even het data formaat van de sensor weten natuurlijk.

Ik meen dat de standaard + en - 6V als signaalniveaus heeft, als je dat met een controller wilt verwerken zal er wel een interface chip nodig zijn a la MAX232 voor RS232. DS3695 bijvoorbeeld. En dan heb je de USART nodig, of SPI, die vast wel in een Arduino zal zitten om de serieel ontvangen data (bit na bit) te ontvangen. Je kunt ook het datasignaal op een pen zitten en de klok op een externe interrupt pen.

[Bericht gewijzigd door Druiloor op vrijdag 22 maart 2013 14:54:31 (12%)]

Standaard SSI protocol, het meest gebruikte seriele protocol voor encoders, en idd altijd RS422.
Het is waarschijnlijk ook het simpelste protocol, vooral omdat er bij encoders vaak geen tijd is voor allerlei fancy extraatjes.

http://en.wikipedia.org/wiki/Synchronous_Serial_Interface

De link naar de datasheet:

http://www.avagotech.com/docs/AV02-0188EN

Ja ik ben niet vertrouwd met het inlezen van encoders.. Enkel analoog of digitaal.

Mvg

Ik gebruikte vroeger zoiets als dit:http://www.ti.com/lit/ds/symlink/sn75176a.pdf om een omzetter voor elkaar te knutselen.

Je kunt ook kant en klare RS422 naar RS232 converters kopen. Dan hang je dat aan een uart in je cpu en je bent wat hardware betreft klaar.

Ehm, in die datasheet wordt nergens over 422 oid geschreven. De interface is gewoon een single ended synchrone interface (data en clk apart). Of mis ik nu iets?

Mij werd verteld dat wanneer de encoder een SSI encoder is en niet gewoon een incrementele encoder, je met een 422 zit opgescheept.

SSI gaat idd altijd over een RS422.

Ja dus zal ik toch een RS422 naar RS232 converter moeten aanschaffen of niet om de data in een Arduino microcontroller in te lezen?

Dat moet niet maar dat is een mogelijkheid en het makkelijkste denk ik.

Als het niet moet, hoe kan ik de data dan wel binnenlezen zonder converter?

Door zelf de benodige level-conversie te bouwen, maar meestal ben je dan zoveel componentjes verder dat je (vooral kwa totaalprijs) beter een chipje kunt kopen die dat doet.

De datasheet is overigens duidelijk in de signalen: op pagina 6 staat de pinbezetting en die laat duidelijk zien dat het single-ended signalen zijn. Daarnaast kun je op pagina 2 lezen wat de gebruikte spanningsniveaus op de in- en uitgangen zijn: 5V logic.

Ik weet niet op welke spanning jouw Arduino werkt, maar als dat (ook) 5V is, kun je de sensor rechtstreeks op de I/O pinnen aansluiten.

De CLOCK-pin (pin 4) van de sensor is een input. Daar moet je dus zelf een klok signaal naartoe gooien. Daarop gooit de sensor seriële data naarbuiten op de DO-pin (pin 5). De CSn-pin (pin 2) gebruik je om de boel te synchroniseren (dan weet je dat de sensor een nieuwe reeks van 10 bits naar buiten spuugt). Op pagina 4 vind je daar meer info over (timing diagram).

Op 25 maart 2013 17:06:33 schreef rrobin_41:
Ja dus zal ik toch een RS422 naar RS232 converter moeten aanschaffen of niet om de data in een Arduino microcontroller in te lezen?

Een Arduino heeft toch gewoon TTL UART? Of heb je een specifieke variant die een RS232 convertor aan boord heeft?

Maargoed, dat doet helemaal niet ter zake, want de datasheet van de AEAT-6010-A06 zegt inderdaad gewoon 5V output levels, en synchroon, dus niks RS-422 of -232 maar gewoon iets SPI-achtigs.

Dus lekker aan die Arduino vast knopen en data inklokken.

Bedankt!

Ik heb het op de volgende wijze dus aangesloten:

Pin connecties:

1: VDD (5V supply voltage): 5V power supply van de Arduino
2: CSn (Chip select): Digitale uitgang 4 van de Arduino
3: VSS (GND): GND van de Arduino
4: CLK (Serial clock-input): Digitale uitgang 7 van de Arduino
5: DO (Serial Data-Output): Digitale ingang 8 van de Arduino

@MNM(tm)

De CLOCK-pin (pin 4) van de sensor is een input. Daar moet je dus zelf een klok signaal naartoe gooien.

Hoe gaat dit in zijn werk om een kloksignaal te sturen?
Is dit een bepaalde frequentie op de digitale uitgang aanbrengen?

De CSn-pin (pin 2) gebruik je om de boel te synchroniseren (dan weet je dat de sensor een nieuwe reeks van 10 bits naar buiten spuugt). Op pagina 4 vind je daar meer info over (timing diagram).

Hoe gaat ook dit in zijn werk?
Moet ik de uitgang bv. constant hoogmaken?

Alvast bedankt!

Dat CLOCK-signaal is minder spannend dan het klinkt.
Wat je moet doen is een lus programmeren die 10x doorlopen wordt (je sensor is een 10-bits versie, dus na 10x de lus doorlopen heb je ze allemaal binnen).
Voor je de lus in gaat, maak je eerst uitgang 7 (CLK) van je Arduino hoog (dat staat zo in het timing diagram) en daarna maak je uitgang 4 (CSn) van je Arduino laag, want CSn betekent dat Chip Select actief laag is.
Nu moet je, volgens de datasheet, 500ns wachten, omdat de sensor die tijd nodig heeft om de sensor data gereed te zetten.

Vervolgens ga je de lus in.
In die lus begin je met uitgang 7 (CLK) laag te maken. Na 500ns maak je uitgang 7 weer hoog. De sensor zal nu het eerste bit naar buiten sturen op de Serial Data-OUT pin en komt du binnen op ingang 8 van je Arduino.
Vervolgens lees je de toestand van ingang 8 uit en sla je die op.
Nu keer je weer terug naar het begin van de dus voor het volgende bitje en dat doe je 10x.

Na alle 10 bitjes verlaat je de lus en maak je uitgang 7 (CLK) weer hoog en daarna maak je uitgang 4 (CSn) hoog.

Klaar.

Heb de code in mekaar gestoken.. @MNM(tm)

// 10-bits Magnetic Encoder inlezen in Aruino
// Robin

int data_out=0; // Bij elke loop komt hier 1 bit bij (max 10)
int x=0; // Om de loop 10x te doorlopen
int CSn=4; // Chip select
int CLK=7; // Clock signaal
int DO=8; // Digital Output van de encoder

void setup()
{
begin.Serial(9600);
pinMode(CSn,OUTPUT);
pinMode(CLK,OUTPUT);
pinMode(DO,INPUT);
}

digitalWrite(CLK,HIGH);
digitalWrite(CSn,LOW);
delay(0.000005);

void loop()
{
if(x<=10)
{

x=x+1; // Max. 10X doorlopen
digitalWrite(CLK,LOW);
delay(0.000005);
digitalWrite(CLK,HIGH);
data_out = digitalRead(DO);

}

}

digitalWrite(CLK,HIGH); // na dat de loop 10x is doorlopen
digitalWrite(CSn,HIGH); // na dat de loop 10x is doorlopen

Sommige "{" stonden niet juist. Deze zou juist moeten zijn:

// 10-bits Magnetic Encoder inlezen in Aruino
// Robin

int data_out=0; // Bij elke loop komt hier 1 bit bij (max 10)
int x=0; // Om de loop 10x te doorlopen
int CSn=4; // Chip select
int CLK=7; // Clock signaal
int DO=8; // Digital Output van de encoder

void setup()
{
Serial.begin(9600);
pinMode(CSn, OUTPUT);
pinMode(CLK, OUTPUT);
pinMode(DO, INPUT);
}

void loop() {

digitalWrite(CLK, HIGH);
digitalWrite(CSn, LOW);
delay(0.000005);
{
if(x<=10)
{

x=x+1; // Max. 10X doorlopen
digitalWrite(CLK, LOW);
delay(0.000005);
digitalWrite(CLK, HIGH);
data_out = digitalRead(DO);

}

}

digitalWrite(CLK, HIGH); // na dat de loop 10x is doorlopen
digitalWrite(CSn, HIGH); // na dat de loop 10x is doorlopen

}

Bijna goed. Je moet de bits in data_out nog wel even een bitje naar links opschuiven voor je de nieuwe bit eraan toevoegt. Zoals je het nu doet, wordt alleen het eerste bitje steeds aangepast en blijft er uiteindelijk alleen maar de waarde 0 of 1 over.

Overigens ben ik verder geheel onbekend met Arduino en de daarbij gebruikte programmeeromgeving, dus ik kan je programma alleen maar in grote lijnen beoordelen.

(Ikzelf werk met de MSP430 van Texas Instruments op het LaunchPad ontwikkelbordje. Is allemaal veel basaler en veel minder "voorgekauwd" dan de Arduino. )

[Bericht gewijzigd door MNM(tm) op woensdag 27 maart 2013 20:50:23 (39%)]

Wat is een goede methode om dat te doen?

Waarom seial begin eignelijk? Ben je daar wat mee van plan?
En zo ver ik weet wil de delay functie een int hebben. Kleinste waarde is dus 1ms. Omdat 500ns genoeg is maar de Arduino niet nouwkeuriger dan kan +-3us gebrui ik delayMicroseconds(1). Wss kan deze ook wel weg gelaten worden omdat de Arduino toch wel 500ns er over doet maar just to be sure.

Ik heb de code aangepast, ongetest, maar dit zou al meer moeten kloppen... Nu ook in code tags

// 10-bits Magnetic Encoder inlezen in Aruino
// Robin

//data pinnen mogen const, scheelt RAM
const int CSn = 4; // Chip select
const int CLK = 7; // Clock signaal
const int DO = 8; // Digital Output van de encoder

unsigned int sensorWaarde = 0;

void setup(){
	//Fix de tris
	pinMode(CSn, OUTPUT);
	pinMode(CLK, OUTPUT);
	pinMode(DO, INPUT);
	
	//Laten we hier maar op beginnen
	digitalWrite(CLK, HIGH);
	digitalWrite(CSn, HIGH);
}



void loop() {
	sensorWaarde = readSensor();
	delayMicroseconds(1); //Tcs wachten voor nog een lezing
}

unsigned int readSensor(){
	unsigned int dataOut = 0;
	
	digitalWrite(CSn, LOW);
	delayMicroseconds(1); //Wachten op Tclkfe
	
	//10 keer doorlopen, van 0 tot 9 dus
	for(int x=0; x<10; x++){
		digitalWrite(CLK, LOW); 
		delayMicroseconds(1); //Tclk/2
		digitalWrite(CLK, HIGH);
		delayMicroseconds(1); //Tdo valid, gelijk ook Tclk/2
		dataOut = (dataOut << 1) | digitalRead(DO); //shift de al ingekomen data naar links en plak de pin state er aan vast. 1e bit is MSB
	}

	digitalWrite(CSn, HIGH); // na dat de loop 10x is doorlopen, chip niet meer selecteren
	
	return dataOut;

}

Timo

Heb het bedrijf zelf gecontacteerd en ze gaven mij de volgende code.
Probleem is dat ik alleen maar 0 0 0 0 0 0 0 uitkrijg op de serial monitor..

//*************************************************************************************************************
//
// Firmware to control the SSI Interface for the AEAT-6010 magnetic encoder
//
//
// 2013-04-12 HB
//
//
//
//*************************************************************************************************************

// Definitions for the AEAT-6010
int SSI_CLK = 7;
int DataIN = 8;
int NCS = 4;
int Test = 13;

// Definitions for variables
unsigned int reading;

// program starts here
// **************************

void setup() {

Serial.begin(9600);

// initialize the digital pin as an output.
pinMode(NCS, OUTPUT); // Chip select
pinMode(SSI_CLK, OUTPUT); // Serial clock
pinMode(DataIN, INPUT); // Serial data IN/OUT
pinMode(Test, OUTPUT);

digitalWrite(SSI_CLK, HIGH);
digitalWrite(Test, LOW);
}

//***********************************************************************
// Main program loop
//***********************************************************************
void loop() {

unsigned int reading;

ReadSSI();
Serial.println(reading,DEC);
delay(10);

}

//***********************************************************************
// Main Loop ends here
// Start of subroutines
//***********************************************************************

void ReadSSI(void)
{
int i;
char Res = 10;
unsigned int mask;

reading = 0;
mask = 0x0200;
digitalWrite(NCS, LOW);
delayMicroseconds(1);
digitalWrite(SSI_CLK, LOW);

for(i=(Res-1);i>0;i--)
{
digitalWrite(SSI_CLK, HIGH);
delayMicroseconds(1);
if (digitalRead(DataIN)) reading |= mask;
digitalWrite(SSI_CLK, LOW);
mask = mask >> 1;

if (i == 1)
{
digitalWrite(SSI_CLK, HIGH);
if (digitalRead(DataIN)) reading |= mask;
}
}

digitalWrite(NCS, HIGH);
}

Beste,

de 10 bits code zou ik normaal toch kunnen lezen op de serial monitor na deze stap niet?

//10 keer doorlopen, van 0 tot 9 dus
for(int x=0; x<10; x++){
digitalWrite(CLK, LOW);
delayMicroseconds(1); //Tclk/2
digitalWrite(CLK, HIGH);
delayMicroseconds(1); //Tdo valid, gelijk ook Tclk/2
dataOut = (dataOut << 1) | digitalRead(DO); //
Serial.println(dataOut);

-------------------------------------------------------------------

Mvg

Op 5 april 2013 19:34:58 schreef septillion:
Waarom seial begin eignelijk? Ben je daar wat mee van plan?
En zo ver ik weet wil de delay functie een int hebben. Kleinste waarde is dus 1ms. Omdat 500ns genoeg is maar de Arduino niet nouwkeuriger dan kan +-3us gebrui ik delayMicroseconds(1). Wss kan deze ook wel weg gelaten worden omdat de Arduino toch wel 500ns er over doet maar just to be sure.

Ik heb de code aangepast, ongetest, maar dit zou al meer moeten kloppen... Nu ook in code tags

// 10-bits Magnetic Encoder inlezen in Aruino
// Robin

//data pinnen mogen const, scheelt RAM
const int CSn = 4; // Chip select
const int CLK = 7; // Clock signaal
const int DO = 8; // Digital Output van de encoder

unsigned int sensorWaarde = 0;

void setup(){
	//Fix de tris
	pinMode(CSn, OUTPUT);
	pinMode(CLK, OUTPUT);
	pinMode(DO, INPUT);
	
	//Laten we hier maar op beginnen
	digitalWrite(CLK, HIGH);
	digitalWrite(CSn, HIGH);
}



void loop() {
	sensorWaarde = readSensor();
	delayMicroseconds(1); //Tcs wachten voor nog een lezing
}

unsigned int readSensor(){
	unsigned int dataOut = 0;
	
	digitalWrite(CSn, LOW);
	delayMicroseconds(1); //Wachten op Tclkfe
	
	//10 keer doorlopen, van 0 tot 9 dus
	for(int x=0; x<10; x++){
		digitalWrite(CLK, LOW); 
		delayMicroseconds(1); //Tclk/2
		digitalWrite(CLK, HIGH);
		delayMicroseconds(1); //Tdo valid, gelijk ook Tclk/2
		dataOut = (dataOut << 1) | digitalRead(DO); //shift de al ingekomen data naar links en plak de pin state er aan vast. 1e bit is MSB
	}

	digitalWrite(CSn, HIGH); // na dat de loop 10x is doorlopen, chip niet meer selecteren
	
	return dataOut;

}

Timo