Mensajes

disculpa que te envié este otro link sobre el manual es casi igual al anterior solo que este me parece que algunas cosas en la sección de comunicación presenta mejor la información http://www.vestildocs.com/manuals/scale-s_1209.pdf saludos

AlbertoBSD no es necesario descargar el manual con el nombre de la marca, tengo el codigo de la placa base del indicador digital de pes es de la serie LP7510E, de todas formas el link para descargar el manual esta aca: http://www.awtscale.com/attachments/89-LP7510_indicator_manual.pdf te agradezco por la ayuda ofrecida

Si bueno la marca del indicador digital de peso es: virtual measurement & control mod. VC 210.

Te cuento que ese patrón de caracteres

Código [Seleccionar] Expandir

C°xxCx° Cx°Cx xxx° xCx x°xC C C C C C C C°xxCx° es el que se repite constantemente cuando la bascula esta indicando el valor 0 kg absolutamente todos esos codigos, sin mover nada simplemente la bascula de mantiene en 0, porque lo digo, porque cuando cambia el valor por ejemplo 200 kg se representan otros símbolos que no poseo en este momento. Cuando vuelve a 0 kg vuelve a indicar el valor

Código [Seleccionar] Expandir

C°xxCx° Cx°Cx xxx° xCx x°xC C C C C C C C°xxCx° completo es un patron que se repite constantemente claro siempre y cuando este en 0 kg cuando cambia a otro peso cambian los codigos.
Espero que me puedan ayudar lo otro que estoy pensando es si en el codigo que estoy utilizando los parámetros de la función main son los indicados si la sincronizacion es de 9600 o en el valor de paridad esta bien, la verdad es que no se realmente. Espero que puedan ayudarme a interpretar estos codigos a valores en Kg saludos amigo

Buenas soy nuevo en el foro.

Mi problema es el siguiente estoy intentando leer los datos que recibo de un indicador digital de peso vía serial a mi pc. Los datos son interpretados por el dato tipo BYTE. El codigo que estoy utilizando es uno que encontre en la web es el siguiente:

Código (c) [Seleccionar] Expandir


#ifndef serie_h
#define serie_h

#include <windows.h>

// Open Serial port
HANDLE OpenSerialPort( char *psPort, // "COM1","COM2"
DWORD bBaudRate, // CBR_9600, CBR_19200. CBR_56000
BYTE bByteSize, // 7,8
BYTE bParity, // NOPARITY, EVENPARITY, ODDPARITY
BYTE bStopBits, // ONESTOPBIT, ONE5STOPBITS, TWOSTOPBITS
DWORD ReadTimeout   // Programmable Read Timeout
);

// Send a byte
BOOL SerialSendByte(HANDLE hPort, BYTE byte);
// return TRUE: Send OK

// Receive a byte
BOOL SerialReceiveByte(HANDLE hPort, BYTE *pbyte, BOOL *pTimeout);
// return TRUE & *pTimeout TRUE Send OK
// return TRUE & *pTimeout FALSE Timeout
// return FALSE Receive Error

// Close Serial Port
BOOL CloseSerialPort(HANDLE hPort);

// Write&Read strings from serial port using standard file I/O functions

/*BOOL ReadFile(
   HANDLE hFile, // handle of file or serial port to read
   LPVOID lpBuffer, // address of buffer that receives data  
   DWORD nNumberOfBytesToRead, // number of bytes to read
   LPDWORD lpNumberOfBytesRead, // address of number of bytes read
   LPOVERLAPPED lpOverlapped // NULL  
  );
*/

/*
BOOL WriteFile(

   HANDLE hFile, // handle to file or serial port to write to
   LPCVOID lpBuffer, // pointer to data to write to file
   DWORD nNumberOfBytesToWrite, // number of bytes to write
   LPDWORD lpNumberOfBytesWritten, // pointer to number of bytes written
   LPOVERLAPPED lpOverlapped // NULL
  );
*/

#endif

