Howdy, Stranger!

It looks like you're new here. If you want to get involved, click one of these buttons!

Sign In with Facebook Sign In with Google Sign In with OpenID

Categories

We have migrated to a new platform! Please note that you will need to reset your password to log in (your credentials are still in-tact though). Please contact lee@programmersheaven.com if you have questions.
Welcome to the new platform of Programmer's Heaven! We apologize for the inconvenience caused, if you visited us from a broken link of the previous version. The main reason to move to a new platform is to provide more effective and collaborative experience to you all. Please feel free to experience the new platform and use its exciting features. Contact us for any issue that you need to get clarified. We are more than happy to help you.

Compiler Warning

samuelmoneillsamuelmoneill Posts: 14Member
Hey guys,

I am having difficulty with the following compiler warning:

[Warning] passing arg 1 of 'write' makes integer from pointer without a cast

[code]
#include
#include
#include
#include
#include "cf_packet.h"

HANDLE hPort;
HANDLE handle;

COMMAND_PACKET
outgoing_response;


BOOL WriteByte(BYTE bybyte)
{
DWORD iBytesWritten=0;
DWORD iBytesToRead = 1;
if(WriteFile(hPort,(LPCVOID)
&bybyte,iBytesToRead,&iBytesWritten,NULL)==0)
return FALSE;
else return TRUE;
}

BOOL WriteString(const void *instring, int length)
{
int index;
BYTE *inbyte = (BYTE *) instring;
for(index = 0; index< length; ++index)
{
if (WriteByte(inbyte[index]) == FALSE)
return FALSE;
}
return TRUE;
}

BOOL ReadByte(BYTE resp)
{
BOOL bReturn = TRUE;
BYTE rx;
DWORD dwBytesTransferred=0;

if (ReadFile (hPort, &rx, 1, &dwBytesTransferred, 0)> 0)
{
if (dwBytesTransferred == 1)
{
resp=rx;
bReturn = TRUE;
}
else bReturn = FALSE;
}
else bReturn = FALSE;
return bReturn;
}

BOOL ReadString(void *outstring, int *length)
{
BYTE data;
BYTE dataout[4096]={0};
int index = 0;
while(ReadByte(data)== TRUE)
{
dataout[index++] = data;
}
memcpy(outstring, dataout, index);
*length = index;
return TRUE;
}

void ClosePort()
{
CloseHandle(hPort);
return;
}

