Go Down

Topic: Arduino mit Processing steuern (Read 5503 times) previous topic - next topic

Serenifly


Da hast du dich leider etwas verguckt. Innerhalb von Java sollte es gar nicht interessieren, weil es da keine Pointer gibt, die man missbrauchen kann.

Das hat rein gar nichts mit Pointern zu tun. Auf die Byte Ordnung muss man da sehr wohl achten. Ich bin da schon mal drauf reingefallen als ich ein Java Program auf einem µC mit einem C# System auf dem PC verbunden habe. :)
Ich habe das dann auf dem PC herumgedreht indem ich eine Klasse runtergeladen habe bei der man bei der Konvertierung von Byte Array <-> Integer die Endianess auf Big Endian umstellen kann.

Was stimmt ist das man je nach verwendeter Klasse die Byte-Ordnung auch in Java ändern kann, wenn man z.B. einen Integer in ein Byte Array wandelt . Ich wollte es aber erst mal so einfach wie möglich halten, ohne zusätzliche Klassen wie ByteBuffer ins Spiel zu bringen.


Was den Code oben betrifft. Kann sein dass ich mich da mit Low/High vertan habe. Das habe ich nur schnell von hier kopiert:
http://stackoverflow.com/questions/2188660/convert-short-to-byte-in-java
Da wird das erst mal nur in ein Array geschrieben.

Auf das ausmaskieren kann man wahrscheinlich auch verzichten.

michael_x

Quote
ein Java Program auf einem µC mit einem C# System auf dem PC verbunden

Das ist ja auch nicht "innerhalb Java" .
In C legt man sich halt mit Pointern am leichtesten auf die Nase.

Aber ich wollte  Jonas eigentlich nicht verunsichern.
Auf dem Arduino müsste ein Firmata sketch um die Autonom-Funktionen erweitert werden.
Das wäre dann eigentlich die Hauptaufgabe.
Ob dazu eine "universelle" Firmata/Processing Kommunikation oder was selbstgestricktes Spezielles kommt, ist nach meiner Einschätzung eher eine Frage der Vorliebe als von Gut/Schlecht.

Serenifly


Das ist ja auch nicht "innerhalb Java" .

Das hier auch nicht.

Habe nochmal drüber nachgedacht:
Wenn man es sowie in dem Code oben auf beiden Seiten komplett per Hand macht, sollte es ohne Probleme gehen. Die Probleme fangen an sobald man auf einer Seite einen automatischen Konverter auf Byte Array Basis oder sowas wie einen I/O Stream verwendet. Die erwarten eine Byte Ordnung, die man nicht immer ändern kann.

Anyways...
Quote
Auf dem Arduino müsste ein Firmata sketch um die Autonom-Funktionen erweitert werden.

Habe mit Firmata praktisch noch nichts richtiges gemacht, aber ja. Es sollte eigentlich ohne große Probleme möglich sein, dass der Arduino von sich aus werkeln kann und trotzdem noch Firmata-Kommandos nebenbei empfängt.

Da gibt es in loop() wohl eine Zeile wie "Wenn Firmata Daten da sind, bearbeite sie". Wenn nicht macht man was anderes.

Quote
Ob dazu eine "universelle" Firmata/Processing Kommunikation oder was selbstgestricktes Spezielles kommt, ist nach meiner Einschätzung eher eine Frage der Vorliebe als von Gut/Schlecht.

Auch der Programmier-Kenntnisse. Was fertiges zu verwenden ist hier wahrscheinlich einfacher.

-Jonas-

ok, danke für eure Anregungen :D

ich werde mir das Firmata-Zeugs wohl noch mal anschauen.. ;)

PS: der Drucksensor mit i2c funktioniert so weit! :)

-Jonas-

#19
Jun 13, 2014, 11:46 pm Last Edit: Jun 13, 2014, 11:48 pm by -Jonas- Reason: 1
soooo ich habe das Problem so weit für mich gelöst. ist erst mal etwas Spielerei.. die richtige Anwendung wird ab jetzt darauf aufgebaut.. :))

fals es jemanden interessiert, oder er die gleichen Probleme hatte, hier die Codes, die ich gebraucht habe. man kann damit Befehle von Processing zum Arduino senden und gleichzeitig Sensordaten vom Arduino an Processing senden.