///Archivo cpp
#include "serie.h"

HANDLE OpenSerialPort( char *psPort, // "COM1","COM2"
DWORD dwBaudRate, // CBR_9600, CBR_19200. CBR_56000
BYTE bByteSize, // 7,8
BYTE bParity, // NOPARITY, EVENPARITY, ODDPARITY
BYTE bStopBits, // ONESTOPBIT, ONE5STOPBITS, TWOSTOPBITS
DWORD Timeout       // Timeout
) {

HANDLE hPort; // port handler
DCB dcbPort; // Port configuration
COMMTIMEOUTS commTimeouts; // Port Timeouts
DWORD dwError; // Error code

// Open Serial Port
hPort=CreateFile(
psPort, // pointer to name of the file
GENERIC_READ | GENERIC_WRITE, // access (read-write) mode
0, // share mode: 0 the object cannot be share
NULL, // pointer to security attributes: NULL the handle cannot be inherited
OPEN_EXISTING, // how to create: Comx exist
0, // file/port attributes
NULL); // handle to file/port with attributes to copy  

// If the function fails, the return value
//is INVALID_HANDLE_VALUE
if ( hPort == INVALID_HANDLE_VALUE ) {
dwError = GetLastError (); // Flush error code
return hPort;
}

// Set Port Configuration

// Delete DCB configuration
FillMemory(&dcbPort, sizeof(dcbPort), 0);
dcbPort.DCBlength = sizeof(dcbPort);

// Current DCB in use for the communications port
GetCommState (hPort, &dcbPort);

// Update DCB with new parameters
dcbPort.BaudRate = dwBaudRate;        
dcbPort.ByteSize = bByteSize;                
dcbPort.Parity = bParity;            
dcbPort.StopBits = bStopBits;        

// Fixed parameters (Disable XON-XOFF and modem handshake)
dcbPort.fBinary = TRUE;               // Binary mode; no EOF check
dcbPort.fParity = TRUE;               // Enable parity checking
dcbPort.fOutxCtsFlow = FALSE;         // No CTS output flow control
dcbPort.fOutxDsrFlow = FALSE;         // No DSR output flow control
dcbPort.fDtrControl = DTR_CONTROL_ENABLE;
// DTR flow control type
// Raises the DTR line when the device is opened
dcbPort.fDsrSensitivity = FALSE;       // DSR sensitivity
dcbPort.fTXContinueOnXoff = TRUE;     // XOFF continues Tx
dcbPort.fOutX = FALSE;                 // No XON/XOFF out flow control
dcbPort.fInX = FALSE;                 // No XON/XOFF in flow control
dcbPort.fErrorChar = FALSE;           // Disable error replacement
dcbPort.fNull = FALSE;                 // Disable null stripping
dcbPort.fRtsControl = RTS_CONTROL_ENABLE;
// RTS flow control
// Raises the RTS line when the device is opened
dcbPort.fAbortOnError = FALSE;         // Do not abort reads/writes on
// error
// Set new configuration
if (!SetCommState (hPort, &dcbPort)) {
dwError = GetLastError (); // Flush error code
CloseSerialPort(hPort);
hPort = INVALID_HANDLE_VALUE;
return hPort;
}

// Set Port Timeouts
// Timeouts preparation  MORE INFORMATION IN WIN32 API: COMMTIMEOUTS
commTimeouts.ReadIntervalTimeout = 0;   // Specifies the maximum time, in milliseconds, allowed to elapse between the arrival
// of two characters on the communications line
// A value of zero indicates that interval time-outs are not used.
commTimeouts.ReadTotalTimeoutMultiplier = 50;   // Specifies the multiplier, in milliseconds, used to calculate
// the total time-out period for read operations.
// For each read operation, this value is multiplied
// by the requested number of bytes to be read.
commTimeouts.ReadTotalTimeoutConstant = Timeout;// Specifies the constant, in milliseconds, used to calculate the total
// time-out period for read operations
//
commTimeouts.WriteTotalTimeoutMultiplier = 10;  // Specifies the multiplier, in milliseconds, used to calculate the
// total time-out period for write operations.
// For each write operation, this value is multiplied
// by the number of bytes to be written.
commTimeouts.WriteTotalTimeoutConstant = 1000;  // Specifies the constant, in milliseconds, used to calculate the total time-out period
// for write operations
// See de win32 api for more information
// Set Timeouts
if (!SetCommTimeouts (hPort, &commTimeouts)) {
dwError = GetLastError (); // Flush error code
CloseSerialPort(hPort);
hPort = INVALID_HANDLE_VALUE;
return hPort;
}
return hPort;
}