HANDLE ConfigureSerialPort(LPCSTR lpszPortName)
{
HANDLE handle = NULL;
DWORD dwError;
DCB PortDCB;
COMMTIMEOUTS CommTimeouts;
// Open the serial port.
handle = CreateFile (lpszPortName, // Pointer to the name of the port
GENERIC_READ | GENERIC_WRITE,
// Access (read-write) mode
0, // Share mode
NULL, // Pointer to the security attribute
OPEN_EXISTING, // How to open the serial port
0, // Port attributes
NULL); // Handle to port with attribute to copy
// Initialize the DCBlength member.
PortDCB.DCBlength = sizeof (DCB);
// Get the default port setting information.
GetCommState (handle, &PortDCB);
// Change the DCB structure settings.
PortDCB.BaudRate = 115200; // Current baud
PortDCB.fBinary = TRUE; // Binary mode; no EOF check
PortDCB.fParity = TRUE; // Enable parity checking
PortDCB.fOutxCtsFlow = FALSE; // No CTS output flow control
PortDCB.fOutxDsrFlow = FALSE; // No DSR output flow control
PortDCB.fDtrControl = DTR_CONTROL_ENABLE; // DTR flow control type
PortDCB.fDsrSensitivity = FALSE; // DSR sensitivity
PortDCB.fTXContinueOnXoff = TRUE; // XOFF continues Tx
PortDCB.fOutX = FALSE; // No XON/XOFF out flow control
PortDCB.fInX = FALSE; // No XON/XOFF in flow control
PortDCB.fErrorChar = FALSE; // Disable error replacement
PortDCB.fNull = FALSE; // Disable null stripping
PortDCB.fRtsControl = RTS_CONTROL_ENABLE; // RTS flow control
PortDCB.fAbortOnError = FALSE; // Do not abort reads/writes on error
PortDCB.ByteSize = 8; // Number of bits/byte, 4-8
PortDCB.Parity = NOPARITY; // 0-4=no,odd,even,mark,space
PortDCB.StopBits = ONESTOPBIT; // 0,1,2 = 1, 1.5, 2

// Configure the port according to the specifications of the DCB structure.
if (!SetCommState (handle, &PortDCB))
{
printf("Could not configure serial port
");
return NULL;
}
// Retrieve the time-out parameters for all read and write operations
// on the port.
GetCommTimeouts (handle, &CommTimeouts);
// Change the COMMTIMEOUTS structure settings.
CommTimeouts.ReadIntervalTimeout = MAXDWORD;
CommTimeouts.ReadTotalTimeoutMultiplier = 0;
CommTimeouts.ReadTotalTimeoutConstant = 0;
CommTimeouts.WriteTotalTimeoutMultiplier = 0;
CommTimeouts.WriteTotalTimeoutConstant = 0;
if (!SetCommTimeouts (handle, &CommTimeouts))
{
printf("Could not set timeouts
");
return NULL;
}
printf("%s", lpszPortName);
return handle;
}

void send_packet(void)
{
//In order to send the entire packet in one call to "write()", we
//need to place the CRC packed against the data. If data_length
//happens to be MAX_DATA_LENGTH, then the position of the CRC is
//outgoing_response.CRC (like you would expect), but if data_length
//is less, the CRC moves into the data area, packed into the first
//unused data position.
//
//Create a pointer to the first unused data positions.
word
*packed_CRC_position;
packed_CRC_position=
(word *)&outgoing_response.data[outgoing_response.data_length];
*packed_CRC_position=
get_crc((ubyte *)&outgoing_response,outgoing_response.data_length+2,0xFFFF);
//command, length, data[data_length], crc, crc
//SendData((ubyte *)&outgoing_response,outgoing_response.data_length+4);
}

word get_crc(ubyte *bufptr,word len,word seed)
{
//CRC lookup table to avoid bit-shifting loops.
static const word crcLookupTable[256] =
{0x00000,0x01189,0x02312,0x0329B,0x04624,0x057AD,0x06536,0x074BF,
0x08C48,0x09DC1,0x0AF5A,0x0BED3,0x0CA6C,0x0DBE5,0x0E97E,0x0F8F7,
0x01081,0x00108,0x03393,0x0221A,0x056A5,0x0472C,0x075B7,0x0643E,
0x09CC9,0x08D40,0x0BFDB,0x0AE52,0x0DAED,0x0CB64,0x0F9FF,0x0E876,
0x02102,0x0308B,0x00210,0x01399,0x06726,0x076AF,0x04434,0x055BD,
0x0AD4A,0x0BCC3,0x08E58,0x09FD1,0x0EB6E,0x0FAE7,0x0C87C,0x0D9F5,
0x03183,0x0200A,0x01291,0x00318,0x077A7,0x0662E,0x054B5,0x0453C,
0x0BDCB,0x0AC42,0x09ED9,0x08F50,0x0FBEF,0x0EA66,0x0D8FD,0x0C974,
0x04204,0x0538D,0x06116,0x0709F,0x00420,0x015A9,0x02732,0x036BB,
0x0CE4C,0x0DFC5,0x0ED5E,0x0FCD7,0x08868,0x099E1,0x0AB7A,0x0BAF3,
0x05285,0x0430C,0x07197,0x0601E,0x014A1,0x00528,0x037B3,0x0263A,
0x0DECD,0x0CF44,0x0FDDF,0x0EC56,0x098E9,0x08960,0x0BBFB,0x0AA72,
0x06306,0x0728F,0x04014,0x0519D,0x02522,0x034AB,0x00630,0x017B9,
0x0EF4E,0x0FEC7,0x0CC5C,0x0DDD5,0x0A96A,0x0B8E3,0x08A78,0x09BF1,
0x07387,0x0620E,0x05095,0x0411C,0x035A3,0x0242A,0x016B1,0x00738,
0x0FFCF,0x0EE46,0x0DCDD,0x0CD54,0x0B9EB,0x0A862,0x09AF9,0x08B70,
0x08408,0x09581,0x0A71A,0x0B693,0x0C22C,0x0D3A5,0x0E13E,0x0F0B7,
0x00840,0x019C9,0x02B52,0x03ADB,0x04E64,0x05FED,0x06D76,0x07CFF,
0x09489,0x08500,0x0B79B,0x0A612,0x0D2AD,0x0C324,0x0F1BF,0x0E036,
0x018C1,0x00948,0x03BD3,0x02A5A,0x05EE5,0x04F6C,0x07DF7,0x06C7E,
0x0A50A,0x0B483,0x08618,0x09791,0x0E32E,0x0F2A7,0x0C03C,0x0D1B5,
0x02942,0x038CB,0x00A50,0x01BD9,0x06F66,0x07EEF,0x04C74,0x05DFD,
0x0B58B,0x0A402,0x09699,0x08710,0x0F3AF,0x0E226,0x0D0BD,0x0C134,
0x039C3,0x0284A,0x01AD1,0x00B58,0x07FE7,0x06E6E,0x05CF5,0x04D7C,
0x0C60C,0x0D785,0x0E51E,0x0F497,0x08028,0x091A1,0x0A33A,0x0B2B3,
0x04A44,0x05BCD,0x06956,0x078DF,0x00C60,0x01DE9,0x02F72,0x03EFB,
0x0D68D,0x0C704,0x0F59F,0x0E416,0x090A9,0x08120,0x0B3BB,0x0A232,
0x05AC5,0x04B4C,0x079D7,0x0685E,0x01CE1,0x00D68,0x03FF3,0x02E7A,
0x0E70E,0x0F687,0x0C41C,0x0D595,0x0A12A,0x0B0A3,0x08238,0x093B1,
0x06B46,0x07ACF,0x04854,0x059DD,0x02D62,0x03CEB,0x00E70,0x01FF9,
0x0F78F,0x0E606,0x0D49D,0x0C514,0x0B1AB,0x0A022,0x092B9,0x08330,
0x07BC7,0x06A4E,0x058D5,0x0495C,0x03DE3,0x02C6A,0x01EF1,0x00F78};

//Initial CRC value is 0x0FFFF.
register word
newCrc;
newCrc=seed;
//This algorithim is based on the IrDA LAP example.
while(len--)
newCrc = (newCrc >> 8) ^ crcLookupTable[(newCrc ^ *bufptr++) & 0xff];
//Make this crc match the one's complement that is sent in the packet.
return(~newCrc);
}

void SendData(unsigned char *data,int length)
{
dword
bytes_written;
bytes_written=0;

if(handle)
{
if((bytes_written=write(handle, data, length)) != length)
printf("SendData(): system call "write()" return error.
Asked for %d bytes to be written, but %d bytes reported as written.
",
length,(int)bytes_written);
}
else
printf("SendData(): "handle" is null
");

}

int main(void)
{
// Can also use COM2, COM3 or COM4 here
hPort = ConfigureSerialPort("COM1");
if(hPort == NULL)
{
printf("Com port configuration failed
");
return -1;
}
// Call your ReadString and WriteString functions here
outgoing_response.command = 31;
outgoing_response.data[0]=0; //col
outgoing_response.data[1]=0; //row
memcpy(&outgoing_response.data[2],">>>This is line 1<<<",20);
outgoing_response.data_length = 22; //the col & row position + the 20 char data length
send_packet();
getchar();
getchar();
ClosePort();
return 0;
}
[/code]

Can anyone tell me how to resolve this?

Also is the function write() defined as a C function? If so where can I find the API that includes it so that I can understand it better?

Any input would be greatly appreciated.

Comments

  • LundinLundin Posts: 3,711Member
    write() appears to be a unix function. It is not a Win API function, nor a standard function. Perhaps it works under Windows as part of POSIX support, I don't know. However, the net tells me that it has the following prototype:

    int write(int fd, char *Buff, int NumBytes);

    fd is a file buffer, not a HANDLE. I doubt you can pass a Windows HANDLE to a function designed for Unix. If it is even possible, you have to typecast as the compiler tells you to do.
Sign In or Register to comment.