Sharer.NET
v1.1.0
Sharers est à la fois un .NET et une bibliothèque Arduino . Il permet à une application de bureau de lire / écrire des variables et des fonctions d'appel à distance sur Arduino , en utilisant le protocole de partager, une communication série. Sharers a initialement été développé pour le projet Ballcuber (https://ballcuber.github.io), mais c'est maintenant une bibliothèque autonome;).
// C#
var connection = new SharerConnection ( "COM3" , 115200 ) ;
connection . Connect ( ) ; Remarque: Pour certaines planches, comme Micro et Leonardo, il est nécessaire de définir les signaux RTS et DTR avec les propriétés RtsEnable et DtrEnable .
// 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, ... Vous pouvez envoyer et recevoir des messages classiques sur le port série avec les fonctions WriteUserData . De plus, l'événement UserDataReceived est augmenté lorsque les données sont envoyées par l'Arduino.
AVERTISSEMENT: il n'est pas possible de lire ou d'écrire des variables et d'appeler des fonctions dans votre gestionnaire d'événements UserDataReceived .
// 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 ();
}Le partager est divisé en 2 référentiels, l'un pour les sources Arduino et l'autre pour les sources .NET
Sharers est disponible dans le gestionnaire de bibliothèque disponible dans les Tools/Manage Libraries... Recherchez simplement le partager et installez la dernière version.
Veuillez télécharger les archives de la bibliothèque de partager: https://github.com/rufus31415/sharer/releases/latest/download/sharer.zip
Sharers a été testé avec Arduino Uno, Nano, Mega et Due. Cela peut fonctionner avec d'autres conseils. Extraire afin que vous obteniez un répertoire partager dans votre répertoire Arduino "Libraries": C:Program Files (x86)ArduinolibrariesSharer
Vous pouvez ensuite profiter des exemples en redémarrant votre IDE Arduino et accéder au File / examples / Sharer .
Share.net est disponible sur NuGet: https://www.nuget.org/packages/share/
Utilisez cette ligne de commande pour l'installer avec votre gestionnaire de packages:
Install-Package Sharer
L'assemblage de parther.dll peut être téléchargé ici: https://github.com/rufus31415/sharer.net/releases/latest/download/shareasssemblies.zip
Cette archive contient le package NuGet Share.nupkg et Share.dll compilé dans la version anycpu pour les objectifs suivants:
L'exemple de formulaires Windows nécessite .NET Framework 3.5. Il peut être téléchargé ici: https://github.com/rufus31415/sharer.net/releases/latest/download/sharerwindowsformsexample.zip
L'exemple de console s'exécute avec .NET Core 3.0. Mais vous n'avez pas besoin de runtime pour l'exécuter. Les exemples de console autonome sont disponibles ici:
© RUFUS31415 Voir le fichier de licence pour plus de détails.
Le fichier d'en-tête <Shater.h> doit être inclus.
Dans Function setup() , le partager est initialisé en passant un baudrate à la fonction Sharer.init(...) . Il appelle en interne Serial.init() avec le même baudrate.
Dans Function loop() , Sharer.run() doit être appelé. Il exécute le noyau interne de Sharers que les commandes décodées reçues.
# include < Sharer.h >
void setup () {
Sharer. init ( 115200 );
}
void loop () {
Sharer. run ();
}Vous pouvez également initialiser le partager avec un autre flux, comme le Serial2 d'Arduino dû si vous utilisez Serial2 pour communiquer avec l'application de bureau:
void setup () {
// Initialize with another Serial interface
Serial2. begin ( 9600 );
Sharer. init (Serial2);
} Pour ajouter une variable dans la liste des variables partagées, vous devez appeler le macro Sharer_ShareVariable . Son premier argument est le type de la variable, et le second est son nom. Cette macro permet au partager d'avoir un pointeur vers la variable, son nom, son type et sa taille de mémoire.
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 ]);
} Pour ajouter une variable dans la liste des fonctions partagées, vous devez appeler le macro Sharer_ShareFunction . Son premier argument est le type retourné, et le second est son nom. Les arguments suivants de la macro décrivent l'argument de la fonction partagée par son type et son nom. Il n'y a pas de limite dans le nombre d'arguments que vous pouvez partager, mais tous les arguments doivent être partagés.
Le partage de méthode de classe n'est pas pris en charge et les fonctions partagées doivent être des fonctions libres (fonctions statiques non membre).
Vous pouvez partager vos propres fonctions, mais toutes les fonctions système comme Analogread, 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);
} Les fonctions void sont des fonctions sans type retourné. Vous devez appeler le macro Sharer_ShareVoid pour partager une fonction vide. Le premier argument est son nom, suivi du type et du nom de chaque argument.
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);
}La classe partager hérite de Stream, vous pouvez donc utiliser les fonctions suivantes. S'il vous plaît, n'utilisez jamais share.print (), sharers.println () ou share.write () dans une fonction partagée, l'écriture est ignorée.
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 );
} Vous pouvez modifier les limites du partager en modifiant les constantes du fichier C:Program Files (x86)ArduinolibrariesSharersrcSharerConfig.h .
// 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 Vous pouvez trouver ici la documentation complète de sharers.net: /share.net/sharer.net.documentation.md.
Une commande prend moins de 10 ms pour être appelée sur un arduino uno (commande + réponse) à 115200 bauds. Le protocole est optimisé afin de ne pas avoir de chaînes pour décoder, juste un flux binaire à interpréter, octet par octet. L'empreinte de la mémoire a été optimisée en utilisant la macro et le progro f () pour stocker les noms de la variable, de la fonction et des arguments dans Flash.
Sharers utilise un protocole unique appelé le protocole de partager. Toutes les commandes en série reçues par l'Arduino sont interprétées.
Pour être poursuivi, je promets ...
J'ai quelques idées pour étendre les fonctionnalités de partage comme:
Si vous souhaitez m'aider avec le développement de partager, je serai heureux de recevoir des demandes de fonctionnalités. La fourche est également la bienvenue;)