BOOL SerialSendByte(HANDLE hPort, BYTE byte){
BOOL bRes;
DWORD dwError, dwNumBytesWritten=0;

bRes=WriteFile(
hPort, // handle to file or serial port to write to
&byte, // pointer to data to write to file
1, // number of bytes to write
&dwNumBytesWritten, // pointer to number of bytes written
NULL // NULL
);


if ((!bRes)||(dwNumBytesWritten!=1)){
dwError = GetLastError (); // Flush error code
}
return bRes;
}

BOOL SerialReceiveByte(HANDLE hPort, BYTE *pbyte, BOOL *pTimeout){
BOOL bRes;
DWORD dwError, lpNumberOfBytesRead=0;

*pTimeout=FALSE;
bRes=ReadFile( hPort, // handle of file or serial port to read
pbyte, // address of buffer that receives data  
1, // number of bytes to read
&lpNumberOfBytesRead, // address of number of bytes read
NULL // NULL  
);

if (!bRes) {
dwError = GetLastError (); // Flush error code
}
if ((bRes)&&(lpNumberOfBytesRead==0)){
*pTimeout = TRUE;
}
return bRes;
}

BOOL CloseSerialPort(HANDLE hPort){
BOOL bRes;
DWORD dwError;

bRes=CloseHandle(hPort);
if (!bRes) {
dwError = GetLastError (); // Flush error code
}
return bRes;
}
///////////////////////////////////////////////////////////////////////////////////////////////////

#include "serie.h"
#include "windows.h"
#include "stdio.h"
#include <stdint.h>

