Sharer.NET
v1.1.0
Sharer ist sowohl eine .NET als auch eine Arduino -Bibliothek . Es ermöglicht eine Desktop -Anwendung , Variablen und Remote -Anruffunktionen auf Arduino zu lesen/zu schreiben, wobei das Sharer Protocol eine serielle Kommunikation bezeichnet. Sharer wurde zunächst für das BallCuber -Projekt (https://ballcuber.github.io) entwickelt, ist aber jetzt eine eigenständige Bibliothek;).
// C#
var connection = new SharerConnection ( "COM3" , 115200 ) ;
connection . Connect ( ) ; Bemerkung: Für einige Boards wie Micro und Leonardo ist es notwendig, die RTS- und DTR -Signale mit den RtsEnable und DtrEnable -Eigenschaften festzulegen.
// C# - My Arduino code has a function : int Sum(int a, byte b);
var result = connection . Call ( "Sum" , 10 , 12 ) ;
// result.Status : OK
// result.Type : int
// result.Value : 22 // C# - Read all digital pins : digitalRead(0) to digitalRead(13)
for ( int i = 0 ; i <= 13 ; i ++ ) {
var digitalValue = connection . Call ( "digitalRead" , i ) ;
// digitalValue.Status : OK
// digitalValue.Type : bool
// digitalValue.Value : true or false
} // C# - Definition of all functions
var functions = connection . Functions ;
// functions[0].Name : function name
// functions[0].ReturnType : enum void, int, long, ...
// functions[0].Arguments[0].Name // Name of first argument
// functions[0].Arguments[0].Type // enum void, int, long, ... // C#
connection . WriteVariable ( "myVar" , 15 ) ; // returns true if writting OK // C# - Write simultaneously several variables by passing a List<WriteVariable>()
connection . WriteVariables ( listOfVariablesToWrite ) ; // C# - Definition of all variables
var variables = connection . Variables ;
// variables[0].Name : variable name
// variables[0].Type : enum int, long, ... // C#
var value = connection . ReadVariable ( "myVar" ) ;
// value.Status : OK
// value.Value : 12 // C# - Read simultaneously several variables
var values = connection . ReadVariables ( new string [ ] { "myVar" , "anotherVar" , "yetAnother" } ) ; // C#
var info = connection . GetInfos ( ) ;
// info.Board : Arduino UNO
// info.CPUFrequency : 16000000 (Hz)
// a lot more : info.CPlusPlusVersion, info.FunctionMaxCount, info.VariableMaxCount, ... Sie können klassische Nachrichten am seriellen Port mit den WriteUserData -Funktionen senden und empfangen. Außerdem wird das Ereignis UserDataReceived erhoben, wenn Daten vom Arduino gesendet werden.
WARNUNG: Es ist nicht möglich, Variablen zu lesen oder zu schreiben und Funktionen in Ihrem UserDataReceived -Ereignishandler aufzurufen.
// C#
connection . WriteUserData ( "Hello!" ) ;
connection . WriteUserData ( 12.2 ) ;
connection . WriteUserData ( new byte [ ] { 0x12 , 0x25 , 0xFF } ) ;
// Event raised when new user data sent by Arduino
connection . UserDataReceived += UserDataReceived ; // C++ Arduino
# include < Sharer.h >
// A simple function that sums an integer and a byte and return an integer
int Sum ( int a, byte b) {
return a + b;
}
// a simple integer
int myVar = 25 ;
void setup () {
Sharer. init ( 115200 ); // Init Serial communication with 115200 bauds
// Expose this function to Sharer : int Sum(int a, byte b)
Sharer_ShareFunction ( int , Sum, int , a, byte, b);
// Share system functions
Sharer_ShareFunction ( bool , digitalRead, uint8_t , pin);
Sharer_ShareVoid (pinMode, uint8_t , pin);
// Expose this variable to Sharer so that the desktop application can read/write it
Sharer_ShareVariable ( int , myVar);
}
// Run Sharer engine in the main Loop
void loop () {
Sharer. run ();
}Der Anteil ist in 2 Repositories unterteilt, eines für die Arduino -Quellen und die andere für .NET -Quellen
Sharer ist im Bibliotheksmanager verfügbar, der in den Menü Tools/Manage Libraries... verfügbar ist. Suchen Sie einfach nach Sharer und installieren Sie die neueste Version.
Bitte laden Sie das Archiv der Share Library herunter: https://github.com/rufus31415/sharer/releases/latest/download/sharer.zip
Der Sharer wurde mit Arduino Uno, Nano, Mega und Fällig getestet. Es kann mit anderen Boards funktionieren. Extrahieren Sie so, dass Sie ein Sharer -Verzeichnis in Ihrem Arduino -Verzeichnis "Bibliotheken" erhalten: C:Program Files (x86)ArduinolibrariesSharer
Sie können dann die Beispiele genießen, indem Sie Ihre Arduino -IDE neu starten und zu File / examples / Sharer wechseln.
Sharer.net ist auf Nuget verfügbar: https://www.nuget.org/packages/sharer/
Verwenden Sie diese Befehlszeile, um sie mit Ihrem Paketmanager zu installieren:
Install-Package Sharer
Sharer.dll Assembly kann hier heruntergeladen werden: https://github.com/RUFUS31415/sharer.net/releases/latest/download/SharerassSemblies.zip
Dieses Archiv enthält den Nuget -Paket Share.nupkg und Sharer.dll, der in AnyCPU -Release für die folgenden Ziele zusammengestellt wurde:
Das Beispiel für Windows -Formulare erfordert .NET Framework 3.5. Es kann hier heruntergeladen werden: https://github.com/rufus31415/sharer.net/releases/latest/download/sharerwindowsFormSexample.zip
Das Beispiel der Konsole wird mit .NET Core 3.0 ausgeführt. Aber Sie brauchen keine Laufzeit, um es auszuführen. Die Beispiele für eigenständige Konsolen finden Sie hier:
© RUFUS31415 Weitere Informationen finden Sie in der Lizenzdatei.
Die Header -Datei <Serhändler.h> sollte enthalten sein.
In der Funktion setup() wird Sharer durch Übergabe eines Baudrate an function Sharer.init(...) initialisiert. Es ruft intern Serial.init() mit demselben Baudrate an.
In der Funktionsschleife loop() sollte Sharer.run() aufgerufen werden. Es läuft den internen Kern von Sharer, der die empfangenen Befehle dekodiert.
# include < Sharer.h >
void setup () {
Sharer. init ( 115200 );
}
void loop () {
Sharer. run ();
}Sie können Share auch mit einem anderen Stream initialisieren, z.
void setup () {
// Initialize with another Serial interface
Serial2. begin ( 9600 );
Sharer. init (Serial2);
} Um eine Variable in die freigegebene Variablenliste hinzuzufügen, sollten Sie die MACRO Sharer_ShareVariable aufrufen. Sein erstes Argument ist der Typ der Variablen und das zweite der Name. Mit diesem Makro kann Sharer einen Zeiger auf die Variable, seinen Namen, seinen Typ und seine Speichergröße haben.
byte myByteVar;
long myLongVar;
int myIntArray[ 2 ];
void setup () {
Sharer. init ( 115200 );
Sharer_ShareVariable (byte, myByteVar);
Sharer_ShareVariable ( long , myLongVar);
Sharer_ShareVariable ( int , myIntArray[ 0 ]);
Sharer_ShareVariable ( int , myIntArray[ 1 ]);
} Um eine Variable in der freigegebenen Funktionsliste hinzuzufügen, sollten Sie die MACRO Sharer_ShareFunction aufrufen. Sein erstes Argument ist der zurückgegebene Typ, und das zweite ist sein Name. Nach Argumenten des Makros beschreiben Sie das Argument der gemeinsam genutzten Funktion durch ihren Typ und seinen Namen. Die Anzahl der Argumente, die Sie teilen können, gibt keine Grenze, aber alle Argumente sollten geteilt werden.
Die gemeinsame Nutzung der Klassenmethoden wird nicht unterstützt, und gemeinsame Funktionen müssen kostenlose Funktionen (statische Funktionen ohne Mitglied) sein.
Sie können Ihre eigenen Funktionen teilen, aber alle Systemfunktionen wie Analograd, DigitalRead, DigitalWrite, Millis, ...
int Sum ( int a, byte b) {
return a + b;
}
void setup () {
Sharer. init ( 115200 );
// Share your function to Sharer : int Sum(int a, byte b)
Sharer_ShareFunction ( int , Sum, int , a, byte, b);
// Sharer system functions
Sharer_ShareFunction ( int , analogRead, uint8_t , pin);
Sharer_ShareFunction ( bool , digitalRead, uint8_t , pin);
} Hohlraumfunktionen sind Funktionen ohne zurückgegebener Typ. Sie sollten den MACRO Sharer_ShareVoid aufrufen, um eine Hohlraumfunktion zu teilen. Das erste Argument ist sein Name, gefolgt von Typ und Namen der einzelnen Argumente.
void TurnLEDOn ( void ) {
pinMode ( 13 , OUTPUT);
digitalWrite ( 13 , true );
}
void SetLEDState ( bool state) {
pinMode ( 13 , OUTPUT);
digitalWrite ( 13 , state);
}
void setup () {
Sharer. init ( 115200 );
// Share your void fuctions
Sharer_ShareVoid (TurnLEDOn);
Sharer_ShareVoid (SetLEDState, bool , state);
// Sharer system void functions
Sharer_ShareVoid (digitalWrite, uint8_t , pin);
}Die Sharer -Klasse erbt vom Stream, sodass Sie die folgenden Funktionen verwenden können. Bitte verwenden Sie niemals Share.print (), Sharer.println () oder Sharer.Write () in einer gemeinsam genutzten Funktion, wobei Sie ignoriert werden.
void loop () {
Sharer. run ();
// gets the number of bytes available in the stream
int available = Sharer. available ();
// reads last reveided byte (-1 if no data to read)
int lastByte = Sharer. read ();
// Empty the stream
Sharer. flush ();
// reads data from the serial buffer until the target is found
// returns, true if data is found
bool found = Sharer. find ( " string to find " );
// Returns the next byte of incoming serial data without removing it from the internal serial buffer
// Successive calls to peek() will return the same character
int nextByte = Sharer. peek ();
// reads characters from the serial buffer into a String
String str = Sharer. readString ();
// Looks for the next valid integer in the incoming serial
int lastInt = Sharer. parseInt ();
lastInt = Sharer. parseInt (SKIP_ALL); // all characters other than digits or a minus sign are ignored when scanning the stream for an integer. This is the default mode
lastInt = Sharer. parseInt (SKIP_NONE); // nothing is skipped, and the stream is not touched unless the first waiting character is valid.
lastInt = Sharer. parseInt (SKIP_WHITESPACE); // only tabs, spaces, line feeds, and carriage returns are skipped.
// returns the first valid floating point number from the Serial buffer
float lastFloat = Sharer. parseFloat ();
lastFloat = Sharer. parseFloat (SKIP_ALL); // all characters other than a minus sign, decimal point, or digits are ignored when scanning the stream for a floating point number. This is the default mode.
lastFloat = Sharer. parseFloat (SKIP_NONE); // Nothing is skipped, and the stream is not touched unless the first waiting character is valid.
lastFloat = Sharer. parseFloat (SKIP_WHITESPACE); // only tabs, spaces, line feeds, and carriage returns are skipped.
// Prints ASCII encoded string
Sharer. print ( 85 ); // sends the string "85"
Sharer. print ( 1.23456 ); // sends the string "1.23"
Sharer. print ( ' N ' ); // sends the string "N"
Sharer. print ( " Hello world. " ); // sends the string "Hello world."
Sharer. print ( 78 , BIN); // sends the string "1001110"
Sharer. print ( 78 , OCT); // sends the string "116"
Sharer. print ( 78 , DEC); // sends the string "78"
Sharer. print ( 78 , HEX); // sends the string "4E"
Sharer. print ( 1.23456 , 0 ); // sends the string "1"
Sharer. print ( 1.23456 , 2 ); // sends the string "1.23"
Sharer. print ( 1.23456 , 4 ); // sends the string "1.2345"
Sharer. println ( " Hello ;) " ); // send the string and a new line "Hello ;)n"
Sharer. println (); // just sends a new line
// Write a single byte
Sharer. write ( 0x12 );
} Sie können die Grenzwerte des Anteils ändern, indem Sie die Konstanten der Datei C:Program Files (x86)ArduinolibrariesSharersrcSharerConfig.h bearbeiten.
// maximum number of shared functions
# define _SHARER_MAX_FUNCTION_COUNT 16
// maximum number of shared variables
# define _SHARER_MAX_VARIABLE_COUNT 32
// circle buffer size for user serial message
# define _SHARER_USER_RECEIVE_BUFFER_SIZE 64
// maximum number of call to Serial.read() each time Sharer.Run() is called
# define _SHARER_MAX_BYTE_READ_PER_RUN 1000 Hier finden Sie die vollständige Dokumentation von Sharer.net: /sharer.net/sharer.net.documentation.md.
Ein Befehl dauert weniger als 10 ms, um eine Arduino Uno (Befehl + Antwort) bei 115200 Bauds aufgerufen zu werden. Das Protokol wird optimiert, damit keine Zeichenfolgen zu entschlüsseln sind, nur einen binären Strom, um das Byte zu interpretieren. Der Speicher Fußabdruck wurde durch Verwendung von F () Makro und Progmem optimiert, um Namen von Variablen, Funktionen und Argumenten in Flash zu speichern.
Sharer verwendet ein einzigartiges Protokol namens Sharer Protocol. Jede vom Arduino empfangene serielle Befehle werden interpretiert.
Fortsetzung sein, verspreche ich ...
Ich habe einige Ideen, um Anteilsfunktionen zu erweitern, wie:
Wenn Sie daran interessiert sind, mir bei der Entwicklung von Sharer zu helfen, erhalte ich gerne Feature -Anfragen. Gabel ist auch willkommen;)
