Java X,Y naar USB port Gcode

[RockboyTheSunriser]

Hallo

Ik ben pascal en ben 19 jaar. Mijn account bestond al een tijdje, dus heb opnieuw wachtwoord aangevraagd. Kijk niet naar mijn vreemde naam , waarschijnlijk was ik een stuk jonger toen ik mezelf aanmelden en me zo noemde.

Voor een stageopdracht dien ik een x,y,z coordinaten vanuit een sensor te lezen en schrijven naar een cnc mantis, welke in Gcode zal moeten worden geschreven. Het is de bedoeling dat de mantis naar de coordinaat punten gaat die hij binnen krijgt. Ik weet niet precies hoeveel keer en wat de buffer van de mantis is, maar dat geeft niet. Het is een test of het zo werkt.

Het is deels een concept waar ik niet te veel over mag vrij geven. Het uitdagende aan dit project is dat ik nog maar weinig af weet van Java. Maar om de discussie beperkt en gericht te houden, houd ik het in Java.

Mijn doelstelling is:

- Binnenkomende data zijn maximaal X1024 en Y760 en zijn ruwe data types. De X en Y verklein ik door ze door tien te delen. (Dit gedeelte werkt overigens al).

- Absolute x en y coordinaat formateren in Gcode (Hoe doe ik dit? Liefst zoektermen waar ik naar kan zoeken)

- Gcode versturen over USB com port 9 (Ik kan al Gcode versturen, maar dit is via de arduino software. Hiermee open ik de verbinding met comport 9. Typ een enkele Gcode command in (letterlijk G0 x100 y100) en de cnc verplaatst naar dat punt.

Het is de bedoeling dat de absolute coordinaten simpel weg direct naar de mantis worden verstuurd. Hoe de mantis reageert en hoe ik eventueel de foute kan oplossen is mijn probleem.

Tot zo ver dus mijn opdracht. Wat ik nu precies vraag is waar moet ik naar zoeken om dit te kunnen laten werken? Dus zoektermen verwijzingen naar een tutorial etc. Ik bedoel zeker niet dat iemand het voor mij gaat maken, maar meer dat ik gerichter te werk ga. Ben nu al een aantal weken bezig en door de bomen zie ik het bos even niet meer.

Indien het werkt, zal ik het project wel posten voor diegene die het interessant vinden. Niet het totale maar het principe coordinaat versturen naar cnc mantis.

Tot nu toe heb ik een source code waarmee ik verbinding heb met de mantis. [attachment=12814:SerialTest.txt]

De mantis geeft START terug en dat betekent dat hij wacht op een command.

De source code om coordinaten uit sensor te halen heb ik ook al. Die wil ik liever niet vrijgeven. In iedergeval kan in de console de ruwe data zien.

Ik mezelf al een Java handleiding aangeschaft:).

Alvast bedankt

Groeten

Pascal

[RockboyTheSunriser]

Misschien beter gezegt, hoe ziet een methode structuur eruit om data wat je ergens uit hebt gehaald te verzenden door eerst een port te openen en te wachten voor een response en daarna de data verzenden.

[Xenion]

Goh met jouw specifiek probleem weet ik het zo direct niet, maar misschien moet je eens zoeken naar client/server dingen en sockets?

[RockboyTheSunriser]

Bedankt voor je reactie.

Ja het is inderdaad iets met server, cient en sockets. Ik weet dat ik met deze source code een String kan sturen over de compoort:

SimpleWrite

(1.75 KiB) 138 keer gedownload

Ik snap hoe het werkt, alleen weet ik niet hoe ik dit programma kan aanpassen, zodat ik een continue stroom met inkomende data (coordinaten) kan versturen i.p.v. de messageString.

Welke termen worden hiervoor gebruikt? Ik zit mijn handleiding te lezen over I/O datastreams en outputstreams. Maar hiermee verzend je telkens maar een bepaalde data stream naar de compoort. Ik snap niet hoe je de inkomende coordinaten benoemd. Is het een reeks int of bytes?

Als ik maximaal bij de X van 0-1024 en bij Y van 0-760 pixels(pixels = coordinaten) binnen krijg, hoe noem ik dit? Hoe krijg ik deze data vanuit een andere programma in mijn SimpleWrite(zie text file) programma ?

gr

pascal

[RockboyTheSunriser]

Hallo

Even een update.

Mijn programma werkt. De comport wordt als eerste geïnitialiseerd en geopend, daarna start de sensor op waarna de inkomende coordinaten worden formateerd naar Gcode. De Gcode wordt direct schreven naar de comport.

