Arduino ansteuern ?

Hallo Community,

Im Allgemeinen:
ich spiele mit dem Gedanken Hardware z.b. Motoren o.ä. mittels eines Interfaces anzusteuern...
soweit so gut.

Erfahrungen dies bezüglich habe ich schon mit dem Velleman K8055 gesammelt welches
sich relativ einfach mit der bereit gestellten dll und header Datei programmieren lässt...

welches aber für meine Anforderungen mittlerweile zu klein geworden ist
ich weis auch das es deutlich größere Interfaces gibt welche aber auch alle deutlich teurer sind
und das zum basteln / testen leider den Rahmen sprengen würde.

aber nun zu meiner frage und zwar:
Ist es möglich mittels C++ (Borland C++ Builder 6) einen Arduino anzusteuern sowie
Daten über die USB Verbindung wieder auszulesen / auszuwerten ?

Wenn ja:
Hat jemand dazu evtl. ein Tutorial oder der gleichen oder besser noch
hat jemand schon Erfahrungen damit gemacht und kann Tipps geben auf was man achten sollte ?

gruß,
Crue

SideWinder

Hilft dir http://hekilledmywire.wordpress.com/category/avr/avr-tutorials/ ?

MfG SideWinder

C++ Forumbot

Dieser Thread wurde von Moderator/in akari aus dem Forum VCL (C++ Builder) in das Forum Rund um die Programmierung verschoben.

Im Zweifelsfall bitte auch folgende Hinweise beachten:
C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

Dieses Posting wurde automatisch erzeugt.

Muss es denn unbedingt dieses Borland-Ding sein? Aber naja, wenn du da Makefiles und eine AVR-Crosscompiling-Toolchain einbinden kannst und evtl. noch avrdude zum Flashen sollte es funktionieren.

Was man jedenfalls nicht benötigt ist diese Arduino-IDE. Für Anfänger vielleicht ganz nett, sonst aber etwas schwach an Features.

Ich verwende einfach meinen bevorzugten Editor, den GCC für AVR und ein etwas aufwändigeres Makefile. Alles halt unter Linux, sollte sich aber auch für Windows zurechtbiegen lassen. Datenaustausch mit dem PC ist kein Problem, am einfachsten wahrscheinlich über die serielle Schnittstelle (geht über die USB-Verbindung). Gibt aber auch noch andere Möglichkeiten.

Danke für die links nach langem hin und her habe ich doch noch ein passendes Tutorial gefunden
welches sich einfach auf meine Anforderungen anpassen lässt.

Ich weis leider nicht mehr wo ich es gefunden hatte aber falls dennoch jemand Interesse hat:

Hier der Code für den Borland C++ Builder:
cpp:

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#include "U_Projekt.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
TForm1 *Form1;
bool CommFlag;
char InBuffer[101];
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
	: TForm(Owner)
{
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button1Click(TObject *Sender)
{
	int port =3;
	DCB dcbCommPort;
	BOOL bPort;
	COMMTIMEOUTS Timeouts;
	DWORD BytesRead;

	Memo1->Clear();
	Memo1->Lines->Add("Es wird versucht eine Verbindung mit COM-Port: "
						 + IntToStr(port) +
						 " Herzustellen");

	AnsiString Port = "COM" +IntToStr(port);
	handle = CreateFile(Port.c_str(),
						GENERIC_READ | GENERIC_WRITE,
						0,
						0,
						OPEN_EXISTING,
						0,
						0);

	if (handle != INVALID_HANDLE_VALUE)
	{
	 Memo1->Lines->Add(" -Verbindung Hergestellt.");
	 Memo1->Lines->Add("");
	 Memo1->Lines->Add("Auslesen des COM-Portes: "+IntToStr(port));

	 dcbCommPort.DCBlength = sizeof(DCB);
	 GetCommState(handle, &dcbCommPort);

	 if(!BuildCommDCB("baud=9600 parity=N data=8 stop=1", &dcbCommPort))
	 {
	  handle = NULL;
	  Memo1->Lines->Add(" -Fehler");
	  return;
	 }
	 if(!SetCommState(handle, &dcbCommPort))
	 {
	  CloseHandle(handle);
	  handle = NULL;
	  Memo1->Lines->Add(" -Fehler");
	  return;
	 }

	 Timeouts.ReadIntervalTimeout = MAXDWORD;
	 Timeouts.ReadTotalTimeoutConstant = 0;
	 Timeouts.ReadTotalTimeoutMultiplier = 0;
	 Timeouts.WriteTotalTimeoutConstant = 250;
	 Timeouts.WriteTotalTimeoutMultiplier = 1;

	 if(!SetCommTimeouts(handle, &Timeouts))
	 {
	  CloseHandle(handle);
	  handle = NULL;
	  Memo1->Lines->Add(" -Fehler");
	  return;
	 }

	 CommFlag = true;
	 Button1->Enabled = false;
	 Button2->Enabled = true;
	 Memo1->ReadOnly = false;
	 Memo1->SetFocus();

	 while(CommFlag)
	 {
	  Application->ProcessMessages();
	  ReadFile(handle, InBuffer, 100, &BytesRead, NULL);
	  if(BytesRead)
	  {
	   InBuffer[BytesRead] = 0;
	   Memo1->SetSelTextBuf(InBuffer);
	  }
	 }

	 CloseHandle(handle);
	 handle = NULL;
	 Button1->Enabled = true;
	 Button2->Enabled = false;
	 Memo1->ReadOnly = true;
	}
	else Memo1->Lines->Add(" -Es Konnte keine Verbindung hergestellt werden");

}
//---------------------------------------------------------------------------
void __fastcall TForm1::FormCloseQuery(TObject *Sender, bool &CanClose)
{
	CommFlag = false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Button2Click(TObject *Sender)
{
	CommFlag = false;
}
//---------------------------------------------------------------------------
void __fastcall TForm1::Memo1KeyPress(TObject *Sender, char &Key)
{
	// If a Memo1 key is pressed, transmit it out the serial port.
	// Set the key to 0 so it will not echo in Memo1.

	if(handle) TransmitCommChar(handle, Key);
	Key = 0;
}
//---------------------------------------------------------------------------

header:

//---------------------------------------------------------------------------

#ifndef U_ProjektH
#define U_ProjektH
//---------------------------------------------------------------------------
#include <Classes.hpp>
#include <Controls.hpp>
#include <StdCtrls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class TForm1 : public TForm
{
__published:	// Von der IDE verwaltete Komponenten
	TButton *Button1;
	TButton *Button2;
	TMemo *Memo1;
	void __fastcall Button1Click(TObject *Sender);
	void __fastcall FormCloseQuery(TObject *Sender, bool &CanClose);
	void __fastcall Button2Click(TObject *Sender);
	void __fastcall Memo1KeyPress(TObject *Sender, char &Key);
private:	// Benutzer-Deklarationen
public:		// Benutzer-Deklarationen
	__fastcall TForm1(TComponent* Owner);

	HANDLE handle;
};
//---------------------------------------------------------------------------
extern PACKAGE TForm1 *Form1;
//---------------------------------------------------------------------------
#endif

und hier noch den Code für den Arduino dieser war nicht inhalt des Tutorials sondern
enstand vor wenigen minuten zum Testen des Codes:

char Data[8];
char PIN[14];

void setup() {    
  Serial.begin(9600);
  for(int pin = 0; pin <= 13; pin += 1)  
  {                          
   pinMode(pin, OUTPUT);
  }   
  PIN[0]='0';
  PIN[1]='1';
  PIN[2]='2';
  PIN[3]='3';
  PIN[4]='4';
  PIN[5]='5';
  PIN[6]='6';
  PIN[7]='7';
  PIN[8]='8';  
  PIN[9]='9';  
}

void loop() {
     if (Serial.available()==7) 
     {
       for (int i=0;i<=7;i+=1)
       {
	 Data[i] = Serial.read();
       }   
       Serial.print(Data[0]);  //D
       Serial.print(Data[1]);  //8 
       Serial.print(Data[2]);  //8  
       Serial.print(Data[3]);  //
       Serial.print(Data[4]);  // =
       Serial.print(Data[5]);  //
       Serial.print(Data[6]);  //1
       Serial.println(""); 

       if (Data[0]=='D'){ 
        for(int i = 0; i <= 13; i += 1) {
          if (Data[1]=='0'&&Data[2]==PIN[i]){
           if (Data[6]=='1') digitalWrite(i, HIGH);
           if (Data[6]=='0') digitalWrite(i, LOW);
         }
         if (Data[1]=='1'&&Data[2]==PIN[i]){
           if (Data[6]=='1') digitalWrite(i+10, HIGH);
           if (Data[6]=='0') digitalWrite(i+10, LOW);
         }  
        } 
       }  
     }
}

Beide Codes sind zwar noch verbesserungs bedürftig bzw. müssen noch leicht für meine zwecke angepasst werden am im groben und
ganzen sollte es auch so Funktionieren.

Die Ausgänge am Arduino lassen sich somit mit dem Code "D08 = 1" an und "D08 = 0" ausschalten.

Da ich mein problem somit gelöst habe kann hier gerne zu gemacht werden.

gruß,
Crue