wie ihr sicher schon gemerkt habt, bin ich ein Anfänger was programmieren angeht, meine Version hier ist also garantiert noch verbesserungsfähig. Das ganze ist garantiert schlanker zu lösen. Gerade was globale/ lokale Variablen angeht, habe ich den Durchblick überhaupt nicht :D. Wer Lust hat kann ja gerne auch Anregungen geben ;)

Das wär's bis jetzt mal :)

Arduino Code:
Code: [Select]

// benötigte Libraries:
#include <Wire.h>  // für I2C Übertragungen

int led1 = 13;
int led2 = 12;

int ldrP = A0;           // der Pin, an dem das LDR ausgelesen wird

int Umdrehungen = 0;    // die Vareibel, die es dann zurück gibt.
boolean booleanReadMotorumdrehungen = true;

float T;             // speichert die Temperatur des Drucksensors
float P;             // speichert den Druck des Drucksensors


byte c[5];                                  // speichert die erhaltenen Bytes (Status Byte, MSB-Druck, LSB-Druck, MSB-Temperatur, LSB-Temperatur) zwischen
unsigned long millisReadDrucksensor0 = 0;   // speichert millis();
unsigned long millisReadDrucksensor1 = 0;   // speichert millis();
unsigned long intervalReadDrucksensor = 7;  // gibt an, wie lange die Pause zwischen Anfrage und Auslesen ist
boolean booleanReadDrucksensor = true;

const int SERIAL_BUFFER_SIZE = 64;
char serialBuffer[SERIAL_BUFFER_SIZE];

const int INCOMMING_DATA_SIZE = 10;
int array[INCOMMING_DATA_SIZE];

boolean booleanSerialCommunication = false;

void setup()
{
 Serial.begin(9600);
 Wire.begin();

 // definiert die Pins als OUTPUT oder INPUT:
 pinMode(led1, OUTPUT);
 pinMode(led2, OUTPUT);
}

void loop()
{
 readDrucksensor();
 
 if (Serial.available() > 0)
 {
   static byte index;
   char inByte = Serial.read();
   
   if(inByte >= 34 && inByte < 65 && index < SERIAL_BUFFER_SIZE - 1 && booleanSerialCommunication == false)
   {
     serialBuffer[index++] = inByte;
   }
   
   else if(inByte == '\n' && booleanSerialCommunication == false)
   {
     serialBuffer[index] = '\0';
     index = 0;
     booleanSerialCommunication = true;
   }
   else if(inByte == 'A')
   {
     Serial.print(T);
     Serial.print(",");
     Serial.print(P);
     Serial.print(",");
     Serial.print(readMotorenumdrehungen());
     Serial.print('\n');
   }
 }
 
 if (booleanSerialCommunication == true)
 {
   encodeSerial();
   booleanSerialCommunication = false;
 }
 
 
 analogWrite(led1, array[0]/12);
 analogWrite(led2, array[1]/12);
 
}

void encodeSerial()
{
 char stringBuffer[SERIAL_BUFFER_SIZE+1];
 int INDEX = 0;
 char *str;
 char *p;
 strncpy(stringBuffer, serialBuffer, SERIAL_BUFFER_SIZE);
 for( str = strtok_r(stringBuffer, ",", &p); str; str = strtok_r(NULL, ",", &p))
 {
   array[INDEX++] = atoi(str);
 }
}

void readDrucksensor()
{

 millisReadDrucksensor1 = millis();

 if (booleanReadDrucksensor == true)
 {
   Wire.beginTransmission(0x40);
   Wire.write(0xAC);
   Wire.endTransmission();

   millisReadDrucksensor0 = millisReadDrucksensor1;

   booleanReadDrucksensor = false;                  
 }

 if(millisReadDrucksensor1 - millisReadDrucksensor0 > intervalReadDrucksensor)
 {
   Wire.requestFrom(0x40, 5);

   while(Wire.available())
   {
     for(int i = 0; i < 5; i++)
     {
       c[i] = Wire.read();
     }
   }

   // fügt MSB und LSB der neu erhaltenen Daten zusammen
   int Prel = (c[1]*256) + c[2];
   int Trel = (c[3]*256) + c[4];

   // Skaliert die zusammengefügten Daten in "bar"
   P = map(Prel, 16384, 49152, 0, 10000);
   T = map(Trel, 384, 64384, -10000, 30000);
   P /= 1000.0;
   T /= 200.0;

   booleanReadDrucksensor = true;
 }
}