De data wordt nu bij elke positie verandering verstuurd. Hoe kan ik ervoor zorgen dat de inkomende data 1 keer per seconden wordt verstuurd en de rest van de data gewoon wordt weggegooid? Dus eigenlijk als ik 12 gcodes p/s heb, die ik wil verdelen in 2 Gcodes van het gemiddelde van de 12 gcodes. Hoe doe ik dit? Naar welke term moet ik zoeken om dit te kunnen?

gr

pascal

[Xenion]

Het eenvoudigste lijkt mij dat je in je programma een buffer zet waarin 12 Gcodes kunnen:

Je wacht dan tot je er 12 hebt ontvangen. Daarvan bereken je dan het gemiddelde en je verstuurt dat. Daarna maak je de buffer leeg en je wacht tot die weer volloopt..

Nog makkelijker zou zijn als je gewoon de sample-frequentie van de sensor zou kunnen aanpassen.

[RockboyTheSunriser]

Hoe noemen ze dit bufferen? Is dit bufferedreader die ze eerst in een buffer stopt?

[Xenion]

Je moet die buffer gewoon zien als een blok geheugen. Dat kan een eenvoudige array zijn.

Het idee is dat je eerst die array van 12 elementen laat vollopen. Als die dan vol zit, bereken je het gemiddelde en verstuur je dat. Zo ontvangt jouw programma wel 12 codes/s, maar het verzendt maar 1 code/s.

[RockboyTheSunriser]

Als ik het begrijp is het gemiddelde berekenen van een array met een aantal getallen te berekenen op ongeveer deze manier:

imgByteArray1 = [1,2,3,4]

imgByteArray2 = [4,3,2,1]

totalImgByteArray = imgByteArray1 + imgByteArray2

//totalImgByteArray will equal [5,5,5,5]

aveImgByteArray = totalImgByteArray / 2

//aveImgByteArray will equal [2.5,2.5,2.5,2.5]

Maar ik hoe benoem ik dan elke Gcode? Is het dan gewoon de .length equals 12 gcode bijvoorbeeld? of is het dan aveImgByteArray = totalImgByteArray/12 ?

[Xenion]

Er is niet 1 perfecte manier om zoiets te doen.

Ik heb geen idee wat die Gcodes precies zijn en hoe je daar een gemiddelde van zou moeten berekenen maar stel dat je 12x per seconde een double waarde binnen krijgt, dan zou je iets als volgt kunnen doen:

Code: Selecteer alles

int count = 0;

double buffer = 0;

while(true){ // loop waarin inputs binnen komen

    if( input ){ // stel dat je een input binnenkrijgt

  count++;

  buffer += input_waarde;

  if( count == 12 ){ // als je er 12 gekregen hebt

    send_output( buffer/12 ); // verzend

    // reset buffer en count

    buffer = 0;

    count = 0;

  }

    }

}

Een alternatief is om van buffer een list ofzo te maken en telkens dat je een nieuwe waarde krijgt, voeg je die toe aan de list. Wanneer je dan merkt dat de lengte 12 is verwerk je de inputs en verstuur je iets. Je kan het evengoed met een datastructuur doen van vaste grootte, zoals een array en dan houd je zelf bij in een counter aan de hoeveelste waarde je zit.

[RockboyTheSunriser]

Ik krijg nu met

onIrevent(Irevent arg0)

int X, Y;

X = arg0.getX();

Y = arg0.getY();

Dit zijn de coördinaten die als het goed is met ongeveer 100 hz worden verstuurd. Als ik het nog goed begrijp doe ik om het gemiddelde van 12 coördinaten te verkrijgen, zodat ik theoretisch gezien 8 hz krijg dit :

int count = 0;

double buffer = 0;

while(true){ // loop waarin inputs binnen komen

if( input ){ // stel dat je een input binnenkrijgt

count++;

buffer += X; // X zijn de de coordinaat waarde wat binne komt.

if( count == 12 ){ // als je er 12 gekregen hebt

send_output( buffer/12 ); // verzend

// reset buffer en count

buffer = 0;

count = 0;

}

}

Het resultaat op mijn console blijft het zelfde. Dus als de muis wordt geactiveerd blijft hij de laatste coördinaat versturen. Als ik de While naar while(X == true) geeft hij aan dat ik hem moet veranderen naar boolean, terwijl het een long type is) Wat doe ik nu verkeerd:)?

[Xenion]

Dit zijn de coördinaten die als het goed is met ongeveer 100 hz worden verstuurd. Als ik het nog goed begrijp doe ik om het gemiddelde van 12 coördinaten te verkrijgen, zodat ik theoretisch gezien 8 hz krijg dit :

