Ciao a tutti,
ho la necessità di visualizzare da qualche parte i dati che ho inviato ad arduino tramite un programma console scritto con Visual C++.
Al momento, come periferica di stampa, avrei a disposizione solo il serial monitor dell'ide di arduino.
Il problema è che quando è Visual c++ che occupa la porta, io non posso accedere al serial monitor. Quando riesco ad accedervi immagino che sia troppo tardi per captare qualcosa.
Mi sono documentato un pò sulle funzioni del metodo serial e sull'interfacciamento con altri sw, ma senza risultati.
il codice che carico su arduino è il seguente:
byte inByte;
byte messaggio[] = {
0, 0, 0, 0, 0, 0, 0, 0};
void setup()
{
Serial.begin(9600);
}
void loop()
{
if (Serial.available() > 0) {
inByte = Serial.read();
for (int ii=0; ii<=7; ii++)
{
messaggio[ii] = inByte;
ii = ii + 1;
}
delay(1000);
Serial.println("il valore di e'" );
Serial.print (messaggio[0]);
Serial.print (messaggio[1]);
Serial.print (messaggio[2]);
Serial.print (messaggio[3]);
Serial.print (messaggio[4]);
Serial.print (messaggio[5]);
Serial.print (messaggio[6]);
Serial.println (messaggio[7]);
}
}
Se interessa, il programma in Visual è invece il seguente (il metodo di output è sendData_startString)
// sendPacket.cpp : file di progetto principale.
namespace sendPacket {
#include "stdafx.h"
#include <cstdio>
#include <stdlib.h>
#include <string>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <stdexcept>
using namespace System;
using namespace std;
using namespace System::IO;
using namespace System::IO::Ports;
using namespace System::Threading;
//initialize flags structure (:1 means 1 bit register dimension, using bitfields)
struct FLAGS{
unsigned short pitch:1;
unsigned short roll:1;
unsigned short thrust:1;
unsigned short yaw:1;
unsigned short acc:1;
unsigned short height:1;
unsigned short acc_height:1;
unsigned short trigger:1;
unsigned short freq:8;
};
//initialize data to send
struct SCIENTIFIC_COMMANDDATA
{
//always 0x17
unsigned char packetdescriptor;
//pitch, roll, thrust, yaw commands. 0..4095 2048=middle
unsigned short pitch;
unsigned short roll;
unsigned short thrust;
unsigned short yaw;
//flags
//Bit 0(0x01): Pitch control through serial interfacae enabled
//Bit 1(0x02): Roll control through serial interface enabled
//Bit 2(0x04): Thrust control through serial interface enabled
//Bit 3(0x08): Yaw control through serial interface enabled
//Bit 4(0x10): ACC-Mode on/off
//Bit 5(0x20): Height control - on/off (only with ACC)
//Bit 6(0x40): overwrite ACC/Height mode control
//(0=mode selected by RC 1=mode selected by Bit 4 and 5)
//Bit 7(0x80): Trigger Scientific status packet (triggers a response
//with the actual scientific state)
//Bit 8..15: sendrate of the scientific packet in 5Hz
//(0=off;1=5Hz, 20=100Hz, 200=1kHz)
//Scientific packet is send for three seconds max.
//after the last command_data packet
unsigned short flags;
};
//send-data methods
void sendData_startString(array<unsigned char> ^ startString)
{
StringComparer^ stringComparer = StringComparer::OrdinalIgnoreCase;
//Thread^ readThread = gcnew Thread(gcnew ThreadStart(PortChat::Read));
// Create a new SerialPort object with default settings.
SerialPort^ _serialPort = gcnew SerialPort("COM4");
// Allow the user to set the appropriate properties.
_serialPort->BaudRate = 9600 ;
_serialPort->Parity = Parity::None;
_serialPort->DataBits = 8;
_serialPort->StopBits = StopBits::One;
_serialPort->Handshake =Handshake::None;
// Set the read/write timeouts
// _serialPort->ReadTimeout = 500;
// _serialPort->WriteTimeout = 500;
_serialPort->Open();
int ii;
for(ii=0;ii<10;ii++)
{
_serialPort->Write(startString,0,3);
Thread::Sleep(1000);
}
_serialPort->Close();
}
//declare crc methods
unsigned short crc_update(unsigned short crc, unsigned char data)
{
data ^= (crc & 0xff);
data ^= data << 4;
return ((((unsigned short )data << 8) | ((crc>>8)&0xff)) ^ (unsigned char )(data >> 4)
^ ((unsigned short )data << 3));
}
unsigned short crc16(void* data, unsigned short cnt)
{
//unsigned short crc=0xff;
unsigned char * ptr=(unsigned char *) data;
int i;
unsigned short crc;
for (i=0;i<cnt;i++)
{
crc=crc_update(crc,*ptr);
Console::WriteLine("crc:"+crc);
ptr++;
}
return crc;
}
int data;
unsigned short crc=0xff;
unsigned short crc_fin;
int main(array<System::String ^> ^args)
{
//initialize struct
FLAGS myFlags;
SCIENTIFIC_COMMANDDATA scientific_commanddata;
//set startstring
array<unsigned char>^ startString={'>','*','>'};
//unsigned char startString[]={'>','*','>'};
// flags manually set
myFlags.pitch=0;
myFlags.roll=0;
myFlags.thrust=0;
myFlags.yaw=0;
myFlags.acc=1;
myFlags.height=0;
myFlags.acc_height=0;
myFlags.trigger=1;
myFlags.freq= 20; //20 hz??
//other SCIENTIFIC_COMMANDATA variables manually set
scientific_commanddata.packetdescriptor = 0x17;
scientific_commanddata.pitch= 0;
scientific_commanddata.roll=0;
scientific_commanddata.thrust=100;
scientific_commanddata.yaw=0;
_int8 length=sizeof(scientific_commanddata);
void* ptr;
ptr=&(scientific_commanddata.packetdescriptor);
void *data_p=&data;
crc16(ptr,length);
sendData_startString(startString);
printf("sizeof startString: %d bytes\n",sizeof(startString));
printf("sizeof scientific_commandata: %d bytes\n",sizeof(scientific_commanddata));
printf("sizeof flags: %d bytes\n",sizeof(myFlags));
printf("sizeof lenght: %d bytes\n",sizeof(length));
printf("starbytes: %s\n",startString);
printf("crc16: %d\n",crc);
char Hex[64];
_itoa_s(crc, Hex, 16);
printf("crc16 (hex): %s\n",Hex);
getchar();
return 0;
}
Quale è il "tricks"? Memorizzare diversamente le variabili (magari sulla eeprom), oppure cambiare qualcosa più a livello hw?
Grazie mille! E buona giornata. 
Marco.