int readMotorenumdrehungen()
{
 int ldr = analogRead(ldrP);

 if(ldr > 30 && booleanReadMotorumdrehungen == true)
 {
   booleanReadMotorumdrehungen = false;
 }

 if(ldr < 30 && booleanReadMotorumdrehungen == false)
 {
   Umdrehungen++;
   booleanReadMotorumdrehungen = true;
 }
 return Umdrehungen;
}

void returnSerial()
{
 Serial.print('H');
 Serial.print(',');
 for(int i = 0; i < INCOMMING_DATA_SIZE; i++)
 {
   Serial.print(array[i]);
   Serial.print(',');
 }
 Serial.print('\n');
}


Processing Code:
Code: [Select]
import processing.serial.*;

Serial uBootPort;  // Create object from Serial class

int startx = 50;
int starty = 250;
int breite = 30;
int hoehe = -200;
int V = 0;
short speed = 0;



boolean establishContact = false;

float fgcolor;      // Fill color
float xpos, ypos;   // Starting position of the ball

char HEADER = 'H';


void setup() {
 size(750, 750);
 String portName = Serial.list()[0];
 uBootPort = new Serial(this, "/dev/tty.usbmodem1411", 9600);

 uBootPort.bufferUntil('\n');
 
 
 
 smooth();
}

void draw() {
 
 if (millis() > 2000 && establishContact == false)
 {
   uBootPort.write('A');
   establishContact = true;
 }
 
 if (establishContact == true)
 {
   uBootPort.write(speed + "0");
   uBootPort.write(',');
 
   uBootPort.write(speed + "0");
   uBootPort.write('\n');
 }
 
 
 background(252, 234, 194);
 noStroke();

 fill(252, 234, 210);
 rect(startx, starty, breite, hoehe);

 fill(255, 166, 82);
 rect(startx, starty, breite, -V);

 fill(0, 0, 0);

 text(xpos, 150, 30);
 text(ypos, 150, 60);
 text(fgcolor, 150, 90);

 String s = "Hauptantrieb";

 text("Hauptantreib", 50, 40);
 text(speed, 50, 270);
}

void serialEvent(Serial uBootPort) {
 // read the serial buffer:
 String myString = uBootPort.readStringUntil('\n');
 // if you got any bytes other than the linefeed:
 if (myString != null)
 {
   myString = trim(myString);
   // split the string at the commas
   // and convert the sections into floats:
   float sensors[] = float(split(myString, ','));
   // print out the values you got:
   for (int sensorNum = 0; sensorNum < sensors.length; sensorNum++) {
     print("Sensor " + sensorNum + ": " + sensors[sensorNum] + "\t");
   }
   // add a linefeed after all the sensor values are printed:
   println();
   if (sensors.length > 1) {
     xpos = sensors[0];
     ypos = sensors[1];
     fgcolor = sensors[2];
   }
   // send a byte to ask for more data:
   uBootPort.write('A');
 }
}

void mouseDragged()
{
 if ((mouseX > startx) && (mouseX < startx + breite) && (mouseY > starty + hoehe) && (mouseY < starty)) {
   V=(starty-mouseY);
 }

 if ((mouseX > startx) && (mouseX < startx + breite) && (mouseY > starty) && (mouseY < starty + 10)) {
   V=0;
 }

 if ((mouseX > startx) && (mouseX < startx + breite) && (mouseY < starty+hoehe) && (mouseY > (starty+hoehe)-10 )) {
   V=starty-(starty + hoehe);
 }
 speed = (short)(int(map(V, 0, starty+hoehe, 0, 255))/4);
}

void mousePressed()
{
 if ((mouseX > startx) && (mouseX < startx + breite) && (mouseY > starty + hoehe) && (mouseY < starty)) {
   V=(starty-mouseY);
 }

 if ((mouseX > startx) && (mouseX < startx + breite) && (mouseY > starty) && (mouseY < starty + 10)) {
   V=0;
 }

 if ((mouseX > startx) && (mouseX < startx + breite) && (mouseY < starty+hoehe) && (mouseY > (starty+hoehe)-10 )) {
   V=starty-(starty + hoehe);
 }
 speed = (short)(int(map(V, 0, starty+hoehe, 0, 255))/4);
}

Go Up