Pff uiteindelijk gebruik je best gewoon de laatste positie hoor. Negeer gewoon 11/12 en zend steeds de 12e.

Nogmaals, kan je niet in de instellingen van je sensor vragen om te samplen op een lagere frequentie? Dan heb je daar verder niks meer aan te doen?

Die code die ik gaf is pseudocode om een idee te illustreren. Je mag die niet gewoon letterlijk kopiëren want.

Het enige dat je moet doen is gewoon niet elke meting doorsturen. Je kan dat op verschillende manieren doen maar gewoon ergens een simpel tellertje dat bijhoudt hoeveel metingen je al gehad hebt is voldoende. Je verzendt enkel als de teller op 12 staat en wanneer dat gebeurt reset je hem.

[RockboyTheSunriser]

ja ik snap wat je bedoelt. Ik heb nu de code zo

int AX, AY;

int AZ;

int oX, oY;

int bufferX = 0;

int bufferY = 0;

int counter = 0;

public void onIrEvent(IREvent arg0) {

oX = (int) arg0.getAx()/10;

oY = (int) arg0.getAy()/10;

bufferX = (int) oX;

bufferY = (int) oY;

// System.out.println("Onbewerkte coordinaten: " + "X:"+ oX +" "+ "Y:" + oY);

counter ++;

if (counter == 12) {

System.out.println("X average =" + bufferX / 12);

System.out.println("Y average =" + bufferY / 12);

bufferX = AX;

bufferY = AY;

counter = 0;

SendingGcode();

}

}



Nu neem ik aan dat hij het gemiddelde berekent, maar het lijkt erop dat hij gewoon de coordinaten deelt door 12. Daarom als ik bufferY/12 doe krijg ik: waardes van 3, 4 of 5 terwijl als ik deel door 1 (niks dus) krijg ik gewoon 36 48 en 60 . En kleine waardes daar tussen .

Wat ik verwachte is dat de binnekomende data wat varieert van X0 tot X102 en Y0 tot Y76 met een sample frequentie van 100 hz wordt terug gebracht naar 8 hz(theoretisch gezien). Weet niet zeker of dit precies juist is wat ik zeg.Het instellen van de sensor sample frequentie lukt me (nog) niet, dit zou ik op kunnen zoeken, maar wil het voorlopig op deze manier proberen. Als dit niet goed of helemaal niet werkt dan probeer ik de andere manier uit.

Ben zelf een beginner in Java.

@Edit

Ik snap het denk ik al. Wat je bedoelde met 11/12 waarvan je de laatste alleen weergeeft. Je hoeft de bufferX en bufferY dan niet te delen door 12, toch?

[Xenion]

Code: Selecteer alles

...

public void onIrEvent(IREvent arg0) {

...

 bufferX = (int) oX;

 bufferY = (int) oY;

...

 }

Dit klopt niet als je wil uitmiddelen: je zet de waarde van de buffer op wat je binnenkrijgt. Hiermee verlies je alle vorige informatie. In mijn voorbeeldcode stond er een +=. Als je dat niet in java mag zeggen dan moet je x = x+y doen ipv x += y.

Maar kijk nu eerst maar of het werkt met gewoon elke keer de 12e waarde door te sturen, dan moet je inderdaad niet delen door 12 want dat zou nergens op slaan.

[RockboyTheSunriser]

Dit werkt prima nu. Dank je wel voor de tijd om het mij uit te leggen.

Het volgende probleem is nu dat de CNC machine nog niet de Gcode verstaat. Middels outputstream schrijf ik de Gcodes naar de interface van de CNC machine. De interface van de CNC verstaat alleen Gcodes. Met de Arduino Seriele monitior, waarmee je een string kan versturen over de comport, kan ik letterlijk G0 X50 Y50 versturen waarna de CNC machine direct positioneert naar X50 Y50. Wat ik niet begrijp is dat middels outputstream ik de gcode eerst in bytes formateer op deze manier. Letterlijk een string versturen is theoretisch gezien onmogelijk toch?

Weet iemand mij te vertellen op welke manier ik de Gcode wel kan versturen en waarom niet op deze manier(het lukt wel, maar de CNC interface doet er niks mee). De poort wordt overigens gedetecteerd en geopend.:

public void SendingGcode(){

Gcode = String.format( "G0 X%d Y%d Z%d", AX, AY, AZ);

try {

// Verstuurt de geformateerde Gcode (G1 X00 Y00)

outputStream.write(Gcode.getBytes());

System.out.println("Sending Gcode" + Gcode);

} catch (IOException e) {}

}