unit SerialNGBasic; interface uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, Buttons, ExtCtrls, SerialNG; type TSerialNGBasicDLG = class(TForm) OKBtn: TButton; CancelBtn: TButton; Bevel1: TBevel; Label3: TLabel; Label4: TLabel; Label5: TLabel; Label6: TLabel; Label7: TLabel; Label8: TLabel; CBPort: TComboBox; CBBaud: TComboBox; CBData: TComboBox; CBStop: TComboBox; CBParity: TComboBox; CBFlow: TComboBox; private { Private declarations } public { Public declarations } procedure SetDLGData(SerialPortNG: TSerialPortNG); procedure GetDLGData(SerialPortNG: TSerialPortNG); end; var SerialNGBasicDLG: TSerialNGBasicDLG; implementation {$R *.DFM} procedure TSerialNGBasicDLG.SetDLGData(SerialPortNG: TSerialPortNG); var i: Integer; begin i := CBPort.Items.IndexOf(SerialPortNG.CommPort); if i >= 0 then CBPort.ItemIndex := i else CBPort.ItemIndex := 1; //COM2 i := CBBaud.Items.IndexOf(IntToStr(SerialPortNG.BaudRate)); if i >= 0 then CBBaud.ItemIndex := i else CBBaud.ItemIndex := 6; // 9600 i := CBData.Items.IndexOf(IntToStr(SerialPortNG.DataBits)+’ Bit’); if i >= 0 then CBData.ItemIndex := i else CBData.ItemIndex := 4; // 8 Bit CBStop.ItemIndex := SerialPortNG.StopBits; CBParity.ItemIndex := SerialPortNG.ParityType; case SerialPortNG.FlowControl of fcNone: CBFlow.ItemIndex := 0; fcXON_XOFF: CBFlow.ItemIndex := 1; fcRTS_CTS: CBFlow.ItemIndex := 2; fcDSR_DTR: CBFlow.ItemIndex := 3; else CBFlow.ItemIndex := 0; end; end; procedure TSerialNGBasicDLG.GetDLGData(SerialPortNG: TSerialPortNG); begin SerialPortNG.CommPort := CBPort.Items[CBPort.ItemIndex]; SerialPortNG.BaudRate := StrToIntDef(CBBaud.Items[CBBaud.ItemIndex],9600); SerialPortNG.DataBits := StrToIntDef(Copy(CBData.Items[CBData.ItemIndex],1,1),8); SerialPortNG.StopBits := CBStop.ItemIndex; SerialPortNG.ParityType := CBParity.ItemIndex; SerialPortNG.FlowControl := BasicFlowModes[CBFlow.ItemIndex]; SerialPortNG.Active := True; end; end. unit SerialNG; // DomIS Internet Solutions www.domis.de // Visit SerialNG Homepage www.domis.de/serialng.htm // This Source is distributed under the terms of Open-Source // This mean You can use this Source free for Open-Source development // Additionally I allow the use for any inhouse Projects // If You want to make a Closed-Source Project with this Source, // You have to reference Back to the Source and have to distribute the Source // Any changes should be marked and this header should remain here // Under all circumstances it is prohibited to use this source for military Products!!! // Refer the readme.txt // This is Version 2 of the Basic Communication Component // I’ve made a complete redesign of the whole Component // So the Component is incompatible with the Version 1 // News: // Using Overlapped features for Windows Platform Compatiblity // Using CommEvents for state detection // More (and more meaningfull) Events // Sending will not block the main Program // Support the development of SerialNG with a donation. Any amount will be welcome // You may transmit the Money to my Bank-Account // Kto. 654130-604, Postbank Frankfurt/M, BLZ 500 100 60, Kennwort SerialNG // for International transmission, use the IBAN Code // IBAN DE 56 5001 0060 0654 1306 04 // You may also use Paypal if You like // Link for EURO transmission // https://www.paypal.com/xclick/business=paypal%40domis.de&item_name=Support+SerialNG+Development&item_number=SerialNG-EUR&tax=0¤cy_code=EUR // Link for USD transmission // https://www.paypal.com/xclick/business=paypal%40domis.de&item_name=Support+SerialNG+Development&item_number=SerialNG-USD&tax=0¤cy_code=USD // Thank You for using and supporting SerialNG! // Installation // You have to register this component with the Delphi funktion «Component/Install Component» // create a new component library and add this component // the TSerialNG component appears in the «Samples» part of the component toolbar // See domis.de/serialnginst.htm // Usage // Please take a look to the Demofiles. // Start with SerialNGBasicDemo.dpr, this contains a very simple approach to the component // The Base of the Version 1.X of this unit is taken from «TSerialPort: Basic Serial Communications in Delphi» // created by Jason «Wedge» Perry, but I could not find him again // PC serial port Pins are as follows // Name Dir 9Pin 25Pin // DCD In 1 8 // RXD In 2 3 // TXD Out 3 2 // DTR Out 4 20 // GND — 5 7 // DSR In 6 6 // RTS Out 7 4 // CTS In 8 5 // RI In 9 22 // Dir means the direction from the ports view (e.g. DCD is an input, You can read this port) // Version History // All Version are available at www.domis.de/serialng.htm // 2.0.0 28. Aug 2001, Basic stable Version // 2.0.1 30. Aug 2001, Fixing Thread stoperror in PortWord // 2.0.2 17. Sep 2001, Deleting double declared Property Error, use instead CommError // Changed declaration of procedure GetCommNames(CommNames: TStrings); // prevent duplicate Entries in this function // 2.0.3 9. Nov 2001, Changed Cardinal type to DWORD in TWorkThread.Execute for // Delphi 3 backcompatibility // 2.0.4 28. Nov 2001, Problem in not Active Mode fixed ( // sleep(200) prevent consuming 100% of cpu-time in inactive mode) // 2.0.5 8. Jan 2002, Problem in GetDataAsPChar fixed ( // The pending Zero was not patched in the right place) // 2.0.6 4. Apr 2002, Changed *all* Cardinal type to DWORD and made several Changes in // Demo Forms for Delphi 3 backcompatibility // 2.0.7 16. Apr 2002, Found and fixed the norty Error which occours sometimes after // the Termination of the Threads (the Overlapped Result wrote into undefined Memory) // The Thread waits now until everything Pending Overlapped is done // 2.0.8 13. Mai 2002, Correct Error with the default timing settings (Thanks to Hynek Cernoch) // 2.0.9 27. Mai 2002, Patched an “\\.\” in front of Comportname to allow connection to virtual Comports // 2.0.10 27. Aug 2002, Function for finding the CommPorts in the Registry created and placed in // Unit CommPortList. The CheckOS function is moved into theis Unit too. // 2.0.11 6. Sep 2002, Again or Finally? Found and fixed the norty Error which occours sometimes after // the Termination of the Threads (the Overlapped Result wrote into undefined Memory) // Now the WaitCommEvent Overlapped is manually Terminated, by Setting (!) the hEvent manually // Some minor cleanups in Destroy and PortWork. It seem (!) to run now! // 2.0.12 10. Sep 2002, Again! Small, but significant Error in PortWork. Closing the Handles to the Overlapped // Records should not be there — fixed and running. Thanks to Jens G�hring // 2.0.13 25. Sep 2002, Fixed a Problem for multi instancing, e.g. running two or more SerialNGPorts at the same time // The Names of the Overlapped Events are allway the same, so the second Port used the event from // the previous instanced Port instead creating a new event // 2.0.14 1. Okt 2002, Made a more robust solution for creating the Eventnames. There is now a 1:200000 chance that // the program can not create a Eventname. This occours only on Multiport installation. // The 1:200000 chance is a compromise between hangup the program in an endless loop and returning an Error. // 2.0.15 17. Okt 2002, A Ssmall change in the ReadSettings from Registry Procedure suggested by Ron Hoving // After reading the Settings they are used now instantly // 2.0.16 14. Nov 2002, Patched an suggestion from Krystian (Poland) // The Linestates CTS, DSR and RLSD are now updated, even if no Event is assigned // 2.0.17 25. Mrz 2003 GetStatus is now (and must!) called prior to DoCommEvent, to ensure the actual state is used // Prozesserror gives the Self pointer (instead the wrong Owner pointer) // The silly Eventname stuff removed // 2.0.18 24. Jun 2003 Changes on the RI behaviour: // The RI Linestate is now updated at the same place as CTS,DSR and RLSD and valid in the OnCommEvent // The RI Event is now on Win9x/mE simulated as NT/2K/XP does, on the falling RI edge only!!! // Thus the OnRingEvent is called *only* on the falling edge of the signal // Additionally a new OnRIEvent has been inserted. This Event is manually generated if a // change in the RI Signal has been detected. // If Your Program should show a ‘RING’… ‘RING’ because a Modem is attached use the OnRingEvent // If Your Program will track the RI Pin State use the OnRIEvent // 2.0.19 07. Okt 2003 New Parameterlist fpr processerror, reinstall of component neccessary // 2.0.20 15. Okt 2003 Fixing a Thread error: StartTime was uninitilized in the case of receiving Chars between // the opening of the Port and the first ‘ReadNoWait’. // Probably this Error will occour only in Debugsessions // 2.0.21 01. Dec 2003 Made some changes for (more) compatibility to francois piette’s ICS. // If in a ‘OnDataAvailable’ Event of the TWSocket the SerialNG Thread calls ‘Synchronize’ // the Thread is locked, and the ‘SendInProgress’ Flag will never become reset. // This behaviour results (probably) in the WndProc work of ICS. // I made a work around: A new Property ‘ThreadQuiteMode’ is now integrated. // If this Flag become True the Thread will not call synchronize. // Be careful with this Flag, since You receive no messages, you may been misleaded. // You have to Poll incoming data by Yourself. // 2.0.22 13. Jan 2004 Fixed an Error in QuieteMode using Enter and LeaveCriticalSection. This is made // to add and remove the Data securily without the need of Threadsynchronize // 2.0.23 13. Mrz 2004 Found and fixed a Problem under fast (2.4GHz) Win2K and XP Computers: // Windows seems to send the EventCharEvent before the received Chars are moved into // the WindowsQueue. So the CommStatus.cbInQue contains an invalid char amount // I now call the ClearCommError at least twice until no changes in the results // 2.0.24 16. Nov 2004 Fixed a Problem occours under Win2K: wrong result out of GetOverlappedResult // Thanks to Phil Young (62Nds), and ThomasD // I am working on a Multiport-Single-Thread version, this will cause some incompatiblities to the current version // This will become Version 2.1.0 interface {$BOOLEVAL OFF} uses Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs; // Definitions for the DCB found in windows.pas for reference only // All of the baud rates that the DCB supports. const BaudRateCount = 15; BaudRates: array[0..BaudRateCount-1] of DWord = (CBR_110, CBR_300, CBR_600, CBR_1200, CBR_2400, CBR_4800, CBR_9600, CBR_14400, CBR_19200, CBR_38400, CBR_56000, CBR_57600, CBR_115200, CBR_128000, CBR_256000); // The business with the TimeOuts during sending Data, and esspeccialy during // reception of Data depends on the selected Baudrate. // while on 9600 Baud every 1ms a Char is received, is this time on 256KBaud only 4�s // Strange enough, windows support only 1ms as shortest Intervall! // Below some standard TimeOuts for the given Baudrates in �s XTOCharDelayDef: array [0..BaudRateCount-1] of DWord = (100000, 37000, 18000, 9000, 4500, 2300, 1100, 760, 570, 290, 200, 190, 95, 85, 43); // Parity types for parity error checking // NOPARITY = 0; ODDPARITY = 1; EVENPARITY = 2; MARKPARITY = 3; SPACEPARITY = 4; // Stopbits // ONESTOPBIT = 0; ONE5STOPBITS = 1; TWOSTOPBITS = 2; // Bitmasks for the «Flags» Field of the DCB record const bmfBinary = $0001; // binary mode, no EOF check bmfParity = $0002; // enable parity checking bmfOutxCtsFlow = $0004; // CTS output flow control bmfOutxDsrFlow = $0008; // DSR output flow control // DTR Control Flow Values DTR_CONTROL_DISABLE = 0; DTR_CONTROL_ENABLE = 1; DTR_CONTROL_HANDSHAKE = 2; bmfDtrControlEnable = $0010; // DTR Enable bmfDtrControlHandshake = $0020; // DTR Handshake bmfDsrSensitivity = $0040; // DSR sensitivity bmfTXContinueOnXoff = $0080; // XOFF continues Tx bmfOutX = $0100; // XON/XOFF out flow control bmfInX = $0200; // XON/XOFF in flow control bmfErrorChar = $0400; // enable error replacement bmfNull = $0800; // enable null stripping // RTS Control Flow Values RTS_CONTROL_DISABLE = 0; RTS_CONTROL_ENABLE = 1; RTS_CONTROL_HANDSHAKE = 2; RTS_CONTROL_TOGGLE = 3; bmfRtsControlEnable = $1000; // RTS Enable bmfRtsControlHandshake = $2000; // RTS Enable bmfRtsControlToggle = $3000; // RTS Enable bmfAbortOnError = $4000; // abort reads/writes on error // Basic FlowControlModes // You may declare more _exotic_ Modes, like Sending RTS/CTS, receiving XOn/XOff 🙂 const fcNone = 0; fcXON_XOFF = bmfOutX or bmfInX or bmfTXContinueOnXoff; fcRTS_CTS = bmfOutxCtsFlow or bmfRtsControlHandshake; fcDSR_DTR = bmfOutxDsrFlow or bmfDtrControlHandshake; fcClearFlowCtrl = Not (fcXON_XOFF or fcRTS_CTS or fcDSR_DTR or bmfDtrControlEnable or bmfRtsControlEnable); const BasicFlowModes: array[0..3] of Word = (fcNone, fcXON_XOFF, fcRTS_CTS, fcDSR_DTR); // Constants for using in the ErrorNoise Property // I tried to catch Errors, send Warnings or sometimes Messages for Your convinience. // If You set the ErrorNoise Property to one of the Values this kind of Messages will be reported // while those with higher Numbers not const enError = 0; // Errors like unable to Open Port enWarning = 1; // Warnings like cant pause Thread enMsg = 2; // Messages like starting with Port opening enDebug = 3; // Debughelpermessage like im am here or there enAll = 255; // Show all const // Set some constant defaults. // These are the equivalent of COM2:9600,N,8,1; dflt_CommPort = ‘COM2’; dflt_BaudRate = CBR_9600; dflt_ParityType = NOPARITY; dflt_ParityErrorChar = #0; dflt_ParityErrorReplacement = False; dflt_StopBits = ONESTOPBIT; dflt_DataBits = 8; dflt_XONChar = #$11; {ASCII 11h} dflt_XOFFChar = #$13; {ASCII 13h} dflt_XONLimDiv = 33; // Set the XONLimit to dflt_XONLimDiv/100*RxQueueSize dflt_XOFFLimDiv = 33; // Set the XONLimit to dflt_XONLimDiv/100*RxQueueSize dflt_FlowControl = fcNone; dflt_StripNullChars = False; dflt_BinaryMode = True; dflt_EventChar = #0; // Timeout defaults, fits only to 9600 Baud! // Look that CharDelay is in micro, ExtraDely in milli Seconds! dflt_RTOCharDelayTime = 1100; // 1100microsec (1100E-06 secs) dflt_RTOExtraDelayTime = 250; // 250msec ( 250E-03 secs) dflt_WTOCharDelayTime = 1100; // 1100microsec (1100E-06 secs) dflt_WTOExtraDelayTime = 250; // 1000msec ( 250E-03 secs) dflt_XTOAuto = True; // lets the Component adjust CharDelay timing on every Baudrate change dflt_ClusterSize = 3072; //Max Clustersize dflt_RTSState = True; dflt_DTRState = True; dflt_ErrorNoise = enMsg; dflt_BREAKState = False; dflt_RxQueueSize = 4096; dflt_TxQueueSize = 4096; dflt_ThreadQuietMode = False; dflt_AutoReadRequest = False; type // Special Event function for the Error and Warning TNotifyErrorEvent = procedure(Sender: TObject;Place, Code: DWord; Msg: String; Noise: Byte) of object; // TSerialCluster is a Object for the Receiving Process. // If You just want to receive some Data, don’t care // Under normal circumstances You have not to deal with this Object // I decided to realize the receiving Process as follow: // Between two cycles in the WorkThread may the SerialPort receive more than one Character. // Basicly those Chars are named «Cluster» (and not «Telegram», as You might expect) // How many Chars are stored in one TSerialCluster depeds on, User controlled, Conditions // 1. the ClusterSize is reched // 2. the Receivingtime is reached // 3. an (Line-) Error occoured // 4. The Program set the «ReadRequest» Property to «True» // If the condition is met, the received Chars are Stored as a Cluster into the ClusterList PSerialCluster = ^TSerialCluster; TSerialCluster = class (TObject) private ClusterData: Pointer; // Pointer to Data ClusterSize: Integer; // How many Bytes in Datafield ClusterCCError: DWord; // This Value comes from the ClearCommError function and is a Bitfield // CE_RXOVER = 1; { Receive Queue overflow } // CE_OVERRUN = 2; { Receive Overrun Error } // CE_RXPARITY = 4; { Receive Parity Error } // CE_FRAME = 8; { Receive Framing error } // CE_BREAK = $10; { Break Detected } // CE_TXFULL = $100; { TX Queue is full } // CE_MODE = $8000; { Requested mode unsupported } public constructor Create(Data: Pointer; Size: Integer; CCError: DWord); function GetCCError: DWord; function GetSize: Integer; procedure GetData(Dest: Pointer); function GetDataAsString: String; function GetDataAsPChar(Dest: PChar): PChar; destructor Destroy; override; end; // TSerialPortNG is the Heart of the Job, everything what has to do with the // SerialPort should be done with this Component // The Concept is as follows: // After instancing the Port is still closed // You should set the Property «CommPort» to the full Name of the Port e.g. ‘COM1’ // After this set the «Active» Property to «True» // Sending Data ist performed with the SendData or the SendString procedures // since Sendig is «Overlapped» the procedures returns immidiatly and You can do // some other Jobs in Your main Programm // You should not reentry this Procedures until they done there Job (Will give a warning). // If send is done the component call the «OnWriteDone» Event. // You also can ask the «SendInProgress» Property. // Reading Data is fairly simple, just Read the Data with one of the «ReadNextCluster…» functions // You place the read Access into the «OnRxClusterEvent». // See sample Programs for more Information TSerialPortNG = class(TComponent) private // Variables holding Values for Properties fCommPort: ShortString; fBaudRate: DWord; fParityType: Byte; fParityErrorChar: Char; fParityErrorReplacement: Boolean; fStopBits: Byte; fDataBits: Byte; fXONChar: Char; fXOFFChar: Char; fXONLimDiv: Byte; // 0..100 fXOFFLimDiv: Byte; // 0..100 fFlowControl: LongInt; fStripNullChars: Boolean; // Strip null chars? fEventChar: Char; fErrorNoise: Byte; // These fields are set in the EventThread fCommStateFlags: TComStateFlags; fCommStateInQueue: DWord; fCommStateOutQueue: DWord; fCommError: DWord; fCommEvent: DWord; fModemState: DWord; // TimeOut definitions fRTOCharDelayTime: DWord; // in �s max: 4.294.967.295�s aprox 1h 20min fRTOExtraDelayTime: Word; // in ms fWTOCharDelayTime: DWord; // in �s fWTOExtraDelayTime: Word; // in ms fXTOAuto: Boolean; fActive: Boolean; fRTSState: Boolean; fDTRState: Boolean; fBREAKState: Boolean; fCTSState: Boolean; fDSRState: Boolean; fRLSDState: Boolean; fRingState: Boolean; fClusterSize: Word; fRxQueueSize: Word; fTxQueueSize: Word; fReadRequest: Boolean; // Force Thread to Read the Queue fSendInProgress: Boolean; fWrittenBytes: DWord; fThreadQuietMode: Boolean; fAutoReadRequest: Boolean; // Eventvariables fOnTxQueueEmptyEvent: TNotifyEvent; fOnCommEvent: TNotifyEvent; fOnCommStat: TNotifyEvent; fOnBreakEvent: TNotifyEvent; fOnCTSEvent: TNotifyEvent; fOnDSREvent: TNotifyEvent; fOnLineErrorEvent: TNotifyEvent; fOnRingEvent: TNotifyEvent; fOnRIEvent: TNotifyEvent; fOnRLSDEvent: TNotifyEvent; fOnRxClusterEvent: TNotifyEvent; fOnRxCharEvent: TNotifyEvent; fOnRxEventCharEvent: TNotifyEvent; fOnWriteDone: TNotifyEvent; fOnProcessError: TNotifyErrorEvent; hCommPort: THandle; // Handle to the port. WriteOverlapped: TOverlapped; //Overlapped field for Write ReadOverlapped: TOverlapped; //Overlapped field for Read StatusOverlapped: TOverlapped; //Overlapped field for Status BytesToWrite: DWord; WriteStartTime: DWord; WorkThread: TThread; WorkThreadIsRunning: Boolean; WorkThreadIsTerminated: Boolean; ShutdownInProgress: Boolean; RxDClusterList: TList; LastErr: Integer; Platform: Integer; // 0 Win32s on Win3.11, 1 Win 9x, 2 WinNT CriticalSection: TRTLCriticalSection; // Procedures for setting the variables, refrenced in the Properties procedure SetCommPort(value: ShortString); procedure SetBaudRate(value: DWord); procedure SetParityType(value: Byte); procedure SetParityErrorChar(value: Char); procedure SetParityErrorReplacement(value: Boolean); procedure SetStopBits(value: Byte); procedure SetDataBits(value: Byte); procedure SetXONChar(value: Char); procedure SetXOFFChar(value: Char); procedure SetXONLimDiv(value: Byte); procedure SetXOFFLimDiv(value: Byte); procedure SetFlowControl(value: LongInt); procedure SetStripNullChars(value: Boolean); procedure SetEventChar(value: Char); procedure SetRTOCharDelayTime(value: DWord); procedure SetRTOExtraDelayTime(value: Word); procedure SetWTOCharDelayTime(value: DWord); procedure SetWTOExtraDelayTime(value: Word); procedure SetXTOAuto(value: Boolean); procedure SetClusterSize(value: Word); procedure SetRxQueueSize(value: Word); procedure SetTxQueueSize(value: Word); procedure SetErrorNoise(value: Byte); procedure SetSignalRTS(State: Boolean); procedure SetSignalDTR(State: Boolean); procedure SetSignalBREAK(State: Boolean); procedure SetReadRequest(value: Boolean); procedure SetActive(NewState: Boolean); // Rest of Procedures procedure InitOverlapped(var Overlapped: TOverlapped); procedure ResetOverlapped(var Overlapped: TOverlapped); procedure SetOverlapped(var Overlapped: TOverlapped); procedure SetupDCB; procedure PortWork (ReOpen: Boolean); //If ReOpen is True the Port will be (Re-) Opened, otherwise closed. The ActiveFlag will bes Set! procedure EnableEvents; procedure ProcessError(Place, Code: DWord; Msg: String; Noise: Byte); procedure WorkThreadDone(Sender: TObject); procedure WaitForThreadNotRunning(Counter: Integer); protected public // Procedures for external calling constructor Create(AOwner: TComponent); override; //Create the Component destructor Destroy; override; //Destroy procedure SendData (Data: Pointer; Size: DWord); //Send binary Data procedure SendString(S: String); //Send String Data // Clusterfunctions works on received Datapackages function NextClusterSize: Integer; function NextClusterCCError: DWord; function ReadNextCluster(var ClusterSize: Integer; var CCError: DWord): Pointer; function ReadNextClusterAsString: String; function ReadNextClusterAsPChar(Dest: PChar): PChar; // Clears the Queues procedure ClearTxDQueue; procedure ClearRxDQueue; // Sets the Timingfields in depedecy to the Baudrate procedure XTODefault; // Save and retrieves the Setting to/from the registry procedure WriteSettings(Regkey, RegSubKey: String); // e.g. WriteSettings(‘Software/DomIS’,’SerialNGAdvDemo’) will save to HKEY_CURRENT_USER\Software\DomIS\SerialAdvDemo procedure ReadSettings(Regkey, RegSubKey: String); published //If You set Active to True, the component tries to Open the Port, if Opened the state remains True. property Active: Boolean read FActive write SetActive default False; property ComHandle: THandle read hCommPort default INVALID_HANDLE_VALUE; property CommPort: ShortString read fCommPort write SetCommPort; property BaudRate: DWord read fBaudRate write SetBaudRate default dflt_BaudRate; property ParityType: Byte read fParityType write SetParityType default dflt_ParityType; property ParityErrorChar: Char read fParityErrorChar write SetParityErrorChar default dflt_ParityErrorChar; property ParityErrorReplacement: Boolean read fParityErrorReplacement write SetParityErrorReplacement default dflt_ParityErrorReplacement; property StopBits: Byte read fStopBits write SetStopBits default dflt_StopBits; property DataBits: Byte read fDataBits write SetDataBits default dflt_DataBits; property XONChar: Char read fXONChar write SetXONChar default dflt_XONChar; property XOFFChar: Char read fXOFFChar write SetXOFFChar default dflt_XOFFChar; property XONLimDiv: Byte read fXONLimDiv write SetXONLimDiv default dflt_XOnLimDiv; property XOFFLimDiv: Byte read fXOFFLimDiv write SetXOFFLimDiv default dflt_XOffLimDiv; property FlowControl: LongInt read fFlowControl write SetFlowControl default dflt_FlowControl; property StripNullChars: Boolean read fStripNullChars write SetStripNullChars default dflt_StripNullChars; property EventChar: Char read fEventChar write SetEventChar default dflt_EventChar; // One part of the Clusterdefinition is here, please read carefully // The «RTOCharDelayTime» is the Time that may delay between two received Chars // This Time should be Computed depending from the Baudrate e.g. 9600 Baud -> 960 Chars per Second -> Delay 1ms // You can use the CharDelayDefault Procedure to set RTOCharDelayTime and WTOCharDelayTime depending // of the selected Baudrate! property RTOCharDelayTime: DWord read fRTOCharDelayTime write SetRTOCharDelayTime default dflt_RTOCharDelayTime; // The «RTOExtraDelayTime» is the Time that may delay addionally once // So if the (CharCount*RTOCharDelayTime)/1000 + RTOExtraDelayTime extends the measured Time, a Cluster will be build property RTOExtraDelayTime: Word read fRTOExtraDelayTime write SetRTOExtraDelayTime default dflt_RTOExtraDelayTime; // Clustersize specify how long one Cluster could become max property ClusterSize: Word read fClusterSize write SetClusterSize default dflt_ClusterSize; // RxQueueSize specify the amount of Chars that could be received without reading, // this should be longer than the Cluster size to prevent overrun errors property RxQueueSize: Word read fRxQueueSize write SetRxQueueSize default dflt_RxQueueSize; property TxQueueSize: Word read fTxQueueSize write SetTxQueueSize default dflt_TxQueueSize; property WTOCharDelayTime: DWord read fWTOCharDelayTime write SetWTOCharDelayTime default dflt_WTOCharDelayTime; property WTOExtraDelayTime: Word read fWTOExtraDelayTime write SetWTOExtraDelayTime default dflt_WTOExtraDelayTime; property XTOAuto: Boolean read fXTOAuto write SetXTOAuto default dflt_XTOAuto; property RTSState: Boolean read fRTSState write SetSignalRTS default dflt_RTSState; property DTRState: Boolean read fDTRState write SetSignalDTR default dflt_DTRState; property BREAKState: Boolean read fBREAKState write SetSignalBREAK default dflt_BreakState; property CTSState: Boolean read fCTSState; property DSRState: Boolean read fDSRSTate; property RLSDState: Boolean read fRLSDState; property RingState: Boolean read fRingState; property ErrorNoise: Byte read fErrorNoise write SetErrorNoise default dflt_ErrorNoise; property ReadRequest: Boolean read fReadRequest write SetReadRequest default False; property SendInProgress: Boolean read fSendInProgress; property CommError: DWord read fCommError; property CommStateFlags: TComStateFlags read fCommStateFlags; property CommStateInQueue: DWord read fCommStateInQueue; property CommStateOutQueue: DWord read fCommStateOutQueue; property ModemState: DWord read fModemState; property CommEvent: DWord read fCommEvent; property WrittenBytes: DWord read fWrittenBytes; property ThreadQuietMode: Boolean read fThreadQuietMode write fThreadQuietMode default dflt_ThreadQuietMode; //THIS FLAG SHOULD BE SET TO TRUE ONLY IN VERY SPECIAL CASES!!! No Syncromize call in the Thread if True. property AutoReadRequest: Boolean read fAutoReadRequest write fAutoReadRequest default dflt_AutoReadRequest; // Event Properties property OnCommEvent: TNotifyEvent read fOnCommEvent write fOnCommEvent; property OnCommStat: TNotifyEvent read fOnCommStat write fOnCommStat; property OnTxQueueEmptyEvent: TNotifyEvent read fOnTxQueueEmptyEvent write fOnTxQueueEmptyEvent; property OnWriteDone: TNotifyEvent read fOnWriteDone write fOnWriteDone; property OnBreakEvent: TNotifyEvent read fOnBreakEvent write fOnBreakEvent; property OnCTSEvent: TNotifyEvent read fOnCTSEvent write fOnCTSEvent; property OnDSREvent: TNotifyEvent read fOnDSREvent write fOnDSREvent; property OnLineErrorEvent: TNotifyEvent read fOnLineErrorEvent write fOnLineErrorEvent; property OnRingEvent: TNotifyEvent read fOnRingEvent write fOnRingEvent; // RING, RING on falling edge of the RI Pin property OnRIEvent: TNotifyEvent read fOnRIEvent write fOnRIEvent; // on every change of the RI Pin property OnRLSDEvent: TNotifyEvent read fOnRLSDEvent write fOnRLSDEvent; property OnRxClusterEvent: TNotifyEvent read fOnRxClusterEvent write fOnRxClusterEvent; property OnRxCharEvent: TNotifyEvent read fOnRxCharEvent write fOnRxCharEvent; property OnRxEventCharEvent: TNotifyEvent read fOnRxEventCharEvent write fOnRxEventCharEvent; property OnProcessError: TNotifyErrorEvent read fOnProcessError write fOnProcessError; end; // The TWorkThread class deals with several CommEvents and controll the receiving // of Clusters and check the Sendprocess // Under normal cirumstances You don’t have to deal with TWorkThread = class(TThread) private Owner: TSerialPortNG; Place, Code: DWord; Msg: String; Noise: Byte; Cluster: TSerialCluster; procedure ThreadSynchronize(Method: TThreadMethod); procedure SetProcessError(APlace, ACode: DWord; AMsg: String; ANoise: Byte); procedure ProcessError; procedure RxClusterEvent; procedure CommEvent; procedure CommStatEvent; procedure BreakEvent; procedure CTSEvent; procedure DSREvent; procedure LineErrorEvent; procedure RingEvent; procedure RIEvent; procedure RLSDEvent; procedure RxCharEvent; procedure RxEventCharEvent; procedure TxQueueEmptyEvent; procedure WriteDone; protected public constructor Create(AOwner: TSerialPortNG); procedure Execute; override; end; procedure Register; implementation uses Registry, CommPortList; var VersionInfo: TOSVersionInfo; procedure Register; begin RegisterComponents(‘Samples’, [TSerialPortNG]); end; // // TSerialCluster Component // constructor TSerialCluster.Create(Data: Pointer; Size: Integer; CCError: DWord); begin inherited Create; ClusterData := Data; // Take the Pointer ClusterSize := Size; // Size of Data ClusterCCError := CCError; end; function TSerialCluster.GetCCError: DWord; begin GetCCError := ClusterCCError; end; function TSerialCluster.GetSize: Integer; begin GetSize := ClusterSize; end; procedure TSerialCluster.GetData(Dest: Pointer); begin if Dest Nil then Move(ClusterData^, Dest^, ClusterSize); end; function TSerialCluster.GetDataAsString: String; var S: String; begin SetLength(S,ClusterSize); Move(ClusterData^, S[1], ClusterSize); GetDataAsString := S; end; function TSerialCluster.GetDataAsPChar(Dest: PChar): PChar; type TMaxSize = array[0..MaxLongInt-1] of Char; PMaxSize = ^TMaxSize; begin if Dest Nil then begin Move(ClusterData^, Dest^, ClusterSize); PMaxSize(Dest)^[ClusterSize] := #0; end; GetDataAsPChar := Dest; end; destructor TSerialCluster.Destroy; begin Dispose(ClusterData); inherited Destroy; end; // // TSerialPortNG Component definition // // // Serveral «Set…» procedure for the Property mapping procedure TSerialPortNG.SetCommPort(value: ShortString); begin if value fCommPort then begin fCommPort := value; PortWork(fActive); end; end; procedure TSerialPortNG.SetBaudRate(value: DWord); begin if value fBaudRate then begin fBaudRate := value; if fXTOAuto then XTODefault; // Adjust the CharDelay Timeouts if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetParityType(value: Byte); begin if value fParityType then begin fParityType := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetParityErrorChar(value: Char); begin if value fParityErrorChar then begin fParityErrorChar := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetParityErrorReplacement(value: Boolean); begin if value fParityErrorReplacement then begin fParityErrorReplacement := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetStopBits(value: Byte); begin if value fStopBits then begin fStopBits := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetDataBits(value: Byte); begin if value fDataBits then begin fDataBits := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetXONChar(value: Char); begin if value fXONChar then begin fXONChar := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetXOFFChar(value: Char); begin if value fXOFFChar then begin fXOFFChar := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetXONLimDiv(value: Byte); begin if value fXONLimDiv then begin if value > 100 then begin ProcessError(0100,value,’Warning XOnLimDef set to 100′,enWarning); value := 100; end; fXONLimDiv := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetXOFFLimDiv(value: Byte); begin if value fXOFFLimDiv then begin if value > 100 then begin ProcessError(0100,value,’Warning XOffLimDef set to 100′,enWarning); value := 100; end; fXOFFLimDiv := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetFlowControl(value: LongInt); begin if value fFlowControl then begin fFlowControl := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetStripNullChars(value: Boolean); begin if value fStripNullChars then begin fStripNullChars := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetEventChar(value: Char); begin if value fEventChar then begin fEventChar := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetRTOCharDelayTime(value: DWord); begin if value fRTOCharDelayTime then fRTOCharDelayTime := value; end; procedure TSerialPortNG.SetRTOExtraDelayTime(value: Word); begin if value fRTOExtraDelayTime then fRTOExtraDelayTime := value; end; procedure TSerialPortNG.SetWTOCharDelayTime(value: DWord); begin if value fWTOCharDelayTime then begin fWTOCharDelayTime := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetWTOExtraDelayTime(value: Word); begin if value fWTOExtraDelayTime then begin fWTOExtraDelayTime := value; if fActive then SetupDCB; end; end; procedure TSerialPortNG.SetXTOAuto(value: Boolean); begin if value fXTOAuto then begin fXTOAuto := value; if fXTOAuto then XTODefault; end; end; procedure TSerialPortNG.SetClusterSize(value: Word); begin fClusterSize := value; end; procedure TSerialPortNG.SetRxQueueSize(value: Word); begin if value fRxQueueSize then begin fRxQueueSize := value; if not SetupComm(hCommPort,fRxQueueSize,fTxQueueSize) then ProcessError(0101,GetLastError,’Error can not set Quesize’,enError); end; end; procedure TSerialPortNG.SetTxQueueSize(value: Word); begin if value fTxQueueSize then begin fTxQueueSize := value; if not SetupComm(hCommPort,fRxQueueSize,fTxQueueSize) then ProcessError(0102,GetLastError,’Error can not set Quesize’,enError); end; end; procedure TSerialPortNG.SetErrorNoise(value: Byte); begin fErrorNoise := value; end; procedure TSerialPortNG.SetReadRequest(value: Boolean); begin fReadRequest := value; end; procedure TSerialPortNG.SetActive(NewState: Boolean); begin // You may expect that this function set only the fActive Value // This is done by the PortWork procedure, depending from the successful // opened Port if NewState fActive then PortWork(NewState); end; // // Several Methods procedure TSerialPortNG.ProcessError(Place, Code: DWord; Msg: String; Noise: Byte); begin if ShutdownInProgress then Exit; // No Messages now the Component is in Destroystate if Noise Nil then begin TSerialCluster(RxDClusterList.Items[i]).Free; RxDClusterList.Items[i] := Nil; end; end; RxDClusterList.Free; WorkThread.Free; DeleteCriticalSection(CriticalSection); inherited Destroy; end; // PortWork Closes or Opens the Port depending of the Parm // It sets the fActive Variable depending of result of Opening the Port procedure TSerialPortNG.PortWork(ReOpen: Boolean); var CommPortName: array [0..127] of Char; begin if fActive then // The Port is Open, Close first begin ProcessError(0100,0,’Msg start deactivating Port’,enMsg); if not SetCommMask(hCommPort,0) then ProcessError(0101,GetLastError,’Error disabling CommEvents’,enError); fActive := False; // The WorkThread check this Flag if not PurgeComm(hCommPort, PURGE_RXABORT or PURGE_RXCLEAR or PURGE_TXABORT or PURGE_TXCLEAR) then ProcessError(0102,GetLastError,’Error clearing Queues’,enError); WaitForThreadNotRunning(15); if WorkThreadIsRunning then ProcessError(0104,0,’Warning ThreadIsRunning’,enWarning); SetSignalDTR(False); SetSignalRTS(False); if not CloseHandle(hCommPort) then ProcessError(0103,GetLastError,’Error closing Port’,enError); hCommPort := INVALID_HANDLE_VALUE; end; // The Port is Closed, the Thread is Idle if ReOpen then begin // Reopen the Port with (new) Parms ProcessError(0110,0,’Msg start reactivating Port’,enMsg); hCommPort := CreateFile(StrPCopy(CommPortName,’\\.\’+Copy(fCommPort,1,79)), GENERIC_READ OR GENERIC_WRITE, 0, nil, OPEN_EXISTING, FILE_FLAG_OVERLAPPED,0); fActive := (hCommPort INVALID_HANDLE_VALUE); if fActive then begin if not SetupComm(hCommPort,fRxQueueSize,fTxQueueSize) then ProcessError(0111,GetLastError,’Error setup Queuesize’,enError); SetupDCB; SetSignalDTR(dflt_DTRState); SetSignalRTS(dflt_RTSState); EnableEvents; end else ProcessError(0112,GetLastError,’Error reopening Port’,enError); end; end; // Internal method to enable all Events procedure TSerialPortNG.EnableEvents; begin if not SetCommMask(hCommPort, EV_BREAK or EV_CTS or EV_DSR or EV_ERR or EV_RING or EV_RLSD or EV_RXCHAR or EV_RXFLAG or EV_TXEMPTY) then ProcessError(0201,GetLastError,’Error activating CommEventMask’,enError); end; // Public method to cancel and flush the receive buffer. procedure TSerialPortNG.ClearRxDQueue; begin if fActive then if not PurgeComm(hCommPort, PURGE_RXABORT or PURGE_RXCLEAR) then ProcessError(0301,GetLastError,’Error clearing RxD Queue’,enError); end; // Public method to cancel and flush the transmit buffer. procedure TSerialPortNG.ClearTxDQueue; begin if fActive then if not PurgeComm(hCommPort, PURGE_TXABORT or PURGE_TXCLEAR) then ProcessError(0401,GetLastError,’Error clearing TxD Queue’,enError); end; // Public method to Play with the RTS Line // It is an Error to work on this Line while in the Flowmode bmfOutxCtsFlow is set! procedure TSerialPortNG.SetSignalRTS(State: Boolean); begin if fActive then begin if State then begin if not EscapeCommFunction(hCommPort,SETRTS) then ProcessError(0501,GetLastError,’Error setting RTS’,enError) end else begin if not EscapeCommFunction(hCommPort,CLRRTS) then ProcessError(0502,GetLastError,’Error clearing RTS’,enError) end; fRTSState := State; end; end; // Public method to Play with the DTR Line // It is an Error to work on this Line while in the Flowmode bmfOutxDtrFlow is set! procedure TSerialPortNG.SetSignalDTR(State: Boolean); begin if fActive then begin if State then begin if not EscapeCommFunction(hCommPort,SETDTR) then ProcessError(0601,GetLastError,’Error setting DTR’,enError) end else begin if not EscapeCommFunction(hCommPort,CLRDTR) then ProcessError(0602,GetLastError,’Error clearing DTR’,enError) end; fDTRState := State; end; end; // Public method to set the break State procedure TSerialPortNG.SetSignalBREAK(State: Boolean); begin if fActive then begin if State then begin if not SetCommBreak(hCommPort) then ProcessError(0701,GetLastError,’Error setting BREAK State’,enError) end else begin if not ClearCommBreak(hCommPort) then ProcessError(0702,GetLastError,’Error clearing BREAK State’,enError) end; fBREAKState := State; end; end; // Initialize the device control block. procedure TSerialPortNG.SetupDCB; var MyDCB: TDCB; MyCommTimeouts: TCommTimeouts; // SDCB: array[0..79] of Char; begin // 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. if not GetCommState(hCommPort, MyDCB) then begin ProcessError(0801,GetLastError,’Error getting DCB from CommState’,enError); Exit; end; MyDCB.BaudRate := fBaudRate; MyDCB.Flags := bmfBinary; //Must be set under Win32 if fParityType NOPARITY then // If a ParityType is selceted, set Paritybit automatic MyDCB.Flags := MyDCB.Flags or bmfParity; MyDCB.Parity := fParityType; if fParityErrorReplacement then MyDCB.Flags := MyDCB.Flags or bmfErrorChar; MyDCB.Flags := MyDCB.Flags or fFlowControl; if fStripNullChars then MyDCB.Flags := MyDCB.Flags or bmfNull; MyDCB.ErrorChar := fParityErrorChar; MyDCB.EvtChar := fEventChar; MyDCB.StopBits := fStopBits; MyDCB.ByteSize := fDataBits; MyDCB.XONChar := fXONChar; MyDCB.XOFFChar := fXOFFChar; MyDCB.XONLim := fRxQueueSize * fXONLimDiv div 100; // Send XOn if e.g fXONLimDiv = 33 -> 33% full MyDCB.XOFFLim := fRxQueueSize * fXOFFLimDiv div 100; // Send XOff if e.g fXOffLimDiv = 33 -> 100%-33%=67% Percent full MyDCB.EOFChar := #0; //Ignored under Win32 // 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); //Read Timeouts are disabled here, because they realized manually in the WorkThread MycommTimeouts.ReadIntervalTimeout := MAXDWORD; MycommTimeouts.ReadTotalTimeoutMultiplier := 0; MycommTimeouts.ReadTotalTimeoutConstant := 0; //Write Timeouts disable here MycommTimeouts.WriteTotalTimeoutMultiplier := 0; MycommTimeouts.WriteTotalTimeoutConstant := 0; if not SetCommTimeouts(hCommPort, MyCommTimeouts) then ProcessError(0802,GetLastError,’Error setting CommTimeout’,enError); if not SetCommState(hCommPort, MyDCB) then ProcessError(0802,GetLastError,’Error setting CommState, 87 indicate that Parms are incorrect’,enError); end; // Public Send data method. procedure TSerialPortNG.SendData(Data: Pointer; Size: DWord); var MyCommTimeOuts: TCommTimeOuts; begin if fSendInProgress then begin ProcessError(0901,0,’Msg, dont enter SendData while SendInProgress is set’,enMsg); Exit; end else begin GetCommTimeouts(hCommPort, MyCommTimeouts); //Read Timeouts are disabled MycommTimeouts.ReadIntervalTimeout := MAXDWORD; MycommTimeouts.ReadTotalTimeoutMultiplier := 0; MycommTimeouts.ReadTotalTimeoutConstant := 0; //Write Timeouts calculated from the settings MycommTimeouts.WriteTotalTimeoutMultiplier := 0; MycommTimeouts.WriteTotalTimeoutConstant := ((fWTOCharDelayTime*Size) div 1000) + fWTOExtraDelayTime; if not SetCommTimeouts(hCommPort, MyCommTimeouts) then ProcessError(0902,GetLastError,’Error setting CommTimeout’,enError); BytesToWrite := Size; if not WriteFile(hCommPort, Data^, Size, fWrittenBytes, @WriteOverlapped) then begin LastErr := GetLastError; if LastErr ERROR_IO_PENDING then begin ProcessError(0903,LastErr,’Error writing Data’,enError); ResetOverlapped(WriteOverlapped); fSendInProgress := False; end else begin WriteStartTime := GetTickCount; fSendInProgress := True; end; end else // Write was done immidiatly begin if Assigned(fOnWriteDone) then fOnWriteDone(Self); end; end; end; // Public SendString Method procedure TSerialPortNG.SendString(S: String); begin if Length(S) > 0 then SendData(@S[1], Length(S)); end; // Public NextClusterSize Method // Return the Number of Databytes // 0..MAXINT indicates that a Cluster is available, 0 = No Bytes, but an Error code // -1 not Cluster is available function TSerialPortNG.NextClusterSize: Integer; begin EnterCriticalSection(CriticalSection); try if RxDClusterList.Count > 0 then if RxDClusterList.Items[0] = Nil then RxDClusterList.Pack; if RxDClusterList.Count > 0 then NextClusterSize := TSerialCluster(RxDClusterList.Items[0]).GetSize else NextClusterSize := -1; finally LeaveCriticalSection(CriticalSection); end; end; // Public NextClusterCCError Method // Returns the ErrorCode of the Next Cluster // Returns MAXDWORD if no Cluster in List function TSerialPortNG.NextClusterCCError: DWord; begin EnterCriticalSection(CriticalSection); try if RxDClusterList.Count > 0 then if RxDClusterList.Items[0] = Nil then RxDClusterList.Pack; if RxDClusterList.Count > 0 then NextClusterCCError := TSerialCluster(RxDClusterList.Items[0]).GetCCError else NextClusterCCError := MAXDWORD; finally LeaveCriticalSection(CriticalSection); end; end; // Public Method to read and remove the next Cluster from the List // If no Cluster is avail the Method retuns NIL // Else, You have to deal with the Pointer, and Free him self function TSerialPortNG.ReadNextCluster(var ClusterSize: Integer; var CCError: DWord): Pointer; var DataBuffer: Pointer; begin EnterCriticalSection(CriticalSection); try if RxDClusterList.Count > 0 then if RxDClusterList.Items[0] = Nil then RxDClusterList.Pack; if RxDClusterList.Count > 0 then begin CCError := TSerialCluster(RxDClusterList.Items[0]).GetCCError; ClusterSize := TSerialCluster(RxDClusterList.Items[0]).GetSize; GetMem(DataBuffer, ClusterSize); TSerialCluster(RxDClusterList.Items[0]).GetData(DataBuffer); TSerialCluster(RxDClusterList.Items[0]).Free; RxDClusterList.Delete(0); ReadNextCluster := DataBuffer; end else begin ClusterSize := -1; CCError := MAXDWORD; ReadNextCluster := Nil; end; finally LeaveCriticalSection(CriticalSection); end; end; // Public Method to read and remove the next Cluster from the List // The Cluster is moved into a String function TSerialPortNG.ReadNextClusterAsString: String; begin EnterCriticalSection(CriticalSection); try if RxDClusterList.Count > 0 then if RxDClusterList.Items[0] = Nil then RxDClusterList.Pack; if RxDClusterList.Count > 0 then begin ReadNextClusterAsString := TSerialCluster(RxDClusterList.Items[0]).GetDataAsString; TSerialCluster(RxDClusterList.Items[0]).Free; RxDClusterList.Delete(0); end else ReadNextClusterAsString := ”; finally LeaveCriticalSection(CriticalSection); end; end; // Public Method to read and remove the next Cluster from the List // The Cluster is moved into «Dest». «Dest» should Point to enough Space to avoid // Exception Errors function TSerialPortNG.ReadNextClusterAsPChar(Dest: PChar): PChar; begin EnterCriticalSection(CriticalSection); try if Dest Nil then begin if RxDClusterList.Count > 0 then if RxDClusterList.Items[0] = Nil then RxDClusterList.Pack; if RxDClusterList.Count > 0 then begin ReadNextClusterAsPChar := TSerialCluster(RxDClusterList.Items[0]).GetDataAsPChar(Dest); TSerialCluster(RxDClusterList.Items[0]).Free; RxDClusterList.Delete(0); end else ReadNextClusterAsPChar := Nil; end else ReadNextClusterAsPChar := Nil; finally LeaveCriticalSection(CriticalSection); end; end; // Private Method procedure TSerialPortNG.WorkThreadDone(Sender: TObject); begin WorkThreadIsRunning := False; end; // Public Method to fit the TimeOut Values to the current Baudrate // If the Property XTOAuto is true this method will be called from the SetBaud method procedure TSerialPortNG.XTODefault; var i: Integer; NewXTO: DWord; begin NewXTO := 1100; for i := 0 to BaudRateCount-1 do begin if fBaudRate >= BaudRates[i] then NewXTO := XTOCharDelayDef[i]; end; SetRTOCharDelayTime(NewXTO); SetWTOCharDelayTime(NewXTO); end; // Saves all Setting into the Registry // e.g. WriteSettings(‘Software/DomIS’,’SerialNGAdvDemo’) // will save to HKEY_CURRENT_USER\Software\DomIS\SerialAdvDemo procedure TSerialPortNG.WriteSettings(Regkey, RegSubKey: String); var FIniFile: TRegIniFile; begin FIniFile := TRegIniFile.Create(RegKey); try try with FIniFile do begin WriteString(RegSubKey, ‘CommPort’, fCommPort); WriteString(RegSubKey, ‘BaudRate’, IntToStr(fBaudRate)); WriteString(RegSubKey, ‘ParityType’, IntToStr(fParityType)); WriteString(RegSubKey, ‘ParityErrorChar’, fParityErrorChar); WriteBool (RegSubKey, ‘ParityErrorReplacement’, fParityErrorReplacement); WriteString(RegSubKey, ‘StopBits’, IntToStr(fStopBits)); WriteString(RegSubKey, ‘DataBits’, IntToStr(fDataBits)); WriteString(RegSubKey, ‘XONChar’, fXONChar); WriteString(RegSubKey, ‘XOFFChar’, fXOFFChar); WriteString(RegSubKey, ‘XONLimDiv’, IntToStr(fXONLimDiv)); WriteString(RegSubKey, ‘XOFFLimDiv’, IntToStr(fXOFFLimDiv)); WriteString(RegSubKey, ‘FlowControl’, IntToStr(fFlowControl)); WriteBool (RegSubKey, ‘StripNullChars’, fStripNullChars); WriteString(RegSubKey, ‘EventChar’, fEventChar); WriteString(RegSubKey, ‘RTOCharDelayTime’, IntToStr(fRTOCharDelayTime)); WriteString(RegSubKey, ‘RTOExtraDelayTime’, IntToStr(fRTOExtraDelayTime)); WriteString(RegSubKey, ‘ClusterSize’, IntToStr(fClusterSize)); WriteString(RegSubKey, ‘RxQueueSize’, IntToStr(fRxQueueSize)); WriteString(RegSubKey, ‘TxQueueSize’, IntToStr(fTxQueueSize)); WriteString(RegSubKey, ‘WTOCharDelayTime’, IntToStr(fWTOCharDelayTime)); WriteString(RegSubKey, ‘WTOExtraDelayTime’, IntToStr(fWTOExtraDelayTime)); WriteBool (RegSubKey, ‘XTOAuto’, fXTOAuto); WriteBool (RegSubKey, ‘RTSState’, fRTSState); WriteBool (RegSubKey, ‘DTRState’, fDTRState); WriteBool (RegSubKey, ‘BREAKState’, fBREAKState); WriteString(RegSubKey, ‘ErrorNoise’, IntToStr(fErrorNoise)); WriteBool (RegSubKey, ‘Active’, FActive); ProcessError(0501,0,’Settings saved’,enMsg); end; except ProcessError(0502,0,’Error saving Settings’,enError); end; finally FIniFile.Free; end; end; // Read all Settings from the Registry // e.g. ReadSettings(‘Software/DomIS’,’SerialNGAdvDemo’) // will read from HKEY_CURRENT_USER\Software\DomIS\SerialAdvDemo procedure TSerialPortNG.ReadSettings(Regkey, RegSubKey: String); var FIniFile: TRegIniFile; Activate: Boolean; function CharFromStr(S: String):Char; begin if Length(S) > 0 then CharFromStr := S[1] else CharFromStr := #0; end; begin FIniFile := TRegIniFile.Create(RegKey); try try with FIniFile do begin Activate := ReadBool(RegSubKey, ‘Active’, False); //Read the Active Flag into a save place if Activate then // The Port should be activated // if the Port is the same as opened, the port stays open CommPort := ReadString(RegSubKey, ‘CommPort’, dflt_CommPort) else begin // The Port should be deactivated Active := False; // Deactivate fCommPort := ReadString(RegSubKey, ‘CommPort’, dflt_CommPort) //Store new name end; fBaudRate := StrToIntDef(ReadString(RegSubKey, ‘BaudRate’, ”),dflt_BaudRate); fParityType := StrToIntDef(ReadString(RegSubKey, ‘ParityType’, ”), dflt_ParityType); ParityErrorChar := CharFromStr(ReadString(RegSubKey, ‘ParityErrorChar’, dflt_ParityErrorChar)); fParityErrorReplacement := ReadBool(RegSubKey, ‘ParityErrorReplacement’, dflt_ParityErrorReplacement); fStopBits := StrToIntDef(ReadString(RegSubKey, ‘StopBits’, ”), dflt_StopBits); fDataBits := StrToIntDef(ReadString(RegSubKey, ‘DataBits’, ”), dflt_DataBits); fXONChar := CharFromStr(ReadString(RegSubKey, ‘XONChar’, dflt_XONChar)); fXOFFChar := CharFromStr(ReadString(RegSubKey, ‘XOFFChar’, dflt_XOFFChar)); fXONLimDiv := StrToIntDef(ReadString(RegSubKey, ‘XONLimDiv’,”), dflt_XONLimDiv); fXOFFLimDiv := StrToIntDef(ReadString(RegSubKey, ‘XOFFLimDiv’,”), dflt_XOFFLimDiv); fFlowControl := StrToIntDef(ReadString(RegSubKey, ‘FlowControl’,”), dflt_FlowControl); fStripNullChars := ReadBool(RegSubKey, ‘StripNullChars’, dflt_StripNullChars); fEventChar := CharFromStr(ReadString(RegSubKey, ‘EventChar’, dflt_EventChar)); fRTOCharDelayTime := StrToIntDef(ReadString(RegSubKey, ‘RTOCharDelayTime’,”), dflt_RTOCharDelayTime); fRTOExtraDelayTime := StrToIntDef(ReadString(RegSubKey, ‘RTOExtraDelayTime’,”), dflt_RTOExtraDelayTime); fClusterSize := StrToIntDef(ReadString(RegSubKey, ‘ClusterSize’,”), dflt_ClusterSize); fRxQueueSize := StrToIntDef(ReadString(RegSubKey, ‘RxQueueSize’,”), dflt_RxQueueSize); fTxQueueSize := StrToIntDef(ReadString(RegSubKey, ‘TxQueueSize’,”), dflt_TxQueueSize); fWTOCharDelayTime := StrToIntDef(ReadString(RegSubKey, ‘WTOCharDelayTime’,”), dflt_WTOCharDelayTime); fWTOExtraDelayTime := StrToIntDef(ReadString(RegSubKey, ‘WTOExtraDelayTime’,”), dflt_WTOExtraDelayTime); fXTOAuto := ReadBool(RegSubKey, ‘XTOAuto’, dflt_XTOAuto); fRTSState := ReadBool(RegSubKey, ‘RTSState’, dflt_RTSState); fDTRState := ReadBool(RegSubKey, ‘DTRState’, dflt_DTRState); fBREAKState := ReadBool (RegSubKey, ‘BREAKState’, dflt_BREAKState); fErrorNoise := StrToIntDef(ReadString(RegSubKey, ‘ErrorNoise’,”), dflt_ErrorNoise); Active := Activate; //After all force the new settings ProcessError(0401,0,’Settings readed’,enMsg); end; except ProcessError(0402,0,’Error reading Settings’,enError); end; finally FIniFile.Free; end; end; procedure TSerialPortNG.WaitForThreadNotRunning(Counter: Integer); begin while (Counter > 0) and (WorkThreadIsRunning) do begin Sleep(75); Dec(Counter); end; end; // // WorkThread Definitions // The Workthread manage all the Work in the Background // — Checks wether the writing is done // — Checks if Data are received // — Checks the Status // — Calls the Events // Saves the process error Variables procedure TWorkThread.SetProcessError(APlace, ACode: DWord; AMsg: String; ANoise: Byte); begin Place := APlace; Code := ACode; Msg := AMsg; Noise := ANoise; end; // Calls the ProcessError Eventhandler procedure TWorkThread.ProcessError; begin Owner.ProcessError(Place,Code,Msg,Noise); end; // Create the Thread constructor TWorkThread.Create(AOwner: TSerialPortNG); begin Owner := AOwner; inherited Create(False); end; // Events… procedure TWorkThread.RxClusterEvent; begin if assigned(Owner.fOnRxClusterEvent) then Owner.fOnRxClusterEvent(Owner); end; procedure TWorkThread.CommEvent; begin Owner.fOnCommEvent(Owner); end; procedure TWorkThread.CommStatEvent; begin Owner.fOnCommStat(Owner); end; procedure TWorkThread.BreakEvent; begin Owner.fOnBreakEvent(Owner); end; procedure TWorkThread.CTSEvent; begin Owner.fOnCTSEvent(Owner); end; procedure TWorkThread.DSREvent; begin Owner.fOnDSREvent(Owner); end; procedure TWorkThread.LineErrorEvent; begin Owner.fOnLineErrorEvent(Owner); end; procedure TWorkThread.RingEvent; begin Owner.fOnRingEvent(Owner); end; procedure TWorkThread.RIEvent; begin Owner.fOnRIEvent(Owner); end; procedure TWorkThread.RLSDEvent; begin Owner.fOnRLSDEvent(Owner); end; procedure TWorkThread.RxCharEvent; begin Owner.fOnRxCharEvent(Owner); end; procedure TWorkThread.RxEventCharEvent; begin Owner.fOnRxEventCharEvent(Owner); end; procedure TWorkThread.TxQueueEmptyEvent; begin Owner.fOnTxQueueEmptyEvent(Owner); end; procedure TWorkThread.WriteDone; begin if Assigned(Owner.fOnWriteDone) then Owner.fOnWriteDone(Owner); end; procedure TWorkThread.ThreadSynchronize(Method: TThreadMethod); begin if not Owner.fThreadQuietMode then Synchronize(Method); end; // // Workthread Maincycle procedure TWorkThread.Execute; var WrittenBytes: DWORD; BytesRead: DWORD; CommStatus: TComStat; CommErrorCode: DWORD; CommEventFlags: DWORD; ModemState: DWORD; RetCode: DWord; StartTime, TickTime: DWord; ClusterData: Pointer; Buffer: Pointer; BufferSize: DWord; WaitForReadEvent: Boolean; WaitForCommEvent: Boolean; HandleEvent: array[0..1] of DWord; ActiveMode, TerminateMode: Boolean; // The local Procedure evaluates the Events generated by the CommPort // and calles the Events of the Mainprogram procedure DoCommEvent; begin if Owner.ShutdownInProgress then Exit; Owner.fCommEvent := CommEventFlags; if (CommEventFlags and EV_BREAK) 0 then if assigned(Owner.fOnBreakEvent) then ThreadSynchronize(BreakEvent); if (CommEventFlags and EV_CTS) 0 then begin if assigned(Owner.fOnCTSEvent) then ThreadSynchronize(CTSEvent); end; if (CommEventFlags and EV_DSR) 0 then begin if assigned(Owner.fOnDSREvent) then ThreadSynchronize(DSREvent); end; if (CommEventFlags and EV_ERR) 0 then begin if assigned(Owner.fOnLineErrorEvent) then ThreadSynchronize(LineErrorEvent); end; if (CommEventFlags and EV_RING) 0 then begin if assigned(Owner.fOnRingEvent) then ThreadSynchronize(RingEvent); end; if (CommEventFlags and EV_RLSD) 0 then begin if assigned(Owner.fOnRLSDEvent) then ThreadSynchronize(RLSDEvent); end; if (CommEventFlags and EV_RXCHAR) 0 then begin if assigned(Owner.fOnRxCharEvent) then ThreadSynchronize(RxCharEvent); end; if (CommEventFlags and EV_RXFLAG) 0 then begin if assigned(Owner.fOnRxEventCharEvent) then ThreadSynchronize(RxEventCharEvent); end; if (CommEventFlags and EV_TXEMPTY) 0 then begin if assigned(Owner.fOnTxQueueEmptyEvent) then ThreadSynchronize(TxQueueEmptyEvent); end; if CommEventFlags 0 then if assigned(Owner.fOnCommEvent) then ThreadSynchronize(CommEvent); end; // Fetch the ModemStatus and CommErrorCode and CommStatus and generate // a CommStatEvent if something changed procedure GetStatus; var ExecDoCommEvent: Boolean; ExecRIEvent: Boolean; ClrCommErrDone: Boolean; begin ExecDoCommEvent := False; ExecRIEvent := False; if GetCommModemStatus(Owner.hCommPort,ModemState) then begin // There is a Bug in Win9x on signalizing the RING Event // We catch this manually here // The RingEvent is singnalize only on the falling edge of the RI! if Owner.Platform = VER_PLATFORM_WIN32_WINDOWS then begin if ((ModemState and MS_RING_ON) = 0) and ((Owner.fModemState and MS_RING_ON) 0) then // The RingIndicator Line has changed and is now False // generate Event begin CommEventFlags := EV_RING; Owner.fRingState := (ModemState and MS_RING_ON) 0; ExecDoCommEvent := True; end; end; if ((ModemState xor Owner.fModemState) and MS_RING_ON) 0 then ExecRIEvent := True; Owner.fModemState := ModemState; // Krystian from Poland suggest to add these 3 lines and got correct states // even if no Event is assigned. Owner.fCTSState := (ModemState and MS_CTS_ON) 0; Owner.fDSRState := (ModemState and MS_DSR_ON) 0; Owner.fRLSDState := (ModemState and MS_RLSD_ON) 0; Owner.fRingState := (ModemState and MS_RING_ON) 0; if ExecRIEvent and assigned(Owner.fOnRIEvent) then ThreadSynchronize(RIEvent); if ExecDoCommEvent then DoCommEvent; end else begin SetProcessError(9905,GetLastError,’Error getting ModemStatus’,enError); ThreadSynchronize(ProcessError); end; ClrCommErrDone := False; repeat if ClearCommError(owner.hCommPort, CommErrorCode, @CommStatus) then begin if (Owner.fCommError CommErrorCode) or (Owner.fCommStateFlags CommStatus.Flags) or (Owner.fCommStateInQueue CommStatus.cbInQue) or (Owner.fCommStateOutQueue CommStatus.cbOutQue) then begin Owner.fCommError := CommErrorCode; Owner.fCommStateFlags := CommStatus.Flags; Owner.fCommStateInQueue := CommStatus.cbInQue; Owner.fCommStateOutQueue := CommStatus.cbOutQue; if Assigned(Owner.fOnCommStat) then ThreadSynchronize(CommStatEvent); end else ClrCommErrDone := True; end else begin SetProcessError(9803,GetLastError,’Error ClearCommError’,enError); ThreadSynchronize(ProcessError); ClrCommErrDone := True; end until ClrCommErrDone; end; // This local procedure checks if the Writing is done procedure CheckWriter; begin if Owner.fSendInProgress then begin if GetOverlappedResult(Owner.hCommPort,Owner.WriteOverlapped,WrittenBytes, FALSE) then begin Owner.fWrittenBytes := WrittenBytes; Owner.fSendInProgress := False; if WrittenBytes Owner.BytesToWrite then begin SetProcessError(9701,RetCode,’Error write TimeOut’,enError); ThreadSynchronize(ProcessError); end; ThreadSynchronize(WriteDone); end else begin RetCode := GetLastError; case RetCode of ERROR_IO_INCOMPLETE :; ERROR_IO_PENDING: begin TickTime := GetTickCount; if ((WrittenBytes*Owner.fWTOCharDelayTime)/1000+Owner.fWTOExtraDelayTime) 0 then begin GetMem(ClusterData,BytesRead); Move(Buffer^,ClusterData^,BytesRead); Cluster := TSerialCluster.Create(ClusterData,BytesRead,CommErrorCode); end else Cluster := TSerialCluster.Create(Nil,0,CommErrorCode); // The Storing of the Cluster into the Queue is done a CriticalSection EnterCriticalSection(Owner.CriticalSection); try Owner.RxDClusterList.Add(Cluster); finally //End of safe block LeaveCriticalSection(Owner.CriticalSection); end; ThreadSynchronize(RxClusterEvent); end; end; //Checks if Data is wainting in the RxDQueue and reads if Conditions are met //is called only if no Overlapp is running procedure ReadNoWait; begin if CommStatus.cbInQue = 0 then // No Char received StartTime := GetTickCount // Remember this Time as a Startpoint else // at least one Char was received begin // A Cluster is completed if one of the followoing conditions fit // — Owner request reading now // — cbInQue is greater than ClusterSize // — (cbInQue * fRTOCharDelayTime)/1000 + fRTOExtraDelayTime is greater than the elapsed Time // — a (Line-) Error occoured TickTime := GetTickCount; if (Owner.fReadRequest) or (CommStatus.cbInQue >= Owner.ClusterSize) or (((CommStatus.cbInQue * Owner.fRTOCharDelayTime)/1000 + Owner.fRTOExtraDelayTime) 0) then begin BufferSize := CommStatus.cbInQue; GetMem(Buffer,BufferSize); if ReadFile(owner.hCommPort, PChar(Buffer)^, BufferSize, BytesRead, @Owner.ReadOverlapped) then begin //We have received something Owner.fReadRequest := False; // Reset the Requestflag DoRxClusterStore; // Store Data and fire Event… FreeMem(Buffer,BufferSize); // Free Buffer Buffer := Nil; StartTime := GetTickCount // Remember this Time as a Startpoint end else // ReadFile was not successful, this may caused by the Overlapped function begin RetCode := GetLastError; if RetCode = ERROR_IO_PENDING then // Yes, Reading is in Progress WaitForReadEvent := True else begin // Error while reading Owner.fReadRequest := False; FreeMem(Buffer,BufferSize); Buffer := Nil; SetProcessError(9804,RetCode,’Error reading Data’,enError); ThreadSynchronize(ProcessError); end; end; end; end; end; // Checks for new events //is called only if no Overlapp is running procedure CommEventNoWait; begin CommEventFlags := 0; if WaitCommEvent(Owner.hCommPort,CommEventFlags,@Owner.StatusOverlapped) then begin GetStatus; // Update Statusflags 25.3.2003 DoCommEvent; // Event Occours, fire Events end else begin RetCode := GetLastError; if RetCode = ERROR_IO_PENDING then WaitForCommEvent := True //Check the Overlapped.hEvent else begin SetProcessError(9907,RetCode,’Error calling WaitCommEvent’,enError); ThreadSynchronize(ProcessError); end; end; end; // Checks for received Data while an Overlapp is running procedure ProcessWaitForRead; begin if not GetOverlappedResult(Owner.hCommPort,Owner.ReadOverlapped,BytesRead, False) then begin RetCode := GetLastError; if RetCode = ERROR_OPERATION_ABORTED then SetProcessError(9907,RetCode,’Error read aborted’,enError) else SetProcessError(9908,RetCode,’Error getting Overlappedresult’,enError); ThreadSynchronize(ProcessError); end else // Successfull Overlapped read begin DoRxClusterStore; // Store Data and fire Event… FreeMem(Buffer,BufferSize); // Free Buffer Buffer := Nil; StartTime := GetTickCount // Remember this Time as a Startpoint end; WaitForReadEvent := False; end; // Checks for new Events while an Overlapp is running procedure ProcessWaitForComm; begin if (Owner.fActive) then begin GetStatus; DoCommEvent; end; WaitForCommEvent := False; end; // Main Cycle of the Thread begin StartTime := GetTickCount; WaitForCommEvent := False; WaitForReadEvent := False; ActiveMode := Owner.fActive; TerminateMode := Terminated; while not TerminateMode do begin if ActiveMode then begin Owner.WorkThreadIsRunning := True; if (Owner.fActive) then GetStatus; // Picup several Information about the actual State of Com CheckWriter; // Checks for pending Writeprocess if (not WaitForReadEvent) and (Owner.fActive) then // Start new Action only if not deactivating ReadNoWait; // Reads if avail, no waiting here if not WaitForCommEvent and (Owner.fActive) then // Start new Action only if not deactivating CommEventNoWait; // Check for Events, no waiting here // WaitForMultiple Events if (WaitForReadEvent and WaitForCommEvent) then begin HandleEvent[0] := Owner.ReadOverlapped.hEvent; HandleEvent[1] := Owner.StatusOverlapped.hEvent; RetCode := WaitForMultipleObjects(2,@HandleEvent,False,75); if (Owner.fActive) then GetStatus; // Picup several Information about the actual State of Com case RetCode of WAIT_OBJECT_0: begin ProcessWaitForRead; end; WAIT_OBJECT_0 + 1: begin ProcessWaitForComm; end; WAIT_TIMEOUT: begin end; else SetProcessError(9911,RetCode,’Error getting Overlappedresult’,enError); ThreadSynchronize(ProcessError); WaitForReadEvent := False; WaitForCommEvent := False; end; end else if WaitForReadEvent then begin RetCode := WaitForSingleObject(Owner.ReadOverlapped.hEvent,75); if (Owner.fActive) then GetStatus; // Picup several Information about the actual State of Com case RetCode of WAIT_OBJECT_0: begin if (Owner.fActive) then ProcessWaitForRead; end; WAIT_TIMEOUT: begin end; else SetProcessError(9912,RetCode,’Error getting Overlappedresult’,enError); ThreadSynchronize(ProcessError); WaitForReadEvent := False; end; end else if WaitForCommEvent then// WaitForCommEvent begin RetCode := WaitForSingleObject(Owner.StatusOverlapped.hEvent,75); if (Owner.fActive) then GetStatus; // Picup several Information about the actual State of Com case RetCode of WAIT_OBJECT_0: begin ProcessWaitForComm; end; WAIT_TIMEOUT: begin end; else SetProcessError(9913,RetCode,’Error getting Overlappedresult’,enError); ThreadSynchronize(ProcessError); WaitForCommEvent := False; end; end; if not Owner.fActive then // The owner wants to deactivate the port begin if WaitForReadEvent then Owner.SetOverlapped(Owner.ReadOverlapped); if WaitForCommEvent then begin SetCommMask(Owner.hCommPort,0); Owner.SetOverlapped(Owner.StatusOverlapped); end; if (not WaitForCommEvent) and (not WaitForReadEvent) and (not Owner.fSendInProgress) then ActiveMode := False; // We do so if everything pending is finished end; end else // not ActiveMode begin Owner.WorkThreadIsRunning := False; ActiveMode := Owner.fActive; Sleep(200); //prevent consuming 100% of cpu-time in inactive mode end; if Terminated and (not ActiveMode) then //No termination before deactivation TerminateMode := True; end; // while not Terminated Owner.WorkThreadIsTerminated := True; end; end. –PAGE_BREAK–object Form1: TForm1 Left = 226 Top = 214 BorderIcons = [biSystemMenu, biMinimize] BorderStyle = bsSingle Caption = #1051#1086#1075#1080#1095#1077#1089#1082#1080#1081′ ‘#1072#1085#1072#1083#1080#1079#1072#1090#1086#1088 ClientHeight = 473 ClientWidth = 607 Color = clBlack Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = ‘MS Sans Serif’ Font.Style = [] OldCreateOrder = False OnClose = FormClose OnCreate = FormCreate PixelsPerInch = 96 TextHeight = 13 object SpeedButton1: TSpeedButton Left = 536 Top = 352 Width = 65 Height = 41 OnClick = SpeedButton1Click end object SpeedButton2: TSpeedButton Left = 432 Top = 352 Width = 65 Height = 41 OnClick = SpeedButton2Click end object Label1: TLabel Left = 8 Top = 400 Width = 117 Height = 14 Caption = #1043#1083#1091#1073#1080#1085#1072′ ‘#1087#1088#1077#1076#1087#1091#1089#1082#1086#1074#1086#1081 Color = clBlack Font.Charset = DEFAULT_CHARSET Font.Color = clWindow Font.Height = -11 Font.Name = ‘Arial’ Font.Style = [] ParentColor = False ParentFont = False end object Label2: TLabel Left = 8 Top = 416 Width = 67 Height = 14 Caption = #1088#1077#1075#1080#1089#1090#1088#1072#1094#1080#1080′:’ Font.Charset = DEFAULT_CHARSET Font.Color = clWindow Font.Height = -11 Font.Name = ‘Arial’ Font.Style = [] ParentFont = False end object Label3: TLabel Left = 328 Top = 384 Width = 22 Height = 22 Caption = ‘Hz’ Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -19 Font.Name = ‘Arial’ Font.Style = [] ParentFont = False end object Label4: TLabel Left = 200 Top = 408 Width = 181 Height = 18 Caption = #1058#1072#1081#1084#1072#1091#1090′ ‘#1086#1078#1080#1076#1072#1085#1080#1103’ ‘#1087#1091#1089#1082#1072′:’ Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -16 Font.Name = ‘Arial’ Font.Style = [] ParentFont = False end object Label5: TLabel Left = 256 Top = 432 Width = 63 Height = 22 Caption = #1062#1080#1082#1083#1086#1074 Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -19 Font.Name = ‘Arial’ Font.Style = [] ParentFont = False end object Chart1: TChart Left = 95 Top = 12 Width = 514 Height = 301 AllowPanning = pmHorizontal AllowZoom = False BackWall.Brush.Color = clBlack BackWall.Color = clBlack BackWall.Pen.Color = clWhite Title.Brush.Color = clWhite Title.Color = clWhite Title.Frame.Color = clWhite Title.Text.Strings = ( ‘TChart’) Title.Visible = False BackColor = clBlack BottomAxis.Automatic = False BottomAxis.AutomaticMaximum = False BottomAxis.AutomaticMinimum = False BottomAxis.Axis.Color = clWhite BottomAxis.Grid.Color = clWhite BottomAxis.LabelsFont.Charset = DEFAULT_CHARSET BottomAxis.LabelsFont.Color = clWhite BottomAxis.LabelsFont.Height = -11 BottomAxis.LabelsFont.Name = ‘Arial’ BottomAxis.LabelsFont.Style = [] BottomAxis.Maximum = 16.000000000000000000 BottomAxis.MinorGrid.Color = clWhite BottomAxis.MinorTicks.Color = clWhite BottomAxis.Ticks.Color = clWhite BottomAxis.TicksInner.Color = clWhite DepthAxis.Automatic = False DepthAxis.AutomaticMaximum = False DepthAxis.AutomaticMinimum = False DepthAxis.Axis.Color = clWhite DepthAxis.Grid.Color = clWhite DepthAxis.LabelsFont.Charset = DEFAULT_CHARSET DepthAxis.LabelsFont.Color = clWhite DepthAxis.LabelsFont.Height = -11 DepthAxis.LabelsFont.Name = ‘Arial’ DepthAxis.LabelsFont.Style = [] DepthAxis.Maximum = 500.000000000000000000 DepthAxis.Minimum = 16.000000000000000000 DepthAxis.MinorGrid.Color = clWhite DepthAxis.MinorTicks.Color = clWhite DepthAxis.Ticks.Color = clWhite DepthAxis.TicksInner.Color = clWhite DepthAxis.Title.Font.Charset = DEFAULT_CHARSET DepthAxis.Title.Font.Color = clWhite DepthAxis.Title.Font.Height = -11 DepthAxis.Title.Font.Name = ‘Arial’ DepthAxis.Title.Font.Style = [] Frame.Color = clWhite LeftAxis.Automatic = False LeftAxis.AutomaticMaximum = False LeftAxis.AutomaticMinimum = False LeftAxis.Axis.Color = clWhite LeftAxis.Grid.Color = clWhite LeftAxis.Inverted = True LeftAxis.Maximum = 8.000000000000000000 LeftAxis.MinorGrid.Color = clWhite LeftAxis.MinorTicks.Color = clWhite LeftAxis.Ticks.Color = clWhite LeftAxis.TicksInner.Color = clSilver Legend.Font.Charset = DEFAULT_CHARSET Legend.Font.Color = clWhite Legend.Font.Height = -11 Legend.Font.Name = ‘Arial’ Legend.Font.Style = [] Legend.Frame.Color = clWhite Legend.Visible = False RightAxis.Axis.Color = clSilver ScaleLastPage = False TopAxis.Automatic = False TopAxis.AutomaticMaximum = False TopAxis.AutomaticMinimum = False TopAxis.Axis.Color = clSilver TopAxis.Grid.Color = clSilver TopAxis.LabelsFont.Charset = DEFAULT_CHARSET TopAxis.LabelsFont.Color = clWhite TopAxis.LabelsFont.Height = -11 TopAxis.LabelsFont.Name = ‘Arial’ TopAxis.LabelsFont.Style = [] TopAxis.Maximum = 16.000000000000000000 TopAxis.Minimum = 16.000000000000000000 View3D = False BevelOuter = bvNone Color = clBlack TabOrder = 0 object Series1: TLineSeries Marks.ArrowLength = 8 Marks.Visible = False SeriesColor = clRed Dark3D = False Pointer.InflateMargins = True Pointer.Style = psRectangle Pointer.Visible = False Stairs = True XValues.DateTime = False XValues.Name = ‘X’ XValues.Multiplier = 1.000000000000000000 XValues.Order = loAscending YValues.DateTime = False YValues.Name = ‘Y’ YValues.Multiplier = 1.000000000000000000 YValues.Order = loNone end object Series2: TLineSeries Marks.ArrowLength = 8 Marks.Visible = False SeriesColor = clGreen Dark3D = False Pointer.InflateMargins = True Pointer.Style = psRectangle Pointer.Visible = False Stairs = True XValues.DateTime = False XValues.Name = ‘X’ XValues.Multiplier = 1.000000000000000000 XValues.Order = loAscending YValues.DateTime = False YValues.Name = ‘Y’ YValues.Multiplier = 1.000000000000000000 YValues.Order = loNone end object Series3: TLineSeries Marks.ArrowLength = 8 Marks.Visible = False SeriesColor = clYellow Dark3D = False Pointer.InflateMargins = True Pointer.Style = psRectangle Pointer.Visible = False Stairs = True XValues.DateTime = False XValues.Name = ‘X’ XValues.Multiplier = 1.000000000000000000 XValues.Order = loAscending YValues.DateTime = False YValues.Name = ‘Y’ YValues.Multiplier = 1.000000000000000000 YValues.Order = loNone end object Series4: TLineSeries Marks.ArrowLength = 8 Marks.Visible = False SeriesColor = clBlue Dark3D = False Pointer.InflateMargins = True Pointer.Style = psRectangle Pointer.Visible = False Stairs = True XValues.DateTime = False XValues.Name = ‘X’ XValues.Multiplier = 1.000000000000000000 XValues.Order = loAscending YValues.DateTime = False YValues.Name = ‘Y’ YValues.Multiplier = 1.000000000000000000 YValues.Order = loNone end object Series5: TLineSeries Marks.ArrowLength = 8 Marks.Visible = False SeriesColor = clWhite Dark3D = False Pointer.InflateMargins = True Pointer.Style = psRectangle Pointer.Visible = False Stairs = True XValues.DateTime = False XValues.Name = ‘X’ XValues.Multiplier = 1.000000000000000000 XValues.Order = loAscending YValues.DateTime = False YValues.Name = ‘Y’ YValues.Multiplier = 1.000000000000000000 YValues.Order = loNone end object Series6: TLineSeries Marks.ArrowLength = 8 Marks.Visible = False SeriesColor = clGray Dark3D = False Pointer.InflateMargins = True Pointer.Style = psRectangle Pointer.Visible = False Stairs = True XValues.DateTime = False XValues.Name = ‘X’ XValues.Multiplier = 1.000000000000000000 XValues.Order = loAscending YValues.DateTime = False YValues.Name = ‘Y’ YValues.Multiplier = 1.000000000000000000 YValues.Order = loNone end object Series7: TLineSeries Marks.ArrowLength = 8 Marks.Visible = False SeriesColor = clFuchsia Dark3D = False Pointer.InflateMargins = True Pointer.Style = psRectangle Pointer.Visible = False Stairs = True XValues.DateTime = False XValues.Name = ‘X’ XValues.Multiplier = 1.000000000000000000 XValues.Order = loAscending YValues.DateTime = False YValues.Name = ‘Y’ YValues.Multiplier = 1.000000000000000000 YValues.Order = loNone end object Series8: TLineSeries Marks.ArrowLength = 8 Marks.Visible = False SeriesColor = clTeal Dark3D = False Pointer.InflateMargins = True Pointer.Style = psRectangle Pointer.Visible = False Stairs = True XValues.DateTime = False XValues.Name = ‘X’ XValues.Multiplier = 1.000000000000000000 XValues.Order = loAscending YValues.DateTime = False YValues.Name = ‘Y’ YValues.Multiplier = 1.000000000000000000 YValues.Order = loNone end end object ColorBox1: TColorBox Left = 88 Top = 32 Width = 38 Height = 22 Selected = clGreen Color = clBlack ItemHeight = 16 TabOrder = 1 end object ColorBox2: TColorBox Left = 88 Top = 64 Width = 38 Height = 22 Selected = clGradientActiveCaption Color = clBlack ItemHeight = 16 TabOrder = 2 end object ColorBox3: TColorBox Left = 88 Top = 96 Width = 38 Height = 22 Selected = clRed Color = clBlack ItemHeight = 16 TabOrder = 3 end object ColorBox4: TColorBox Left = 88 Top = 128 Width = 38 Height = 22 Selected = clLime Color = clBlack ItemHeight = 16 TabOrder = 4 end object ColorBox5: TColorBox Left = 88 Top = 160 Width = 38 Height = 22 Selected = clYellow Color = clBlack ItemHeight = 16 TabOrder = 5 end object ColorBox6: TColorBox Left = 88 Top = 192 Width = 38 Height = 22 Selected = clBlue Color = clBlack ItemHeight = 16 TabOrder = 6 end object ColorBox7: TColorBox Left = 88 Top = 223 Width = 38 Height = 22 Selected = clFuchsia Color = clBlack ItemHeight = 16 TabOrder = 7 end object ColorBox8: TColorBox Left = 88 Top = 255 Width = 38 Height = 22 Selected = clAqua Color = clBlack ItemHeight = 16 TabOrder = 8 end object ScrollBar1: TScrollBar Left = 120 Top = 300 Width = 481 Height = 17 Max = 484 PageSize = 0 TabOrder = 9 OnChange = ScrollChange end object StaticText1: TStaticText Left = 8 Top = 32 Width = 72 Height = 28 Caption = #1050#1072#1085#1072#1083′ 1′ Color = clBlack Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -19 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentColor = False ParentFont = False TabOrder = 10 end object StaticText2: TStaticText Left = 8 Top = 64 Width = 72 Height = 28 Caption = #1050#1072#1085#1072#1083′ 2′ Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -19 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 11 end object StaticText3: TStaticText Left = 8 Top = 96 Width = 72 Height = 28 Caption = #1050#1072#1085#1072#1083′ 3′ Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -19 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 12 end object StaticText4: TStaticText Left = 8 Top = 128 Width = 72 Height = 28 Caption = #1050#1072#1085#1072#1083′ 4′ Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -19 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 13 end object StaticText5: TStaticText Left = 8 Top = 160 Width = 72 Height = 28 Caption = #1050#1072#1085#1072#1083′ 5′ Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -19 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 14 end object StaticText6: TStaticText Left = 8 Top = 192 Width = 72 Height = 28 Caption = #1050#1072#1085#1072#1083′ 6′ Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -19 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 15 end object StaticText7: TStaticText Left = 8 Top = 225 Width = 72 Height = 28 Caption = #1050#1072#1085#1072#1083′ 7′ Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -19 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 16 end object StaticText8: TStaticText Left = 8 Top = 253 Width = 72 Height = 28 Caption = #1050#1072#1085#1072#1083′ 8′ Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -19 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 17 end object StaticText9: TStaticText Left = 432 Top = 328 Width = 172 Height = 28 Caption = #1052#1072#1089#1096#1090#1072#1073#1080#1088#1086#1074#1072#1085#1080#1077 Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -19 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 18 end object GroupBox1: TGroupBox Left = 8 Top = 320 Width = 145 Height = 73 Caption = #1047#1072#1087#1091#1089#1082 Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -19 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 19 object RadioButton1: TRadioButton Left = 8 Top = 24 Width = 134 Height = 17 Caption = #1055#1086′ ‘#1087#1077#1088#1077#1076#1085#1077#1084#1091’ ‘#1092#1088#1086#1085#1090#1091 Checked = True Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -11 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 0 TabStop = True end object RadioButton2: TRadioButton Left = 8 Top = 48 Width = 129 Height = 17 Caption = #1055#1086′ ‘#1079#1072#1076#1085#1077#1084#1091’ ‘#1092#1088#1086#1085#1090#1091 Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -11 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 1 end object RadioButton3: TRadioButton Left = 8 Top = 72 Width = 113 Height = 17 Caption = #1055#1086′ ‘#1096#1072#1073#1083#1086#1085#1091 Enabled = False Font.Charset = DEFAULT_CHARSET Font.Color = clWhite Font.Height = -11 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 2 Visible = False end end object ComboBox1: TComboBox Left = 200 Top = 336 Width = 185 Height = 21 ItemHeight = 13 TabOrder = 20 Text = #1042#1099#1073#1086#1088′ ‘#1087#1091#1089#1082#1086#1074#1086#1075#1086’ ‘#1082#1072#1085#1072#1083#1072 Items.Strings = ( #1050#1072#1085#1072#1083′ 1′ #1050#1072#1085#1072#1083′ 2′ #1050#1072#1085#1072#1083′ 3′ #1050#1072#1085#1072#1083′ 4′ #1050#1072#1085#1072#1083′ 5′ #1050#1072#1085#1072#1083′ 6′ #1050#1072#1085#1072#1083′ 7′ #1050#1072#1085#1072#1083′ 8′ #1053#1077#1090) end object ComboBox2: TComboBox Left = 200 Top = 360 Width = 185 Height = 21 ItemHeight = 13 TabOrder = 21 Text = #1042#1099#1073#1086#1088’ ‘#1090#1072#1082#1090#1086#1074#1086#1075#1086’ ‘#1075#1077#1085#1077#1088#1072#1090#1086#1088#1072 OnChange = ComboBox2Change Items.Strings = ( ‘(clk/6) 1 228 800 Hz’ ‘(clk/8) 921 600 Hz’ ‘(clk/16) 460 800 Hz’ ‘(clk/32) 230 400 Hz’ ‘(clk/64) 115 200 Hz’ ‘(clk/128) 57 600 Hz’ ‘(clk/256) 28 800 Hz’ #1055#1088#1086#1080#1079#1074#1086#1083#1100#1085#1099#1081) end object BitBtn1: TBitBtn Left = 432 Top = 408 Width = 169 Height = 41 Caption = #1047#1072#1087#1091#1089#1082 Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -19 Font.Name = ‘MS Sans Serif’ Font.Style = [] ParentFont = False TabOrder = 22 OnClick = BitBtn1Click end object TrackBar1: TTrackBar Left = 0 Top = 432 Width = 113 Height = 45 Max = 100 SelStart = 100 TabOrder = 23 OnChange = TrackBar1Change end object Edit1: TEdit Left = 120 Top = 432 Width = 33 Height = 24 Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -13 Font.Name = ‘Courier New’ Font.Style = [] ParentFont = False ReadOnly = True TabOrder = 24 Text = ‘0’ end object MaskEdit1: TMaskEdit Left = 200 Top = 384 Width = 119 Height = 22 EditMask = ‘!99999;1; ‘ Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = ‘Courier New’ Font.Style = [] MaxLength = 5 ParentFont = False TabOrder = 25 Text = ‘ 0’ end object MaskEdit2: TMaskEdit Left = 200 Top = 432 Width = 47 Height = 24 EditMask = ‘!99999;1; ‘ Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -13 Font.Name = ‘Courier New’ Font.Style = [] MaxLength = 5 ParentFont = False TabOrder = 26 Text = ‘65535’ OnChange = MaskEdit2Change end object SerialPortNG1: TSerialPortNG CommPort = ‘COM1’ BaudRate = 19200 RTOCharDelayTime = 570 WTOCharDelayTime = 570 ErrorNoise = 255 OnRxClusterEvent = SerialPortNG1RxClusterEvent end end продолжение
–PAGE_BREAK–unit Unit1; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, TeEngine, Series, ExtCtrls, TeeProcs, Chart, StdCtrls, ComCtrls, Buttons, ComDrv32, SerialNG, Mask, Math; type TForm1 = class(TForm) Chart1: TChart; Series1: TLineSeries; Series2: TLineSeries; Series3: TLineSeries; Series4: TLineSeries; Series5: TLineSeries; Series6: TLineSeries; Series7: TLineSeries; Series8: TLineSeries; ColorBox1: TColorBox; ColorBox2: TColorBox; ColorBox3: TColorBox; ColorBox4: TColorBox; ColorBox5: TColorBox; ColorBox6: TColorBox; ColorBox7: TColorBox; ColorBox8: TColorBox; StaticText1: TStaticText; StaticText2: TStaticText; StaticText3: TStaticText; StaticText4: TStaticText; StaticText5: TStaticText; StaticText6: TStaticText; StaticText7: TStaticText; StaticText8: TStaticText; ScrollBar1: TScrollBar; SpeedButton1: TSpeedButton; SpeedButton2: TSpeedButton; StaticText9: TStaticText; GroupBox1: TGroupBox; RadioButton1: TRadioButton; RadioButton2: TRadioButton; RadioButton3: TRadioButton; ComboBox1: TComboBox; ComboBox2: TComboBox; BitBtn1: TBitBtn; SerialPortNG1: TSerialPortNG; TrackBar1: TTrackBar; Edit1: TEdit; Label1: TLabel; Label2: TLabel; MaskEdit1: TMaskEdit; Label3: TLabel; Label4: TLabel; MaskEdit2: TMaskEdit; Label5: TLabel; procedure FormCreate(Sender: TObject); procedure ScrollChange(Sender: TObject); procedure BitBtn2Click(Sender: TObject); procedure SpeedButton1Click(Sender: TObject); procedure SpeedButton2Click(Sender: TObject); procedure FormClose(Sender: TObject; var Action: TCloseAction); procedure BitBtn1Click(Sender: TObject); procedure SerialPortNG1RxClusterEvent(Sender: TObject); procedure TrackBar1Change(Sender: TObject); procedure ComboBox2Change(Sender: TObject); procedure MaskEdit2Change(Sender: TObject); private { Private declarations } scale:word; dwError:dword; pName:PWideChar; flag:byte; function StrToIntM(str:string):dword; public { Public declarations } end; TArrBuf512 = array[0..511] of byte; var Form1: TForm1; implementation uses SerialNGBasic; {$R *.dfm} procedure TForm1.FormCreate(Sender: TObject); var i:word; s:string; begin SerialPortNG1.Active := True; scale := 500; ScrollBar1.Visible := False; Chart1.BottomAxis.Minimum := 0; Chart1.BottomAxis.Maximum := scale; Series1.Clear; Series2.Clear; Series3.Clear; Series4.Clear; Series5.Clear; Series6.Clear; Series7.Clear; Series8.Clear; for i := 0 to 500 do begin Series1.AddXY(i, ((i mod 1)*0.5)+0.25, ”, ColorBox1.Selected); Series2.AddXY(i, ((i mod 2)*0.5)+1.25, ”, ColorBox2.Selected); Series3.AddXY(i, ((i mod 2)*0.5)+2.25, ”, ColorBox3.Selected); Series4.AddXY(i, ((i mod 2)*0.5)+3.25, ”, ColorBox4.Selected); Series5.AddXY(i, ((i mod 2)*0.5)+4.25, ”, ColorBox5.Selected); Series6.AddXY(i, ((i mod 2)*0.5)+5.25, ”, ColorBox6.Selected); Series7.AddXY(i, ((i mod 2)*0.5)+6.25, ”, ColorBox7.Selected); Series8.AddXY(i, ((i mod 2)*0.5)+7.25, ”, ColorBox8.Selected); end; end; procedure TForm1.ScrollChange(Sender: TObject); begin Chart1.BottomAxis.Minimum := ScrollBar1.Position; Chart1.BottomAxis.Maximum := ScrollBar1.Position + scale; end; procedure TForm1.BitBtn2Click(Sender: TObject); begin Close; end; procedure TForm1.SpeedButton1Click(Sender: TObject); begin if (scale (500 — scale)) then ScrollBar1.Position := (500 — scale); Chart1.BottomAxis.Minimum := ScrollBar1.Position; Chart1.BottomAxis.Maximum := ScrollBar1.Position + scale; end; procedure TForm1.SpeedButton2Click(Sender: TObject); begin if (scale > 0) then scale := scale — 10; if (scale = 500) then ScrollBar1.Visible := False else ScrollBar1.Visible := True; ScrollBar1.Max := 500 — scale; Chart1.BottomAxis.Minimum := ScrollBar1.Position; Chart1.BottomAxis.Maximum := ScrollBar1.Position + scale; end; procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction); begin SerialPortNG1.Active := False; end; procedure TForm1.BitBtn1Click(Sender: TObject); var s:string; begin if (ComboBox2.ItemIndex -1) and (ComboBox1.ItemIndex -1) then begin s := ‘ ‘; s[1] := char($FF); s[2] := char($AA); s[3] := char($3A); s[4] := char((((ComboBox1.ItemIndex shl 1) or byte(RadioButton2.Checked))or (ComboBox2.ItemIndex shl 5))); SerialPortNG1.SendString(s); flag := 1; end else MessageBox(0, ‘���������� ������� ����� ��������� ������ � ������� �������� ���������!’, ‘������’, MB_OK or MB_ICONINFORMATION); end; procedure TForm1.SerialPortNG1RxClusterEvent(Sender: TObject); var i:integer; n:integer; p:^TArrBuf512; size:integer; error:DWord; begin n := SerialPortNG1.NextClusterSize; if n >= 0 then begin p := SerialPortNG1.ReadNextCluster(size, error); if (flag=1) then begin Series1.Clear; Series2.Clear; Series3.Clear; Series4.Clear; Series5.Clear; Series6.Clear; Series7.Clear; Series8.Clear; for i := 0 to n do begin Series8.AddXY(i, -(((p^[i] shr 7) and 1)*0.5)+7.75, ”, ColorBox8.Selected); Series7.AddXY(i, -(((p^[i] shr 6) and 1)*0.5)+6.75, ”, ColorBox7.Selected); Series6.AddXY(i, -(((p^[i] shr 5) and 1)*0.5)+5.75, ”, ColorBox6.Selected); Series5.AddXY(i, -(((p^[i] shr 4) and 1)*0.5)+4.75, ”, ColorBox5.Selected); Series4.AddXY(i, -(((p^[i] shr 3) and 1)*0.5)+3.75, ”, ColorBox4.Selected); Series3.AddXY(i, -(((p^[i] shr 2) and 1)*0.5)+2.75, ”, ColorBox3.Selected); Series2.AddXY(i, -(((p^[i] shr 1) and 1)*0.5)+1.75, ”, ColorBox2.Selected); Series1.AddXY(i, -(( p^[i] and 1)*0.5)+0.75, ”, ColorBox1.Selected); end; flag := 0; end; end; end; procedure TForm1.TrackBar1Change(Sender: TObject); begin Edit1.Text := IntToStr(TrackBar1.Position); end; procedure TForm1.ComboBox2Change(Sender: TObject); begin if ComboBox2.ItemIndex = 7 then begin MaskEdit1.Visible := true; Label3.Visible := true; MaskEdit1.Text := ”; end else begin MaskEdit1.Visible := False; Label3.Visible := false; end; end; procedure TForm1.MaskEdit2Change(Sender: TObject); begin if MaskEdit2.Text ” then if StrToIntM(MaskEdit2.Text) > 65535 then MaskEdit2.Text := ‘65535’; end; function TForm1.StrToIntM(str:string):dword; var i,num:integer; begin num := 0; if (length(str) > 0) and (length(str) = ‘0’)and(str[i] = ‘0’) and (Key = ‘A’) and (Key = ‘a’) and (Key = ‘a’) and (Key = ‘0’) and (Key ” then for i := 1 to length(s) do if s[i] ‘ ‘ then s1 := s1 + s[i]; if s1 ” then begin if (StrToInt(s1) > 1024) then begin MaskEdit2.Text := ‘1024’; count := 1024; end; count := StrToInt(s1); end; end; function TForm2.StrToHex(str:string):integer; var i,num:integer; begin num := 0; if (length(str) > 0) and (length(str) = ‘0’)and(str[i] = ‘A’)and(str[i] = ‘a’)and(str[i] = ‘0’) and (Key = ‘A’) and (Key = ‘a’) and (Key = ‘a’) and (Key = ‘0’) and (Key = ‘A’) and (Key = ‘a’) and (Key = ‘a’) and (Key ” then begin if StrToHex(MaskEdit4.Text) > count-1 then MaskEdit4.Text := Format(‘%3x’, [count-1]); if StrToHex(MaskEdit4.Text) ” then begin if StrToHex(MaskEdit3.Text) > count-1 then MaskEdit3.Text := Format(‘%3x’, [count-1]); if StrToHex(MaskEdit4.Text)
–PAGE_BREAK–object Form3: TForm3 Left = 239 Top = 164 AutoScroll = False BorderIcons = [biSystemMenu, biMinimize] Caption = ‘Form3’ ClientHeight = 287 ClientWidth = 509 Color = clBtnFace Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -11 Font.Name = ‘MS Sans Serif’ Font.Style = [] OldCreateOrder = False Visible = True PixelsPerInch = 96 TextHeight = 13 object Label1: TLabel Left = 24 Top = 16 Width = 474 Height = 29 Caption = #1042#1110#1088#1090#1091#1072#1083#1100#1085#1080#1081′ ‘#1074#1080#1084#1110#1088#1102#1074#1072#1083#1100#1085#1080#1081’ ‘#1082#1086#1084#1087#1083#1077#1082#1089 Font.Charset = DEFAULT_CHARSET Font.Color = clWindowText Font.Height = -24 Font.Name = ‘Arial’ Font.Style = [fsBold] ParentFont = False end object BitBtn1: TBitBtn Left = 16 Top = 64 Width = 153 Height = 41 Caption = #1051#1086#1075#1110#1095#1085#1080#1081′ ‘#1072#1085#1072#1083#1110#1079#1072#1090#1086#1088 TabOrder = 0 OnClick = BitBtn1Click end object BitBtn2: TBitBtn Left = 16 Top = 120 Width = 153 Height = 41 Caption = #1043#1077#1085#1077#1088#1072#1090#1086#1088’ ‘#1073#1072#1081#1090 TabOrder = 1 OnClick = BitBtn2Click end object BitBtn3: TBitBtn Left = 16 Top = 176 Width = 153 Height = 41 Caption = ‘BitBtn3’ Enabled = False TabOrder = 2 end object BitBtn4: TBitBtn Left = 16 Top = 232 Width = 153 Height = 41 Caption = ‘BitBtn4’ Enabled = False TabOrder = 3 end end unit Unit3; interface uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, Buttons; type TForm3 = class(TForm) BitBtn1: TBitBtn; BitBtn2: TBitBtn; BitBtn3: TBitBtn; BitBtn4: TBitBtn; Label1: TLabel; procedure BitBtn1Click(Sender: TObject); procedure BitBtn2Click(Sender: TObject); private { Private declarations } public { Public declarations } end; var Form3: TForm3; implementation uses Unit1, Unit2; {$R *.dfm} procedure TForm3.BitBtn1Click(Sender: TObject); begin Form1.Visible := True; end; procedure TForm3.BitBtn2Click(Sender: TObject); begin Form2.Visible := true; end; end. 11124-Dec-2008 16:50:5009-Feb-2009 02:47:50208024-Dec-2008 16:50:5044, 13, 0, 557Atmel AVR Assembler111.objD:\_DISK C\diplom\main.asmD:\_DISK C\diplom\AVR SimulatorATmega8515falseR00R01R02R03R04R05R06R07R08R09R10R11R12R13R14R15R16R17R18R19R20R21R22R23R24R25R26R27R28R29R30R31Auto000D:\_DISK C\diplom\main.asmD:\_DISK C\diplom\main.asmF:\Program Files\Atmel\AVR Tools\AvrAssembler\AppnotesI11100100,0246962377372800011F:\Program Files\Atmel\AVR Tools\AvrAssembler2\Appnotes\main.asmF:\Program Files\Atmel\AVR Tools\AvrAssembler2\Appnotes\m8515def.inc00000main.asm257 :020000020000FC :1000000010C000000000000000000000000006C258 :100010000000EDC100000000000000000000000032 :10002000000002E00EBF0FE50DBF0FE001BD00ECC8 :1000300005BF789414D202E009BF00E003BF222775 :10004000442700E007BB0FEF08BBA895413009F03B :10005000CDC1442708E10AB9C0E0DCE77FEF052FF6 :10006000007E06950695069506950695003069F57D :10007000052F0071E9F4052F0E70069511E0003090 :1000800019F0110F0A95D9F7052F017049F4A895B9 :1000900066B36123E1F7A89566B36123E1F308C075 :1000A000A89566B36123E1F3A89566B36123E1F7F0 :1000B00006B309937A95E1F77A9506B309937A9591 :1000C000E1F77A9506B3099379C1013089F5052FD7 :1000D0000071E9F4052F0E70069511E0003019F05B :1000E000110F0A95D9F7052F017049F4A89566B349 :1000F0006123E1F7A89566B36123E1F308C0A895F1 :1001000066B36123E1F3A89566B36123E1F706B313 :100110000993000000007A95D1F77A9506B3099308 :10012000000000007A95D1F77A9506B3099346C18D :100130000230A9F5052F0071E9F4052F0E70069520 :1001400011E0003019F0110F0A95D9F7052F017051 :1001500049F4A89566B36123E1F7A89566B36123D6 :10016000E1F308C0A89566B36123E1F3A89566B3EF :100170006123E1F706B3099313E01A95F1F7000044 :100180007A95C1F77A9506B3099313E01A95F1F7BA :1001900000007A95C1F77A9506B309930FC1033031 :1001A000B9F5052F0071E9F4052F0E70069511E0E1 :1001B000003019F0110F0A95D9F7052F017049F495 :1001C000A89566B36123E1F7A89566B36123E1F3CF :1001D00008C0A89566B36123E1F3A89566B36123CF :1001E000E1F706B3099318E01A95F1F70000000053 :1001F0007A95B9F77A9506B3099318E01A95F1F74D :10020000000000007A95D1F77A9506B30993D6C01D :100210000430A9F5052F0071E9F4052F0E7006953D :1002200011E0003019F0110F0A95D9F7052F017070 :1002300049F4A89566B36123E1F7A89566B36123F5 :10024000E1F308C0A89566B36123E1F3A89566B30E :100250006123E1F706B3099313E11A95F1F7000062 :100260007A95C1F77A9506B3099313E11A95F1F7D8 :1002700000007A95C1F77A9506B309939FC00530BF :10028000B9F5052F0071E9F4052F0E70069511E000 :10029000003019F0110F0A95D9F7052F017049F4B4 :1002A000A89566B36123E1F7A89566B36123E1F3EE :1002B00008C0A89566B36123E1F3A89566B36123EE :1002C000E1F706B3099318E21A95F1F70000000070 :1002D0007A95B9F77A9506B3099318E21A95F1F76A :1002E000000000007A95B9F77A9506B3099366C0C5 :1002F0000630A9F5052F0071E9F4052F0E7006955B :1003000011E0003019F0110F0A95D9F7052F01708F :1003100049F4A89566B36123E1F7A89566B3612314 :10032000E1F308C0A89566B36123E1F3A89566B32D :100330006123E1F706B3099313E51A95F1F700007D :100340007A95C1F77A9506B3099313E51A95F1F7F3 :1003500000007A95C1F77A9506B309932FC007304C :1003600009F042C0052F0071E9F4052F0E700695C3 :1003700011E0003019F0110F0A95D9F7052F01701F :1003800049F4A89566B36123E1F7A89566B36123A4 :10039000E1F308C0A89566B36123E1F3A89566B3BD :1003A0006123E1F706B309937A95E1F77A9506B3ED :1003B00009937A95E1F77A9506B30993C0E0DCE7F3 :1003C0000991A8955D9BFDCF0CB97A95C9F77A95EF :1003D0000991A8955D9BFDCF0CB97A95C9F7099154 :1003E000A8955D9BFDCF0CB908E90AB92ECE0F93F5 :1003F0000FB70F930CB1213059F00A3A59F405E0C8 :1004000003BF002702BF21E0C0E0DCE733270AEA90 :10041000099333950F910FBF0F9118950F931F9369 :100420000FB70F9300E003BFC0E0DCE7333089F47F :1004300009910A3A71F409910A3359F40991502F3C :1004400041E0C0E0DCE70027099309930993099391 :10045000099322270F910FBF1F910F91189508E95B :100460000AB906E000BD00E017E100BD19B901E0DE :10047000009300C00895F894A8955D9BFDCF0CB93A :0404800078940895CF :00000001FF cls @F:\avr\avreal\avreal32 +MEGA8515 -p1 -w -v -o1000 -fBODEN=1,BLEV=1,CKSEL=0,BRST=1,CKOPT=0,SUT=1,EESV=1,BLB0=1,BLB1=1,S8515C=0 @pause #include .def tmp = r16 .def tmp1 = r17 .def RX_flag = r18 .def RX_Counter = r19 .def RX_Complete = r20 .def command = r21 .def tmp2 = r22 .def tmp3 = r23 .equ UC_REG = 0xC000 .equ RX_Buffer = 0x7C00 .macro USART_TRANSMITT_M utm_l0: wdr sbis UCSRA, UDRE rjmp utm_l0 out UDR, tmp .endm .macro WAIT_PUSK mov tmp, command andi tmp, 0b00010000 brne wp_l5 mov tmp, command andi tmp, 0b00001110 lsr tmp ldi tmp1, 1 wp_l0: cpi tmp, 0 breq wp_l1 lsl tmp1 dec tmp brne wp_l0 wp_l1: mov tmp, command andi tmp, 0b00000001 brne wp_l2 wp_l3: wdr in tmp2, PINB and tmp2, tmp1 brne wp_l3 wp_l4: wdr in tmp2, PINB and tmp2, tmp1 breq wp_l4 rjmp wp_l5 wp_l2: wdr in tmp2, PINB and tmp2, tmp1 breq wp_l2 wp_l6: wdr in tmp2, PINB and tmp2, tmp1 brne wp_l6 wp_l5: .endm .macro ANALYZE_CLK_6 ac6_l0: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle dec tmp3 // 1 cycle brne ac6_l0 // 2 cycles or // 1 cycle dec tmp3 // 1 cycle ac6_l1: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle dec tmp3 // 1 cycle brne ac6_l1 // 2 cycles dec tmp3 in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle .endm .macro ANALYZE_CLK_8 ac8_l0: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle nop // +2 cyle nop dec tmp3 // 1 cycle brne ac8_l0 // 2 cycles or // 1 cycle dec tmp3 // 1 cycle ac8_l1: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle nop // +2 cyle nop dec tmp3 // 1 cycle brne ac8_l1 // 2 cycles dec tmp3 in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle .endm .macro ANALYZE_CLK_16 ac16_l0: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle ldi tmp1, 3 // +10 cyle ac16_l2: dec tmp1 brne ac16_l2 nop dec tmp3 // 1 cycle brne ac16_l0 // 2 cycles or // 1 cycle dec tmp3 // 1 cycle ac16_l1: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle ldi tmp1, 3 // +10 cyle ac16_l3: dec tmp1 brne ac16_l3 nop dec tmp3 // 1 cycle brne ac16_l1 // 2 cycles dec tmp3 in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle .endm .macro ANALYZE_CLK_32 ac32_l0: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle ldi tmp1, 8 // +26 cyle ac32_l2: dec tmp1 brne ac32_l2 nop nop dec tmp3 // 1 cycle brne ac32_l0 // 2 cycles or // 1 cycle dec tmp3 // 1 cycle ac32_l1: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle ldi tmp1, 8 // +26 cyle ac32_l3: dec tmp1 brne ac32_l3 nop nop dec tmp3 // 1 cycle brne ac32_l3 // 2 cycles dec tmp3 in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle .endm .macro ANALYZE_CLK_64 ac64_l0: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle ldi tmp1, 19 // +58 cyle ac64_l2: dec tmp1 brne ac64_l2 nop dec tmp3 // 1 cycle brne ac64_l0 // 2 cycles or // 1 cycle dec tmp3 // 1 cycle ac64_l1: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle ldi tmp1, 19 // +58 cyle ac64_l3: dec tmp1 brne ac64_l3 nop dec tmp3 // 1 cycle brne ac64_l1 // 2 cycles dec tmp3 in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle .endm .macro ANALYZE_CLK_128 ac128_l0: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle ldi tmp1, 40 // +122 cyle ac128_l2: dec tmp1 brne ac128_l2 nop nop dec tmp3 // 1 cycle brne ac128_l0 // 2 cycles or // 1 cycle dec tmp3 // 1 cycle ac128_l1: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle ldi tmp1, 40 // +122 cyle ac128_l3: dec tmp1 brne ac128_l3 nop nop dec tmp3 // 1 cycle brne ac128_l1 // 2 cycles dec tmp3 in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle .endm .macro ANALYZE_CLK_256 ac256_l0: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle ldi tmp1, 83 // +250 cyle ac256_l2: dec tmp1 brne ac256_l2 nop dec tmp3 // 1 cycle brne ac256_l0 // 2 cycles or // 1 cycle dec tmp3 // 1 cycle ac256_l1: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle ldi tmp1, 83 // +250 cyle ac256_l3: dec tmp1 brne ac256_l3 nop dec tmp3 // 1 cycle brne ac256_l1 // 2 cycles dec tmp3 in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle .endm .macro ANALYZE_CLK_VN acv_l0: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle dec tmp3 // 1 cycle brne acv_l0 // 2 cycles or // 1 cycle dec tmp3 // 1 cycle acv_l1: in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle dec tmp3 // 1 cycle brne acv_l1 // 2 cycles dec tmp3 in tmp, PINB // 1 cycle st Y+, tmp // 2 cycle .endm .org 0 rjmp RESET nop;rjmp INT0 nop;rjmp INT1 nop;rjmp TIMER1_CAPT nop;rjmp TIMER1_COMPA nop;rjmp TIMER1_COMPB nop;rjmp TIMER1_OVF rjmp TIMER0_OVF nop;rjmp SPI_STC rjmp USART_RXC nop;rjmp USART_UDRE nop;rjmp USART_TXC nop;rjmp ANA_COMP nop;rjmp INT2 nop;rjmp TIMER0_COMP nop;rjmp EE_RDY nop;rjmp SPM_RDY RESET:; set stack pointer to top of RAM ldi tmp, high(RAMEND) out SPH, tmp ldi tmp, low(RAMEND) out SPL, tmp; enable WDT with 2,1s timeout ldi tmp, (1
–PAGE_BREAK–program Project1; uses Forms, Unit1 in ‘Unit1.pas’ {Form1}, Unit2 in ‘Unit2.pas’ {Form2}, Unit3 in ‘Unit3.pas’ {Form3}; {$R *.res} begin Application.Initialize; Application.CreateForm(TForm3, Form3); Application.CreateForm(TForm1, Form1); Application.CreateForm(TForm2, Form2); Application.Run; end. #### ###��##��##################�### ###��##��##################(### ###@#####################################�##�###��#�###�#�#��##���#���###�##�###��#�###�#�#��##���##1###############�33331##########��3333##########33333###########������###########33331##DD#######����##FvvD######���1#Gggfv@#####���1#&vvggd######��1#wwgbvt######��1wwwr«gf@#####��1wwwr»vv@#####��3#wr”«gf@#####��3#wr»”&f@#####���#ww«w»”@######��1�wr'””@######��1��w””$#######��1rwr”�########��3#’w”/�#######��3#«ww$�########��##»”##�#######��1#####�#######��1#####��######��3####���p######�31###��##�3333;�31###��##�33333��3###���#��333���3####��#���������####������������####������������#####�###############�#�#���#���#���#���#���#���##�� #�##?�##?�###�###�###�###�###�###�##?�##?�##?�###����������#��~#��>###?###?###?�##?�##?�##?����####0###��##M#A#I#N#I#C#O#N########################### ######�#####
МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ
НАЦІОНАЛЬНИЙ ТЕХНІЧНИЙ УНІВЕРСИТЕТ
“ХАРКІВСЬКИЙ ПОЛІТЕХНІЧНИЙ ІНСТИТУТ”
Факультет xxxxКафедра Обчислювальна техніка та програмування__
Спеціальність Системне програмування xxxx___________
До захисту допускаю
Завідувач кафедри
________________проф._xxxxxxxx
(ініціали та прізвище)
_________________________________
(підпис, дата)
ДИПЛОМНИЙ ПРОЕКТ
Освітньо-каліфікаційного рівня спеціаліст__
Тема проекту:Віртуальний вимірювальний комплекс на базі учбового______ лабораторного стенду EV8031________________________________________
затверджена наказом по НТУ «ХПІ» від “21” листопада2008р. № xxxxx
Харків 2009
Найменування виробу,
об’єкту або теми
Найменування
документу
Фор-
мат
Кільк.
арк.
При-мітка
Документи загальні
Завдання
А4
2
Звіт
А4
91
Програмні документи
Документи дипломного проекту
Технічне завдання
А4
8
Специфікація
А4
2
Текст програми
А4
48
Опис програми
А4
8
Керівництво оператора
А4
7
Плакати
Тема проекту
А1
1
Структурна схема стенду, та розподілення його ресурсів
А1
1
Результати роботи
А1
1
Протокол обміну з COM портом продолжение
–PAGE_BREAK—-PAGE_BREAK–
8
Оформлення пояснювальної записки
01.02.2009
Xxxxx М.В.
9
Підготовка плакатів та доповіді
07.02.2009
Xxxxx М.В.
Керівник ДП _______________________________М.В. Xxxxx___
(підпис і дата) (ініціали та прізвище)
Студент-дипломник _____________________________________
(підпис і дата) (ініціали та прізвище)
ВІРТУАЛЬНИЙ ВИМІРЮВАЛЬНИЙ КОМПЛЕКС НА БАЗІ УЧБОВОГО ЛАБОРАТОРНОГО СТЕНДУ EV8031
Специфікація
xxxxxxx03077-01
Аркушів _2_
Харків 2009
Позначення
Найменування
Примітка
Документація по комплексах
Xxxxx.03077-13 12 01-1
Текст програми
Xxxxx.03077-13 12 01-1-ЛЗ
Текст програми
Xxxxx.03077-13 34 01-1
Керівництво оператора
Xxxxx.03077-13 34 01-1-ЛЗ
Керівництво оператора
Xxxxx.03077-13 13 01-1
Опис програми
Xxxxx.03077-13 13 01-1-ЛЗ
Опис програми
ЗМІСТ
ЗМІСТ
ВСТУП
1 ПІДСТАВА ДЛЯ РОЗРОБКИ
2 ПРИЗНАЧЕННЯ РОЗРОБКИ
3 ВИМОГИ ДО ПРОГРАМНОГО ВИРОБУ
3.1 Вимоги до функціональних характеристик
3.2 Вимоги до надійності
3.3 Умови експлуатації
3.4 Вимоги до складу і параметрів технічних засобів
3.5 Вимоги до інформаційної та програмної сумістності
3.6 Вимоги до маркування й упакування
3.7 Вимоги до транспортування і зберігання
4 ВИМОГИ ДО ПРОГРАМНОЇ ДОКУМЕНТАЦІЇ
5 ТЕХНІКО-ЕКОНОМІЧНІ ПОКАЗНИКИ
6 СТАДІЇ ТА ЕТАПИ РОЗРОБКИ
7 ПОРЯДОК КОНТРОЛЮ І ПРИЙМАННЯ
ВСТУП
Данний програмний продукт є комплексом засобів, які дозволяють виконувати тестування цифрових пристроїв, за допомогою аналізу отриманої з них послідовності у відгук на подані тестові послідовності, за допомогою логічного аналізатора та генератора слів, відповідно.
Система, що розробляється, повинна мати зручний інтерфейс користувача, а зв’язок, зі стендом, повинен виконуватись за допомогою послідовного порту. Також, продукт повинен виглядати у вигляді готових модулів, для зручного запуску, або, у випадку ПЗ мікроконтролера, зручного завантаження стандартними засобами.
1 ПІДСТАВА ДЛЯ РОЗРОБКИ
Підставою для розробки є “завдання на виконання дипломного проекту”, видане викладачем кафедри “Обчислювальної техніки та програмування” xxxxxxxxxxxxxx1xxxі затверджене кафедрою “Обчислювальна техніка та програмування”/протокол № 2/від 7.10.2008, а також наказом № xxxxxx по Національному технічному університету “Харківський політехнічний інститут” від 25.10.2008.
Найменування теми дипломного проекту:”Віртуальний вимірювальний комплекс на базі учбового лабораторного стенду EV8031”.
2 ПРИЗНАЧЕННЯ РОЗРОБКИ
Данний порограмний продукт призначений для налагодження різноманітних цифрових пристроїв, і має для цього декілька віртуальних пристоїв: логічний аналізатор та генератор слів. Подача тестової послідовності забеспечується генератором слів, а аналіз реакції пристрою – за допомогою логічного аналізатора.
Такий віртуальний комплекс дозволяє швидко і зручно налагодити необхідний цифровий пристрій, завдяки зручному інтерфейсу користувача, такому як у пакеті Electronic Workbench.
3 ВИМОГИ ДО ПРОГРАМНОГО ВИРОБУ
3.1 Вимоги до функціональних характеристик
Програмний продукт повинен забеспечувати наступні функціональні можливості:
Для ЛА:
— відображення сигналу на моніторі ПК у вигляді діаграм;
— дозволяти керування логічним аналізатором з ПК (через СОМ порт); продолжение
–PAGE_BREAK–
— можливість змінення масштабів по вісі часу ;
— зсув сигналу за часом;
зміна кольору сигналу;
можливість встановлення частоти реєстрації;
можливість встановлення передпускової реєстрації;
можливість встановлення типу сигналу запуску;
можливість встановлення каналу запуску;
Для ГC:
встановлення послідовності слів, які необхідно генерувати;
можливість встановлення частоти генерації;
можливість встановлення типу генерації: циклічний, одноразовий, пошаговий;
можливість керування запуском та зупенненям;
можливість перемикання ГС та ЛА у парний режим роботи.
3.2 Вимоги до надійності
Програмний вироб повинен забеспечувати виключення тупікових ситуацій в роботі. При обриві лінії зв’язку послідовного інтерфейсу програма повинна видати повідомлення про відсутність зв’язку з пристроєм.
3.3 Умови експлуатації
Програмний продукт “Віртуальний вимірювальний комплекс” повинен безперебійно функціонувати в нормальних умовах експлуатації:
температура навколишнього середовища від 5 до 35°С;
вібрації, зовнішні магнітні, радіаційні і електричні поля не повинні перевищувати норми.
Для нормальної експлуатації системи необхідні початкові знання по експлуатації ПЕОМ.
Вимоги до рівня кваліфікації користувача – мінімальні знання спілкування з Windows-вікнами ПЕОМ.
3.4 Вимоги до складу і параметрів технічних засобів
Для функціонування програмного виробу необхідний ПЕОМ IBM PC AT/ATX з центральним процессором не нижче Pentium!!! або його аналогом, наявність послідовного COM порту.
3.5 Вимоги до інформаційної та програмної сумістності
При написанні програми повинні бути використані можливості які надає операційна система Windows. Програма повинна корректно працювати під керуванням Windows2000/XP.
Для написання модулів віртуального вимірювального комплексу повинна бути використана мова програмування Delphi 7.
3.6 Вимоги до маркування й упакування
На початку кожного файлу вихідних текстів програми записувати наступну інформацію:
ім’я данного файлу: __________________.____.;
функціональне призначення: ______(у проекті)________;
файл створений для дипломного проекта захисту кваліфікації фахівця
зафахом : Системне програмування
тема проекту : Віртуальний вимірювальний комплекс на базі учбового лабораторного стенду EV8031;
керівник :М.І. Скородєлов, викладач кафедри ОТП;
розробник : О.О. Ісмаілов, студент групи КІТ23а;
рік розробки : 2008.
На захисті надати файли програми (проекту) в розпакованому вигляді і упаковані zip або rar архіватором.
3.7 Вимоги до транспортування і зберігання
Транспортування результатів проектування може здійснюватися за допомогою будь-яких доступних носіїв: CD-R, CD-RW, Flash-RAM, HDD.
Берегти на накопичувачах сумістно: файли початкових текстів розробки, виконуваний файл, допоміжні файли і файли документів проекту.
4 ВИМОГИ ДО ПРОГРАМНОЇ ДОКУМЕНТАЦІЇ
Програмна документація програмного продукту “Віртуальний вимірювальний комплекс на базі учбового лабораторного стенду” повинна мітстити наступні документи:
Специфікація;
Текст програми(мікроконтроллера, і ПК);
Опис програми;
Керівництво оператора.
Додаткові вимоги до програмної.
Розробити Звіт про виконання дипломного проекту. У документі Звіт виклад основних розділів дипломного проекту повинен займали не менше 60 сторінок(без урахування розділів по економіці, охорони праці та додатків).
5 ТЕХНІКО-ЕКОНОМІЧНІ ПОКАЗНИКИ
Техніко-економічні показники повинні бути визначені в процессі розробки і зазначені у відповідному розділі звіту про виконання дипломного проекту.
6 СТАДІЇ ТА ЕТАПИ РОЗРОБКИ
Розробка програмного продукту відповідає стадії робочого проекту. Етапи розробки виконують в наступному порядку:
отримання завдання;
збір початкових матеріалів;
огляд літератури й обгрунтування необхідності розробки;
визначення областей застосування;
розробка технічного завдання;
техніко-економічне обгрунтування розробки;
розробка алгоритму розв’язання задачі;
розробка структури програмного продукту;
визначення конфігурації програмних засобів;
розробка пояснювальної записки(розділу або розділів Звіту);
програмування і налагодження програмного продукту;
розробка програмних документів;
тестування програмного продукту;
коректування програми та програмних документів за результатами тестування.
7 ПОРЯДОК КОНТРОЛЮ І ПРИЙМАННЯ
При прийманні дипломної роботи перевіряється:
Комплектність, зміст та оформлення документації згідно розділу 4 цього документу.
Відповідність програмного продукту згідно вимогам до програмного продукту розділу 3 цього документу.
РЕФЕРАТ
Звіт про ДП: 93 стр., 31 рис., 12 табл., 24 джерела
КЛЮЧОВІ СЛОВА: віртуальні пристрої, логічні аналізатори, генератор слів, учбово-лабораторний стенд EV8031.
У данній роботі розглянуте створення программного забеспечення таких віртуальних пристроїв, як:
Логічний аналізатор;
Генератор слів.
Та об’єднання їх у віртуальний вимірювальний комплекс на базі учбового лабораторного стенду.
Розроблено алгоритм і программа реалізації завдання. Чітко сформульовані основні проблеми, існуючі при розробці таких комплексів, та визначені нові підхіди для їх вирішення.
Розглянуті питання охорони праці й навколишнього середовища, проведена техніко-економічна оцінка роботи. На підставі аналізу результатів зроблені висновки й рекомендації для подальшої роботи в данному напрямку. продолжение
–PAGE_BREAK–
РЕФЕРАТ
Отчёт по ДП: 93 стр., 31 рис., 12 табл., 24 источника
КЛЮЧЕВЫЕСЛОВА: виртуальные приборы, логические анализаторы, генератор слов, учебно-лабораторный стенд EV8031.
В данной работе рассматривается создание программного обеспечения таких виртуальных приборов, как:
Логический анализатор;
Генератор слов.
И объединения их в виртуальный измерительный комплекс на базе учебно-лабораторного стенда.
Разработан алгоритм и программа реализации задания. Четко сформулированы основные проблемы, существующие при разработке таких комплексов, и указаны пути их решения.
Рассмотрены вопросы охраны труда и окружающей среды, проведена технико-экономическая оценка работы. На основе анализа результатов сделаны выводы и рекомендации для дальнейшей работы в данном направлении.
ABSTRACT
Report on DP: 93 page, 31 fig., 12 tables., 24 source
KEYWORDS: virtual devices, logic analyzers, generator of words, educational laboratory stand EV8031.
Creation of software of such virtual devices is examined in this work, as:
— Logic analyzer;
— Generator of words.
And associations them in a virtual measuring complex on the base of educational laboratory stand.
An algorithm and program of realization of task is developed. Basic problems, existing at development of such complexes, are expressly formulated, and the ways of their decision are indicated.
The questions of labour and environment protection are considered, the technical and economic estimation of work is conducted. On the basis of analysis of results conclusions and recommendations are done for further work in this direction.
ЗМІСТ
РЕФЕРАТ
ВСТУП
1 ВИБІР ТА ОБҐРУНТУВАННЯ ОСНОВНИХ ТЕХНІЧНИХ РІШЕНЬ
1.1. Аналіз вихідного технічного завдання та постановка задачі
1.2.Огляд і аналіз аналогічних пристроїв
1.2.1. Портативні вимірювальні комплекси на базі дискретних спеціалізованих приладів
1.2.2. Спеціалізовані мікропроцесорні прилади
1.2.3. Прилади за технологією «віртуальні інструменти»
1.2.3.1. Віртуальні прилади фірми «Белвар»
1.2.3.2. Віртуальні прилади фірми «Omega»
1.2.3.3. Віртуальні прилади фірми «National Instruments»
1.3 Порівняльний аналіз та висновки
1.3.1 Короткі висновки 40
1.4. Зв’язок ВВК з IBM PC
1.4.1 Вибір інтерфейсу зв’язку
2 ОБЗОР АПАРАТНОЇ ЧАСТИНИ
2.1 Лабораторный стенд EV8031
2.1.1 Системний контроллер
2.1.2 Зовнішня пам’ять ОЗП
2.1.3 Порти вводу/виводу
2.1.4 Порт послідовної передачі данних
2.1.5 Мікроконтроллер
2.2 Мікроконтроллер ATMega8515
2.2.1 Архітектура AVR
2.2.2 Розподілення пам’яті мікроконтролера
2.2.3 Порти вводу виводу
Рис. 7 Блок схема порта вводу/виводу
2.2.4 Переривання та обробка переривань
2.2.5 Таймери
2.2.6 Послідовний приємопередавач USART
3 РОЗРОБКА ПРОГРАМНОГО ЗАБЕСПЕЧЕННЯ
3.1 Розробка програмного забеспечення мікроконтроллера продолжение
–PAGE_BREAK–
3.1.1 Розробка логічного аналізатора
3.1.2 Розробка генератора слів
3.1.3 Розробка алгоритму приємо передавача
3.1.4 Розробка головного циклу програми
3.2 Розробка програмного забеспечення ПК
3.2.1 Розробка інтерфейсу логічного аналізатора
Рис. 18 Інтерфейс користувача логічного аналізатора
3.2.2 Розробка інтерфейсу генератора слів
Рис. 19 Інтерфейс користувача генератору слів
3.2.3 Розробка інтерфейсу прийому/передачі
3.2.3 Розробка алгоритму програми
4 ТЕСТУВАННЯ ПРОГРАМНОГО ЗАБЕСПЕЧЕННЯ
5 БІЗНЕС-ПЛАН
5.1 Доцільність виробництва продукту
5.2 Опис характеристик продукту
5.2.1 Найменування та призначення
5.2.2 Загальні параметри продукту
5.3 Оцінка витрат на розробку
5.3.1 Визначення потреби у матеріальних та трудових ресурсах
5.4 Розрахунок витрат та договірної ціни продукту
5.5 Розрахунок витрат на тиражування
5.6 Аналіз стратегії маркетингу
5.6.1 Схема просування товару
5.6.2 Стимулювання продажу
5.6.3 Організація реклами та витрати на неї
5.7 Розробка фінансового плану
5.8 Висновки
6 ОХОРОНА ПРАЦІ ТА НАВКОЛИШНЬОГО СЕРЕДОВИЩА
6.1 Загальні питання охорони праці
6.2 Характеристика виробничого середовища приміщення, де виконується проектна робота
6.3 Аналіз небезпечних і шкідливих факторів
6.4 Виробнича санітарія
6.4.1 Метереологічні умови
6.4.2 Забезпечення виробничого освітлення
6.4.3 Шум
6.4.4 Випромінювання вiд екрана
6.5 Техніка безпеки
6.6 Пожежна безпека
6.7 Охорона навколишнього середовища
6.8 Висновок
ВИСНОВКИ продолжение
–PAGE_BREAK–
ВСТУП
Будь-який IBM-сумісний персональний комп’ютер (ПК), навіть той що декілька років простояв на полиці за непотрібністю, може перетворитися в дуже добрий віртуальний прилад або цілий вимірювальний комплекс. Для цього потрібно лише підключитидо ПК один або декілька не дуже складних зовнішніх пристроїв або плат розширення. При цьому весь інтелектуальний потенциал комп’ютера можна використати для побудови програмної частини приладу, за рахунок якої і будуть реалізовуватися всі його основні функціональні можливості. Віртуальний прилад, таким чином, представляє собою більш чи менш складне програмне забеспечення, яке встановлюється на ПК, та деякого інтерфейсного пристрою (ІП) який дозволяє сполучити ПК з джерелами та приймачами інформації.
Можна разраховувати на те, що віртуальний прилад надає користувачеві набагато більш широкі можливості в порівнянні з класичним вимірювальним приладом, який має той же рівень технічних характеристик.
У даному дипломному проекті як раз і розглядається можливість створення віртуального вимірювального комплексу: логічного аналізатору та генератору слів.
Реальні форми сигналів, діючих, наприклад, на системних шинах, не грають істотної ролі. Важливі тільки їхні логічні стани в ті моменти часу, коли вони сприймаються приладом і містять необхідну інформацію.
Такий комплекс може використовуватися в якості універсального вимірювального приладу, призначеного для запам’ятовування та слідкування за системними сигналами, що надходять на його входи в вигляді «чистих» двійкових сигналів та зберігати їх в своїй внутрішній цифровій пам’яті при налагодженні функціональних вузлів і пристроїв різних апаратних засобів обчислювальної техніки (периферійних пристроїв і т.п.), мікропроцесорних і мікроконтролерних систем різного призначення, радіотехнічних систем і пристроїв, засобів телекомунікації і т.д.
Такий віртуальний вимірювальний комплекс може замінити собою цілий комплект рiзноманiтних вимiрювальних приладiв.
Він дозволяє виконувати наступні дії:
реєстрації послідовності логічних станів водночас і синхронно в багатьох точках схеми та протягом значного часового інтервалу;
реєстрації станів контрольних точок в деякому інтервалі часу, що передує вибраній оператором події;
оперативного подання результатів вимірів в різноманітних форматах, зручних для оператора та що не відрізняються від основних форм документування, таких, наприклад, як шістнадцятирічний формат, двійковий формат, дизасемблерний формат та інші.
Розробці такого віртуального вимірювального комплексу і присвячений даний дипломний проект.
1 ВИБІР ТА ОБҐРУНТУВАННЯ ОСНОВНИХ ТЕХНІЧНИХ РІШЕНЬ
1.1. Аналіз вихідного технічного завдання та постановка задачі
Пристрій, що розробляється в даному дипломному проекті – віртуальний вимірювальний комплекс (ВВК): логічний аналізатор. Такий ВВК може використовуватися в якості універсального вимірювального приладу, призначеного для для запам’ятовування та слідкування за системними сигналами, що надходять на його входи в вигляді «чистих» двійкових сигналів та зберігати їх в своїй внутрішній цифровій пам’яті при налагодженні функціональних вузлів і пристроїв різних апаратних засобів обчислювальної техніки (периферійних пристроїв і т.п.), мікропроцесорних і мікроконтролерних систем різного призначення, радіотехнічних систем і пристроїв, засобів телекомунікації і т.д. Такий ВВК може замінити собою цілий комплект вимірювальних приладів.
Саме через його універсальність, мобільність та легкість у використанні, а також відносно не високу ціну, цей ВВК пропонується для використання у лабораторіях ВУЗу при проведенні лабораторних робіт з таких дисциплін, як „Комп’ютерна електроніка”, „Комп’ютерна схемотехніка”, „Периферійні пристрої” та інші.
Розглянувши весь спектр лабораторних робіт, що проводяться по цих предметах, можна визначити основні технічні вимоги до віртуального вимірювального комплексу: логічного аналізатору, які є достатніми, для того, щоб цей ВВК можна було використовувати при проведенні цих лабораторних робіт. Ці технічні вимоги приведені нижче.
Розроблювальний ВВК повинний мати наступні характеристики:
— У режимі логічного аналізатору:
Кількість каналів – 8;
Кількість станів, що реєструються – 1024;
Тактовий генератор – внутрішній з змінною частотою або зовнішній;
Запуск – за позитивним або негативним перепадом на одній з 8-ми вхідних ліній.
Глибина передпускової реєстрації – задається програмно.
Елементна база – однокриштальний мікроконтролер типу ATMega8515.
Конструктивне виконання – зовнішній пристрій, що підключається до ПК через інтерфейс RS232;
Також, віртуальний вимірювальний комплекс: логічний аналізатор повинен дозволяти у інтерфейсі користувача відображати часові діаграми на екрані ПК. Програма візуалізації має дозволяти виконувати масштабування та скролінг цих діаграм, обирати їх колір, користуватися різноманітними настройками.
З погляду розроблювача такий ВВК – це нестандартний периферійний пристрій, що передає оброблений сигнал на персональний комп’ютер (ПК) для його остаточного аналізу і відображення. Програмні засоби ВВК при цьому повинні забезпечити максимально зручний і звичний для користувача режим введення і відображення інформації: повинний мати вікно, у якому можливо задати параметри і побачити результат (діаграму сигналу).
Процедура взаємодії користувача з ВВК полягає в наступному: користувач, за допомогою спеціального меню, задає настроювання приладу і режим його роботи.
Таким чином загальна задача, яка сформульована в початковому технічному завданні, може бути розбита на окремі функціональні задачі:
Апаратна частина яка приймає і перетворить аналогові сигнали в цифрові;
Програмне забезпечення пристрою: містить у собі питання побудови інтерфейсу і сервісних програм;
Організація зв’язку розроблювального пристрою з комп’ютером;
Для того щоб перейти до розгляду кожної функціональної задачі окремо необхідно розглянути питання, що стосуються пристрою у цілому. Також необхідно розглянути варіанти побудови пристроїв такого типу.
1.2.Огляд і аналіз аналогічних пристроїв
При пошуку складних несправностей в дискретних пристроях виникає необхідність одночасного спостереження декількох сигналів, однократних і аперіодичних, поведінки системи в моменти часу, попередні якій-небудь події або наступні за ним. Такі можливості надає логічний аналізатор — прилад для збору і аналізу даних про реальні умови роботи дискретних пристроїв.
Логічний аналізатор (ЛА) являє собою комбінацію багатоканального реєстратора двійкових сигналів, побудованого на базі швидкодіючого ЗП з розвиненою системою управління процесом запису даних, і екранного пульта-дисплея, що відображає записану в ЗП інформацію в формі, найбільш зручній для її аналізу.
Розрізнюють два типи логічних аналізаторів: аналізатори логічних станів і аналізатори тимчасових діаграм.
Аналізатори логічних станів фіксують стани контрольних точок схеми, що перевіряється під час тактових сигналів, що задаються пристроєм, що перевіряється, і записують процес зміни станів синхронно з його роботою.
Аналізатори тимчасових діаграм фіксують стани контрольних точок схеми, що перевіряється в моменти часу, які задаються незалежно працюючим тактовим внутрішнім генератором аналізатора.
Стани контрольних точок фіксуються в дискретні моменти часу (при подачі тактових сигналів) в двійковій формі; 0- при відсутності сигналу, 1-при його наявності.
Логічні аналізатори мають два основних режими: реєстрації і відображення.
Реєстрацією називається процес запису стану сигналів, що поступають по вхідних каналах аналізатора, в його запам’ятовуючі пристрої. Реєстрація починається по сигналу запуску реєстрації, який може бути або зовнішнім сигналом, або кодовим словом, або послідовністю кодових слів.
Відображенням називається процес індикації на екрані електронно-променевої трубки тимчасових діаграм або логічних станів, записаної в ЗП в процесі реєстрації.
Для установки режиму, способу запуску реєстрації, відображення, а також кодових слів запуску реєстрації на панелі управління є перемикачі і гнізда для підключення зовнішніх сигналів.
Оскільки в режимі реєстрації процес запису сигналів в ЗП ЛА йде відповідно до вибраної тактової частоти, сигнали, які за часом коротше чергового тактового періоду і з’являються після тактового сигналу, небудуть записані, хоч і можуть спричинити неясну зміну станів асинхронної логіки. Для виявлення подібної ситуації деякі ЛА мають режим фіксації перешкод. Цей режим не дозволяє виміряти ширину короткого сигналу, однак вказує на його наявність і тимчасове положення. Основними характеристиками ЛА є:
1. число каналів одночасної реєстрації станів сигналів;
2. рівні вхідних логічних сигналів;
3. глибина реєстрації, т.е максимальна кількість запам’ятовувань каналу інформації;
4. максимальна частота реєстрації, що визначає мінімальний інтервал часу між двома послідовними відліками станів вхідних сигналів.
Глибина реєстрації визначається місткістю ЗП, а максимальна частота реєстрації — швидкодією ЗП аналізатора.
Аналізатори, що Випускаються в цей час мають від 8 до 48 каналів реєстрації, частоту реєстрації від 20 до 200 МГц, глибину реєстрації від 64 до 2048 біт на каналі.
Процес реєстрації в ЛА може бути початий при появі на входах:
• спеціально заданого зовнішнього сигналу;
• заданої кодової комбінації (слово стану) сигналів ; продолжение
–PAGE_BREAK–
• заданої послідовності кодових комбінацій.
Існують наступні способи запуску реєстрації: прямий, затриманий і з попередньою установкою.
При прямому запуску сигнал запуску відразу включає процес реєстрації, а при затриманому — через певний час, що задається числом тактів затримки. При запуску з попередньою установкою аналізатор реєструє стани в контрольних точках пристрою, що діагностується незалежно від сигналу запуску і дозволяє зберегти і видати на відображення дані, які були записані за N тактів до появи сигналу і М-N.
В даний час створення багатоцільових, портативних вимірювальних комплексів йде по трьох напрямках:
На базі дискретних спеціалізованих приладів;
Спеціалізовані мікропроцесорні прилади;
Прилади за технологією «віртуальні інструменти»;
Розглянемо ці напрямки більш докладно:
1.2.1. Портативні вимірювальні комплекси на базі дискретних спеціалізованих приладів
Як правило, зараз будь-який пристойний прилад має інтерфейс підключення до комп’ютера й таким образом з’являється можливість створення багатоцільових вимірювальних комплексів, у яких здійснюється взаємозалежне керування роботою приладів, де частина необхідних функцій обробки сигналів здійснюється окремими приладами (у межах закладених у них можливостей), частина функцій разом з вихідними даними приладів передається керуючому комп’ютеру. При такому способі з’являється можливість створення дійсно досить багатофункціональних вимірювальних комплексів. Про портативність подібних комплексів можна говорити, звичайно, з великою натяжкою, хіба тільки в тім смислі, що в принципі вони є переносними.
О промисловому (захищеному) виконанні говорити не приходиться. Вартість висока, надійність низька (велика кількість складових), функціональні можливості фіксовані й обмежені можливостями комплектуючих приладів. Модернізація й адаптація до об’єктів діагностики — дорогі, трудомісткі, у більшості випадків повною мірою просто нездійсненні. Використовуються, в основному, для оснащення лабораторних установок, проведення НИР ОКР і ін.
1.2.2. Спеціалізовані мікропроцесорні прилади
Аналізатори-збирачі. На сьогоднішній день це досить широка номенклатура приладів як вітчизняного, так і імпортного виробництва. Прилади дійсно портативні, багатоцільові, можуть бути у захищеному виконанні аж до забезпечення вимог по іскровзривобезпеки. В останній якості практично не мають альтернативи, але у всіх інших випадках на сьогоднішній день це вже далеко не кращий шлях рішення подібних задач. Справа в тім, що подібні прилади у всіх випадках являють собою, по суті, спеціалізовані «саморобні» портативні комп’ютери з убудованими пристроями вводу-виводу даних і унікальним програмним забезпеченням фірми-виробника. У кожного виробника подібні прилади є зовсім унікальними як по виконанню «у залізі», так і по програмному забезпеченні. Як комп’ютери, по більшості своїх технічних параметрів і сервісних можливостей вони не йдуть ні в яке порівняння з «звичайними» сучасними портативними комп’ютерами, тим більше з темпами їхнього безупинного удосконалювання і зниження вартості. Вартість приладів досить висока і на практиці може збільшуватися (навіть у рази) за рахунок комплектації відповідним програмним забезпеченням. Вартість програмного забезпечення практично завжди порівнянна з вартістю «заліза», а іноді і перевершує його. У цілому можна сказати так: річ гарна, іноді незамінна, але в більшості випадків далеко не краща на сьогоднішній день.
1.2.3. Прилади за технологією «віртуальні інструменти»
Формально термін означає «удавані прилади», власне кажучи, функціонально, це, звичайно, зовсім дійсні прилади і віртуальність їх складається тільки в тім, що окремо, як звичні дискретні прилади «у залізі» вони дійсно не існують. Реалізуються апаратно-програмним шляхом і базуються на трьох основних складовим:
Обчислювальні й апаратні можливості сучасних комп’ютерів, для переносних приладів — це Notebook;
Спеціалізовані мови програмування для задач обробки й аналізу сигналів;
Апаратні пристрої вводу-виводу спеціально розроблені для роботи під керуванням програм, написаних на вищезгаданих спеціалізованих мовах програмування.
Одне з найбільш вдалих і отримавших дуже широке поширення в усьому світі пропозицій по практичній реалізації даної технології створення приладів — апаратні пристрої вводу-виводу і спеціалізована мова графічного програмування LabVIEW фірми National Instruments, США. Обширнейшая бібліотека стандартних функцій обробки сигналів і створення інтерфейсу для користувача (вид приладу на моніторі), налагоджені драйвери взаємодії з апаратними пристроями, величезна номенклатура самих пристроїв вводу-виводу в сполученні з можливостями сучасних комп’ютерів дозволяють при мінімально можливих на сьогоднішній день витратах створювати в дуже короткий термін будь-які складні прилади, причому дуже високої якості. Це обумовлено тим, що всі основні складові подібного приладу (комп’ютер, системне ПО, пристрій вводу-виводу) — це фірмові вироби масового виробництва, протестовані виготовлювачем і гарантовані для забезпечення, що сопрягаются по всім необхідним параметрам, найбільш повного використання всіх можливостей кожного з названих компонентів. При цьому всі основні компоненти безупинно удосконалюються по своїх функціональних і технічних параметрах з повним збереженням наступності з попередніми версіями. Наприклад, раз уже створений в остаточному виді прилад можна переустановити на іншій, більш сучасний комп’ютер і він відразу почне працювати, наприклад, більш швидко без яких-небудь переробок самої програми приладу. З погляду габаритів приладів, навіть теоретично немає нічого рівного, оскільки в габаритах, наприклад, одна сучасного Notebook може бути реалізоване практично необмежена кількість різних приладів. З цим же зв’язані і вартісні показники подібних приладів. Наприклад, навіть один прилад типу стандартного вузькополосногоспектроаналізатору у віртуальному виконанні буде коштувати в 1.5-2 рази дешевше, ніж у традиційному дискретному. З огляду на те, що за технологією віртуальних приладів у рамках разових витрат «на залізо» може бути реалізоване (і так на практиці завжди і відбувається) безліч приладів, вартість подібного рішення стає просто несоизмеримо малої в порівнянні з іншими способами реалізації. Оскільки технологія «віртуальних приладів» являє собою зовсім нову і, можна сказати, революційну технологію в приладобудуванні, вона дозволяє сполучити такі якості, що у процесі удосконалювання традиційних приладів, як правило, сполучити неможливо: краще, дешевше, швидше, надійніше. Розглянемо даний тип приладів більш докладно.
1.2.3.1. Віртуальні прилади фірми «Белвар»
Ця фірма пропонує користувачам цифрові логічні аналізатори у вигляді невеликих приставок до персонального комп’ютера. Наприклад АКС-3161, це професійна модель віртуального 16 – канального логічного аналізатору з частотою дискретизації 200МГц, виконана у вигляді приставки до ПК та підключається до LPT-порту комп’ютера. Має гнучки можливості захвату та відображення цифрового потоку даних, широкими можливостями по роботі з зовнішньою тактовою частотою. Має наступні технічні параметри:
Внутришні частоти дискретизаії 1,25 кГц…200 МГц (17 ступенів)
16 каналів
Буфер даних 131000 виборок на канал
Режими запуску: по шаблону; по фронту; безперервний
Цифровий регістратор: від 4 секунд до 1 часу
Порогова напруга 1,0…2,4 В
Споживча потужність 4,5 Вт (800 мВт у режимі очікування)
Нестабільність частоти дискретизації 0,01%
Вхідна напруга 0…7 В макс.
Вхідна ширина смуги частот 40 МГц
Вхідний імпеданс 100 кОм/8 пФ
Габаритні розміри 150х86х26 мм
Зовнішній вигляд цього логічного аналізатору приведений на рис. 1.1
/>
Рисунок 1.1 Зовнішній вигляд приставки до комп’ютера АСК-3161
Нижче на рис. 1.2 приведено вікно програми інтерфейсу користувача з діаграмою сигналів.
/>
Рисунок 1.2 Вид деяких вікон ПО приставки до комп’ютера АСК-3161
АКС-3162 – віртуальний 16-канальний логічний аналізатор виконаний у вигляді плати розширення в ISA-слот комп’ютера та працює разом з осцилографічною плотою АСК-3101. Єдине для обох плат програмне забезпечення дозволяє синхронізувати і бачити на екрані одночасно 2 канали аналогової та 16 каналів цифрової інформації. Сполучення аналогових та цифрових функцій дозволяє використовувати систему як осцилограф змішаних сигналів для пошуку аналогових перешкод у цифрових схемах, аналізу фронтів, логічних рівнів та ін.
АКС-3162 має наступні технічні параметри:
16 каналів
Мінімальний період виборок: 50 нс у реальному часі
Максимальний період виборок 2,5 мс
Запуск: будь-яка комбінація логічних рівнів на вході аналізатору, або синхронізуючий сигнал з плати осцилографу
Можливість запису до запускаючої події 7872 відліку
Довжина запису 8000 відліків на кожний канал
Вхідний імпеданс 1 МОм/30 пФ
Рівень спарцьовування запуску обираємий: ТТЛ або КМОП
Зовнішній вигляд цього логічного аналізатору приведений на рис. 1.3
/>
Рисунок 1.3 Зовнішній вигляд приставки до комп’ютера АСК-3162
Нижче на рис. 1.4 приведено вікно програми інтерфейсу користувача з діаграмою сигналів.
/>
Рисунок 1.4 Вид деяких вікон ПО приставки до комп’ютера АСК-3162
АКС-3166 – це більш потужний логічний аналізатор, має наступні технічні характеристики:
16 каналів
Діапазон частот дискретизації 2 кГц…200 МГц
Довжина запису 2М слова на канал
Регулювання розміру предзапису та постзапису продолжение
–PAGE_BREAK–
Діапазон установки порогів спрацьовування по входах ±2,5 В с дискретністю 20 мВ
Режими запуску: при наявності шаблону даних, по тривалості шаблону даних, по фронту будь-якого біта даних, за шаблоном даних та/або по фронту будь-якого біту даних у різноманітних комбінаціях
Інтерфейс зв’язку з комп’ютером USB 1.1 або LPT (EPP)
Професійні вимірювальні щупи дозволяють легко і швидко здійснити підключення до контактів аналізуємої плати
Цей логічний аналізатор призначений для аналізу потоку цифрових даних одночасно по 16 каналам з частотою дискретизації до 200 МГц, а також може бути використаний у якості цифрового регістратору даних. Буфер 2М виборок на канал дозволяє забезпечити високу точність часових вимірів достатньо тривалих потоків даних. Гнучкий набір варіантів синхронізації та шаблонів запуску дозволяє визначити різноманітні збої у потоці даних, що приводять до порушення роботи апаратури. Даний аналізатор забезпечує нормальну роботу з апаратурою, яка має різні логічні порогові рівні вхідних сигналів, тому що пороги обираються користувачем.
Інтерфейс користувача програми складається з набору робочих панелей (вікон). Кожна панель має набір керуючих елементів (КЕ), які дозволяють користувачу впливати на роботу програми та індикаторів, що відображають необхідну інформацію. Більшість цих елементів є частиною стандартного інтерфейсу Windowsі не потребують спеціальних пояснень по їх використанню.
Зовнішній вигляд цього логічного аналізатору приведений на рис. 1.5
/>
Рисунок 1.5 Зовнішній вигляд приставки до комп’ютера АСК-3166
Для керування програмою користувач може також використовувати команди спливаючього меню головної панелі. АКС-3166 має зрозумілий та зручний інтерфейс, котрий може налагоджуватися користувачем. Нижче на рис. 1.6 приведено вікно програми інтерфейсу користувача з діаграмою сигналів.
/>
Рисунок 1.6 Вид деяких вікон ПО приставки до комп’ютера АСК-3166
1.2.3.2. Віртуальні прилади фірми «Omega»
Логический анализатор Omega – Logic : використовується для запису аналізу послідовних та паралельних потоків обміну, а також генерації заданих цифрових послідовностей. Збудований на основі базового блоку Omega. Завдяки використанню ПЛІС пристрій має недосяжну для мікроконтролерних аналогів швидкодію та точність обробки даних. 4 режими запису дозволяють оптимально використовувати внутрішню пам’ять аналізатора. Наявність різноманітних вбудованих та користувальницьких засобів аналізу сигналів дає можливість швидко та ефективно оброблювати великі об’єми інформації. Цей аналізатор має наступні технічні параметри:
Логічний аналізатор:
Кількість каналів: 2, 4, 8
Об’єм внутрішньої пам’яті: 128 КБайт (опціонально 512K)
Режими запису: нормальний, адаптивний, дельта, з зовнішньою синхронізацією.
Максимальна частота запису: 20 МГц.
Стабільність задаючього генератора: +/-100ppm (опціонально +/-25ppm)
Аналізатор протоколів: I2C, MicroWire, SPI, RS232, 1Wire, CAN …
Налагодження режимів відображення інформації (двійковий, десятковий, шістнадцятковий, символьний).
Вбудована макромова аналізу і генерації послідовностей.
Збереження даних у файли різних форматів.
Генератор: 8 каналів, 128 КБайт пам’яті, максимальна частота — 20 МГц, однократний та циклічний режим.
Логічний пробник — 16 каналів.
Електричні параметри (з адаптером LA16):
— Вхідний опір — 100 кОм
— Вихідний опір — 100 Ом
— Вхідна ємність — 10 пФ (без кабелю)
— Напруга порогового рівня — 1.4В (TTL)
1.2.3.3. Віртуальні прилади фірми «NationalInstruments»
Ця фірма є розробником технології віртуальних приладів – революційної концепції, що змінила підхід та методику проведення вимірів та розробки систем автоматизації. Максимально використовуючи можливості комп’ютерів та сучасних інформаційних технологій, віртуальні прилади дозволили збільшити продуктивність і знизити собівартість рішень за рахунок використання гнучкого та простого у освоєнні програмного забезпечення, такого як середовище графічного програмування LabVIEW, а також модульного обладнання, такого як, наприклад, модулі стандарту PXI, призначеного для збору даних та керуванням приладами.
Розглядаючи новітні прилади збору даних цієї фірми, можна виділити наступні: це універсальній зовнішній пристрій збору даних USB 6008/6009, а також внутрішні плати збору даних М серії, що мають стандартній та поширений для звичайних ПК швидкий інтерфейс РСІ.
Розглянемо тепер більш детально технічні характеристики цих приладів:
USB 6008/6009 зображено на рис. 1.7.
8 каналів аналогового вводу, з дозволом 12 або 14 біт, частота оцифровки до 48 кГц;
Гвитові термінали для підключення датчиків;
Швидке plug-and-playпідключення до ПК;
Драйвери для ОС Windows, MacOSXта Linux;
Багатофункціональний ввід/вивід для проведення збору та збереження даних;
Живлення по шині USB;
Безкоштовне ПО для збору та збереження даних.
/>
Рисунок 1.7 Зовнішній вигляд приставки до комп’ютера USB 6008/6009
Плати збору даних М серії зображено на рис. 1.8.
До 32 аналогових входів, 4 виходів та 48 цифрових ліній;
Дозвіл до 18 розрядів;
Програмує мий вхідний діапазон;
Аналоговий вивід до 2,8 МГц (16 розрядів);
Високошвидкісний (до 10 МГц) ввід/вивід цифрових сигналів;
У 5 разів покращена точність вимірів за рахунок нелінійної калібрування в усіх діапазонах;
Повна підтримка LabVIEWта інструментального драйверу NI-DAQmx.
/>
Рисунок 1.8 Зовнішній вигляд плати збору даних М серії
LabVIEWявляє собою високоефективне середовище графічного програмування, у якому можна створювати гнучкі та масштабовані прикладні програми вимірів, керування та тестування з мінімальними часовими та грошовими затратами. Приклад прикладної програми вимірів, створеної у LabVIEWзображено на рис.1.9.
/>
Рисунок 1.9 Зовнішній вигляд вікон прикладної програми вимірів,
створеної у LabVIEW
LabVIEWсполучає у собі гнучкість традиційної мови програмування з інтерактивною технологією Експрес ВП, яка включає у себе автоматичне створення коду, використання помічників при конфігуруванні вимірів, шаблони прикладних програм та Експрес ВП, що налагоджуються. Завдяки цим особливостям, і експерти можуть легко та швидко створювати прикладні програми у LabVIEW.
1.3 Порівняльний аналіз та висновки
Задачу реалізації ВВК аналогічного розроблювальному, можна вирішити декількома шляхами:
За допомогою спеціалізованих плат (реалізація на «твердій» логіці). Даний спосіб дозволяє мінімізувати як розміри, так і вартість апаратної частини, але при цьому зростають вимоги до ПК, тому що на нього лягає вся обробка вхідного сигналу.
За допомогою плат на «програмувальній» логіці. Даний спосіб дозволяє не тільки передбачити захист плати від позамежного рівня вхідного сигналу, але і перекласти частину його обробки на мікроконтролер плати, що дозволяє розвантажити ПК.
1.3.1 Короткі висновки
Як видно з приведеного порівняння реалізація ВВК за допомогою «твердої» логіки приводить до значно менших грошових витрат, але при цьому і швидкість роботи усього ВВК, і можливість використовувати ПК у багатозадачном режимі різко знижуються через велику кількість обчислень, що виконує ПК. Приймаючи це до уваги, у процесі дипломного проектування був розроблений ВВК на «програмувальній» логіці, що дозволило в значній мірі розвантажити ПК, і значно зменшити число даних для обміну, тому що вся попередня обробка сигналу виконується мікроконтролером.
1.4. Зв’язок ВВК з IBMPC
Підключення ВВК до ПК можна здійснити використовуючи будь-який убудований інтерфейс. Коротке порівняння деяких з них приведено в табл. 1.
Таблиця 1.
Порівняння методів підключення ВIК продолжение
–PAGE_BREAK–
Системна магістраль ISA
Інтерфейс
Centronics
Інтерфейс
RS-232C
Швидкість обміну
Висока (до 5 Мбайт/с і вище)
до 100 Кбайт/с
115200 Кбiт/с
Довжина і тип лінії зв’язку з комп’ютером
Вбудовані ПС (лінія зв’язку відсутня)
До 2 м, багатопровідний кабель
До 15м, одиночний провід
Складність вузлів сполучення з ПК
Від малої до середньої
Від малої до середньої
Від середньої до високої
Додатковий конструктив
Не потрібний
Потрібний
Потрібний
Зовнішнє джерело живлення
Не потрібне
Потрібне
Потрібне
Формат і розрядність даних
Паралельний,
16 розрядів
Паралельний,
8 розрядів
Послідовний
Необхідність наявності драйвера
+
+
–
Кількість ПС, що підключаються до ПК
До 6
1
1
З погляду розроблювального ВВК найбільш привабливим виглядає інтерфейс RS-232.
1.4.1 Вибір інтерфейсу зв’язку
У розроблювальному ВВК зв’язок пристрою з ПК буде здійснюватися за допомогою COM порту (інтерфейс RS-232). Даний вид зв’язку дозволяє забезпечити достатню для роботи ВВК швидкість і при цьому є найбільш зручним з погляду ПО, тому що не вимагає спеціального драйвера. Розглянемо цей інтерфейс більш докладно.
2 ОБЗОР АПАРАТНОЇ ЧАСТИНИ
2.1 Лабораторный стенд EV8031
/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>
Рис. 1 Блок схема стенду EV8031
Вся логіка стенду реалізована на програмуємій логічній мікросхемі EPM7128STC100. Системний контроллер керує режимами роботи, виробу керуючих сигналів на ОЗП, регістри защіпки, динамічним світлодіодним індикатором, клавіатурою.
2.1.1 Системний контроллер
Системний контроллер зв’язаний з мікроконтроллером за допомогою шини данних AD0..7 та старших 4-х біт адресу A12..15. Коли мікроконтроллер виконує операцію читання/запису данних у зовнішню пам’ять спочатку на лінії AD0..7(мультиплексується із A0..7 на момент синхроімпульсу лінії ALE) та лінії A8..15 виводиться адрес комірки, молодші 8 біт та старші – відповідно. Після закінчення синхроімпульсу ALEна лініях AD0..7 з’являється 8 біт данних. Коли старший біт адресу дорівнює 1, системний контроллер залишає лінію nRCSу високому стані, і старші 4 біта адресу, разом із молодшим байтом адресу, який надійшов по лініям AD0..7 у період синхроімпульсу, тепер керують адресою пристрою котрому надсилається керуючий байт. Перелік адрес за якими розташовані керуючі слова пристроїв наданий у таблиці 2.1.
Таблиця 2.1.
Адрес
Тип цикла
B7
B6
B5
B4
B3
B2
B1
B
Имя
Порты периферийных устройств
8xx
Запись
[Порт A]
PA_REG
8xx1
Запись
[Порт B]
PB_REG
8xx2
Запись
[Порт C]
PC_REG
8xx3
Запись
x
x
x
x
x
TRISC
x
x
TRIS продолжение
–PAGE_BREAK—-PAGE_BREAK–
2.1.2 Зовнішня пам’ять ОЗП
Коли старший 15 біт адресу дорівнює 0 системний контроллер встановлює лінію вибору кристаллу ОЗП – nRCSу низький логічний рівень, а лінії nRRDта nRWRповторюють стани ліній nRDта nWRвідповідно. Лінія RA14 повторює лінію A14тільки у тому випадку якщо вибраний режим роботи стенда із мікроконтроллером AVR. У випадку роботи із мікроконтроллером 80C51 лінією буде керувати системний контроллер перші 16кбайт – коди інструкцій программи, другі 16кбайт – данні.
2.1.3 Порти вводу/виводу
Стенд має три 8-ми бітних портів вводу/виводу PORTA(лінії PA0..7), PORTB(лінії PB0..7), PORTC(лінії PC0..7). Порти PORTA та PORTB виконані на регістрах защіпках і працюють тільки на виход, а PORTC – у системному контроллері і може працювати як на вход так і на виход. Коли мікроконтроллер записує байт по адресу 8xx0(x – не впливають і можуть бути будь якими), системний контроллер встановлює лінію PACLK у високий стан. Регістр защіпка запам’ятовує лінії AD0..7 та повторює іх стан на своїх вихідних лініях – PA0..7. Аналогічно отримується доступ до портів PORTB та PORTCале доступ виконується за адресами 8xx1 та 8хх2 відповідно. За адресою 8хх3 знаходиться байт керування режимом роботи на вхід або на вихід, за відповідає біт 2. Якщо він дорівнює 0 порт працює на вхід, якщо 1 на вихід.
2.1.4 Порт послідовної передачі данних
Модуль послідовного зв’язку створений на мікросхемі приймача 1489, передавача 74НС04, мултиплексора каналу передачі (усередині системного контроллеру). Вибор каналу послідовної передачі забеспечується сигналами CFG1,CFG0 за адресою 9001h(см. таблицу 1). Програмне встановлення сигналів CFG0 у ‘1’, а CFG1 у ’0’ формує вибір додаткового каналу послідовної передачі данних, гніздо X12. Додатковий послідовний канал має повний набір сигналів інтерфейсу RS-232C. Сам пристрій який реалізує послідовну прийом/передачу знаходиться у мікроконтроллері і називається UARTабо USART, його лінії RxD, TxDзв’язані із системним контроллером, а він в свою чергу може комутувати їх на 3 напрямки:COM1, COM2, RS485.
2.1.5 Мікроконтроллер
Стенд підтримує 2 типи мікроконтроллерів: мікроконтроллер AT89C51 із ядром і8031, та ATMega8515 із AVRядром який і розглядається у данному документі. Для перемиканням між режимами підтримки першого або другого мікроконтроллеру, системний контроллер має лінію Х9(0 – AVR, 1 — i8031).
2.2 Мікроконтроллер ATMega8515
КМОП мікроконтроллер АТ8515 реалізований за AVRRISCархітектурою (Гарвардська архітектура із роздільною пам’яттю та роздільними шинами для пам’яті програм та даних) та сумісний за похідним кодом і тактуванню із 8-ми розрядними мікроконтролерами родини FVR. Виконуючи команди за один тактовий цикл, він забезпечує могутню систему команд із 32-ма 8-розрядними регістрами загального призначення та конвеєрне звернення до пам’яті програм. Шість із 32 регістрів можуть використовуватись як три 16-розрядних регістра-вказіника при косвенній адресації простору пам’яті. Виконання відносних переходів та команд виклику реалізується із прямою адресацією усіх 4К адресного простору. Адреса периферійних функцій міститься у просторі пам’яті вводу/виводу. Архітектура ефективно підтримує як мови високого рівня, так і програми на мовах асемблеру.
2.2.1 Архітектура AVR
Мікроконтроллер має 32 регістри загального призначення які безпосередньо підключені до АЛУ, це дозволяє виконувати більшість команд за один такт. Мікроконтроллер має 8 кбайт неодноразово-програмуємої пам’яті программ, 512 байт внутрішнього ПЗП, 512 байт внутрішнього ОЗП та інтерфейс який дозволяє розширити ций об’єм завдяки підключенню зовнішнього ОЗП, 4 – 8-ми бітних порта та 1 – 3-х бітний порт, 1 – 8-ми бітний таймер та 1 – 16 – бітний таймер, які мають зовнішні лінії синхронізації, переривання за переповненням та зрівненням. Також мікроконтроллер має зовнішні переривання, послідовний програмуємий приемопередавач, програмуємий “WatchDog” таймер із окремим RC-генератором, порт SPIта три програмуємі режими роботи єнергосбереження.
/>
Рис 1. Блок схема мікроконтроллеру ATMega8515
2.2.2 Розподілення пам’яті мікроконтролера
Розподілення пам’яті мікроконтроллера показано на рис. 2.
Внутрішній ОЗП мікроконтроллеру розташований за адресою 0060h та закінчується 025Fh. Починаючи з адреси 0260hдо FFFFhможна адресувати зовнішню пам’ять. На рис. 3 надана структурна схема підключення зовнішнього ОЗП до мікроконтроллеру.
/>
Рис 2. Розподілення пам’яті мікроконтроллера.
Внутрішній ОЗП мікроконтроллеру розташований за адресою 0060h та закінчується 025Fh. Починаючи з адреси 0260hдо FFFFhможна адресувати зовнішню пам’ять. На рис. 3 надана структурна схема підключення зовнішнього ОЗП до мікроконтроллеру.
Рис. 3 Структурна схема підключення ОЗП до мікроконтроллера
/>
На відміну від внутрішньої пам’яті доступ до зовнішньої триває довше на 1 такт(або на 2 такти у залежності від налаштовувань). На рис. 4 подана
часова діаграма доступу до зовнішньої пам’яті:
/>
Рис. 4 Часова діаграма доступу до зовнішньої пам’яті.
Робота зовнішнього СОЗП(SRAM) налаштовується за допомогою регістру MCUCR рис 5.
/>
Рис. 5 Опис полів регістру MCUCR
Робота зовнішнього SRAM дозволяється встановленням біту SREу регістрі MCUCR. За зрівняннями зі зверненням до внутрішньої пам’яті даних, звернення до зовнішньої пам’яті потребує додаткового циклу на кожний байт. Це означає, що для виконання команд LD, ST, LDS, STS, PUSHта POPпотрібен додатковий тактовий цикл. Якщо стек розташований у зовнішній SRAM, то для переривання, виклику підпрограм та вертання потрібно буде два додаткових цикла, оскільки в стеку буде зберігатися та відновлятися двубайтовий лічильник команд. Якщо інтерфейс із зовнішньою пам’яттю використовується із станом чекання, то на кожний байт необхідно ще два додаткових тактових цикла. Це призводить до наступного ефекту. Командам пересилання даних необхідно два додаткових тактових цикла, тоді для обробки переривання, виклику підпрограми та при вертанні з підпрограми потрібно на чотири тактових циклу більше, ніж це вказано в описі системи команд.
Встановлений у 1 біт SRE дозволяє звернення до зовнішнього SRAMданих та переводить роботу портів А, С, ліній WRта RDна виконання альтернативної функції, також змінюється напрямок роботи портів. Після встановлення SRE у 0 звертання до зовнішньої пам’яті недозволяється, а напрямок роботи портів встановлюється у читання.
При встановленому у 1 SRWдо циклу звертання до зовнішнього SRAMдозволяється один цикл чекання. При скиданні у 0 біті SRW звертання до зовнішнього SRAM виконується за 3 цикли. См. рис. 4 Цикл та звернення до зовнішнього SRAM без стану очікування, та рис. 6 із станом очікування. продолжение
–PAGE_BREAK–
/>
Рис.6 Звернення до зовнішньої SRAM зі станом очікування
2.2.3 Порти вводу виводу
Порти вводу/виводу можуть робити на вхід та на вихід. За це відповідає відповідний регістр напрямку DDRx(x-назва порту A, B…). Також порт має регістр стану PORTx запис данних у який відображається на порт, якщо порт знаходиться у режимі видачі. А якщо порт працює у режимі читання цей регістр вмикає/вимикає підтягуючі резистори. Для читання порту використовується регістр PINx. Також більшість портів мають альтернативні функції і коли порт іх виконує, відповідні регістри DDRx, PORTxта PINxне впливають на роботу порта. На рис. 7 зображена блок-схема порта який немає альтернативної функції.
/>
Рис. 7 Блок схема порта вводу/виводу
2.2.4 Переривання та обробка переривань
Найважливіша характеристика будьякого мікроконтроллера це — час відгуку на переривання. Відгук на виконання усіх дозволених переривань AVRскладає мінімум 4 тактових цикла. Впродовж 4 тактових циклів вміст лічильника команд(2 байта) зберігається у стек, та вказівник стеку зменшується на 2. Вектор вказує перехід на підпрограму обробки переривання та цей перехід займає 3 тактових цикла. Якщо переривання виникає за час виконання багатоциклової команди, то команда закінчує виконання, а потім обслуговується переривання. Вертання з підпрограми обробки переривання (як і виклик підпрограми) займає 4 тактових цикла. Впродовж цих 4 циклів стан лічильника команд (2 байта) відновляється зі стеку та вказівник стеку збільшується на 2. Коли мікроконтроллер виходить з перервання, він завжди вертається у основну програму та виконує ще одну команду, перш ніж почати обслуговувати якесь відкладене переривання.
Відзначимо, що регістр статусу SREGне обробляється апаратними можливостями AVR,ані для переривань, ані для підпрограм.
При обробці підпрограм переривань, які потребують збереження SREG, збереження потрібно виконувати програмними засобами користувача. Для переривань, які запускаються статичними подіями (наприклад співпадання вмісту регістру зрівняння 1А із станом таймеру/лічильника1). Прапорець переривання встановлюється у момент виникнення події. Якщо прапорець скинутий, але умови виникнення переривання продовжують існувати, прапорець не буде встановлюватись до тих пір, доки ця подія не виникне знову.
2.2.5 Таймери
Мікроконтроллер має один 8-розрядний та один 16-розрядний таймери лічильники. Вони можуть тактуватися, як від внутрішнього, так і від зовнішнього генератора. Блок схеми таймерів зображена на рис. 8 та рис. 9. Кожний таймер має свій окремий попередній дільник із чотирма ступенями ділення: CK/8, CK/64, CK/256, CK/1024, де CK– це вхідний тактовий сигнал. Цей тактовий сигнал, за замовчуванням, з’єднаний із головним тактовим сигналом системи. Обидва таймери мають загальний регістр стану таймерів, у якому зберігаються такі прапори стану, як:переповнення, співпадання за зрівненням та захвату події. Встановлення дозволення/недозволення переривань виконується у регістрі масок переривань таймерів/лічільників TIMSK. При тактуванні таймеру/лічильника від зовнішнього генератора цей сигнал синхронізується із тактовою частотою CPU. Для запеспечення правильної синхронізації зовнішнього сигналу необхідно, щоб мінімальний час між двома вхідними тактовими тактовими циклами був не менш одного циклу внутрішнього тактового сигналу CPU. Зовнішній тактовий сигнал синхронізується за підніманням фронту внутрішнього тактового сигналу CPU.Точність таймерів росте зі зменшенням коєфіцієнту попереднього ділення. Аналогічним чином, високий коефіцієнт попереднього ділення зручно використовувати при реалізації функцій із низькою швидкістю виконання, або точної синхронізації рідко виникаючих дій. Оба таймери підтримують зрівнення.
2.2.6 Послідовний приємопередавач USART
Блок-схема передавача USART показана на рис. 10. Передача данних починається записом передаваємих данних у регістр данних I/O USART(UDR). Дані пересилаються з UDR у зсувний регісир передачі у наступних випадках:
Новий символ записаний в UDR після того, як був виданий з регістру стоповий біт попереднього символа. Зсувний регістр завантажується миттєво.
/>
Рис. 8 Блок схема 8-ми бітного таймеру мікроконтроллеру
/>
Рис.9 блок-схема 16-бітного таймеру мікроконтроллера
/>
Рис. 10 Блок-схема послідовного приємопередавача
Якщо з 10 або 11-розрядного зсувного регістру видана вся інформація(зсувний регістр передачі пустий), дані з UDRнадсилаються у зсувний регістр. У цей час встановлюється біт UDRE(USARTDataRegisterEmpty) регістру статуса USART(UCSRA). При встановленому у стан 1 біті UDRE USART готовий прийняти наступний символ. Запис в UDR очищує біт UDRE. У цей самий час, коли дані пересилаються з UDR у 10(11)-розрядний зсувний регістр, біт 0 зсувного регістру скидається у стан 0(стан 0-стартовий біт), а біт 9 та 10 встановлюється у стан 1(стан 1 – стоповий біт). Також приємопередавач має налаштування для організації приємопередавача 9 бітних символів, налаштувати швидкість передачі можна за допомогою спеціального бод-генератора. Бод-генератор представляє собою дільник, генеруючий імпульси передачі із частотою, яка визначається виразом:
/>
Де BAUD– частота в бодах, Fosc– частота тактового генератору CPU, UBRR– вміст регістру UBRRHта UBRRL. Для того, щоб можна було точно обирати усі швидкості прийому/передачі потрібно використовувати спеціальні частоти. Прийом виконується асинхронно, коли регістр данних заповнюється прийнятим байтом у регістрі UCSRAвстановлюється біт RXC. Також USARTпідтримує обробку переривань по прийому та по передачі. Більш детальна інформація знаходиться у даташиті, який можна знайти на сайті виробника http:\\www.atmel.com.
3 РОЗРОБКА ПРОГРАМНОГО ЗАБЕСПЕЧЕННЯ
3.1 Розробка програмного забеспечення мікроконтроллера
Розробка програмного забеспечення мікроконтроллера починається із розподілення його ресурсів для створення ПО в цілому. Оскільки мікроконтроллер використовується у складі стенда, треба взяти на увагу ресурси, які займає стенд, і оскільки він представляє собою закінчений пристрій, треба знайти вільні ресурси, які можна використовувати, без внесення змін у схему або монтажу печатної плати. На рис. 11 зображена принципова схема стенду. Стенд має два роз’єма розширення, один системний(X1) другий періферцйний(X10). Періферійний має 2 порта які працюють на вихід, 1 порт мікроконтроллера який просто виведений на раз’єм розширення і 1 порт який реалізований у системному контроллері. Для реалізації логічного аналізатора можна використати порт мікроконтроллера, який виведений на роз’єм розширення, а для реалізації генератора слів можна використати порт А стенду. Схема розподілення ресурсів стенду показана на рис. 12.
/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>
/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>
Рис. 12 Схема розподілення ресурсів стенду
3.1.1 Розробка логічного аналізатора
Найпростіший алгоритм, за яким можна зробити реестрацію вхідної послідовності, це лінійна послідовність команд, які читають порт та запам’ятовують данні у регістри. Всьго у мікроконтроллера ATMega8515 32 регістри, тому алгоритм дозволяє прочитати та зберегти 32 стани порту, а так як команда читання порту у регістр(inR0, PINB) займає 1 такт, такий код виконується із максимальною швидкістю. Швидкість буде дорівнювати швидкості тактового генератору мікроконтроллера – 7 372 800 Гц. продолжение
–PAGE_BREAK–
/>
/>
/>
/>
/>
/>
/>/>
/>/>
/>/>
Рис 13. Блок схема алгоритму найшвидшої реестрації
Наступний алгоритм менш швидкий але дозволяє зареєструвати 512 станів вхідної послідовності. Він аналогічний попередньому тільки після кожної команди читання порту додається команда збереження у пам’ять. Швидкість виконання такого алгоритму дорівнює 7 372 800/3 = 2 457 600 Гц. Незважаючи на швидкісь код такого алгоритму займає багато пам’яті програм.
Наступний алгоритм дозволяє зареєструвати 1024 стани вхідної послідовності, але має ще менш швидкі характеристики, та займає ще більший об’єм програмної пам’яті мікроконтроллера. Швидкість такого алгоритму 7 372 800/5 = 1 474 560 Гц.
Наступний алгоритм виконує аналогічні дії попередньому але займає набагато менше пам’яті программ. Він складається із 4-ох послідовно розташованих однакових циклів. Це зв’язано з тим, що для підсумку необхідної кількості операцій використовується однобайтовий лічильник. 1024/256 = 4 послідовно розташованих циклів. Швидкість такого алгоритму 7 372 800/8 = 921 600 Гц. Для того щоб зменшити об’єм коду потрібно використати 2-ох байтовий лічильник, але тоді швидкість зменшиться до 7 372 800/9 = 819 200 Гц.
Можна піти іншим шляхом. 1024 у HEX коді це 0400h. А якщо початкова адреса пам’яті данних буде кратною 0100h, для перевірки того, що цикл був виконаний 1024 рази потрібно перевіряти тільки старший байт адреси.
Наступний алгоритм реалізує передпускову реєстрацію. Оскільки невідомо, коли з’явиться необхідна зміна стану пускового каналу, необхідно постійно реєструвати вхідну послідовність. Пам’ять у такому разі треба використовувати по кільцю рис. 15.
Коли виникає необхідна зміна стану пускового каналу, починається відлік зареєстрованих станів, він дорівнює:
1024 – [глибина передпускової реєстрації] (байт)
/>
/>/>/>
/>/>/>/>
/>/>/>
/>/>
/>
/>/>
Рис. 14 Блок схема алгоритму реєстрації, яка виконується за допомогою циклів
/>/>/>/>
/>/>/>/>/>/>
/>/>/>/>
/>/>/>/>/>
Рис. 15 Використання пам’яті по кільцю
Коли вказівник стає на адрес 0700h, вказівник перенаправляється на адресу 0300hі реєстрація продовжується доки кількість зареєстрованих байт не дорівнюватиме 1024. Якщо зміна стану довго не відбувається мікроконтроллер увійде до вічного циклу тому передбачено перевірку на прийом команди “СТОП”. Також алгоритм реалізує керування швидкістю реєстрації. Оскільки для виконання затримки використовується таймер, для перевірки переповнення таймеру треба читати регістр стану, потім перевіряти чи виникла подія. Якщо подія виникла – скинути подію і перезапустити таймер, а інакще – перейти на читання регістру стану таймеру і т.д. Це призводить до того, що реакція на таймер буде залежити від швидкості, яка некратна швидкості 1 циклу перевірки таймеру на наявність події. Але з аналізу лабораторного практикуму необхідні швидкості реєстрації дорівнюють 50 гц тому розбіжність в декілька тактів не буде впливати на зареєстровану послідовність.
Всі алгоритми підпрограм аналізу знаходяться у додатках.
3.1.2 Розробка генератораслів
Генератор слів повинен використовувати порт А стенду. Доступ до цього порту можна отримати тільки завдяки звертанню до пам’яті, за адресою 8000h, це виконується за 4 такти. Можна налагодити мікроконтроллер для того, щоб виконувати доступ за 3 такти, а ле для роботи із пам’ятю потрібно знову переналогодити мікроконтроллер на 4 такти. А операції переналагоджування займуть 2 такти, це призведе до зменшення швидкості алгоритму.
Найшвидший і невеликий за обсягом програмного коду алгоритм читання з пам’яті та видачі у порт зображений на рис. 16
/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>
Рис 16. Блок схема алгоритму генератора слів(швидкий варіант)
Цей алгоритм не надає змогу змінювати швидкість генератору, та може працювати тільки у режимі одноразової генерації.
Наступний алгоритм дозволяє виконувати всі три режими:циклічний, одноразовий та шаговий; для перших двох дозволяє міняти швидкість генерації. Швидкість цього алгоритму набагато менша ніж у попередньому випадку, але відповідає технічному завданню. На початку алгоритму налагоджується початкова адреса ГС, потім перевіряється необхідність запуску таймера(пошаговий режим не використовує таймер). Далі йде тіло циклу, умова виходу з якого це, кінець виданих данних, або натиснення кнопки стоп у режимі цикл. Алгоритм зображений на рис. 17.
/>/>/>/>/>/>
/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>
/>/>/>/>/>/>
/>/>/>/>/>/>/>/>/>/>/>Рис. 17 Блок схема алгоритму генератора слів(повнофункціональний варіант)
3.1.3 Розробка алгоритму приємо передавача
Зв’язок забеспечується за допомогою синхронного/асинхронного приємо передавача RS-232. Але оскільки мікроконтроллер працює від блоку живлення 5 вольт, для зв’язку з ПК необхідний перетворювач рівня сигналів(рівень сигналів RS-232 – +/-12 В). Цей перетворювач існує на платі стенду. Тому для налагодження роботи із портом достатньо настроїти стенд записавши за адресою С000h число 1, це вибір другого режиму роботи послідовного порта(див. Табл. 1).
Пристрій USARTмає сигнали RXDта TXD, сигнал прийому та передачі відповідно. Пристрій підтримує стандартні швидкості і налашьовується за допомогою регістру UBRR. Оскільки периферія мікроконтроллеру тактується від загального тактового генератору, то швидкість передавання може бути із похибкою. Для того, щоб похибки не було у тактовому генераторі використовують спеціальні кварци із частотами кратними швидкостям передачі. Стенд EV8031 має кварц із частотою 7,3728 МГц, що відповідає 0%-ній похибці на усіх швидкостях.
Алгоритм налагодження USART складається з налагодження режиму роботи USART. Це поперше кількість стартових, стопових біт, перевірка на додавання або недодавання, кількість інформаційних біт, дозволити/ заборонити прийом і дозволити/заборонити передачу, дозволити/ заборонити обробку переривань за закінченням приймання або за закінченням передавання. Далі налагоджується швидкість записом у регістр UBRR обчисленого або взятого із таблицї даташиту [1]. У пороцессі розробки була знайдена помилка в роботі мікроконтроллера: він пошкоджує данні регістру UBRR, при виконнанні запису у інші регістри, які відносяться до налагоджування USART. Було прийнято рішення встановлювати швидкість USART останньою операцією його налагодження. В нашому випадку перевірка за додатними/недотаними числами не використовується, кількість інформаціонних біт – 8, 1 стартовий та 1 стоповий біт. Для початку передавання у порт данних необхідно зачекати доки попередній сеанс передачі закінчиться. Це виконується перевіркою біта UDREрегістру UCSRA. Далі для початку передавання байту потрібно записати його у регістр UDR. Після цього USART у фоновому режимі починає передачу і зупиняється коли байт переданий. продолжение
–PAGE_BREAK–
Для передачі масиву данних необхідно виконувати такі сеанси для кожного байту масиву.
Прийом по USART більш складний за передачу. Справа у тому, що прийом повинен бути у фоновому режимі, інакше це треба буде робити у головному циклі програми. Після прийому першого байту, треба чекати і приймати байти тільки на час називаємий таймаут, інакше якщо зв’язок раптом обірветься, або прийнятий байт буде результатом завади на лінії передачі, мікроконтроллер увійде у бекінечний цикл(зависання програми). Для цього USARTмає переривання RXC(Recievecomplete). Коли байт надходить до рнгістру UDRспрацьовує переривання, мікроконтроллер починає виконувати обробник переривання. У обробнику перевіряється наявність першого байту команди, і якщо перший байт вірний, наступного разу виконується ініціалізація таймеру на час таймауту(цей час обчислюєтся згідно зі швидкістю прийому/передачі і кількості приймаємих байт) і піднімається прапорець, згідно з яким починається налаштовування приймаємих байт у пам’яті. Прийом продовжується доки не спрацює переривання за таймером, налаштованим на час таймауту. Обробник переривання таймеру зупиняє відлік і виконує діагностику прийнятої послідовності. Згідно з нею налаштовуються відповідні регістри, флаги і обчислюється код за яким виконується перехід до необхідного алгоритму.
3.1.4 Розробка головного циклу програми
У головному циклі програми виконується перевірка на наявність прийнятої послідовності. Якщо послідовність була прийнята і розпізнана як придатна до виконання виконується налаштовування необхідних пристроїв мікроконтроллера і перехід до необхідної підпрограми. Після виконання необхідного коду у випадку логічного аналізатора виконується передача зареєстрованих данних, у разі генератора слів відповідь, що код виконаний.
3.2 Розробка програмного забеспечення ПК
Розробка програмного забезпечення ПК починається з вибору мови програмування, та визначення, які ресурси комп’ютера і ОС необхідні для реалізації програми. Тому, для розробки програмного забеспечення була обрана мова програмування Delphi 7, а для звертання до ком порту використаний компонент SerialNG. Код цього компонента відкритий, не забороняється його використання у комерційних проектах. Також для відображення проаналізованих данних використаний стандартний компонент Chart, він дозволяє створювати графіки, та налагоджувати способ виводу. Інщі компоненти використані у програмі є загальновідомими і опис іхнього призначення можна знайти у [3].
3.2.1 Розробка інтерфейсу логічного аналізатора
/>
Рис. 18 Інтерфейс користувача логічного аналізатора
Розробка прграмного забеспечення для ПК починається із розробки інтер фейсу користувача. Інтерфейс логічного аналізатора повинен мати елементи керування вибором частоти, вибором пкскового каналу і виглядом сиглалу запуску(за підвищенням або спадом). Головне, користувачеві повинно бути надано діаграму усіх 8-ми каналів за часом, та елементи, які дозволяють виконувати зручний перегляд та пошук необхідних послідовностей. Загальний вигляд розробленого інтерфейсу наданий на рис. 18.
3.2.2 Розробка інтерфейсу генератора слів
/>
Інтерфейс користувача генератору слів повинен мати елементи керування режимом роботи генератора: циклічний, одноразовий та шаговий. Також він повинен дозволяти змінювати швидкість генерації, запускати та зупиняти генерацію. Головним елементом інтерфейсу генератора, є список вводу необхідної послідовності. Він повинен передбачати помилки при вводі шістнадцятирічних чисел, та налаштовуванню діапазонів. Загальний вигляд інтерфейсу користувача зображений на рис. 19.
Рис. 19 Інтерфейс користувача генератору слів
Також мова інтерфейсу яка була використана це російська.
3.2.3 Розробка інтерфейсу прийому/передачі
В усіх випадках, зв’язок виконаний через COMпорт. Як і випадку із мікроконтроллером, необхідно спочатку налагодити порт. Сучасні ОС не дозволяють отримувати безпосередній доступ до портів вводу виводу, метою цього є боротьба за беспеку. Але вони надають спеціальні функції для реалізації таких дій. В данному випадку була обрана ОС Windows 2000 або XP. Вона має необхідний обсяг сервісних функцій для реалізації данної дії, їх називають API. Але при розробці за допомогою API виникли деякі проблеми. Більшість яких була зв’язана із великим обсягом часу для розробки стійкого коду роботи із послідовним портом. Були отримані деякі показники, але програма приймала сбійні байти, і інколи зависала. Тому було прийнято рішення використати компонент. Delphi дозволяє створювати і використовувати візуальні компоненти. Ці компоненти спрощують програмування, якщо при розробці непотрібні нестандартні компоненти, але незабороняється іх створювати або встановлювати. В інтернеті можна знайти безліч похідних кодів і багато з них можна використовувати вільно. Одним з таких компонентів є компонент SerialNG. Оскільки останнім часом велика кількість файлів “мігрує”з серверу на сервер, місце знаходження данного компоненту не вказується, але його назви достатньо для пошуку за допомогою відомих пошукових серверів(також не приводиться у цілях реклами). Цей компонент дозволяє візуально налагодити роботу із послідовним портом і нескладний у використанні.
3.2.3 Розробка алгоритму програми
Загальний алгорим за яким працює програма наданий у додатках. Текст програми не містить складних алгоритмів. Можна тільки зазначити, що для фільтрації вводу були використані перехоплювачі повідомлень WM_KEYPRESSED. Обробники таких перехоплювачів змінюють код отриманого символу на неіснуючий, якщо символ виходить за рамки встановлені при розробці обробника. Оскільки код виконаний у вигляді одного програмного модуля, проблем із використанням COM порту не виникає. Треба зазначити, що доступ який надає ОС Windows 2000/XP до порту є монопольним, і якщо на момент виконання данної програми будуть використовуватись інщі програми, які отримують доступ до COM порту, доступ залишиться тільки у вашої програми. Навпаки ж якщо якась з сторонніх програм виконується і доступ до порту належить їй, данна програма не зможе отримати доступ.
4 ТЕСТУВАННЯ ПРОГРАМНОГО ЗАБЕСПЕЧЕННЯ
При тестуванні програмного забеспечення були використані сторонні програмні та апаратні засоби. Одними з таких засобів є монітор послідовних портів wTerm.(рис. 20) Він надає зручний інтерфейс для контролю, передачі, та прийманню данних за допомогою послідовних портів. Перший тест це реакція на команди які надходять із інтерфейсу користувача до стенду. Для цього треба спочатку перевірити стенд. За допомогою wTermв порт передається необхідна послідовність керуючих слів, якщо стенд прийняв послідовність і працює правильно він повинен у відповідь передати відповідь + 1024 байти проаналізованих данних. Для перевірки правильноі працездатності інтерфейсу користувача потрідно з’єднати 2 порти ПК нульмодумним кабелем(прийом передача — схрещені), і wTermнастроїти на роботу із портом COM2. Якщо після натиснення кнопки запуску логічного аналізатора у вікні прийому wTermз’явиться необхідна послідовність, можна спробувати передати логічному аналізатору відповідь у форматі керуючі слова + 1024 байти данних. Якщо данні з’являться у елементі перегляду логічних станів логічного аналізатору можна візуально перевірити іх на достовірність. Аналогічни чином перевіряється генератор слів, тільки для аналізу видаваємих данних використовується осцилограф або ЛА стороннього виробництва. Остаочна перевірка закінчується повноцінною працездатністю програмного забеспечення. Стенд підєднується до порту COM1 і за допомогою генератору сигналів стороннього виробництва перевіряється працездатність ЛА, аналогічно перевіряється ГС, і останній режим – ЛА+ГС можна перевірити з’єднавши шину ЛА і шину ГС перемичками. Після генерації у пошаговому режимі сгенерована послідовність повинна з’являтись у вікні логічного аналізатора.
Остаточна перевірку можна виконати за допомогою генератору сигналів послідовно змцнюючи частоту генерації, таким чином намагаючись зняти реальні технічні показники системи. Але показники які необхідні для проведення лабораторних робіт за аналізом вхідного завдання повністю відповідають показникам працесдатності системи.
/>
Рис. 20 Загальний вигляд монітору послідовного порту wTerm
5 БІЗНЕС-ПЛАН
Резюме
В даному бізнес-плані розглядається можливість реалізації програмного продукту “Віртуальний вимірювальний комплекс”. Даний проект має потребу у інвестиції 1800 грн. Передбачається, що кошти для інвестиції будуть взяті з власного рахунку розробників даного програмного продукту. Розробка програмного продукту триватиме 4 місяці, в ній будуть задіяні 2 спеціаліста, а саме: керівник проекту та програміст. Також буде найнятий інженер для тиражування програмного продукту. Розробка програмного продукту “Віртуальний вимірювальний комплекс” буде вестися на власному комп’ютері розробників, тому кошти для оренди комп’ютеру не потрібні.
В даному бізнес-проекті обрана спрощена форма оподаткування – єдиний податок по ставці 10%. Передбачається, що проект окупиться в перший же рік його реалізації. Потенційними покупцями даного програмного продукту можуть бути:
а) Будинки відпочинку, пансіонати і готелі, підприємства громадського харчування на Чорному й Азовському морях. Для цієї групи потенційних споживачів автономне безперебійне постачання гарячою водою дозволить підвищити рівень обслуговування відпочиваючих. Особлива привабливість гелиосистем для цієї групи клієнтів обумовлена тим, що їхня діяльність протікає в основному в літній період, що є найбільш сприятливим для роботи таких систем. статистичних даних показав, що на Україні функціонує більше 3000 будинків відпочинку й санаторіїв. Для великих пансіонатів і будинків відпочинку час функціонування не обмежується тільки літнім періодом. Тому для них більше кращими будуть двоконтурні системи, що працюють в автоматичному режимі. Для невеликих туристичних баз і кемпінгів, що працюють тільки в літній період, будуть кращими економічної термосифонної системи.
б) Фермерські господарства, селянські садиби, міське населення яке має дачі, для яких використання гелиосистем для одержання гарячої води є комерційно привабливим. Економічний аналіз показує, що якщо підігрів води вироблятися за рахунок електроенергії, то при існуючій собівартості електроенергії на Україні 0.03$/кВт*година матеріальні витрати на придбання колекторів окупаються за 3 роки, якщо вартість теплового колектора не вище 150$/м2. Аналіз статистичних показав, що на Україні функціонує 32400 фермерських господарств, близько 15.9 мільйона чоловік живе в селах і селах і кожна десята міська родина має дачну ділянку. Для структур ці господарства функціонуючих тільки в літній період будуть становити інтерес економічні одноконтурні термосифонні системи гарячого водопостачання й сонячні сушарки. продолжение
–PAGE_BREAK–
в) Громадян зі статком вище за середнє частки, що мають, будинку. Аналіз статистичних даних показав, що таких людей на Україні більше 100 000 чоловік (їхній щомісячний доход перевищує 500$). Для цієї категорії громадян, по міркуваннях забезпечення європейського рівня життя, для незалежності від можливих перебоїв із централізованим постачанням гарячою водою буде привабливим закупити системи сонячних колекторів, що працюють в автоматичному режимі. Прямим підтвердженням привабливості для населення автономних енергетичних систем є успішна реалізація десятками фірм на Україні електронагрівників води. Ціна електронагрівника становить 150-200$, витрати на оплату споживаної електроенергії для гарячого водопостачання родини з 4 чоловік становлять 1$ у день. Істотним недоліком цих систем є те, що вони функціонують тільки при подачі електроенергії. На Україні крім проблеми з постачанням гарячою водою гостро коштує проблема електропостачання. З метою економії практикується відключення електроенергії по кілька разів у добу протягом декількох годин. Таким чином, електронагрівники не в змозі забезпечити дійсно автономне постачання гарячою водою.
г) Будівельних фірм які займаються будівлею елітного житла. Такі фірми будуть постійними клієнтами на ринку гелиосистем. Використання гелиосистем дозволить підвищити не тільки якісні показники комфортності житла, але і його престижність за рахунок наближення до західних стандартів. Аналіз статистичних даних показав, що на Україні працює більше сотні будівельних компаній зазначеного вище профілю. Для таких будівельних фірм уже на стадії проектування житла може бути передбачено, що гаряче водопостачання буде здійснюватися на базі двоконтурних гелиосистем працюючих безперебійно в автоматичному режимі
Ціна нашого програмного продукту, який розроблюється, буде дорівнювати 3540 грн. Прибуток з однієї копії програмного продукту складатиме 590 грн. Передбачається, що в перший рік прибуток складатиме 112690 грн. Аналогів програмного продукту “Віртуальний вимірювальний комплекс ” на ринку СНД та у країнах ближнього зарубіжжя немає.
5.1 Доцільність виробництва продукту
Мета розробки програмного продукту “Віртуальний вимірювальний комплекс ” полягає в тому, що сучасні установи все більше використовують комп’ютерні програмні продукти з діагностичною метою. Для забезпечення точності і логічності при встановленні вольт-амперних характеристик потрібен математичний підхід.
5.2 Опис характеристик продукту
5.2.1 Найменування та призначення
Програмний продукт має назву “Віртуальний вимірювальний комплекс ”. Система проста у використанні й інтуїтивно зрозуміла користувачеві.
Розроблений програмний продукт може бути використаний при перетворенні сонячної енергії у електричну.
5.2.2 Загальні параметри продукту
Функціонування продукту повністю забезпечується стандартною конфігурацією IBM PC/AT сумісних персональних ЕОМ, наявністю процесора CPU-Intel PentiumII, PentiumIIIабо його аналогів AMDК6, AMDK7 і вище з об’ємом оперативної пам’яті 32 Мб, наявністю відеоадаптеру SVGA та накопичувачу на жорсткому магнітному диску об’ємом не менш ніж 400 Мб.
Програмний продукт призначений для праці в середовищі WIN32 для операційної системи Microsoft Windows 98 і вище.
5.3 Оцінка витрат на розробку
5.3.1 Визначення потреби у матеріальних та трудових ресурсах
У таблиці 5.1 приведені витрати на матеріали при розробці програмного продукту.
Таблиця 5.1— Покупні матеріали при розробці даного продукту
Матеріали
Кількість, шт.
Вартість, грн.
Загальна вартість, грн.
Призначення
Дискети
2
3,00
6,00
Збереження програми
Папір
200
0,03
6,00
Роздруківка вихідних текстів
Література
5
0,00
0,00
Уся література була узята в бібліотеці.
Тонер для принтера
2
8,00
16,00
Роздруківка документації
Сумарна вартість, грн.
28,00
Перелік спеціалістів для реалізації проекту приведений у таблиці 5.2.
Таблиця 5.2— Перелік спеціалістів для реалізації проекту
Спеціаліст
Кількість, чол.
Призначення
Керівник проекту
1
Консультації
Програміст
1
Напис програмного продукту
Інженер
1
Тиражування
Розрахуємо розмір оплати спеціалістів.
Трудовитрати в людино-днях обчислюється по формулі:
Т = Тоф+Та+Тс+Тп+То+Тд, (5.1)
де Тоф – трудомісткість вивчення опису задачі та формулювання її постановки;
Та – трудомісткість на розробку алгоритму програми;
Тс – трудомісткість на складання схеми алгоритму;
Тп – трудомісткість на розробку програми;
То – трудомісткість на налагодження програми;
Тд – трудомісткість на оформлення документації.
Трудовитрати всіх видів визначаються через умовну кількість операторів (Q) програми, що обчисляються по формулі:
/>, (5.2)
де q– передбачувана кількість команд програми;
К– коефіцієнт складності програми (для рішення задач у реальному часі – 1,5);
Р– коефіцієнт корекції програми (від 0,4 до 0,8); n– кількість корекцій програми.
У даному програмному комплексі передбачуване число команд програми – 450. Приймаємо коефіцієнт складності програми К=1,5. При наладці програми, можливо, буде зроблено 6корекцій, з них 4з коефіцієнтом 0,7і 2 з коефіцієнтом 0,3. Виходячи з цих даних, можна обчислити умовну кількість операторів програми: продолжение
–PAGE_BREAK–
Q= 450*1,5*(4*0,7+2*0,3) = 2295умовних операторів.
Трудомісткість на вивчення опису програми і формулювання її постановки визначаємо по формулі:
/>, (5.3)
де Vоф– індивідуальна продуктивність виконавця (команд/години);
дані о продуктивності виконавця приведені у таблиці 6.3;
Ккв– коефіцієнт кваліфікації виконавця; v– коефіцієнт, що враховує якість опису (0,9-1,0), в нашому випадку даний коефіцієнт буде дорівнювати 1.
Таблиця 5.3— Дані о продуктивності виконавця
Вигляд роботи
Продуктивність команд/години
Вивчення опису задачі, формулювання постановки задачі.
80
Розробка алгоритмів рішення задачі
20
Складання схеми програми
15
Розробка програми
20
Наладка програми
5
Оформлення документації
20
Коефіцієнт кваліфікації залежить від стажу роботи й дорівнює:
– до 2-х років – 0.8;
– від 2-х до 3-х років – 1.0;
– від 3-х до 5-ти років – 1.2;
– від 5-ти до 7-ми років – 1.4.
У нашому випадку коефіцієнт кваліфікації буде дорівнювати – 1,4.
Трудовитрати на інші види робіт розраховуємо по формулі:
/>, (5.4)
де i – вигляд роботи;
Vi – продуктивність виконавця (таблиця 6.3).
Зробимо розрахунок трудовитрат, який представлений в таблиці 5.4.
Таблиця 5.4— Розрахунок трудовитрат
Вид роботи
Розрахункова кількість людино-діб
Вивчення опису задачі, формулювання постановки задачі
Тоф=2,56
Розробка алгоритмів рішення задачі
Та= 10,25
Складання схеми програми
Тс= 13,66
Розробка програми
Тп=10,25
Наладка програми
То= 40,98
Оформлення документації
Тд=10,25
Разом:
Т=87,95
Зарплату розробникам можна полічити виходячи з місячного окладу розробника і терміну, необхідного для розробки програмного продукту. Термін розробки визначається виходячи з 22 робочих днів в місяць:
Тм = Т/22 =87,95/22 = 3,99 місяця.
Розрахунок витрат на основну заробітну плату зображений в таблиці 5.5.
Пайова участь керівника проекту дорівнює 20 % від посадового окладу.
Для подальшої реалізації програмного продукту потрібно найняти інженера й встановити йому відрядну заробітну плату у розмірі 1 грн. за створення однієї копії.
Додаткова заробітна плата (Здоп.) вміщує до себе доплати, надбавки, гарантійні і компенсаційні виплати, передбачені законодавством.
Додаткову заробітну плату приймаємо 10 % від Зосн
Таблиця 5.5— Розрахунок заробітної плати
Посада
Оклад, грн.
Кіл-ть, людин.
Час зайн-сті, міс.
Заробітна плата за місяць, грн.
Основна заробітна плата, грн.
Керівник проекту продолжение
–PAGE_BREAK–
300
1
4
300*0.2=60
1200*0.2=240
Програміст
200
1
4
200
800
Разом
260
1040
Таким чином додаткова заробітна плата буде дорівнювати 1040*0,1=104 грн.
5.4 Розрахунок витрат та договірної ціни продукту
При розрахунку експлуатаційних витрат необхідно визначити час налагодження програми (Тмв) на ЕОМ по наступній формулі:
/>, (5.5)
де m– витрати машинного часу на налагодження однієї команди (год.).
В дипломному проекті mприйнято рівним одній хвилині.
Після розрахунку Тмв буде дорівнювати
Тмв=2295/84» 27
Вартість машинного часу визначається по наступній формулі:
Змв= См.ч·Тм.в, (5.6)
де Смч – вартість однієї машино-години, з розрахунку 1 грв за 1 год.
Таким чином вартість машинного часу буде дорівнювати Змв = 27 грв.
До відрахувань на соціальні заходи відносяться:
– відрахування на державне (обов’язкове) соціальне страхування, включаючи і відрахування на обов’язкове медичне страхування, що разом складає 2,5 % від Зосн+Здоп. Відрахування на соціальне страхування складає (1040+104)*0,025=28,60 грн.
– відрахування на державне (обов’язкове) пенсійне страхування (у Пенсійний фонд) складає 32 % від Зосн+Здоп. Відрахування на пенсійне страхування складає (1040+104)*0,32=366,08 грн.
– відрахування у Фонд сприяння зайнятості населення – 2.5 % від Зосн+Здоп. Відрахування у Фонд сприяння зайнятості населення складає (1040+104)*0,025=28,60 грн.
Відрахування на страхування від травматизму – 0,85% від Зосн.+Здоп. Дане відрахування складає (1040+104)*0,0085=9,724 грн.
Разом, відрахування на соціальні заходи складають 37,85% від Зосн. +Здоп. Відрахування на соціальні заходи складають (1040+104)*0,3785=433 грн.
До накладних витрат відносяться витрати на повне відновлення і капітальний ремонт Основного фонду (амортизаційні відрахування), орендна плата, вартість машинного часу, витрати на енергію і т.д. У даній роботі накладні витрати приймаються в розмірі 70 % від Зосн. Накладні витрати 1040*0,7=728 грн.
На підставі проведених розрахунків складаємо розрахунок витрат та договірної ціни програмного продукту, що приведений у таблиці 6.6. Необхідно врахувати те, що розрахунок витрат та договірної ціни проводиться для 100 копій програмного продукту. З цього приводу для розрахунку витрат на 1 копію програмного продукту – суму витрат необхідно поділити на 100.
Таблиця 5.6— Розрахунок витрат та договірної ціни програмного продукту
Найменування статті витрат
Сума, грн.
1. Вартість матеріалів і покупних виробів
28,00
2. Основна заробітна плата
1040,00
3. Додаткова заробітна плата
104,00
4. Відрахування на соціальні заходи
433,00
5. Накладні витрати
728,00
6. Вартість машинного часу
27,00
7. Кошторисна вартість (сума пунктів з 1 по 6)
2360,00
8. Прибуток (25% від пункту 7)
590,00
9. Ціна розроблювача (сума пунктів 7, 8)
2950,00
10. ПДВ (20% від пункту 9)
590,00
11. Ціна продажу (сума пунктів 9, 10)
3540,00
5.5 Розрахунок витрат на тиражування
Витрати на тиражування розраховуються наступним чином:
Зтир=См.ч·Тк+Зд+Зи, (5.7)
де Тк – час копіювання системи (1 копія – 0,034 год);
Зд – вартість дискети (1 дискета –3,0 грн.);
Зи – зарплата інженера (1 грн. – 1 копія);
Смч – вартість однієї машино-години (1 грн.).
Витрати на тиражування однієї копії складуть:
Зтир=1*0,034+3,0+1=4,034 грн.
5.6 Аналіз стратегії маркетингу
Стратегія маркетингу є одним з основних техніко-економічних обґрунтувань програмного продукту, що розробляється. При освоєнні ринку підприємство використовує масовий, диференційований або цільовий маркетинг. У залежності від результатів проведеної сегментації ринку підприємство вибирає стратегію маркетингу, розробляє комплекс заходів щодо її реалізації.
Диференційований маркетинг передбачає вихід відразу на декілька сегментів ринку; розробляється відразу декілька комплексів маркетингу стосовно до кожного сегмента і прикладеної споживачам моделі виробу.
Підприємства з обмеженими ресурсами використовують, як правило, стратегію цільового маркетингу, особливо при достатній місткості вибраного сегмента і відсутності великого числа конкурентів. В нашому випадку найкраще вибрати диференційований або цільовий маркетинг.
5.6.1 Схема просування товару
Структура прямих каналів збуту підприємства, що пропонує продукт, включає наступні підрозділи:
– відділ збуту;
– збутові філіали;
– збутові контори підприємства.
Виробник, організуючі реалізацію своєї продукції через збутові філіали, домагається ряду переваг. За допомогою прямих контактів з споживачами через свій збутовий персонал, що звичайно є в складі збутового філіалу, він може провести більш концентровані і своєчасні заходи щодо просування своєї продукції. Реалізація програмного продукту може відбуватися як безпосередньо через виробника, так і через незалежних посередників (дистриб’юторів). Дистриб’ютори поділяються на наступні групи:
– функціонально – спеціалізовані дистриб’ютори;
– дистриб’ютори з товарною спеціалізацією;
– багато товарні дистриб’ютори.
Цінність оптового посередника для виробника продукції багато в чому залежить від того, як до цього посередника відносяться споживачі. Оптовий посередник, як правило, має можливість поставити вироби споживачеві швидше, ніж виробник, так як його склад звичайно привернений до підприємства споживача ближче, ніж філіал збутового органу виробника. продолжение
–PAGE_BREAK–
Послуги посередника сприяють також скороченню витрат на матеріально – технічне забезпечення і обробку облікової документації. У деяких випадках загальні витрати споживача на придбання виробів у посередника будуть нижчими, ніж у разі придбання його у виробника, який призначає ціну без урахування транспортування і страхування. Посередник же доставляє виріб споживачеві власним транспортом, включаючи вартість доставки відразу в ціну, що вигідніше споживачеві.
Програмний продукт “Віртуальний вимірювальний комплекс ” може продаватися як безпосередньо споживачеві, так і через посередників.
5.6.2 Стимулювання продажу
Стимулювання збуту – це цілеспрямована діяльність підприємства по сприянню потенційним споживачам у виборі і придбанні продукції, що випускається ним або по створенню позитивної думки про неї.
Комплекс маркетингового стимулювання вміщує до себе крім рекламної діяльності наступні методи впливу на процес збуту виробів і послуг:
– персональний продаж;
– формування позитивної громадської думка про продукцію підприємства;
– економічне стимулювання збуту.
У нашому випадку найбільш підходять перший і останній методи, тобто персональний продаж та економічне стимулювання збуту.
Розглянемо їх детальніше.
Персональне (особисте) рекламування передбачає безпосередній контакт представника підприємства з споживачем продукції. У ході персонального продажу представник виробника допомагає споживачеві краще засвоїти переваги і вигоди виробу, що пропонується і переконує останнього придбати його або підтримати торгову марку виробника при спілкуванні з іншими споживачами.
Методами економічного стимулювання, що будуть доречними в нашому випадку, є:
— установка програмного продукту;
— повна технічна підтримка в течії року і консультації.
5.6.3 Організація реклами та витрати на неї
Рекламна діяльність становить важливу і невід’ємну частину загальної системи заходів маркетингу. Головна функція реклами полягає в індивідуалізації виробу, що рекламується, тобто виділенні його з маси конкуруючих на основі виділення якої-небудь відмітної властивості.
Шляхом формування попиту реклама активно впливає на виробництво і сприяє досягненню найбільш ефективних комерційних результатів на ринку. Рекламна діяльність підлегла загальним цілям і стратегії маркетингу, зокрема сприяє підготовці ринку до появи нового товару, підтримує початок продажу, їх розширення, досягнення максимальних об’ємів ринку, забезпечує додатковий продаж продукції в період заключної фази життєвого циклу виробу.
Рекламою для даного програмного продукту стане стаття у журналі “Радіохоббі”.
Вартість розміщення статті в даному виданні становить 60 грн.
5.7 Розробка фінансового плану
Мета даного розділу узагальнити матеріали попередніх розділів та представити їх у вартісному виразі.
В цьому розділі створюються карти прогнозу руху готівки для 1, 2 і 3-го років реалізації програмного продукту “Віртуальний вимірювальний комплекс ”. Для першого року реалізації карта прогнозів складена на місяць, для другого по кварталах, для третього загалом на рік. У карти прогнозу вноситься графа “готівка”, тобто різниця між прибутками і сумою витрат. За допомогою цих карт будується таблиця прибутків та витрат. Карти прогнозів готівки для 1, 2 і 3-го років реалізації програмного продукту “Віртуальний вимірювальний комплекс ” представлені, відповідно, в таблицях 6.7, 6.8 і 6.9. Рух готівки
Таблиця 5.7 — Карта руху готівки за перший рік реалізації
Прибуток, витрати
Сума, грн. по місяцях
Всього
Місяць
січень
лютий
берез
квіт
трав
черв
липень
серп
верес
жовт
лист
груд
Обсяг продаж ПП
5
9
10
12
15
25
31
38
46
191
Прибуток від реалізації
295
5310
5900
708
885
1475
18290 продолжение
–PAGE_BREAK—-PAGE_BREAK–
М
І
Н
Н
І –PAGE_BREAK—-PAGE_BREAK—-PAGE_BREAK–
Сума, грн.
Всього
1 рік
2 рік
3 рік
Кількість продаж
191
220
350
761
Прибуток від продаж
112690
12980
20650
448990
Пост. Витр.
Зарплата(осн+дод)
1144
1144
Відчислення на соціальні заходи:
433
433
Вартість матеріалів
28
28
Накладні витрати при реалізації
728
728
Змін.
Витр.
Витрати на рекламу
60
60
60
180
Вартість машинного часу
108
108
Тиражування
770,494
887,48
1411,9
3069,874
Податок
11269
12980
20650
44899
Всього
14432,494
13927,48
22121,9
50481,874
“Чистий” прибуток
98257,506
115872,52
184378,1
398508,126
Визначимо точку беззбитковості – це такий обсяг продаж, при котрому окупаються всі витрати.
Аналітично вона визначається по формулі:
Тб=(Зпост+Зр)/(Цед-Зпер), (5.8)
де Зпост– постійні витрати на строк реалізації ПП (грн.); продолжение
–PAGE_BREAK–
Зр– витрати на розробку ПП (грн.);
Цед– ціна одиниці продукції (грн.);
Зпер– змінні витрати на одиницю продукції.
Зпостта Зпервизначаються з таблиці прибутків та витрат (табл. 5.10). Зпоствміщує до себе заробітну плату на строк розробки програмного продукту, відчислення на соціальне страхування та накладні витрати. Зпервміщує до себе вартість машинного часу, витрати на тиражування, витрати на рекламу на строк реалізації програмного продукту. Витрати на розробку програмного продукту складаються з витрат на матеріали, що необхідні при розробці програмного продукту й складають 28 грн. Зпостдорівнює 2305 грн. Зпердорівнює 3357,874 грн. Ціна одиниці продукту дорівнює 3540,00 грн. Таким чином точка беззбитковості буде дорівнювати наступному значенню:
Тб=(2305+28)/(3540-3357,874)= 13
Графік беззбитковості зображений на рисунку 5.1.
/>
/>/>
/>/>/>
/>
/>
/>/>
/>/>
/>
/>/>/>
Рис.5.1. Графік беззбитковості.
5.8 Висновки
Проведений аналіз дозволяє зробити висновок про доцільність розробки і продажу програмного продукту “ Віртуальний вимірювальний комплекс ” на ринку.
Собівартість продукту становить 3540грн., а прибуток – 590грн. за одиницю програмного продукту.
Максимальна ціна розробленого програмного продукту дорівнює:
Цmax=1.2·(Ccc+1.3·П) = 1,2·(3540+1,3*590)= 5168,4 грн.
Мінімальна ціна розробленого програмного продукту дорівнює:
Цmin=1.2·(Зтир+Зад+1.3·П)=1,2·(4,34+0+1,3·59)= 925,2408грн.
Виходячи з отриманих результатів, установимо ціну продажу без обліку ПДВ. Ціна програмного продукту знаходиться в межах:
925,2408грн.
Приймаємо ціну продажу програмного продукту рівної 3540 грн.
За перший рік планується реалізувати 191 одиницю продукції, за другий – 220, за третій – 350. Завдяки розрахунку точці беззбитковості було визначено обсяг продаж, при котрому окупуються усі витрати, він дорівнює 13 програмним продуктам. Потенційними покупцями даного програмного продукту можуть бути різноманітні споживачі електроенергії, та користувачі ЕОМ, що будуть зацікавлені цим програмним продуктом. Рекламу даного програмного продукту планується проводить завдяки спеціалізованому журналу “Радіохоббі” у вигляді статті, в якій буде описано всі можливості даного програмного продукту.
6 ОХОРОНА ПРАЦІ ТА НАВКОЛИШНЬОГО СЕРЕДОВИЩА
В даному розділі дипломного проекту на тему “Віртуальний вимірювальний комплекс на базі учбового лабораторного стенду EV8031 ” розглядаються питання створення оптимальних умов роботи оператора, користувачів розробляємого програмного продукту.
6.1 Загальні питання охорони праці
Охорона праці — це система правових, соціально-економічних, організаційно-технічних, санітарно-гігієнічних і лікувально-профілактичних заходів та засобів, спрямованих на збереження життя, здоров’я і працездатності людини у процесі трудової діяльності.
Завдання охорони праці – звести до мінімуму імовірність ураження або занедужання працюючого з одночасним створенням комфортних умов при максимальній продуктивності праці.
Для даного етапу реалізації програмного продукту питання охорони праці розглядаються щодо умов роботи оператора та науковця при дослідженні.
6.2 Характеристика виробничого середовища приміщення, де
виконується проектна робота
Приміщення міститься на третьому поверсі триповерхового будинку.
Площа приміщення повинна розраховуватись у відповідності з наступними вимогами: на одне робоче місце повинно відводитися 6 м2, об’єм 20 м3. Комп’ютери повинні розміщуватися на відстані не менше 1 м від стін. Відстань між боковими поверхнями комп’ютерів не повинна бути менше 1,2 м. Відстань між тильною поверхнею одного комп’ютера та екраном іншого – 2,5 м.
Категорія будинку за пожежонебезпекою – категорія В [6]. До цієї категорії належать приміщення, в яких знаходяться тверді пальні речовини та матеріали (при запаленні стороннім джерелом продовжують горіти після його зникнення).
Клас приміщення за пожежонебезпекою П-IІа [6].
Ступінь вогнестійкості будівельних конструкцій триповерхового будинку з категорією пожежонебезпеки В – I та II [6].
Клас приміщення за ступенем небезпеки ураження електричним струмом – приміщення з підвищеною небезпекою, тому що в ньому є можливість одночасного дотику людини до маючих з’єднання з землею металоконструкцій будинку, технологічним апаратом, механізмом та ін. з одного боку, та до металевих конструкцій – з іншого [7].
Помешкання повинно бути світлим, сухим i теплим. Підлоги роблять рівними, без вибоїв, щільними, мають не слизьку i зручну для чищення поверхню, i утримуються в чистоті. Радіатори i трубопроводи опалювальної i водопровідної систем обладнуються діелектриками (дерев’яними i т.д.) i закриваються огородженнями. Не можна застосовувати огородження з шаруватого паперового пластика i т.п.
Характеристика електричної мережі, що живить електроустаткування, приміщення: перемінний струм, частота 50 Гц, напруга 220 В, режим нейтралі – глухозаземлена нейтраль, споживча потужність комп’ютера 300 Вт.
6.3 Аналіз небезпечних і шкідливих факторів
У відповідності до ГОСТ 12.0.003–74 [9] при розробці системи, що виконується на комп’ютері, на людину впливають небезпечні та шкідливі фактори, перелік яких приведений в таблиці 7.1.
Таблиця 6.1 – Перелік небезпечних та шкідливих факторів
Найменування небезпечного та шкідливого фактора
Джерело виникнення фактора
Характер дії на людину
Нормируване значення фактора
Нормативний доку-мент
Продовження таблиці 6.1
1
2
3
4
5
1. Підвищений рівень іонізуючих випромінювань в робочій зоні
Екрани та інші по-верхні ЕОМ
Мутагенні процеси, що виникли все-редені орга-нізму
Кількість в 1см3 повітря: позитивних іонів Ф=1500..3000, легких негативних іонів Ф=3000..5000
[10] продолжение
–PAGE_BREAK–
2. Рентгенівське м’яке випроміню-вання
Монітор (ЕПТ)
Мутагенні процеси, що виникли все-редені орга-нізму
На відстані 5 см від екрану рівень випрмінювання не повинен перевіщу-вати 100 мкр/г
[11]
3. Пряма та від-бита блискість
Невірне розташу-вання ПК
Перевтома зорового аналізатору
Покажчик Р=0
[12]
1
2
3
4
5
4. Підвищений рівень статичної електрики
Діалект-рична по-верхя ком-п’ютера, джерела живлення
Ураження струмом
Е≤20 кВ/м
[13]
5.Підвищена або знижена темпе-ратура повітря
Підвищена:
недолік провітрюва-ності примі-щення, від-сутність кондиціоне-рів;
Знижена:
погана опа-люваність приміщення
Порушення терморегуля-ції організму
t=22..24°C
[14]
6. Підвищений рівень шуму на робочому місці
Друкарська техніка, вен-тиляція, ос-вітлюваль-ний прилад
Загальна втома орга-нізму
L≤50 дБА
[15]
7.Недолік при-роднього освіт-лення
Невірне розташу-вання моні-тору, вікон-них прорізів
Стомлення зорового аналізатору
КПО не нижче 1,5%
[12]
8.Підвищена яскравість світла
Невірне розташу-вання моні-тору
Стомлення зорового аналізатору
В=100 кд/м2
[11]
9.Знижена контрасність
Якість монітору
Стомлення зорового аналізатору
/>= 0,9%
В0 – яскравість об’єкту, Вф– яскравість фону
[11]
10.Підвищене значення напруги в електричному ланцюгу
Електрична, апаратура
Ураження електричним струмом
I=0,6 мА
[18]
11. Підвищена пульсація світ-лового потоку
Лампи ден-ного світла, монітор ЕОМ
Стомлення зору
Кп=5%
[11]
12. Виробничий пил
Статична електрика, накопичена на поверхні комп’ютера
Подразнення
слизової оболонки
ПДК=4мг/м3
[14]
13. Статична напруга
Постійна поза сидін-ня
М’язова вто-ма
Зниження стати-чної витривалості на 40%
[11]
14.Розумова перенапруга
Труднощі виробничо-го завдання
Загальне фі-зичне стом-лення, зни-ження праце-здатності
Зниження витри-валості до вихід-ного 40-50%
[11]
15. Перенапруга зорових аналі-заторів
Монітор ЕОМ
Загальне фі-зичне стом-лення
Подовження часу реакції на світло та звук 40-50%
[11]
6.4Виробнича санітарія
Працівники обчислювального центра піддаються впливові шкідливих і небезпечних факторів виробничого середовища, електромагнітних полів, статичної електрики, шумів .
Оператори зазнають психоемоційної напруги.
6.4.1 Метереологічні умови
Метеорологічні умови на виробництві або мікроклімат визначають наступні параметри: температура (°C), рухливість (м/с), відносна вологість повітря (%) і інтенсивність теплового випромінювання.
З урахуванням параметрів мікроклімату метеоумови в приміщенні поділяються на оптимальні та допустимі.
У відповіді до ГОСТ 12.1.005–88 [14] встановлюються оптимальні умови, при виборі яких враховується пора року та категорія роботи.
За затратами енергії розробка програмного продукту є легкою фізичною роботою (сидяча робота, не потребує фізичного напруження) – категорія 1а.
Але дипломна робота характеризується напруженою розумовою працею. Тому обрані оптимальні параметри мікроклімату, що наведені у таблиці 6.2.
Таблиця 6.2 – Оптимальні праметри мікроклімату
Категорія роботи по енергозатратам
Пора року
Температура повітря, °С
Відносна вологість повітря,%
Швидкість руху повітря,
м/с
легка 1а
Холодна
22-24
40-60
0,1
Тепла
23-25
Приміщення обладнане системами централізованого опалення (загальне парове), кондиціювання повітря та штучною припливно-витяжною вентиляцією відповідно до СНиП 2.04.05-91 [17]. продолжение
–PAGE_BREAK–
6.4.2 Забезпечення виробничого освітлення
При освітленні виробничих приміщень використовується природне освітлення, створюване світлом неба (пряме та відбите), штучне, здійснюване електричними лампами, та комбіноване.
Природне освітлення підрозділяють на бічне, верхнє, комбіноване.
В приміщенні використовується бічне природне освітлення, що здійснюється крізь бічні вікна. Воно повинне забезпечувати коефіцієнт природної освітленності (КПО) не нижче 1,5% [12].
Нормовані значення КПО для будинків, розташованих у IV поясі світлового клімату визначаються за формулою:
/>(6.1)
де />– значення КПО для III поясу світлового клімату складає 1,5%,
m – коефіцієнт світлового клімату (для міста Харкова m=0,9%),
c – коефіцієнт сонячності клімату (с=1).
/>=1,5*0,9*1=1,35%
Загальне освітлення повинно бути рівномірним.
Штучне освітлення приміщення з робочими місцями, обладнаними відеотерміналами ЕОМ загального та персонального користування, має бути обладнане системою загального рівномірного освітлення. Даний вид штучного освітлення і використовується на моєму робочому місці.
Дані по нормах освітлення для створення умов нормальної роботи середньої точності містяться у таблиці 6.3.
Таблиця 6.3 – Характеристика виробничого освітлення
Точність зорової роботи
Міні-маль-ний розмір об’єк-ту
Розряд зорової роботи
Під-роз-ряд зоро-вої праці
Кон-раст об’єк-ту фо-ну
Харак-терис-тика фону
Нормоване значення освітлення
Природ-не
Штучне
/>,%
/>
,%
Lmin, лк
Тип ламп
Середня точність
0,5..1
IV
В
Се-ред-ній
Серед-ня
1,5
1,35
500
Га-зо-роз-ряд-ні
Комфортні умови зорової роботи забезпечуються.
Загальне освітлення має бути виконане у вигляді суцільних або переривчатих ліній світильників, що розміщуються збоку від робочих місць (переважно зліва) паралельно лінії зору працівників. Допускається застосувати світильники таких класів світлорозподілу:
— світильники прямого світла — П;
— переважно прямого світла — Н;
— переважно відбитого світла — В.
При розташуванні відеотерміналів ЕОМ за периметром приміщення лінії світильників штучного освітлення повинні розміщуватися локально над робочими місцями.
Для загального освітлення необхідно застосовувати світильники із розсіювачами та дзеркальними екранними сітками або віддзеркалювачами, укомплектовані високочастотними пускорегулювальними апаратами (ВЧ ПРА). Допускається застосовувати світильники без ВЧ ПРА тільки при використанні моделі з технічною назвою «Кососвіт». Застосування світильників без розсіювачів та екранних сіток забороняється.
Як джерело світла при штучному освітленні повинні застосовуватися, як правило, люмінесцентні лампи типу ЛБ. При обладнанні відбивного освітлення у виробничих та адміністративно-громадських приміщеннях можуть застосовуватися метало галогенові лампи потужністю до 250 Вт. Допускається у світильниках місцевого освітлення застосовувати лампи розжарювання.
Яскравість світильників загального освітлення в зоні кутів промінювання від 50 до 90 відносно вертикалі в подовжній і поперечній площинах повинна складати не більше 200кд/м2, а захисний кут світильників повинен бути не більшим за 40.
Коефіцієнт запасу (Кз) відповідно до СНиП 11-4-79 [12]для освітлювальної установки загального освітлення слід приймати рівним 1.4.
Коефіцієнт пульсації повинен не перевищувати 5% і забезпечуватися застосуванням газорозрядних ламп у світильниках загального і місцевого освітлення. При відсутності світильників з ВЧ ПРА лампи багатолампових світильників або розташовані поруч світильники загального освітлення необхідно підключати до різних фаз трифазної мережі.
Рівень освітленості на робочому столі в зоні розташування документів має бути в межах 300-500 лк. У разі неможливості забезпечити даний рівень освітленості забезпечити даний рівень освітленості системою загального освітлення допускається застосування світильників місцевого освітлення, але при цьому не повинно бути відблисків на поверхні та збільшення освітленості екрану більше ніж 300 лк.
Світильники місцевого освітлення повинні мати напівпрозорий відбивач світла з захисним кутом не меншим за 40 .
Необхідно передбачити обмеження прямої блискості від джерела природного та штучного освітлення, при цьому яскравість поверхонь, що світяться (вікна, джерела штучного світла) і перебувають у полі зору, повинна бути не більшою за 200 кд/м2.
Необхідно обмежувати відбиту блискість шляхом правильного вибору типів світильників та розміщенням робочих місць відносно джерел природного та штучного освітлення. При цьому яскравість відблисків на екрані відеотермінала на повинна перевищувати 40 кд/м2, яскравість стелі при застосуванні системи відбивного освітлення не повинна перевищувати 200 кд/м2.
Необхідно передбачити нерівномірність розподілу яскравості в полі зору осіб, що працюють з відеотерміналом, при цьому відношення значень яскравості робочих поверхонь не повинно перевищувати 3:1, а робочих поверхонь і навколишніх предметів (стіни, обладнання) — 5:1.
Необхідно використовувати систему вимикачів, що дозволяє регулювати інтенсивність штучного освітлення залежно від інтенсивності природного, а також дозволяє освітлювати тільки потрібні для роботи зони приміщення.
Для забезпечення нормованих значень освітлення в приміщеннях з відеотерміналами ЕОМ загально та персонального користування необхідно очищати віконне скло та світильники не рідше ніж 2 рази на рік, та своєчасно проводити заміну ламп, що перегоріли.
Виробничі приміщення, в яких розташовані ЕОМ, не повинні межувати з приміщеннями, де рівні шуму та вібрації перевищують норму (механічні цехи, майстерні тощо).
6.4.3 Шум
У приміщеннях з ЕОМ рівні звукового тиску, рівні звуку та еквівалентні рівні звуку на робочих місцях повинні відповідати вимогам ГОСТ 12.1.003-83 ССБТ [15] ”Шум. Общие требования безопасности”, СН 3223-85 «Санітарні норми допустимих рівнів шуму на робочих місцях з урахуванням напруженості та тяжкості праці», затверджених Міністерством охорони здоров’я України. Рівні шуму на робочих місцях осіб, що працюють з відеотерміналами та ЕОМ, визначені ДСанПІН 3.3.2-007-98[19]
Для забезпечення нормативних рівнів шуму у виробничих приміщеннях та на робочих місцях застосовуються шумопоглинальні засоби, вибір яких обґрунтовується спеціальними інженерно-акустичними розрахунками.
Як засоби шумопоглинання повинні застосовуватися негорючі або важкогорючі спеціальні перфоровані плити, панелі, мінеральна вата з максимальним коефіцієнтом звукопоглинання в межах частот 31.-8000 Гц, або інші матеріали аналогічного призначення, дозволені для оздоблення приміщень органами державного санітарно-епідеміологічного нагляду. Крім того, необхідно застосовувати підвісні стелі з аналогічними властивостями.
6.4.4 Випромінювання вiд екрана
ВДТ генерує декілька типів випромінювання, у тому числі: гамма тормозне, рентгенівське, радіочастотне, мікроволнове, видиме, ультрафіолетове й інфрачервоне випромінювання. Рівні цих випромінювань не перевищують діючих норм.
Вимоги щодо допустимих значень неіонізуючого електромагнітного випромінювання:
– напруженість електромагнітного поляна відстані 50 см. Навкруги ВДТ за електричною складовою не повинна перевищувати: продолжение
–PAGE_BREAK–
у діапазоні частот 5 Гц — 2 кГц – 25 В/м,
у діапазоні частот 2 кГц — 400 кГц – 2,5 В/м,
– щільність магнітного потоку не повинна перевищувати:
у діапазоні частот 5 Гц — 2 кГц – 250 нТл,
у діапазоні частот 2 кГц — 400 кГц – 25 нТл,
– поверхневий електростатичний потенціал не повинен перевищувати 500 В.
Конструктивне рішення екрана дисплея таке, що рентгенівське випромінювання від екрана на відстані 10 см не перевищує 100 мкР/г [19].
У помешканнях із дисплеями необхідно контролювати аероіонізацію. У таблиці 6.4 наведені рівні іонізації повітря робочої зони обчислювального центру (ОЦ).
Таблиця 6.4 — Рівні іонізації повітря робочої зони ОЦ
Рівні
Кількість іонів в 1 см повітря
n+
n-
Мінімально необхідні
400
600
Оптимальні
1500-3000
3000-5000
Максимально допустимі
50000
50000
Варто враховувати, що м’яке рентгенівське випромінювання, що виникає при напрузі на аноді 20-22 кВ, а також напруга на струмоведучих ділянках схеми викликає іонізацію повітря з утворенням позитивних іонів, що вважаються несприятливими для людини.
6.5 Техніка безпеки
Тому що лабораторія, де знаходяться ЕОМ, не є помешканням із підвищеним утриманням механічних, теплових або радіаційних небезпек, але є споживачем електричної енергії (трифазна мережа перемінного струму напругою 220 В та частотою 50 Гц), то в даному помешканні є небезпека поразки людини електричним струмом. Тому при розгляді питань техніки безпеки обмежимося розглядом електробезпеки.
Передбачено такі міри електробезпеки:
– конструктивні заходи електробезпеки;
– схемно-конструктивні заходи електробезпеки;
– експлуатаційні заходи електробезпеки.
Конструктивні заходи безпеки спрямовані на запобігання можливості дотику людини до струмоведучих частин.
Для усунення можливості дотику оператора до струмоведучих частин, усі рубильники встановлені в закритих корпусах, усі струмоведучі частини поміщені в захисний корпус або мають захисний прошарок ізоляції, що виключає можливість дотику до них, застосовується блоковий монтаж. Живлячий електричний ланцюг має ізоляцію, виконану відповідно до ГОСТ 14254-80 [20]. Ступінь захисту устаткування відповідає IР44
(де 4 захист від твердих тіл розміром більш 1 мм; 4 – захист від бризок) відповідно до ПУЭ-87 [7].
Відповідно до ГОСТ 12.2.007.0-75* [21] приймаємо I клас захисту від поразки електричним струмом обслуговуючого персоналу тому, що комп’ютер має робочу ізоляцію й елементи занулення.
Схемно-конструктивні заходи електробезпеки забезпечують безпеку дотику людини до металевих не струмоведучих частин електричних апаратів при випадковому пробої їхньої ізоляції і виникнення електричного потенціалу на них.
Живлення здійснюється від трьох провідної мережі: фазовий дріт, нульовий робочий дріт, нульовий захисний дріт.
Тому що напруга менше 1000 В, але більше 42 В, то відповідно до ГОСТ 12.1.030-81* [22] із метою захисту від поразки електричним струмом застосовуємо занулення, тому що лабораторія є помешканням із підвищеною небезпекою поразки людини електричним струмом, так як можливий одночасний дотик людини до металоконструкцій будинків і т.п., що мають з’єднання з землею з одного боку, і до металевих корпусів електронного устаткування – з іншого.
Занулення – навмисне електричне з’єднання з нульовим захисним провідником металевих не струмоведучих частин, що можуть виявитися під напругою.
Принцип дії занулення – перетворення пробою на корпус в однофазне коротке замикання з метою викликати великий струм, здатний забезпечити спрацьовування захисту і тим самим автоматично відключити ушкоджену установку від живлячої мережі. Таким захистом є: плавкі запобіжники, що здійснюють захист одночасно від струмів короткого замикання і перевантаження.
/>Занулення потребує наявності в мережі нульового дроту, глухого заземлення нейтралі джерела струму і повторного заземлення нульового дроту (рис. 6.1).
Рис. 6.1. Принципова схема занулення
1 — корпус електроустановки;
2 — апарати захисту від струмів КЗ (запобіжники);
Ro — опір заземлення середньої точки обмотки джерела струму;
Rп — опір повторного заземлювача нульового захисного провідника;
Iк — струм короткого замикання;
Iн — частина струму короткого замикання, що протікає через нульовий захисний провідник;
Iз — частина струму короткого замикання, що протікає через землю.
По засобу захисту від поразки електричним струмом проектована система відноситься до I класу відповідно до ГОСТ 12.2.007.0-75* [21].
Призначення елементів занулення:
– призначення нульового захисного провідника – забезпечити необхідне для відключення установки значення струму однофазного короткого замикання шляхом створення для цього струму ланцюга з малим опором;
– призначення заземлення середньої точки – зниження напруги занулених корпусів (а отже, нульового захисного провідника) щодо землі до безпечного значення при замиканні фази на землю;
– призначення повторного заземлення захисного провідника – зниження напруги щодо землі занулених конструкцій у період замикання фази на корпус як при справній схемі занулення, так і у випадку обриву нульового захисного дроту.
Таким чином, занулення здійснює дві захисних дії – швидке автоматичне відключення ушкодженої установки від живлячої мережі і зниження напруги занулених металевих не струмоведучих частин, що виявилися під напругою, щодо землі.
Первинним джерелом живлення ПЕОМ є трьохпровідна мережа: фазовий дріт, нульовий робочий дріт, нульовий захисний дріт. Електроживлення здійснюється від електроустановки (трансформатора) із регульованою напругою під навантаженням. Напруга мережі подається в розподільну шафу.
У помешканні лабораторії прокладена шина повторного захисного заземлення (заземлюєчий провідник) виконана відповідно до ГОСТ 12.1.030 81* [22], що металево з’єднується з заземленою нейтраллю електроустаткування.
Опір заземлюючого пристрою, до якого приєднана нейтраль, не більш 0,6 Ом. Шина повторного захисного заземлювача доступна для огляду.
Для роботи з пристроями під високою напругою необхідні наступні запобіжні заходи:
– не підключати і не відключати рознімання кабелів при напрузі мережі;
– технічне обслуговування і ремонтні роботи допускається виробляти тільки при виключеному живленні мережі;
– до роботи допускаються особи, які навчені і які мають групи допуску до роботи на машинах відповідно до ПУЭ-87 [7].
6.6 Пожежна безпека
Пожежна безпека – стан об’єкта при якому із установленою ймовірністю виключається можливість виникнення і розвитку пожежі, а також забезпечується захист матеріальних цінностей.
Причинами, що можуть викликати пожежу в розглянутому
помешканні, є:
– несправність електропроводки і приладів;
– коротке замикання електричних ланцюгів;
– перегрів апаратури;
– блискавка.
Помешкання обчислювального центру по пожежній безпеці відноситься до категорії В відповідно до ОНТП-24-86 [6], тому що в обігу знаходяться тверді спалимі речовини і матеріали. Ступінь вогнестійкості будинку – II відповідно до СНиП 2.01.02-85 [8], клас помешкання по пожежній небезпеці П-IIа, відповідно до ПУЭ-87 [7].
Пожежна безпека відповідно до ГОСТ 12.1.004-91 [16] забезпечується системами запобігання пожежі, пожежного захисту, організаційно-технічними заходами.
Система запобігання пожежі: продолжение
–PAGE_BREAK–
– контроль і профілактика ізоляції;
– наявність плавких вставок і запобіжників в електронному устаткуванні;
– для захисту від статичної напруги використовується заземлення;
– захист від блискавок будівель і устаткування.
Для даного класу будівель і місцевості із середньою грозовою діяльністю 10 і більш грозових годин у рік, тобто для умов м. Харкова встановлена III категорія захисту від блискавок.
Ступінь захисту відповідному класу помешкання П II-а IР44 для устаткування і IР2Х для світильників.
Система пожежного захисту:
– аварійне відключення і переключення апаратури;
– наявність первинних засобів пожежегасіння, вогнегасників ОП-5, тому що вуглекислота має погану електропровідність, або порошкових вогнегасників;
– система оповіщення, світлова і звукова сигналізація;
– захист легкозаймистих частин устаткування, конструкцій захисними матеріалами;
– використання негорючих матеріалів для акустичної обробки стін і стель;
– у помешканнях, де немає робочого персоналу, встановлена автоматична система пожежного захисту.
Для успішної евакуації персоналу при пожежі розміри дверей робочого помешкання повинні бути наступними: ширина дверей не менше 1,5 м., висота дверей не менше 2,0 м., ширина коридору 1,8 м.; робоче помешкання повинно мати два виходи; відстань від найбільше віддаленого робочого місця не повинне перевищувати 100 м.
Організаційні заходи пожежної профілактики:
– навчання персоналу правилам пожежної безпеки;
– видання необхідних інструкцій і плакатів, плану евакуації персоналу у випадку пожежі.
Будівля обчислювального центру відповідає вимогам пожежної безпеки.
6.7 Охорона навколишнього середовища
При вирішенні технічних задач необхідно приділяти особливу увагу питанню взаємодії виробничої середи з навколишньою природною середою.Результат хозяйственної діяльності людини сказується вже не тільки в локальному, але й у регіональному, а у ряді випадків і глобальному масштабах. Охорона навколишнього середовища становиться важливою соціальною та економічною проблемою.
На порозіІІІтисячоліття людство знаходиться з досить суперечливим надбанням. З одного боку-бурхливі темпи загальнолюдського прогресу, а з другого-його негативні наслідки прямо протилежної спрямованості. Останні проявляються, насамперед, у надмірному забрудненні навколишнього середовища й інтенсивній його деградації.
В законі Украйни про охорону навколишнього середовища регламентується «Законом про охорону навколишнього природного середовища, 1991р. При виконанні дипломної роботи утворюються тверді побутові відходи (папір, канцелярські вироби та інші), а також комп’ютерні та інші види організаційної техніки, яка відпрацювала свій термін. Вони повинні утилізовуватися на полігонах твердих побутових відходів з максимальним використанням в якості вторинних ресурсів.
6.8 Висновок
Дотримання наведених в таблицях 6.1, 6.2, 6.3 нормативних значень параметрів шкідливих та небезпечних факторів, оптимальних параметрів мікроклімату, норм освітлення дозволить забезпечити безпечні умови праці користувача ЕОМ.
СПИСОК ДЖЕРЕЛ ІНФОРМАЦІЇ
Datasheet ATMega8515 www.atmel.com.
Техническое описание стенда EV8031.
М.Е. Фленов, Библія програміста (Delphi), Москва, 2008, 349с.
Стив Тейксейра, Ксавье Пачеко, Borland Delphi 6. Руководство разработчика, Питер, 2008, 1120с.
Парижский С.М., Delphi. Только практика, Питер, 2008, 208 с.
ОНТП-24-86, МВД СССР. “Общесоюзные нормы технологического проектирования. Определение категорий зданий и сооружений по взрывопожарной и пожарной опасности.” — М.: 1986.
ПУЭ-87. Правила установки электроустройств. М.: Энергоатомиздат 1987г.
СНиП 2.01.02-85. ” Строительные нормы и правила. Противопожарные нормы проектирования зданий и сооружений” -М.: Стройиздат.,1986 р.
12.0.003–74* “ССБТ. Опасные и вредные производственные факторы. Классификация.” 1978 (с 01.01.76). Переиздание (сентябрь 1999 г.) с Изменением № 1, утвержденным в октябре 1978 г. (ИУС 11-78).
СН 2152-80 «Санітарно-гігієнічні норми допустимих рівнів іонізації повітря виробничих та громадських приміщень»
ДНАОП 0.00 – 1.31 – 99. Правила охорони праці під час експлуатації електронно-обчислювальних машин.
СНиП 11-4-79 ” Строительные нормы и правила. Естественное и искусственное освещение”-М.: Стройиздат.,1980 р.
ГОСТ 12.1.045 «ССБТ. Электростатические поля. Допустимые уровни на рабочих местах и требования к проведению контроля»
ГОСТ 12.1.005-88 «ССБТ Общие санитарно-гигиенические требования к воздуху рабочей зоны»-Введ. 01.01.89.
ГОСТ 12.1.003-83 «ССБТ Шум. Общие требования безопасности»-Введ. 01.07.84.
ГОСТ 12.1.004-91.” ССБТ. Пожарная безопасность. Общие требования”. Введ. 01.07.92.
СНиП 2.04.05-91 ” Строительные нормы и правила. Отопление, вентиляция и кондиционирование воздуха”-М.: Стройиздат.,1987 р.
ГОСТ 12.1.038-82 «ССБТ Электробезопасность. Предельно-допустимые уровни напряжения прикосновения и токов». -Введ. 01.07.83.
ДСанПіН З.З.2. 007 1998. Державні санітарні правила і норми роботи з візуальними дисплейним терміналами електронно-обчислювальних машин.
ГОСТ 14254-80. Электрооборудование напряжением до 1000 В. Оболочки. Степени защиты. Введ. 01.01.81.
ГОСТ 12.2.007.0-75*. ССБТ. Изделия электротехнические. Общие требования безопасности. Введ. 01.01.78.
ГОСТ 12.1.030-81*. ССБТ. Электробезопасность. Защитное заземление. Зануление. Введ. 01.07.82.
Перерва П.Г. Управление промышленным маркетингом. Харьков, Основа, 1993.
Современный маркетинг / под ред. Е.К.Хруцкого. – М.: Прогресс, 1991.
ВИСНОВКИ
У ході виконання научно дослідницької роботи були розглянуті основні технічні характеристики лабораторного стенду EV8031, а також розглянутий лабораторний практикум з курсу мікроконтроллерних систем.
У ході роботи були розглянуті основні характеристики та ресурси мікроконтроллера ATMega8515та стенду EV8031. Були обчислені його швидкістні характеристики, які необхідні для розробки віртуального вимірювального комплексу.
Було з’ясовано, що дуже складно побудувати такі пристрої як логічний аналізатор та генератор слів на програмній базі мікроконтроллеру. Але отримані характеристики повністю вдовільнили постановлену задачу.
Одночасний доступ двох програм до послідовного поорту неможливий, тому для вирішення задачі було прийнято рішення обь’єднати дві програми у один програмний модуль, але з двома вікнами, для зручності у користуванні.
Побудова інтерфейсу була взята із багатовідомої системи моделювання електронних пристроїв ElectronicWorkbench, де є аналогічні віртуальні пристрої.
У результаті тестування створеного програмного забеспечення, були отримані вдовільні показники. Як було зазначено вище, використання таймеру не призводить до великоі похибки при вимірюванні на швидкості вхідної послідовності 50Гц.
МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ
НАЦІОНАЛЬНИЙ ТЕХНІЧНИЙ УНІВЕРСИТЕТ
“ХАРКІВСЬКИЙ ПОЛІТЕХНІЧНИЙ ІНСТИТУТ”
Кафедра: “Обчислювальна техніка та програмування”
“ЗАТВЕРДЖУЮ”
Завідуючий кафедрою ОТП
__________ /xxxx.А./ продолжение
–PAGE_BREAK–
“___” __________ 2009р.
ВІРТУАЛЬНИЙ ВИМІРЮВАЛЬНИЙ КОМПЛЕКС НА БАЗІ УЧБОВОГО ЛАБОРАТОРНОГО СТЕНДУ EV8031
Текст програми
ЛИСТ ЗАТВЕРДЖЕННЯ
xxxx.03077-01 12 01-1-ЛЗ
РОЗРОБНИКИ
Керівник проекту
_____________/xxx./
“_____”_________2009р.
Виконавець
Студент групи x
/xxxxxx./
“_____”____________2009р.
Харків 2009
ЗАТВЕРДЖЕНО
xxx.03077-01 12 01-1-ЛЗ
ВІРТУАЛЬНИЙ ВИМІРЮВАЛЬНИЙ КОМПЛЕКС НА БАЗІ УЧБОВОГО ЛАБОРАТОРНОГО СТЕНДУ EV8031
Текст програми
xxxxx.03077-01 12 01-1
Аркушів_48_
Харків 2009
ЗМІСТ
1 ТЕКСТ ПРОГРАМНОГО ЗАБЕСПЕЧЕННЯ ПК
1.1 Текст програмного модуля логічного аналізатора, Unit1.pas
2 Тексти програмного модуля генератора слів, Unit2.pas
3 Текст програмного модуля головного вікна ВВК,, Unit3.pas
2 ТЕКСТ ПРОГРАМНОГО ЗАБЕСПЕЧЕННЯ МК
2.1 Текст програмного забеспечення ВВК мікроконтроллера, main.asm
1 ТЕКСТ ПРОГРАМНОГО ЗАБЕСПЕЧЕННЯ ПК
1.1 Текст програмного модуля логічного аналізатора, Unit1.pas
Ім’я данного файлу: Unit1.pas
Функціональне призначення: програмне забеспечення ПК, модуль логічного аналізатора
Файл створений для дипломного проекта захисту кваліфікації фахівця
За фахом: Системне програмування;
Тема проекту: Віртуальний вимірювальний комплекс на базі учбового лабораторного стенду;
Керівник: М.В. Скородєлов, викладач кафедри ОТП;
Розробник: О.О. Ісмаілов, студент групи КІТ-23а;
Рікрозробки: 2009.
unit Unit1;
interface
uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, TeEngine, Series, ExtCtrls, TeeProcs, Chart, StdCtrls, ComCtrls, Buttons, ComDrv32, SerialNG, Mask, Math;
type TForm1 = class(TForm)
Chart1: TChart;
Series1: TLineSeries;
Series2: TLineSeries;
Series3: TLineSeries;
Series4: TLineSeries;
Series5: TLineSeries;
Series6: TLineSeries;
Series7: TLineSeries;
Series8: TLineSeries;
ColorBox1: TColorBox;
ColorBox2: TColorBox;
ColorBox3: TColorBox;
ColorBox4: TColorBox;
ColorBox5: TColorBox;
ColorBox6: TColorBox;
ColorBox7: TColorBox;
ColorBox8: TColorBox;
StaticText1: TStaticText;
StaticText2: TStaticText;
StaticText3: TStaticText;
StaticText4: TStaticText;
StaticText5: TStaticText;
StaticText6: TStaticText;
StaticText7: TStaticText;
StaticText8: TStaticText;
ScrollBar1: TScrollBar;
SpeedButton1: TSpeedButton;
SpeedButton2: TSpeedButton;
StaticText9: TStaticText;
GroupBox1: TGroupBox;
RadioButton1: TRadioButton;
RadioButton2: TRadioButton;
RadioButton3: TRadioButton;
ComboBox1: TComboBox;
ComboBox2: TComboBox;
BitBtn1: TBitBtn;
SerialPortNG1: TSerialPortNG;
TrackBar1: TTrackBar;
Edit1: TEdit;
Label1: TLabel;
Label2: TLabel;
MaskEdit1: TMaskEdit;
Label3: TLabel;
Label4: TLabel;
MaskEdit2: TMaskEdit;
Label5: TLabel;
procedure FormCreate(Sender: TObject);
procedure ScrollChange(Sender: TObject);
procedure BitBtn2Click(Sender: TObject);
procedure SpeedButton1Click(
Sender: TObject);
procedure SpeedButton2Click(Sender: TObject);
procedure FormClose(Sender: TObject; var Action: TCloseAction);
procedure BitBtn1Click(Sender: TObject);
procedure SerialPortNG1RxClusterEvent(Sender: TObject);
procedure TrackBar1Change(Sender: TObject);
procedure ComboBox2Change(Sender: TObject);
procedure MaskEdit2Change(Sender: TObject); продолжение
–PAGE_BREAK–
private
{ Private declarations }
scale:word;
dwError:dword;
pName:PWideChar;
flag:byte;
function StrToIntM(str:string):dword;
public
{ Public declarations }
end;
TArrBuf512 = array[0..511] of byte;
Var Form1: TForm1;
implementation
uses SerialNGBasic;
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
var
i:word;
s:string;
begin
SerialPortNG1.Active := True;
scale := 500;
ScrollBar1.Visible := False;
Chart1.BottomAxis.Minimum := 0;
Chart1.BottomAxis.Maximum := scale;
Series1.Clear;
Series2.Clear;
Series3.Clear;
Series4.Clear;
Series5.Clear;
Series6.Clear;
Series7.Clear;
Series8.Clear;
for i := 0 to 500 do
begin
Series1.AddXY(i, ((i mod 1)*0.5)+0.25, ”, ColorBox1.Selected);
Series2.AddXY(i, ((i mod 2)*0.5)+1.25, ”, ColorBox2.Selected);
Series3.AddXY(i, ((i mod 2)*0.5)+2.25, ”, ColorBox3.Selected);
Series4.AddXY(i, ((i mod 2)*0.5)+3.25, ”, ColorBox4.Selected);
Series5.AddXY(i, ((i mod 2)*0.5)+4.25, ”, ColorBox5.Selected);
Series6.AddXY(i, ((i mod 2)*0.5)+5.25, ”, ColorBox6.Selected);
Series7.AddXY(i, ((i mod 2)*0.5)+6.25, ”, ColorBox7.Selected);
Series8.AddXY(i, ((i mod 2)*0.5)+7.25, ”, ColorBox8.Selected);
end;
end;
procedure TForm1.ScrollChange(Sender: TObject);
begin
Chart1.BottomAxis.Minimum := ScrollBar1.Position;
Chart1.BottomAxis.Maximum := ScrollBar1.Position + scale;
end;
procedure TForm1.BitBtn2Click(Sender: TObject);
begin
Close;
end;
procedure TForm1.SpeedButton1Click(Sender: TObject);
begin
if (scale
scale := scale + 10;
if (scale = 500) then
ScrollBar1.Visible := False
else
ScrollBar1.Visible := True;
ScrollBar1.Max := 500 — scale;
if (ScrollBar1.Position > (500 — scale)) then
ScrollBar1.Position := (500 — scale);
Chart1.BottomAxis.Minimum := ScrollBar1.Position;
Chart1.BottomAxis.Maximum := ScrollBar1.Position + scale;
end;
procedure TForm1.SpeedButton2Click(Sender: TObject);
begin
if (scale > 0) then
scale := scale — 10;
if (scale = 500) then
ScrollBar1.Visible := False
else
ScrollBar1.Visible := True;
ScrollBar1.Max := 500 — scale;
Chart1.BottomAxis.Minimum := ScrollBar1.Position;
Chart1.BottomAxis.Maximum := ScrollBar1.Position + scale;
end;
procedure TForm1.FormClose(Sender: TObject; var Action: TCloseAction);
begin
SerialPortNG1.Active := False;
end;
procedure TForm1.BitBtn1Click(Sender: TObject);
var
s:string;
begin
if (ComboBox2.ItemIndex -1) and (ComboBox1.ItemIndex -1) then
begin
s := ‘ ‘;
s[1] := char($FF);
s[2] := char($AA);
s[3] := char($3A);
s[4] := char((((ComboBox1.ItemIndex shl 1) or byte(RadioButton2.Checked))or (ComboBox2.ItemIndex shl 5)));
SerialPortNG1.SendString(s);
flag := 1;
end
else
MessageBox(0, ‘Необходимо указать номер пускового канала и выбрать тактовый генератор!’, ‘Ошибка’, MB_OK or MB_ICONINFORMATION);
end;
procedure TForm1.SerialPortNG1RxClusterEvent(
Sender: TObject);
var
i:integer;
n:integer;
p:^TArrBuf512;
size:integer;
error:DWord;
begin
n := SerialPortNG1.NextClusterSize;
if n >= 0 then
begin
p := SerialPortNG1.ReadNextCluster(size, error);
if (flag=1) then
begin
Series1.Clear;
Series2.Clear;
Series3.Clear;
Series4.Clear;
Series5.Clear;
Series6.Clear;
Series7.Clear;
Series8.Clear;
for i := 0 to n do
begin
Series8.AddXY(i, -(((p^[i] shr 7) and 1)*0.5)+7.75, ”, ColorBox8.Selected); продолжение
–PAGE_BREAK–
Series7.AddXY(i, -(((p^[i] shr 6) and 1)*0.5)+6.75, ”, ColorBox7.Selected);
Series6.AddXY(i, -(((p^[i] shr 5) and 1)*0.5)+5.75, ”, ColorBox6.Selected);
Series5.AddXY(i, -(((p^[i] shr 4) and 1)*0.5)+4.75, ”, ColorBox5.Selected);
Series4.AddXY(i, -(((p^[i] shr 3) and 1)*0.5)+3.75, ”, ColorBox4.Selected);
Series3.AddXY(i, -(((p^[i] shr 2) and 1)*0.5)+2.75, ”, ColorBox3.Selected);
Series2.AddXY(i, -(((p^[i] shr 1) and 1)*0.5)+1.75, ”, ColorBox2.Selected);
Series1.AddXY(i, -(( p^[i] and 1)*0.5)+0.75, ”, ColorBox1.Selected);
end;
flag := 0;
end;
end;
end;
procedure TForm1.TrackBar1Change(Sender: TObject);
begin
Edit1.Text := IntToStr(TrackBar1.Position);
end;
procedure TForm1.ComboBox2Change(Sender: TObject);
begin
if ComboBox2.ItemIndex = 7 then
begin
MaskEdit1.Visible := true;
Label3.Visible := true;
MaskEdit1.Text := ”;
end
else
begin
MaskEdit1.Visible := False;
Label3.Visible := false;
end;
end;
procedure TForm1.MaskEdit2Change(Sender: TObject);
begin
if MaskEdit2.Text ” then
if StrToIntM(MaskEdit2.Text) > 65535 then
MaskEdit2.Text := ‘65535’;
end;
function TForm1.StrToIntM(str:string):dword;
var
i,num:integer;
begin
num := 0;
if (length(str) > 0) and (length(str)
for i := length(str) downto 1 do
if ((str[i] >= ‘0’)and(str[i]
begin
num := num +
(byte(str[i])-byte(‘0’))*
Round(Power(10,length(str)-i));
end;
StrToIntM := num;
end;
end.
2 Тексти програмного модуля генератора слів, Unit2.pas
Ім’я данного файлу: Unit2.pas
Функціональне призначення: програмне забеспечення ПК, модуль генератора слів
Файл створений для дипломного проекта захисту кваліфікації фахівця
За фахом: Системне програмування;
Тема проекту: Віртуальний вимірювальний комплекс на базі учбового лабораторного стенду;
Керівник: М.В. Скородєлов, викладач кафедри ОТП;
Розробник: О.О. Ісмаілов, студент групи КІТ-23а;
Рікрозробки: 2009.
unit Unit2;
interface
uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, ExtCtrls, Buttons, Mask;
type TForm2 = class(TForm)
ListBox1: TListBox;
RadioGroup1: TRadioGroup;
BitBtn1: TBitBtn;
BitBtn2: TBitBtn;
CheckBox1: TCheckBox;
Label1: TLabel;
GroupBox1: TGroupBox;
RadioButton1: TRadioButton;
RadioButton2: TRadioButton;
ComboBox1: TComboBox;
Label5: TLabel;
Label6: TLabel;
MaskEdit1: TMaskEdit;
Label2: TLabel;
MaskEdit2: TMaskEdit;
MaskEdit3: TMaskEdit;
Label3: TLabel;
Label4: TLabel;
MaskEdit4: TMaskEdit;
MaskEdit5: TMaskEdit;
procedure RadioButton1Click(Sender: TObject);
procedure RadioButton2Click(Sender: TObject);
procedure ListBoxClick(Sender: TObject);
procedure Form2Create(Sender: TObject);
procedure CheckBox1Click(Sender: TObject);
procedure MaskEdit1KeyPress(Sender: TObject; var Key: Char);
procedure MaskEdit1Change(Sender: TObject);
procedure MaskEdit2KeyPress(Sender: TObject; var Key: Char);
procedure MaskEdit2Change(Sender: TObject);
procedure MaskEdit3KeyPress(Sender: TObject; var Key: Char);
procedure MaskEdit4KeyPress(Sender: TObject; var Key: Char);
procedure MaskEdit4Change(Sender: TObject);
procedure MaskEdit3Change(Sender: TObject);
procedure BitBtn1Click(Sender: TObject);
procedure BitBtn2Click(Sender: TObject);
private
{ Private declarations }
index:integer;
count:integer;
buf:array[0..1023]of byte;
function StrToHex(str:string):integer;
public
{ Public declarations }
end;
var Form2: TForm2;
implementation
uses Unit1;
{$R *.dfm}
procedure TForm2.RadioButton1Click(Sender: TObject);
begin
MaskEdit5.Enabled := false;
Label6.Enabled := false;
ComboBox1.Enabled := true;
Label5.Enabled := true;
end;
procedure TForm2.RadioButton2Click(Sender: TObject);
begin продолжение
–PAGE_BREAK–
ComboBox1.Enabled := false;
Label5.Enabled := false;
MaskEdit5.Enabled := true;
Label6.Enabled := true;
end;
procedure TForm2.ListBoxClick(Sender: TObject);
var
s:string;
begin
s:=
ListBox1.Items.ValueFromIndex[ListBox1.ItemIndex];
index := ListBox1.ItemIndex;
MaskEdit1.Text := s[4]+s[5];
end;
procedure TForm2.Form2Create(Sender: TObject);
var
i,j:integer;
s,s1:string;
begin
count := 1024;
index := 0;
ListBox1.Clear;
for i := 0 to count-1 do
begin
s := Format(‘%x’,[i]);
for j := 1 to 3-length(s) do
s1 := s1 + ‘0’;
for j := 1 to length(s) do
s1 := s1 + s[j];
ListBox1.Items.Add(s1+’:00′);
s1 := ”;
buf[i] := 0;
end;
end;
procedure TForm2.CheckBox1Click(Sender: TObject);
begin
if (CheckBox1.Checked = True) then
Form1.Visible := true;
end;
procedure TForm2.MaskEdit1KeyPress(Sender: TObject; var Key: Char);
begin
if not(((Key >= ‘0’) and (Key
((Key >= ‘A’) and (Key
((Key >= ‘a’) and (Key
Key := ‘ ‘;
if (Key >= ‘a’) and (Key
Key := UpCase(Key)
end;
procedure TForm2.MaskEdit1Change(Sender: TObject);
var
s,s1,s2:string;
i:byte;
begin
s1 := ”;
s := Format(‘%x’,[index]);
for i := 1 to 3-length(s) do
s1 := s1 + ‘0’;
for i := 1 to length(s) do
s1 := s1 + s[i];
s2 := s1 + ‘:’;
s1 := ”;
s := Format(‘%x’,[StrToHex(MaskEdit1.Text)]);
for i := 1 to 2-length(s) do
s1 := s1 + ‘0’;
for i := 1 to length(s) do
s1 := s1 + s[i];
buf[index] := StrToHex(MaskEdit1.Text);
s2 := s2 + s1;
ListBox1.Items.Strings[index] := s2;
end;
procedure TForm2.MaskEdit2KeyPress(Sender: TObject; var Key: Char);
var
i,j:integer;
s,s1:string;
begin
if not((Key >= ‘0’) and (Key
(Key = #13)) then
Key := ‘ ‘;
if Key = #13 then
begin
ListBox1.Clear;
for i := 0 to count-1 do
begin
s := Format(‘%x’,[i]);
for j := 1 to 3-length(s) do
s1 := s1 + ‘0’;
for j := 1 to length(s) do
s1 := s1 + s[j];
ListBox1.Items.Add(s1+’:00′);
s1 := ”;
end;
end;
end;
procedure TForm2.MaskEdit2Change(Sender: TObject);
var
i:integer;
s,s1:string;
begin
s1 := ”;
s := MaskEdit2.Text;
if s ” then
for i := 1 to length(s) do
if s[i] ‘ ‘ then s1 := s1 + s[i];
if s1 ” then
begin
if (StrToInt(s1) > 1024) then
begin
MaskEdit2.Text := ‘1024’;
count := 1024;
end;
count := StrToInt(s1);
end;
end;
function TForm2.StrToHex(str:string):integer;
var
i,num:integer;
begin
num := 0;
if (length(str) > 0) and (length(str)
for i := length(str) downto 1 do
begin
if ((str[i] >= ‘0’)and(str[i]
num := num + (byte(str[i])-byte(‘0’))shl(4*(length(str)-i));
if ((str[i] >= ‘A’)and(str[i]
num := num + (byte(str[i])-byte(‘A’)+10)shl(4*(length(str)-i));
if ((str[i] >= ‘a’)and(str[i]
num := num + (byte(str[i])-byte(‘a’)+10)shl(4*(length(str)-i));
end;
StrToHex := num;
end;
procedure TForm2.MaskEdit3KeyPress(Sender: TObject; var Key: Char); продолжение
–PAGE_BREAK–
begin
if not(((Key >= ‘0’) and (Key
((Key >= ‘A’) and (Key
((Key >= ‘a’) and (Key
Key := ‘ ‘;
if (Key >= ‘a’) and (Key
Key := UpCase(Key);
end;
procedure TForm2.MaskEdit4KeyPress(Sender: TObject; var Key: Char);
begin
if not(((Key >= ‘0’) and (Key
((Key >= ‘A’) and (Key
((Key >= ‘a’) and (Key
Key := ‘ ‘;
if (Key >= ‘a’) and (Key
Key := UpCase(Key);
end;
procedure TForm2.MaskEdit4Change(Sender: TObject);
begin
if MaskEdit4.Text ” then
begin
if StrToHex(MaskEdit4.Text) > count-1 then
MaskEdit4.Text := Format(‘%3x’, [count-1]);
if StrToHex(MaskEdit4.Text)
MaskEdit4.Text := MaskEdit3.Text;
end;
end;
procedure TForm2.MaskEdit3Change(Sender: TObject);
begin
if MaskEdit3.Text ” then
begin
if StrToHex(MaskEdit3.Text) > count-1 then
MaskEdit3.Text := Format(‘%3x’, [count-1]);
if StrToHex(MaskEdit4.Text)
MaskEdit3.Text := MaskEdit4.Text;
end;
end;
procedure TForm2.BitBtn1Click(Sender: TObject);
var
i:integer;
//a:array[1..]
begin
BitBtn1.Enabled := False;
BitBtn2.Enabled := True;
//Form1.SerialPortNG1.SendData();
Form1.SerialPortNG1.SendData(@buf[StrToHex(MaskEdit3.Text)],StrToHex(MaskEdit4.Text)-StrToHex(MaskEdit3.Text));
end;
procedure TForm2.BitBtn2Click(Sender: TObject);
begin
BitBtn1.Enabled := True;
BitBtn2.Enabled := False;
end;
end.
3 Текст програмного модуля головного вікна ВВК,, Unit3.pas
Ім’я данного файлу: Unit3.pas
Функціональне призначення: програмне забеспечення ПК, модуль головного вікна ВВК
Файл створений для дипломного проекта захисту кваліфікації фахівця
За фахом: Системне програмування;
Тема проекту: Віртуальний вимірювальний комплекс на базі учбового лабораторного стенду;
Керівник: М.В. Скородєлов, викладач кафедри ОТП;
Розробник: О.О. Ісмаілов, студент групи КІТ-23а;
Рікрозробки: 2009.
unit Unit3;
interface
uses Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, Buttons;
type TForm3 = class(TForm)
BitBtn1: TBitBtn;
BitBtn2: TBitBtn;
BitBtn3: TBitBtn;
BitBtn4: TBitBtn;
Label1: TLabel;
procedure BitBtn1Click(Sender: TObject);
procedure BitBtn2Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var Form3: TForm3;
implementation
uses Unit1, Unit2;
{$R *.dfm}
procedure TForm3.BitBtn1Click(Sender: TObject);
begin
Form1.Visible := True;
end;
procedure TForm3.BitBtn2Click(Sender: TObject);
begin
Form2.Visible := true;
end;
end.
2 ТЕКСТ ПРОГРАМНОГО ЗАБЕСПЕЧЕННЯ МК
2.1 Текст програмного забеспечення ВВК мікроконтроллера, main.asm
Ім’я данного файлу: main.asm
Функціональне призначення: програмне забеспечення ПК, модуль логічного аналізатора
Файл створений для дипломного проекта захисту кваліфікації фахівця
За фахом: Системне програмування;
Тема проекту: Віртуальний вимірювальний комплекс на базі учбового лабораторного стенду;
Керівник: М.В. Скородєлов, викладач кафедри ОТП;
Розробник: О.О. Ісмаілов, студент групи КІТ-23а;
Рікрозробки: 2009.
#include
.def tmp = r16
.def tmp1 = r17
.def RX_flag = r18
.def RX_Counter = r19
.def RX_Complete = r20
.def command = r21
.def tmp2 = r22
.def tmp3 = r23
.equ UC_REG = 0xC000
.equ RX_Buffer = 0x7C00
.macro USART_TRANSMITT_M
utm_l0:
wdr
sbis UCSRA, UDRE
rjmp utm_l0
out UDR, tmp
.endm
.macro WAIT_PUSK
mov tmp, command
andi tmp, 0b00010000
brne wp_l5 продолжение
–PAGE_BREAK–
mov tmp, command
andi tmp, 0b00001110
lsr tmp
ldi tmp1, 1
wp_l0:
cpi tmp, 0
breq wp_l1
lsl tmp1
dec tmp
brne wp_l0
wp_l1:
mov tmp, command
andi tmp, 0b00000001
brne wp_l2
wp_l3:
wdr
in tmp2, PINB
and tmp2, tmp1
brne wp_l3
wp_l4:
wdr
in tmp2, PINB
and tmp2, tmp1
breq wp_l4
rjmp wp_l5
wp_l2:
wdr
in tmp2, PINB
and tmp2, tmp1
breq wp_l2
wp_l6:
wdr
in tmp2, PINB
and tmp2, tmp1
brne wp_l6
wp_l5:
.endm
.macro ANALYZE_CLK_6
ac6_l0:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
dec tmp3 // 1 cycle
brne ac6_l0 // 2 cycles or
// 1 cycle
dec tmp3 // 1 cycle
ac6_l1:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
dec tmp3 // 1 cycle
brne ac6_l1 // 2 cycles
dec tmp3
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
.endm
.macro ANALYZE_CLK_8
ac8_l0:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
nop // +2 cyle
nop
dec tmp3 // 1 cycle
brne ac8_l0 // 2 cycles or
// 1 cycle
dec tmp3 // 1 cycle
ac8_l1:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
nop // +2 cyle
nop
dec tmp3 // 1 cycle
brne ac8_l1 // 2 cycles
dec tmp3
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
.endm
.macro ANALYZE_CLK_16
ac16_l0:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
ldi tmp1, 3 // +10 cyle
ac16_l2:
dec tmp1
brne ac16_l2
nop
dec tmp3 // 1 cycle
brne ac16_l0 // 2 cycles or
// 1 cycle
dec tmp3 // 1 cycle
ac16_l1:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
ldi tmp1, 3 // +10 cyle
ac16_l3:
dec tmp1
brne ac16_l3
nop
dec tmp3 // 1 cycle
brne ac16_l1 // 2 cycles
dec tmp3
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
.endm
.macro ANALYZE_CLK_32
ac32_l0:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
ldi tmp1, 8 // +26 cyle
ac32_l2:
dec tmp1
brne ac32_l2
nop
nop
dec tmp3 // 1 cycle
brne ac32_l0 // 2 cycles or
// 1 cycle
dec tmp3 // 1 cycle
ac32_l1:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
ldi tmp1, 8 // +26 cyle
ac32_l3:
dec tmp1
brne ac32_l3
nop
nop
dec tmp3 // 1 cycle
brne ac32_l3 // 2 cycles
dec tmp3
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
.endm
.macro ANALYZE_CLK_64
ac64_l0:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle продолжение
–PAGE_BREAK–
ldi tmp1, 19 // +58 cyle
ac64_l2:
dec tmp1
brne ac64_l2
nop
dec tmp3 // 1 cycle
brne ac64_l0 // 2 cycles or
// 1 cycle
dec tmp3 // 1 cycle
ac64_l1:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
ldi tmp1, 19 // +58 cyle
ac64_l3:
dec tmp1
brne ac64_l3
nop
dec tmp3 // 1 cycle
brne ac64_l1 // 2 cycles
dec tmp3
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
.endm
.macro ANALYZE_CLK_128
ac128_l0:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
ldi tmp1, 40 // +122 cyle
ac128_l2:
dec tmp1
brne ac128_l2
nop
nop
dec tmp3 // 1 cycle
brne ac128_l0 // 2 cycles or
// 1 cycle
dec tmp3 // 1 cycle
ac128_l1:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
ldi tmp1, 40 // +122 cyle
ac128_l3:
dec tmp1
brne ac128_l3
nop
nop
dec tmp3 // 1 cycle
brne ac128_l1 // 2 cycles
dec tmp3
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
.endm
.macro ANALYZE_CLK_256
ac256_l0:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
ldi tmp1, 83 // +250 cyle
ac256_l2:
dec tmp1
brne ac256_l2
nop
dec tmp3 // 1 cycle
brne ac256_l0 // 2 cycles or
// 1 cycle
dec tmp3 // 1 cycle
ac256_l1:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
ldi tmp1, 83 // +250 cyle
ac256_l3:
dec tmp1
brne ac256_l3
nop
dec tmp3 // 1 cycle
brne ac256_l1 // 2 cycles
dec tmp3
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
.endm
.macro ANALYZE_CLK_VN
acv_l0:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
dec tmp3 // 1 cycle
brne acv_l0 // 2 cycles or
// 1 cycle
dec tmp3 // 1 cycle
acv_l1:
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
dec tmp3 // 1 cycle
brne acv_l1 // 2 cycles
dec tmp3
in tmp, PINB // 1 cycle
st Y+, tmp // 2 cycle
.endm
.org 0
rjmp RESET
nop;rjmp INT0
nop;rjmp INT1
nop;rjmp TIMER1_CAPT
nop;rjmp TIMER1_COMPA
nop;rjmp TIMER1_COMPB
nop;rjmp TIMER1_OVF
rjmp TIMER0_OVF
nop;rjmp SPI_STC
rjmp USART_RXC
nop;rjmp USART_UDRE
nop;rjmp USART_TXC
nop;rjmp ANA_COMP
nop;rjmp INT2
nop;rjmp TIMER0_COMP
nop;rjmp EE_RDY
nop;rjmp SPM_RDY
RESET:
; set stack pointer to top of RAM
ldi tmp, high(RAMEND)
out SPH, tmp
ldi tmp, low(RAMEND)
out SPL, tmp
; enable WDT with 2,1s timeout
ldi tmp, (1
out WDTCR, tmp
; enable external SRAM
ldi tmp, (1
out MCUCR, tmp
; enable interrupts
sei
; USART init
rcall USART_Init
// Unmask timer 0 overflov interrupt
ldi tmp, (1
out TIMSK, tmp продолжение
–PAGE_BREAK–
// Stop timer0
ldi tmp, 0b00000000
out TCCR0, tmp
clr RX_Flag
clr RX_Complete
ldi tmp, 0
out DDRB, tmp
ldi tmp, 0b11111111
out PORTB, tmp
loop:
wdr
cpi RX_Complete, 1
breq c_l0
rjmp l0
c_l0:
// reset RX_Complete
clr RX_Complete
// mask RXCIE
ldi tmp, (1
out UCSRB, tmp
// reset RX_Buffer
ldi YL, low(RX_Buffer)
ldi YH, high(RX_Buffer)
ldi tmp3, 0xFF
// do command
mov tmp, command
andi tmp, 0b11100000
lsr tmp
lsr tmp
lsr tmp
lsr tmp
lsr tmp
cpi tmp, 0
brne dc_l0
WAIT_PUSK
ANALYZE_CLK_6
Rjmp dc_end
dc_l0:
cpi tmp, 1
brne dc_l1
WAIT_PUSK
ANALYZE_CLK_8
Rjmp dc_end
dc_l1:
cpi tmp, 2
brne dc_l2
WAIT_PUSK
ANALYZE_CLK_16
Rjmp dc_end
dc_l2:
cpi tmp, 3
brne dc_l3
WAIT_PUSK
ANALYZE_CLK_32
Rjmp dc_end
dc_l3:
cpi tmp, 4
brne dc_l4
WAIT_PUSK
ANALYZE_CLK_64
Rjmp dc_end
dc_l4:
cpi tmp, 5
brne dc_l5
WAIT_PUSK
ANALYZE_CLK_128
Rjmp dc_end
dc_l5:
cpi tmp, 6
brne dc_l6
WAIT_PUSK
ANALYZE_CLK_256
Rjmp dc_end
dc_l6:
cpi tmp, 7
breq cdc_unk
rjmp dc_unk
cdc_unk:
WAIT_PUSK
ANALYZE_CLK_VN
dc_end:
/*
// wait if need befor pusk
WAIT_PUSK
// analyse and store (6 cycles)
// clock time (1/7372800Mhz)*6 = 813,8ns
ANALYZE_CLK_6
*/
// reset RX_Buffer
ldi YL, low(RX_Buffer)
ldi YH, high(RX_Buffer)
// transmitt data
l1:
ld tmp, Y+
USART_TRANSMITT_M
Dec tmp3
brne l1
dec tmp3
l2:
ld tmp, Y+
USART_TRANSMITT_M
Dec tmp3
brne l2
ld tmp, Y+
USART_TRANSMITT_M
dc_unk:
// unmask RXCIE
ldi tmp, (1
out UCSRB, tmp
l0:
rjmp loop
////////////////////////////////////////////////////
// USART receive complete ISR
USART_RXC:
Push tmp
in tmp, SREG
push tmp
// tmp
in tmp, UDR
// if (RX_Flag == 1) goto urxc_l0
cpi RX_Flag, 1
breq urxc_l0
// if (RX == AA)
cpi tmp, 0xAA
brne urxc_end
// init timeout
ldi tmp, 0b00000101
out TCCR0, tmp
clr tmp
out TCNT0, tmp
// set recive_flag
ldi RX_Flag, 1
// reset RX_Buffer
ldi YL, low(RX_Buffer)
ldi YH, high(RX_Buffer) продолжение
–PAGE_BREAK–
clr RX_Counter
ldi tmp, 0xAA
urxc_l0:
// push RX to buffer
st Y+, tmp
inc RX_Counter
urxc_end:
pop tmp
out SREG, tmp
pop tmp
reti
////////////////////////////////////////////////////
// Timer0 overflow ISR
TIMER0_OVF:
Push tmp
Push tmp1
In tmp, SREG
push tmp
// Stop timer0
ldi tmp, 0b00000000
out TCCR0, tmp
// reset RX_Buffer
ldi YL, low(RX_Buffer)
ldi YH, high(RX_Buffer)
cpi RX_Counter, 3
brne t0ovf_l0
ld tmp, Y+
cpi tmp, 0xAA
brne t0ovf_l0
ld tmp, Y+
cpi tmp, 0x3A
brne t0ovf_l0
ld tmp, Y+
mov command, tmp
ldi RX_Complete, 1
//clear buffer
ldi YL, low(RX_Buffer)
ldi YH, high(RX_Buffer)
clr tmp
st Y+, tmp
st Y+, tmp
st Y+, tmp
st Y+, tmp
st Y+, tmp
t0ovf_l0:
// clear recive_flag
clr RX_Flag
pop tmp
out SREG, tmp
pop tmp1
pop tmp
reti
////////////////////////////////////////////////////
// USART init routine
// uses: tmp, tmp1
USART_Init:
Ldi tmp, (1
Out UCSRB, tmp
Ldi tmp, (1
Out UCSRC, tmp
Ldi tmp, 0
Ldi tmp1, 23
Out UBRRH, tmp
Out UBRRL, tmp1
Ldi tmp, 0b00000001
Sts UC_REG, tmp
ret
////////////////////////////////////////////////////
// USART transmit routine
// uses: tmp
USART_Transmit:
cli
ut_l0:
wdr
sbis UCSRA, UDRE
rjmp ut_l0
out UDR, tmp
sei
ret
МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ
НАЦІОНАЛЬНИЙ ТЕХНІЧНИЙ УНІВЕРСИТЕТ
“ХАРКІВСЬКИЙ ПОЛІТЕХНІЧНИЙ ІНСТИТУТ”
Кафедра: “Обчислювальна техніка та програмування”
“ЗАТВЕРДЖУЮ”
Завідуючий кафедрою ОТП
__________ /xxxx./
“___” __________ 2009р.
ВІРТУАЛЬНИЙ ВИМІРЮВАЛЬНИЙ КОМПЛЕКС НА БАЗІ УЧБОВОГО ЛАБОРАТОРНОГО СТЕНДУ EV8031
Опис програми
ЛИСТ ЗАТВЕРДЖЕННЯ
xxxxx.03077-01 13 01-1-ЛЗ
РОЗРОБНИКИ
Керівник проекту
/xxxxxxxxx./
“_____”____________2009р.
Виконавець
студент групи xxxxx
/xxxx./
“_____”_______________2009р.
Харків 2009
ЗАТВЕРДЖЕНО
xxx.03077-01 13 01-1-ЛЗ
ВІРТУАЛЬНИЙ ВИМІРЮВАЛЬНИЙ КОМПЛЕКС НА БАЗІ УЧБОВОГО ЛАБОРАТОРНОГО СТЕНДУ EV8031
Опис програми
xxxx.03077-01 13 01-1
Листів_8_
Харків 2009
АНОТАЦІЯ
Даний документ містить у собі опис програми, методів та алгоритмів, що використовуються, опис потреб та особливостей функціонування продукту, розробленого у межах дипломного проектування “віртуального вимірювального комплексу”. Система призначена для тестування різноманітних цифрових пристроїв.
ABSTRACT
The given document contains the description of programs, methods and algorithms which were used. It describes the requirements and peculiarities of operation of the product developed within the framework of degree projection of a virtual analyze complex. The program implementation of the methods of analysis of self-descriptiveness and diagnostics.
ЗМІСТ
1. ЗАГАЛЬНІ ВІДОМОСТІ продолжение
–PAGE_BREAK–
1.1 Позначення і найменування програми
1.2 Програмне забезпечення, необхідне для функціонування програми
1.3 Обрана мова програмування
2. ФУНКЦІОНАЛЬНЕ ПРИЗНАЧЕННЯ
2.1 Призначення програми
2.2 Функціональні обмеження
3. ОПИС ЛОГІЧНОЇ СТРУКТУРИ ПРОГРАМИ
3.1 Алгоритм програми
4. ВИКОРИСТАНІ ТЕХНІЧНІ ЗАСОБИ
5. ВИКЛИК І ЗАВАНТАЖЕННЯ
5.1 Виклик програми
5.2 Точки входу в програму
5.3 Використання оперативної пам’яті
6. ВХІДНІ ДАНІ ПРОГРАМИ
7. ВИХІДНІ ДАНІ ПРОГРАМИ
1. ЗАГАЛЬНІ ВІДОМОСТІ
1.1 Позначення і найменування програми
Програмний продукт має найменування „Віртуальний вимірювальний пристрій ”. Відповідно головний завантажувальний модуль системи має назву “BBK.exe”(складається с перших букв слів імені продукту), головний модуль також підключає додаткові функціональні модулі, які виконують окремі функції. Це такі модулі:
Модуль, який предоставляє користувачу вибір необхідних віртуальних пристроїв;
Модуль, який предоставляє інтерфейс користувача логічного аналізатора;
Модуль який предоставляє інтерфейс генератора слів.
1.2 Програмне забезпечення, необхідне для функціонування програми
Для функціонування програми необхідні:
операційна система Windows2000/XP.
1.3 Обрана мова програмування
При виборі комп’ютерної техніки доцільно використовувати IBM-сумісні системи через їхнє велике поширення і доступність. На комп’ютерах цієї серії найбільш поширені операційні системи Microsoft Windows NT/2000/XP. Тому реалізація програми була здійсннена для операційних систем Microsoft Windows 2000/XP на IBM-сумісних комп’ютерах.
Існує досить багато сучасних середовищ і мов програмування. При обиранні мови програмування були розглянуті декіка важливих факторів, які повинні як найбільше відповідати висунутим до продукту вимогам.
Вимоги до програмного продукту:
зручний інтерфейс з користувачем;
простота використання, не вимагаючи спеціального навчання користувача;
наочність вихідних даних;
обробка великих структур даних;
вимоги до середовища розробки;
простота програмування;
великий набір компонентів;
зручний інтерфейс середовища;
можливість створення зручного інтерфейсу;
невисокі вимоги до обладнання;
простота налагодження програм.
Враховуючи всі вищенаведені вимоги к мовам програмування, було прийнято рішення для створення системи використовувати наступні мови програмування:
програмне забеспечення ПК – Delphi 7;
програмне забеспечення МК – AVRStudio;
Завантаження пошивки до мікроконтроллеру AVReal32.
2. ФУНКЦІОНАЛЬНЕ ПРИЗНАЧЕННЯ
2.1 Призначення програми
Програмний продукт призначений для налагодження різноманітних цифрових пристроїв. А також отримання проаналізованих данних тестуємого пристрою(логічний аналізатор), після подачі на нього тестової послідовності(генератор слів).
2.2 Функціональні обмеження
Програмний продукт відповідає поставленим до нього вимогам і у межах обумовлених ними не має функціональних обмежень.
3. ОПИС ЛОГІЧНОЇ СТРУКТУРИ ПРОГРАМИ
3.1 Алгоритм програми
Розроблене програмне забезпечення функціонує за наступним загальним алгоритмом: cтворюється головне вікно програми на якому розташовані елементи керування. Програма складається з троьох вікон. Перше вікно дозволяє обирати необхідний віртуальний пристрій. Друге і третє вікно – інтерфейс користувача логічного аналізатора та генератора слів. Обидва вікна очікують налаштовувань пристрою, та оброблюють елементи керування. Елемент керування запуском та зупинненням виконує передачу введених налаштовувань, за допомогою інтерфейса користувача, і передає налаштовування і данні за допомогою COM порту у мікроконтроллер. Після цього програма очікує прийом відповіді. Після прийому відповіді переходить у обробку елементів керування.
4. ВИКОРИСТАНІ ТЕХНІЧНІ ЗАСОБИ
Для роботи програмного продукту необхідна IBM PC/AT сумісна персональна ЕОМ, наявність процесору Pentium II 433МГц та вище з обсягом оперативної пам’яті 128Мб або більше, наявністю відео адаптеру VGA або SVGA, а також послідовного приємопередавача СОМ порта або RS-232.
Необхідний об’єм на жорсткому диску 5 Мб для продукту.
При розробці використовувалася ПЕОМ з наступними параметрами: Pentium Tualatin, 512 Мб RIMM ОЗП, жорсткий диск ємністю 80 Гб, відеокарта GeForce2 MX 400 32Мб.
5. ВИКЛИК І ЗАВАНТАЖЕННЯ
5.1 Виклик програми
Програмне запеспечення ПК інсталляції не потребує, потрібно тільки зробити копію програмного модуля у зручне місце, і завантажувати стандартними засобами операційної системи.
Програмне забеспечення мікроконтроллера потребує наявності встановленого пакету внутрішньосистемного програматору AVReal32. Також на момент програмування цільова ситема повинна бути підєднана спеціальним кабелем – програматором, також цільва система повинна бути підключена до блоку живлення(допускається живлення від USB). Програмування починається запуском спеціально підготовленого *.bat файлу.яки містить командну строку із необхідними налаштовуваннями програмування цілевої системи. Файл який містить завантажувальний код має розширення *.hex. продолжение
–PAGE_BREAK–
5.2 Точки входу в програму
Точкою входу до будь-якого з модулів програми є запуск головного модуля „ВВК.ехе”, що здійснює створення головного вікна програми, де є можливість обирати подальші дії.
5.3 Використання оперативної пам’яті
Програмний продукт потребує менше 5 Мб оперативної пам’яті.
6. ВХІДНІ ДАНІПРОГРАМИ
Вхідними даними програмного забеспечення ПК є налаштовування користувача, і у разі використання логічного аналізатору прийняті по COM порту данні. Вхідними данними програмного забеспечення мікроконтроллера є прийняті команди і у разі режиму генератору слів прийнята послідовність данних по COM порту.
7. ВИХІДНІ ДАНІПРОГРАМИ
Вихідними даними програмного забеспечення ПК є налаштовування користувача, і у разі використання генератору слів передаваємі по COM порту данні. Вихідними данними програмного забеспечення мікроконтроллера є прередаваємі відповіді і у разі режиму логічного аналізатора передаваєма послідовність проаналізованих данних по COM порту.
МІНІСТЕРСТВО ОСВІТИ І НАУКИ УКРАЇНИ
НАЦІОНАЛЬНИЙ ТЕХНІЧНИЙ УНІВЕРСИТЕТ
“ХАРКІВСЬКИЙ ПОЛІТЕХНІЧНИЙ ІНСТИТУТ”
Кафедра: “Обчислювальна техніка та програмування”
“ЗАТВЕРДЖУЮ”
Завідуючий кафедрою ОТП
__________ /xxxxxxxx./
“___” __________ 2009р.
ВІРТУАЛЬНИЙ ВИМІРЮВАЛЬНИЙ КОМПЛЕКС НА БАЗІ УЧБОВОГО ЛАБОРАТОРНОГО СТЕНДУ EV8031
Керівництво оператора
ЛИСТ ЗАТВЕРДЖЕННЯ
xxxxx.03077-0134 01-1-ЛЗ
РОЗРОБНИКИ
Керівник проекту
__________ /xxxxx./
“_____”_______________2009р.
Виконавець
студент групи xx-23а
/xxxxxxxx./
“_____”_______________2009р.
Харків 2009
ЗАТВЕРДЖЕНО
xxxxxxxxxxxxxxxxxxxx
ВІРТУАЛЬНИЙ ВИМІРЮВАЛЬНИЙ КОМПЛЕКС НА БАЗІ УЧБОВОГО ЛАБОРАТОРНОГО СТЕНДУ EV8031
Керівництво оператора
xxxxxxx.03077-0134 01-1
Аркушів
Харків 2009
АНОТАЦІЯ
Документ «Керівництво оператора» містить інформацію для перевірки, забезпечення функціонування й налаштовування системи «Віртуальний вимірювальний комплекс». У даному документі зазначені відомості про програмний продукт, його призначення й умови застосування, характеристика, установка, звернтання до програми.
ABSTRACT
Document «Guidance of operator» contains information for verification, providing of functioning and tuning of the system «Virtual measuring complex». In this document the noted information is about a software product, his setting and terms of application, description, setting, zverntannya to the program.
ЗМІСТ
1 ПРИЗНАЧЕННЯ ПРОГРАМНОГО ПАКЕТУ
2 УМОВИ ВИКОНАННЯ
3 ЗАВАНТАЖЕННЯ ПРОЕКТУ
4 ПОВІДОМЛЕННЯ ОПЕРАТОРУ
1 ПРИЗНАЧЕННЯ ПРОГРАМНОГО ПАКЕТУ
Програмний продукт призначений для налагодження різноманітних цифрових пристроїв. А також отримання проаналізованих данних тестуємого пристрою(логічний аналізатор), після подачі на нього тестової послідовності(генератор слів).
2 УМОВИ ВИКОНАННЯ
Нормальна робота з данним програмним продуктом можлива лише на комп’ютерах IBM PC/AT(чи сумісному з ним) серії не нижче Pentium !!!, з операційною системою Microsoft Windows 2000/XP.
Для нормального функціонування програмного продукту необхідна наявність таких характеристик:
SVGA відеоадаптер не менше 1024х768х32;
Жорсткий диск;
Пам’ять(бажано не нижче 128Мб);
Маніпулятор типу “миша”;
Клавіатура;
COM – порт.
3 ЗАВАНТАЖЕННЯ ПРОЕКТУ
Щоб завантажити програму, необхідно запустити файл BBK.exe. Після цього перед користувачем з’являється вікно(рис. 3.1) із чотирма кнопками. Дві зних залишені для розширення програмного забеспечення: генератор сигналу вільної форми та осцилограф. А інші дві дозволяють викликати додаткові вікна: логічний аналізатор(рис. 3.2) та генератор слів(рис. 3.3).
/>
Рис 3.1 Головне віко віртуального вимірювального пристрою
/>
Рис 3.2 Вікно логічного аналізатора
/>
Рис 3.3 Вікно генератора слів
Інтерфейс складається з трьох вікон. Перше – головне вікно дозволяє відкривати вікна необхідних пристроїв. Вікна працюють як по одинці так і разом у залежності від налагодження.
Логічний аналізатор(рис.3.2) має наступні елементи керування:
керування кольором кожного з восьми сигналів;
змінення масштабу відображеного сигналу;
перегляд сигналу за допомогою полоси зсуву;
керування типом запуску якщо вибраний запус по каналу;
вибір запуску за необхідним каналом, або невикористовувати;
вибір глибини передпускової реєстрації;
вибір швидкості реєстрації данних з переліку або вільно;
запуск аналізатора;
останов аналізатора на випадок очікування пуску, який довго не наступає.
Генератор слів(рис. 3.3) має наступні елементи керування:
керування вводом необхідних послідовностей;
керування кількістю необхідних слов;
керування діапазоном з якого по який генерувати;
керування режимами роботи: циклічна генерація, одноразова, шагова.
Пуск генерації, або шаг;
Останов генерації у випадку наприклад циклічної генерації;
Керування швидкістю генерації з переліку а також вільно;
Режим роботи генератора слів та логічного аналізатора у парі.
4 ПОВІДОМЛЕННЯ ОПЕРАТОРУ продолжение
–PAGE_BREAK–
Програма виключає введення невірних даних у поля ввода, таким чином там де очікується ввід шістнадцятирічного числа можливо ввести твльки цифри від до 9 та символи від a до f і, якщо символи вводяться у нижньому регістрі вводу, програма автоматично переводить іх до верхнього регістру. Також блокуються деякі несумісні операції, для того, щоб не дозволити користувачеві виконувати неможливі або невірні дії. Також виконується перевірка на наявність налаштовування обов’язкоаих параметрів, інакше виводиться повідомлення у якому зазначене виконання обов’язкових дій.
/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>
/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>
/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>
/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>
/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>
/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>
/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/>/> @F:\avr\avreal\avreal32 +MEGA8515 -p1 -e -w -v -o1000 -c 111.hex @pause � #TSERIALNGBASICDLG#0#####TPF0#TSerialNGBasicDLG#SerialNGBasicDLG#Left#�##Top#�##BorderStyle##bsDialog#Caption##Serial Basic Settings ClientHeight#�##ClientWidth#�##Color# clBtnFace Font.Charset# ANSI_CHARSET Font.Color# clWindowText#Font.Height#� Font.Name##Arial Font.Style###OldCreateOrder #Position##poScreenCenter#Scaled# PixelsPerInch#x TextHeight####TBevel#Bevel1#Left# #Top# #Width#Z##Height#o#Shape##bsFrame###TLabel#Label3#Left###Top###Width###Height###Caption##&Port FocusControl##CBPort###TLabel#Label4#Left#�##Top###Width#4#Height###Caption# &Baudrate FocusControl##CBBaud###TLabel#Label5#Left###Top#Q#Width#0#Height###Caption# &Databits FocusControl##CBData###TLabel#Label6#Left#�##Top#Q#Width###Height###Caption##&Stop FocusControl##CBStop###TLabel#Label7#Left###Top#1#Width#”#Height###Caption##Pari&ty FocusControl##CBParity###TLabel#Label8#Left#�##Top#1#Width#B#Height###Caption# &Flowcontrol FocusControl##CBFlow## TComboBox#CBPort#Left#9#Top###Width#h#Height###Style##csDropDownList ItemHeight## Items.Strings###COM1##COM2##COM3##COM4##COM5##COM6##COM7##COM8##TabOrder#### TComboBox#CBBaud#Left#�##Top###Width#i#Height###Style##csDropDownList ItemHeight## Items.Strings###110##300##600##1200##2400##4800##9600##14400##19200##38400##56000##57600##115000##128000##256000##TabOrder#### TComboBox#CBData#Left#P#Top#Q#Width#Q#Height###Style##csDropDownList ItemHeight## Items.Strings###4 Bit##5 Bit##6 Bit##7 Bit##8 Bit##TabOrder#### TComboBox#CBStop#Left#�##Top#Q#Width#i#Height###Style##csDropDownList ItemHeight## Items.Strings## 1 Bit (*)##1,5 Bits##2 Bits##TabOrder#### TComboBox#CBParity#Left#9#Top#1#Width#h#Height###Style##csDropDownList ItemHeight## Items.Strings###None (*)##Odd##Even##Mark##Space##TabOrder#### TComboBox#CBFlow#Left#�##Top#1#Width#i#Height###Style##csDropDownList ItemHeight## Items.Strings###None (*)##XOn-XOff##RTS-CTS##DSR-DTR##TabOrder#####TButton#OKBtn#Left#q##Top# #Width#]#Height###Caption##OK#Default #ModalResult###TabOrder#####TButton CancelBtn#Left#q##Top#/#Width#]#Height###Cancel #Caption##Cancel#ModalResult###TabOrder#####