int main(){
HANDLE hPort;
BOOL bRes;
BYTE byte;
BOOL timeout;

hPort=OpenSerialPort("COM1",CBR_9600,8,NOPARITY,TWOSTOPBITS,5000);

if (hPort==INVALID_HANDLE_VALUE){
printf("Error abriendo puerto com1");
return 1;
}

while(1){
bRes=SerialReceiveByte(hPort,&byte,&timeout);
if (!bRes) {
break;
}

if (timeout){
printf("\n--->timeout\n");
}

else
{
       putchar(byte);
}

}

if (!bRes) {
printf("Error leyendo de puerto com1");
return 1;
}

CloseSerialPort(hPort);
return 0;

bien lo que obtengo de salida  en la pantalla de la pc es lo siguiente:C°xxCx° Cx°Cx xxx° xCx x°xC C C C C C C C°xxCx° y este patron se repite constantemente. En este caso esos valores simbolizan el numero 0 que muestra el indicador digital de peso quisiera saber como puedo convertir esos valores del tipo BYTE al valor 0 Kg que muestra el indicador digital de peso pero en la pc.

Gracias de antemano por la ayuda

Buenas, soy nuevo en el foro y necesito ayuda con un problema que he tenido ya desde hace ya un tiempo, el asunto es el siguiente, en el programa que estoy creando decidi almacenar imagenes a la bdd (mysql, si ya se que no lo recomiendan pero igual lo necesito hacer así), estoy trabajando con wxwidgets para que tengan una idea primero mostrare como muestro imagenes en un marco:
______________________________________________________________________

Programa 1.

class MyFrame: public wxFrame
   {
   public:
   MyFrame();
   void OnPaint( wxPaintEvent &event );
   wxBitmap imagen_b;
   unsigned char *arreglo;
   int ancho, largo;
   
   private:
   
   DECLARE_EVENT_TABLE()
   };

MyFrame::MyFrame():wxFrame(NULL,wxID_ANY,"This is the thing")
{
   wxInitAllImageHandlers();
   SetBackgroundColour(* wxWHITE);
   
   wxImage image;
   
   if (!image.LoadFile( _T("Imagen.jpg")))
   wxLogError(wxT("Can't load JPG image"));
   
   /*else
   {
   imagen=wxBitmap(image);
   }*/
   //arreglo=image.GetData();
   
   
   arreglo=(unsigned char *) malloc (image.GetWidth() * image.GetHeight() * 3);
   memcpy (arreglo, image.GetData(), image.GetWidth() * image.GetHeight() * 3);
   ancho=image.GetWidth();
   largo=image.GetHeight();
   
   image.Destroy();
   
   wxImage nueva_imagen(ancho, largo, arreglo);
   imagen_b=wxBitmap(nueva_imagen);
   nueva_imagen.Destroy();
   
   this->Connect(wxEVT_PAINT, wxPaintEventHandler(MyFrame::OnPaint));
   //this->Centre();
   
}

void MyFrame::OnPaint(wxPaintEvent &event)
{
   wxPaintDC dc( this );
   PrepareDC( dc );
   
   //if (imagen.Ok())
   dc.DrawBitmap(imagen_b, 10, 100);
}
____________________________________________________________________


y perfecto aqui todo es una maravilla me muestra la imagen perfectamente en mi marco.

El problema surje cuando necesito almacenar los datos que conforman la imagen en la base de dato en este caso MYSQL, para ser mas especifico el problema se me presenta con el unsigned char *arreglo, les mostrare ahora el codigo pero queriendo almacenar los datos a la bdd:
_____________________________________________________________________

Programa 2.

arreglo=(unsigned char *) malloc (image.GetWidth () * image.GetHeight () * 3);
   memcpy(arreglo, image.GetData(), image.GetWidth() * image.GetHeight() * 3);
   int ancho=image.GetWidth();
   int largo=image.GetHeight();
image.Destroy();

sprintf(consulta, "INSERT INTO imagen VALUES('%hhu', '%d', '%d'),  *(arreglo++), ancho, alto);

if(mysql_query(conn, consulta)==0)
   wxMessageBox("\nDatos incertados con exito\n");
   
   else
   
   wxMessageBox("\nDATOS NO INCERTADOS\n");
___________________________________________________________________

El paso previo inserta correctamente los datos, el problema sucede aca:

Show();
wxInitAllImageHandlers();
MYSQL *conn;
   MYSQL_RES *res;
   MYSQL_ROW row;
   char *server="localhost";
   char *user="root";
   char *password="12345";
   char *base_de_datos="Programa";
   char consulta0[1024];
   conn=mysql_init(NULL);
   int numero_filas;
   
if(!mysql_real_connect(conn, server, user, password, base_de_datos, 3306, NULL, 0))
{
   wxMessageBox("No se pudo establecer Conexion con la base de datos");
   exit(1);
   }
   
   //sprintf(consulta0, "SELECT * FROM imagen");
   
   int ancho, largo;
   char *fa=strdup(factura.c_str());
   char f[100];
   strcpy(f, fa);

sprintf(consulta0, "SELECT * FROM imagen where num_f='%s'", f);
   
if(mysql_query(conn, consulta0)==0)
{
res=mysql_store_result(conn);
numero_filas=mysql_num_rows(res);
   
while((row=mysql_fetch_row(res)))
{
ancho=atoi(row[1]);
largo=atoi(row[2]);
unsigned char* arreglo= reinterpret_cast<unsigned char*>(row[0]);;

wxImage nueva_imagen(ancho, largo,arreglo);
imagen_b=wxBitmap(nueva_imagen);
nueva_imagen.Destroy();
}
}
   mysql_close(conn);
   this->Connect(wxEVT_PAINT, wxPaintEventHandler(VImagenProveedor::OnPaint));
   
}

void VImagenProveedor::OnPaint(wxPaintEvent &WXUNUSED(event)){   
   wxPaintDC dc(this);
   PrepareDC(dc);

   //if (imagen.Ok())
   dc.DrawBitmap(imagen_b, 10, 100);
}
____________________________________________________________________

bien les describire entonces mi problema:

al agregar la variable arreglo al objeto nueva_imagen (wxImage nueva_imagen(ancho, largo,arreglo))

El resultado es que no me muestra la imagen como lo hacia anteriormente en el programa 1, el problema se origina en el inserción de la variable unsigned *char arreglo a la bdd ya que me altera la codificación de la variable y debido a ello me vienen varias preguntas que serian:
1)¿En MYSQL unsigned char* esta representado por un tipo de dato blob, binary, varchar?
2)¿Como se inserta correctamente la variable arreglo a la base de dato, asi:
sprintf("%hhu", *(arreglo++)) como lo tengo en el programa o es %c o %u?
3)he intentado hacer lo siguiente para evitarme problemas:

arreglo=(unsigned char *) malloc (image.GetWidth () * image.GetHeight () * 3);
memcpy(arreglo, image.GetData(), image.GetWidth() * image.GetHeight() * 3);

char* ch=reinterpret_cast<char*>(arreglo);

sprintf(consulta, "INSERT INTO imagen VALUES('%s', '%d', '%d'),  arreglo, ancho, alto);


en este caso es peor ya que ni siquiera se almacenan los datos, en cambio si lo intento con (%c, arreglo) me inserta el valor.

este son las preguntas que me vienen a la mente las cuales me podrian ayudar a resolver este problema que tengo, otro dato para que tengan en cuenta es que intente lo siguiente:

supongase que quiero insertar el valor arreglo pero como un char *.

char* ch=reinterpret_cast<char*>(arreglo);
wxMessagebox(*ch);

y me muestra solamente el caracter especial ÿ (a lo mejor ese el problema que no esta respresentada por valores Assci) yo pensaba que me iba a mostrar un conjunto de caracteres pero solo me muestra ese.

Pero cuando logro insertar la variable arreglo de la siguiente forma:

sprintf(consulta, "INSERT INTO imagen VALUES('%huu'),  *(arreglo++). [(no coloco %s porque no me deja almacenar el dato de esa forma, al  almacenarlo el programa se queda guindado, pero con %huu no sucede eso, el problema que he notado con eso es que solo me toma un caracter)]

y en el siguiente segmento del programa donde quiero tomar la variable almacenada que es:
unsigned char* arreglo= reinterpret_cast<unsigned char*>(row[0]);

en esta parte como dije anteriormente es la que tiene el problema ya que en esta oportunidad no me muestra la imagen.

Entonces como método de prueba quiero mostrar en pantalla el valor de (row[0]) que es la variable almacenada arreglo, pero de la forma por defecto char* ya que MYSQL convierte todo las variables almacenadas a la forma char* así la haya almacenado de la forma %huu, el valor es el siguiente:

wxMessagebox(*row[0]);
me muestra 255.

De esta manera logro corroborar que si hubo una modificación de mi variable inicial ya que
char* ch=reinterpret_cast<char*>(arreglo);
wxMessagebox(*ch); me muestra el caracter especial ÿ

mientras que wxMessagebox(*row[0]); me muestra 255.

Se supone que si quiero mostrar la imagen correspondiente el valor que tomo de la bdd debe ser igual ÿ ni siquiera me esta haciendo eso.

son dudas que espero me ayuden a solucionar les doy gracias de antemano por la ayuda que me puedan ofrecer, ya que este tema me ha costado solucionarlo y así me ayudarían a comprender mas de mysql y c++, ya que como pueden observar tengo muchas dudas con respecto a este tema.