Access Violation! Inaccessible Value Serial.pas - delphi

Question

I have a problem with my Serial.pas file, as I am trying to access Com Ports, I am getting access violations and then for the variable hCommPort it says its inaccessible value. At the bottom of this post, the very bottom is the code I use to send my com port and baud rate to Serial.pas.
I have looked all over the place to find a solution for it but I can't seem to find or I just don't have the know how to fix it and it seems I have no knowledge about access violations as I have not dealt with them before.
Any help will be greatly appreciated
Here is the whole code for Serial.pas
unit Serial;
interface
uses
Windows, Messages, SysUtils, Classes,
Graphics, Controls, Forms, Dialogs;
// This is the Device Control Block record.
// It is the structure that contains the
// serial port setup parameters. This
// structure must be initialized before the
// serial port can be used. It is declared
// in the windows.pas unit and looks like this:
{type TDCB = record
DCBLength:DWord;
Baudrate:DWord;
Flags:LongInt;
wReserved:Word;
XONLim:Word;
XOFFLim:Word;
ByteSize:Byte;
Parity:Byte;
StopBits:Byte;
XONChar:Char;
XOFFChar:Char;
ErrorChar:Char;
EOFChar:Char;
EvtChar:Char;
wReserved1:Word;
end;}
type
// You can't do anything without a comm port.
TCommPort = (cpCOM1, cpCOM2, cpCOM3, cpCOM4,
cpCOM5, cpCOM6, cpCOM7, cpCOM8, cpCOM9);
// All of the baud rates that the DCB supports.
TBaudRate = (br110, br300, br600, br1200, br2400, br4800, br9600,
br14400, br19200, br38400, br56000, br115200, br128000, br256000, br009600);
// Parity types for parity error checking
TParityType = (pcNone, pcEven, pcOdd, pcMark, pcSpace);
TStopBits = (sbOne, sbOnePtFive, sbTwo);
TDataBits = (db4, db5, db6, db7, db8);
TFlowControl = (fcNone, fcXON_XOFF, fcRTS_CTS, fcDSR_DTR);
// Two new notify events.
TNotifyTXEvent = procedure(Sender : TObject; data : string) of object;
TNotifyRXEvent = procedure(Sender : TObject; data : string) of object;
// Set some constant defaults.
// These are the qquivalent of
// COM2:9600,N,8,1;
const
dflt_CommPort = cpCOM2;
dflt_BaudRate = br9600;
dflt_ParityType = pcNone;
dflt_ParityErrorChecking = False;
dflt_ParityErrorChar = 0;
dflt_ParityErrorReplacement = False;
dflt_StopBits = sbOne;
dflt_DataBits = db8;
dflt_XONChar = $11; {ASCII 11h}
dflt_XOFFChar = $13; {ASCII 13h}
dflt_XONLim = 1024;
dflt_XOFFLim = 2048;
dflt_ErrorChar = 0; // For parity checking.
dflt_FlowControl = fcNone;
dflt_StripNullChars = False;
dflt_EOFChar = 0;
type
TSerialPort = class(TComponent)
private
hCommPort : THandle; // Handle to the serial port.
fCommPort : TCommPort;
fBaudRate : TBaudRate;
fParityType : TParityType;
fParityErrorChecking : Boolean;
fParityErrorChar : Byte;
fParityErrorReplacement : Boolean;
fStopBits : TStopBits;
fDataBits : TDataBits;
fXONChar : byte; {0..255}
fXOFFChar : byte; {0..255}
fXONLim : word; {0..65535}
fXOFFLim : word; {0..65535}
fErrorChar : byte;
fFlowControl : TFlowControl;
fStripNullChars : Boolean; // Strip null chars?
fEOFChar : Byte;
fOnTransmit : TNotifyTXEvent;
fOnReceive : TNotifyRXEvent;
fAfterTransmit : TNotifyTXEvent;
fAfterReceive : TNotifyRXEvent;
ReadBuffer : String; // Where the results from the read goes.
procedure SetCommPort(CP : TCommPort);
procedure SetBaudRate(BR : TBaudRate);
procedure SetParityType(PT : TParityType);
procedure SetParityErrorChecking(SPEC : Boolean);
procedure SetParityErrorChar(PEC : Byte);
procedure SetParityErrorReplacement(PER : Boolean);
procedure SetStopBits(SSB: TStopBits);
procedure SetDataBits(SDB : TDataBits);
procedure SetXONChar(SXC : byte);
procedure SetXOFFChar(SXOC : byte);
procedure SetXONLim(SXOL : word);
procedure SetXOFFLim(SXFL : word);
procedure SetErrorChar(SEC : byte);
procedure SetFlowControl(SFC : TFlowControl);
procedure SetStripNullChars(SSNC : Boolean);
procedure SetEOFChar(SEOFC : Byte);
procedure Initialize_DCB;
protected
public
constructor Create(AOwner : TComponent); override;
destructor Destroy; override;
function OpenPort(MyCommPort : TCommPort) : Boolean;
function ClosePort : boolean;
procedure SendData(data : PChar; size : DWord);
function GetData : String;
function InputBufferCount: LongInt;
function PortIsOpen : boolean;
procedure FlushTX;
procedure FlushRX;
published
property CommPort : TCommport read fCommPort
write SetCommPort
default dflt_CommPort;
property BaudRate : TBaudRate read fBaudRate
write SetBaudRate
default dflt_BaudRate;
property ParityType : TParityType read fParityType
write SetParityType
default dflt_ParityType;
property ParityErrorChecking : Boolean read fParityErrorChecking
write SetParityErrorChecking
default dflt_ParityErrorChecking;
property ParityErrorChar : Byte read fParityErrorChar
write SetParityErrorChar
default dflt_ParityErrorChar;
property ParityErrorReplacement : Boolean read fParityErrorReplacement
write
SetParityErrorReplacement
default
dflt_ParityErrorReplacement;
property StopBits : TStopBits read fStopBits
write SetStopBits
default dflt_StopBits;
property DataBits : TDataBits read fDataBits
write SetDataBits
default dflt_DataBits;
property XONChar : byte read fXONChar
write SetXONChar
default dflt_XONChar;
property XOFFChar : byte read fXOFFChar
write SetXOFFChar
default dflt_XOFFChar;
property XONLim : word read fXONLim
write SetXONLim
default dflt_XONLim;
property XOFFLim : word read fXOFFLim
write SetXOFFLim
default dflt_XOFFLim;
property ErrorChar : byte read fErrorChar
write SetErrorChar
default dflt_ErrorChar;
property FlowControl : TFlowControl read fFlowControl
write SetFlowControl
default dflt_FlowControl;
property StripNullChars : Boolean read fStripNullChars
write SetStripNullChars
default dflt_StripNullChars;
property EOFChar : byte read fEOFChar
write SetEOFChar
default dflt_EOFChar;
property OnTransmit : TNotifyTXEvent read fOnTransmit
write fOnTransmit;
property OnReceive : TNotifyRXEvent read fOnReceive
write fOnReceive;
property AfterTransmit : TNotifyTXEvent read fAfterTransmit
write fAfterTransmit;
property AfterReceive : TNotifyRXEvent read fAfterReceive
write fAfterReceive;
end;
procedure Register;
implementation
// Create method.
constructor TSerialPort.Create(AOwner : TComponent);
begin
inherited Create(AOwner);
// Initalize the handle to the port as
// an invalid handle value. We do this
// because the port hasn't been opened
// yet, and it allows us to test for
// this condition in some functions,
// thereby controlling the behavior
// of the function.
//TSerialPort.Create(AOwner);
hCommPort := INVALID_HANDLE_VALUE;
// Set initial settings. Even though
// the default parameter was specified
// in the property, if you were to
// create a component at runtime, the
// defaults would not get set. So it
// is important to call them again in
// the create of the component.
fCommPort := dflt_CommPort;
fBaudRate := dflt_BaudRate;
fParityType := dflt_ParityType;
fParityErrorChecking := dflt_ParityErrorChecking;
fParityErrorChar := dflt_ParityErrorChar;
fParityErrorReplacement := dflt_ParityErrorReplacement;
fStopBits := dflt_StopBits;
fDataBits := dflt_DataBits;
fXONChar := dflt_XONChar;
fXOFFChar := dflt_XOFFChar;
fXONLim := dflt_XONLim;
fXOFFLim := dflt_XOFFLim;
fErrorChar := dflt_ErrorChar;
fFlowControl := dflt_FlowControl;
fStripNullChars := dflt_StripNullChars;
fEOFChar := dflt_EOFChar;
//fOnTransmit := nil;
//fOnReceive := nil;
end;
// Public method to open the port and
// assign the handle to it.
function TSerialPort.OpenPort(MyCommPort : TCommPort) : Boolean;
var
MyPort : PChar;
begin
// Make sure that the port is Closed first.
ClosePort;
MyPort := PChar('COM' + IntToStr(ord(fCommPort)+1));
hCommPort := CreateFile(MyPort,
GENERIC_READ OR GENERIC_WRITE,
0,
nil,
OPEN_EXISTING,
0,0);
// Initialize the port.
Initialize_DCB;
// Was successful if not and invalid handle.
result := hCommPort <> INVALID_HANDLE_VALUE;
end;
// Public method to Close the port.
function TSerialPort.ClosePort : boolean;
begin
FlushTX;
FlushRX;
// Close the handle to the port.
result := CloseHandle(hCommPort);
hCommPort := INVALID_HANDLE_VALUE;
end;
// Public Send data method.
procedure TSerialPort.SendData(data : PChar; size : DWord);
var
NumBytesWritten : DWord;
begin
if hCommPort = INVALID_HANDLE_VALUE then exit;
if assigned(fOnTransmit) then fONTransmit(self, Data);
WriteFile(hCommPort,
Data^,
Size,
NumBytesWritten,
nil);
// Fire the transmit event.
if assigned(fAfterTransmit) then fAfterTransmit(self, Data);
end;
function TSerialPort.InputBufferCount: LongInt;
var
oStatus: TComStat;
dwErrorCode: DWord;
begin
Result := 0;
if hCommPort = INVALID_HANDLE_VALUE then
Exit;
ClearCommError(hCommPort, dwErrorCode, #oStatus);
Result := oStatus.cbInQue;
end;
// Public Get data method.
function TSerialPort.GetData : String;
var
NumBytesRead : DWord;
// <<cbInQue>> Specifies the number
// of bytes received by the serial
// provider but not yet read by a
// ReadFile operation.
BytesInQueue : LongInt; // Number of bytes in the input buffer
oStatus: TComStat; // Variable for the ComStat structure.
dwErrorCode: DWord; // Variable to put the error codes in.
begin
if hCommPort = INVALID_HANDLE_VALUE then exit;
if assigned(fOnReceive) then fONReceive(self, ReadBuffer);
// Get the total number of bytes that
// are waiting to be read from the
// input buffer.
ClearCommError(hCommPort, dwErrorCode, #oStatus);
BytesInQueue := oStatus.cbInQue;
if BytesInQueue > 0 then begin
SetLength(ReadBuffer, BytesInQueue + 1);
ReadFile(hCommPort,
PChar(ReadBuffer)^,
BytesInQueue,
NumBytesRead,
nil);
SetLength(ReadBuffer, StrLen(PChar(ReadBuffer)));
end;
if assigned(fAfterReceive) then fAfterReceive(self, ReadBuffer);
result := ReadBuffer;
end;
// Destroy method.
destructor TSerialPort.Destroy;
begin
// Close the port first;
ClosePort;
inherited Destroy;
end;
// Initialize the device control block.
procedure TSerialPort.Initialize_DCB;
var
MyDCB : TDCB;
//file://MyCommTimeouts : TCommTimeouts;
begin
// Only want to perform the setup
// if the port has been opened and
// the handle assigned.
if hCommPort = INVALID_HANDLE_VALUE then exit;
// The GetCommState function fills in a
// device-control block (a DCB structure)
// with the current control settings for
// a specified communications device.
// (Win32 Developers Reference)
// Get a default fill of the DCB.
GetCommState(hCommPort, MyDCB);
case fBaudRate of
br110 : MyDCB.BaudRate := 110;
br300 : MyDCB.BaudRate := 300;
br600 : MyDCB.BaudRate := 600;
br1200 : MyDCB.BaudRate := 1200;
br2400 : MyDCB.BaudRate := 2400;
br4800 : MyDCB.BaudRate := 4800;
br9600 : MyDCB.BaudRate := 9600;
br14400 : MyDCB.BaudRate := 14400;
br19200 : MyDCB.BaudRate := 19200;
br38400 : MyDCB.BaudRate := 38400;
br56000 : MyDCB.BaudRate := 56000;
br128000 : MyDCB.BaudRate := 128000;
br256000 : MyDCB.BaudRate := 256000;
end;
// Parity error checking parameters.
case fParityType of
pcNone : MyDCB.Parity := NOPARITY;
pcEven : MyDCB.Parity := EVENPARITY;
pcOdd : MyDCB.Parity := ODDPARITY;
pcMark : MyDCB.Parity := MARKPARITY;
pcSpace : MyDCB.Parity := SPACEPARITY;
end;
if fParityErrorChecking then inc(MyDCB.Flags, $0002);
if fParityErrorReplacement then inc(MyDCB.Flags, $0021);
MyDCB.ErrorChar := char(fErrorChar);
case fStopBits of
sbOne : MyDCB.StopBits := ONESTOPBIT;
sbOnePtFive : MyDCB.StopBits := ONE5STOPBITS;
sbTwo : MyDCB.StopBits := TWOSTOPBITS;
end;
case fDataBits of
db4 : MyDCB.ByteSize := 4;
db5 : MyDCB.ByteSize := 5;
db6 : MyDCB.ByteSize := 6;
db7 : MyDCB.ByteSize := 7;
db8 : MyDCB.ByteSize := 8;
end;
// The 'flags' are bit flags,
// which means that the flags
// either turn on or off the
// desired flow control type.
case fFlowControl of
fcXON_XOFF : MyDCB.Flags := MyDCB.Flags or $0020 or $0018;
fcRTS_CTS : MyDCB.Flags := MyDCB.Flags or $0004 or
$0024*RTS_CONTROL_HANDSHAKE;
fcDSR_DTR : MyDCB.Flags := MyDCB.Flags or $0008 or
$0010*DTR_CONTROL_HANDSHAKE;
end;
if fStripNullChars then inc(MyDCB.Flags,$0022);
MyDCB.XONChar := Char(fXONChar);
MyDCB.XOFFChar := Char(fXONChar);
// The XON Limit is the number of
// bytes that the data in the
// receive buffer must fall below
// before sending the XON character,
// there for resuming the flow
// of data.
MyDCB.XONLim := fXONLim;
// The XOFF limit is the max number
// of bytes that the receive buffer
// can contain before sending the
// XOFF character, therefore
// stopping the flow of data.
MyDCB.XOFFLim := fXOFFLim;
// Character that signals the end of file.
if fEOFChar <> 0 then MyDCB.EOFChar := char(EOFChar);
// The SetCommTimeouts function sets
// the time-out parameters for all
// read and write operations on a
// specified communications device.
// (Win32 Developers Reference)
// The GetCommTimeouts function retrieves
// the time-out parameters for all read
// and write operations on a specified
// communications device.
// GetCommTimeouts(hCommPort, MyCommTimeouts);
// MyCommTimeouts.ReadIntervalTimeout := ...
// MyCommTimeouts.ReadTotalTimeoutMultiplier := ...
// MyCommTimeouts.etc...................
// SetCommTimeouts(hCommPort, MyCommTimeouts);
SetCommState(hCommPort, MyDCB);
end;
// Set the comm port.
procedure TSerialPort.SetCommPort(CP : TCommPort);
begin
if fCommPort <> CP then begin <------------- Here is where access violation happens
fCommPort := CP;
Initialize_DCB;
end;
end;
// Set the baud rate.
procedure TSerialPort.SetBaudRate(BR : TBaudRate);
begin
if fBaudRate <> BR then begin
fBaudRate := BR;
Initialize_DCB;
end;
end;
// Set the parity check type.
procedure TSerialPort.SetParityType(PT : TParityType);
begin
if fParityType <> PT then begin
fParityType := PT;
Initialize_DCB;
end;
end;
// Do we want to do parity error checking?
procedure TSerialPort.SetParityErrorChecking(SPEC : Boolean);
begin
if fParityErrorChecking <> SPEC then begin
fParityErrorChecking := SPEC;
Initialize_DCB;
end;
end;
// Set the parity error char.
procedure TSerialPort.SetParityErrorChar(PEC : Byte);
begin
if fParityErrorChar <> PEC then begin
fParityErrorChar := PEC;
Initialize_DCB;
end;
end;
// Set wether to replace parity errors with error char.
procedure TSerialPort.SetParityErrorReplacement(PER : Boolean);
begin
if fParityErrorReplacement <> PER then begin
fParityErrorReplacement := PER;
Initialize_DCB;
end;
end;
// Set the stop bits.
procedure TSerialPort.SetStopBits(SSB : TStopBits);
begin
if fStopBits <> SSB then begin
fStopBits := SSB;
Initialize_DCB;
end;
end;
// Set the data bits.
procedure TSerialPort.SetDataBits(SDB : TDataBits);
begin
if fDataBits <> SDB then begin
fDataBits := SDB;
Initialize_DCB;
end;
end;
// Set the XON Char.
procedure TSerialPort.SetXONChar(SXC : byte);
begin
if fXONChar <> SXC then begin
fXONChar := SXC;
Initialize_DCB;
end;
end;
// Set the XOFF Char.
procedure TSerialPort.SetXOFFChar(SXOC : byte);
begin
if fXOFFChar <> SXOC then begin
fXOFFChar := SXOC;
Initialize_DCB;
end;
end;
// Set the XON Limit.
procedure TSerialPort.SetXONLim(SXOL : word);
begin
if fXONLim <> SXOL then begin
fXONLim := SXOL;
Initialize_DCB;
end;
end;
// Set the XOFF Limit.
procedure TSerialPort.SetXOFFLim(SXFL : word);
begin
if fXOFFLim <> SXFL then begin
fXOFFLim := SXFL;
Initialize_DCB;
end;
end;
// Set the error character.
procedure TSerialPort.SetErrorChar(SEC : byte);
begin
if fErrorChar <> SEC then begin
fErrorChar := SEC;
Initialize_DCB;
end;
end;
// Set the type of flow control desired.
procedure TSerialPort.SetFlowControl(SFC : TFlowControl);
begin
if fFlowControl <> SFC then begin
fFlowControl := SFC;
Initialize_DCB;
end;
end;
// Do we want to strip off the null characters?
procedure TSerialPort.SetStripNullChars(SSNC : Boolean);
begin
if fStripNullChars <> SSNC then begin
fStripNullChars := SSNC;
Initialize_DCB;
end;
end;
// Set the EOF char.
procedure TSerialPort.SetEOFChar(SEOFC : Byte);
begin
if fEOFChar <> SEOFC then begin
fEOFChar := SEOFC;
Initialize_DCB;
end;
end;
// Public function to check if the port is open.
function TSerialPort.PortIsOpen : boolean;
begin
Result := hCommPort <> INVALID_HANDLE_VALUE;
end;
// Public method to cancel and flush the receive buffer.
procedure TSerialPort.FlushRx;
begin
if hCommPort = INVALID_HANDLE_VALUE then exit;
PurgeComm(hCommPort, PURGE_RXABORT or PURGE_RXCLEAR);
ReadBuffer := '';
end;
// Public method to cancel and flush the transmit buffer.
procedure TSerialPort.FlushTx;
begin
if hCommPort = INVALID_HANDLE_VALUE then exit;
PurgeComm(hCommPort, PURGE_TXABORT or PURGE_TXCLEAR);
end;
// Register the component in its own menu selection.
procedure Register;
begin
RegisterComponents('Misc', [TSerialPort]);
end;
end.
The below information is sent to this Serial.pas:
function TfrmMain.SetCOMPort(Index:Integer;BaudRate:TBaudRate):Boolean;
var
TempPort:TCommPort;
begin
TempPort := cpCOM1;
If Index = 0 then
TempPort:=cpCOM1;
If Index = 1 then
TempPort:=cpCOM2;
If Index = 2 then
TempPort:=cpCOM3;
If Index = 3 then
TempPort:=cpCOM4;
If Index = 4 then
TempPort:=cpCOM5;
If Index = 5 then
TempPort:=cpCOM6;
If Index = 6 then
TempPort:=cpCOM7;
If Index = 7 then
TempPort:=cpCOM8;
If Index = 8 then
TempPort:=cpCOM9;
MySP.CommPort := TempPort;
MySP.BaudRate := BaudRate;
Result := True; <----- don't know if this is correct
end;

Answer 1

if hCommPort = INVALID_HANDLE_VALUE then exit;
An access violation occurs when you attempt to read or write an address that is invalid. In your code the only memory access is the field hCommPort. What this means is that the Self pointer, the instance reference, refers to an invalid address. Common causes for this include the instance reference is nil or refers to an object that has been destroyed.
With the information you provided it is not possible to say any more. You will have to debug your program to work out why Self is not valid.