![]() |
GQLLC GMC-300
0.1
GQ Electronics Geiger-Counter Model 300
|
00001 // ************************************************************************** 00002 // File: gqgmc.hh 00003 // 00004 // Author: Phil Gillaspy 00005 // 00006 // Last Modified: 04/26/2012 00007 // 00008 // Description: 00009 // Declare the class and its methods describing the capabilities 00010 // of the GQ Electronics LLC Geiger-Muller Counter (GQ GMC). 00011 // This code covers the GMC-300 and later models. 00012 // 00013 // INTRODUCTION: 00014 // 00015 // Detailed design documentation is embedded in the source code files. 00016 // The intent is to combine source code and documentation such that a 00017 // separate design document is unnecessary. The author's philosophy is that 00018 // the source code should be considered as part of the design documentation. 00019 // This philosophy was developed over many years of experience wherein the 00020 // design document replicated so much information that was in the source 00021 // code, that doing so generated needless opportunity for inconsistency. 00022 // It is widely recognized that replicating information only increases 00023 // the chances for human error and undue maintenance hardship. 00024 // 00025 // Since the design documentation will be embedded in the source code, 00026 // the organization is constrained to the C/C++ compilation requirements 00027 // that there exist a separate include and source body files. However, 00028 // the author's philosophy is that sofware engineers find the separation 00029 // of information between two files to be an annoyance. It would be much 00030 // preferred that all information were located at the point where the 00031 // software engineer needs to read the code to understand its operation, 00032 // in other words, the source body file (.c,.cc). However, the C/C++ 00033 // convention of separate header and body files precludes that idealism. 00034 // It will be realized that various C/C++ constructs and objects appear 00035 // in both the header and source body files. So the following convention 00036 // is followed as to where to embed the documentation: the documentation 00037 // should appear where the object is defined, not where it declared. 00038 // For example, an enumeration which must be defined as publicly 00039 // visible, will be defined only in the header file and consequently 00040 // should be documented in the header file. As another example, a 00041 // class method is declared in the header file, but defined in the source 00042 // file. Therefore the bulk of the documentation for the method should 00043 // be placed in the source file. 00044 // 00045 // The documentation presented here will not cover any nuclear physics 00046 // technical aspects of the GQ Geiger-Muller counter. 00047 // 00048 // GQ GEIGER-MULLER FEATURES 00049 // 00050 // The discussion of the GQ LLC geiger counter is drawn principally 00051 // from the the GMC-300 model with firmware revision 2.15 and later. 00052 // The GMC-300 records high energy particles which when passing through 00053 // geiger-muller tube ionize the gas and create a transient current. 00054 // Each transient pulsed current is considered a 'count'. 00055 // The basic measured form of the radiation is reported in terms of 00056 // counts per second, counts per minute, or the counts per minute 00057 // averaged over an hour. The GMC-300 is also capable of recording 00058 // the aforementioned measures in a history buffer of 64K bytes. 00059 // The GMC-300 provides a USB interface which, however, is physically 00060 // and logically implemented as a traditional RS-232 serial interface. 00061 // The GMC-300 provides a variety of commands to collect data and 00062 // set operational parameters. The reader is referred to the GQ 00063 // Electronics LLC GMC-200 User Manual for a more thorough 00064 // discussion of the its features. 00065 // 00066 // 00067 // SOFTWARE LICENSE STATEMENT 00068 // 00069 // This software contained in the gqgmc.hh and gqgmc.cc files are 00070 // licensed to the public domain under terms of the GNU GPL 00071 // reproduced here. 00072 // Copyright (C) 2012 Phil Gillaspy 00073 // 00074 // This program is free software: you can redistribute it and/or modify 00075 // it under the terms of the GNU General Public License as published by 00076 // the Free Software Foundation, either version 3 of the License, or 00077 // (at your option) any later version. 00078 00079 // This program is distributed in the hope that it will be useful, 00080 // but WITHOUT ANY WARRANTY; without even the implied warranty of 00081 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 00082 // GNU General Public License for more details. 00083 // 00084 // Additionally, the author, Phil Gillaspy, requires that no copyright 00085 // notice nor acknowledgement to the author is necessary for any 00086 // derivative software using any or all part of this software. 00087 // 00088 // DEVELOPMENT AND BUILD OVERVIEW 00089 // 00090 // The code as written is Linux dependent, however, it should not 00091 // be word-size dependent. So far it has only been compiled for 00092 // 64-bit word size on Linux using GNU g++ 4.6.1. The Eclipse 00093 // IDE was used for software development but this is not a 00094 // necessity. A Makefile is provided so that it is perfectly 00095 // acceptable to compile from the command line using 00096 // "make all", "make bin", or "make lib". The makefile creates 00097 // a library containing the gqgmc class and its methods. This was 00098 // done so third party usage could simply link to the library. 00099 // Along with the makefile there are three associated files, 00100 // Defines.mk, Targets.mk, and Patterns.mk. Defines.mk defines 00101 // the root path of the development directory and various 00102 // compile macros. Targets.mk defines the makefile targets and 00103 // Patterns.mk defines makefile compilation dependencies. 00104 // The makefile expects a specific directory structure. Given the 00105 // the root directory of the source, there should be the following 00106 // subdirectories existing; libs, bin, obj. The libGQGMC.a is 00107 // located in the libs directory. Object files are placed in the 00108 // obj directory. A sample main.c is compiled into a executable, 00109 // gqgmc, and placed in the bin directory. The main.c contains 00110 // sample test code to excercise the various capabilities of 00111 // the GQ GMC geiger counter. 00112 // 00113 // 00114 // DESIGN OVERVIEW 00115 // 00116 // This code provides an interface to GQ Electronics LLC GMC-300 00117 // geiger counter. Therefore the functionality implemented by this 00118 // software consists of providing access to the capabilities 00119 // provided by the geiger counter. These capabilities are 00120 // elucidated in the interface document titled GQ-GMC-ICD.odt. 00121 // Generally, the public methods defined for the gqgmc class 00122 // are matched one for one with the capabilities of the 00123 // GMC-300. Therefore, the user is referred to the interface 00124 // document to ascertain what functionality can be expected of 00125 // this software. The software does make an attempt to abstract 00126 // or otherwise mask the details of the communications mechanism. 00127 // Some capabilities of the GMC-300 are not implemented for the 00128 // reason that they are not meaningful to accessing the radiation 00129 // measurements through a remote computer, or in other words, 00130 // the capability is only useful if the user carries the geiger 00131 // counter in hand. For example, only two of the approximately 00132 // 50 configuration parameters are provided with get and set methods. 00133 // 00134 // 00135 // INCLUDE FILE DOCUMENTATION 00136 // 00137 // This include for C++ string handling 00138 #include <string> 00139 00140 // This include allows use of Linux predefined types 00141 #include <stdint.h> 00142 00143 #ifndef gqgmc_hh_ 00144 #define gqgmc_hh_ 00145 00146 // Define a name space for the GQ LLC geiger counter product line 00147 namespace GQLLC 00148 { 00149 00150 // CONFIGURATION PARAMETER ENUMERATION 00151 // 00152 // Declare a globally visible enumeration to be used for calling the 00153 // writeConfigurationData() method. The value of the enumeration is 00154 // equal to the offset of the parameter in the configuration data 00155 // structure. This is then used as the first parameter in the call to 00156 // writeConfigurationData(). See writeConfigurationData() method in 00157 // gqgmc.cc. 00158 enum cfg_param_t 00159 { 00160 ePowerOnOff = 0, 00161 eAlarmOnOff = 1, 00162 eSpeakerOnOff = 2, 00163 eGraphicModeOnOff = 3, 00164 eBacklightTimeoutSeconds = 4, 00165 eIdleTitleDisplayMode = 5, 00166 eAlarmCPMValue = 6, 00167 eCalibrationCPM0 = 8, 00168 eCalibrationSvUc0 = 10, 00169 eCalibrationCPM1 = 14, 00170 eCalibrationSvUc1 = 16, 00171 eCalibrationCPM2 = 20, 00172 eCalibrationSvUc2 = 22, 00173 eIdleDisplayMode = 26, 00174 eAlarmValueuSvUc = 27, 00175 eAlarmType = 31, 00176 eSaveDataType = 32, 00177 eSwivelDisplay = 33, 00178 eZoom = 34, 00179 eDataSaveAddress = 38, 00180 eDataReadAddress = 41, 00181 eNPowerSavingMode = 44, 00182 eNSensitivityMode = 45, 00183 eNCounterDelay = 46, 00184 eNVoltageOffset = 48, 00185 eMaxCPM = 49, 00186 eNSensitivityAutoModeThreshold = 51, 00187 eSaveDate = 52, 00188 eSaveTime = 55, 00189 eMaxBytes = 58 00190 }; // end enum cfg_param_t 00191 00192 // CONFIGURATION PARAMETER DATA BYTE COUNT 00193 // 00194 // Declare an globally visible enumeration to be used for calling the 00195 // writeConfigurationData() method. The value of the enumeration is equal 00196 // to the number of bytes of data passed to the writeConfigurationData() 00197 // method. For each enumeration element, enum cfg_param_t, there is a 00198 // matching enum cfg_bytecnt_t entry. 00199 enum cfg_bytecnt_t 00200 { 00201 ePowerOnOff_bytecnt = 1, 00202 eAlarmOnOff_bytecnt = 1, 00203 eSpeakerOnOff_bytecnt = 1, 00204 eGraphicModeOnOff_bytecnt = 1, 00205 eBacklightTimeoutSeconds_bytecnt = 1, 00206 eIdleTitleDisplayMode_bytecnt = 1, 00207 eAlarmCPMValue_bytecnt = 2, 00208 eCalibrationCPM0_bytecnt = 2, 00209 eCalibrationSvUc0_bytecnt = 4, 00210 eCalibrationCPM1_bytecnt = 2, 00211 eCalibrationSvUc1_bytecnt = 4, 00212 eCalibrationCPM2_bytecnt = 2, 00213 eCalibrationSvUc2_bytecnt = 4, 00214 eIdleDisplayMode_bytecnt = 1, 00215 eAlarmValueuSvUc_bytecnt = 4, 00216 eAlarmType_bytecnt = 1, 00217 eSaveDataType_bytecnt = 1, 00218 eSwivelDisplay_bytecnt = 1, 00219 eZoom_bytecnt = 4, 00220 eDataSaveAddress_bytecnt = 3, 00221 eDataReadAddress_bytecnt = 3, 00222 eNPowerSavingMode_bytecnt = 1, 00223 eNSensitivityMode_bytecnt = 1, 00224 eNCounterDelay_bytecnt = 2, 00225 eNVoltageOffset_bytecnt = 1, 00226 eMaxCPM_bytecnt = 2, 00227 eNSensitivityAutoModeThreshold_bytecnt = 1, 00228 eSaveDate_bytecnt = 3, 00229 eSaveTime_bytecnt = 3, 00230 eMaxBytes_bytecnt = 1 00231 }; // end enum cfg_bytecnt_t 00232 00233 // SAVE DATA TYPE ENUMERATON 00234 // Define a globally visible enumeration which defines the 00235 // type of data that will be logged in the history buffer. 00236 // This enumeration is to be used in the get and set method 00237 // for the eSaveDataType configuration parameter. See 00238 // getSaveDataType() and setSaveDataType() methods in gqgmc.cc. 00239 enum saveDataType_t 00240 { 00241 eSaveOff = 0, // data logging is off 00242 eCPS = 1, // counts per second 00243 eCPM = 2, // counts per minute 00244 eCPH = 3, // CPM averaged per hour 00245 eMaxSaveDataType = 4 00246 }; 00247 00248 // SOFTWARE KEY ENUMERATION 00249 // 00250 // Define a globally visible enumeration for use in calling the 00251 // sendKey (send software key) command. The software key command 00252 // emulates the same menu keys available on the front panel of 00253 // the GMC-300. The user uses this enumeration as the parameter 00254 // to the sendKey() call. See sendKey() method in gqgmc.cc. 00255 enum softkey_t 00256 { 00257 // The GQGMC User Manual numbers the software keys 1 through 4, 00258 // but the actual value is ASCII 0 through 3. 00259 // We provide one enum named following the User Manual convention. 00260 eKey1 = '0', eKey2 = '1', eKey3 = '2', eKey4 = '3', 00261 // The user can use a second, more intuitive, enumeration: 00262 // key 1 is the left arrow 00263 // key 2 is the up arrow 00264 // key 3 is the down arrow 00265 // key 4 is the enter/menu key 00266 eLeftArrow = '0', eUpArrow = '1', eDownArrow = '2', eEnter = '3' 00267 }; 00268 00269 // GMC ERROR CODES 00270 // 00271 // Define an enumeration of all possible error conditions. This needs 00272 // to be globally visible so external routines can use the error code 00273 // to access error text with the idea that the display of the error 00274 // condition and its associated text message to the end user can 00275 // be separated from this class. The idea is that this is a low level 00276 // driver which should be not contain high level GUI functionality. 00277 enum gmc_error_t 00278 { 00279 eNoProblem, eUSB_open_failed, eOlder_firmware, eGet_version, 00280 eGet_serial_number, eGet_CPM, eGet_CPS, eGet_AutoCPS, eGet_CFG, 00281 eErase_CFG, eUpdate_CFG, eWrite_CFG, eClear_USB, 00282 eGet_battery_voltage, eGet_history_data, 00283 eGet_history_data_length, eGet_history_data_address, 00284 eGet_history_data_overrun, eLast_error_code 00285 }; 00286 00287 // PUBLIC CONSTANTS 00288 // 00289 // Publicly available constants which specify the maximum allowed 00290 // requested length of history data and the maximum address in history 00291 // buffer, respectively. External users can use this to guard against 00292 // erroneous requests for history data. Actually, getHistoryData() 00293 // method has guards also. 00294 uint32_t const kHistory_Data_Maxsize = 0x1000; // 4k bytes 00295 uint32_t const kHistory_Addr_Maxsize = 0x10000; // 64k bytes 00296 00297 // CLASS DECLARATION 00298 // 00299 // The Class declaration - see gqgmc.cc for documentation 00300 class GQGMC 00301 { 00302 // PUBLIC METHODS 00303 public: 00304 00305 // Constructor 00306 GQGMC(); 00307 00308 // Destructor is trivial, so coded inline 00309 virtual 00310 ~GQGMC() 00311 { 00312 delete[] mHistory_data; 00313 }; 00314 00315 // SUPPORTING PUBLIC METHODS 00316 00317 // Method to call to open USB port. 00318 virtual 00319 void 00320 openUSB(string usb_device_name); 00321 00322 // Method to close USB port 00323 virtual 00324 void 00325 closeUSB(void); 00326 00327 // Method to clear the read (input) buffer of the USB-serial port. 00328 // This arguably should be a private method, but I can see the 00329 // outside possibility that a third party might need this. 00330 virtual 00331 void 00332 clearUSB(); 00333 00334 // Method to call to check any and all error conditions exihibited 00335 // by the GQGMC class, implementation is trivial so coded inline. 00336 virtual 00337 enum gmc_error_t 00338 getErrorCode() 00339 { 00340 return mError_code; 00341 }; 00342 00343 // Method to get a text description of the error code. 00344 virtual 00345 std::string 00346 getErrorText(gmc_error_t err); 00347 00348 // PUBLIC METHODS PROVIDING ACCESS TO GQ GMC CAPABILITIES 00349 // Begin the public methods for issuing commands to the GQ GMC 00350 // and returning data (if any). 00351 00352 // Method to get GQ GMC version. 00353 virtual 00354 std::string 00355 getVersion(); 00356 00357 // Method to get serial number 00358 virtual 00359 std::string 00360 getSerialNumber(); 00361 00362 // Method to get the count per minute value. 00363 virtual 00364 uint16_t 00365 getCPM(); 00366 00367 00368 // Method to get the count per second value. 00369 virtual 00370 uint16_t 00371 getCPS(); 00372 00373 // Method to get voltage value of battery. 00374 virtual 00375 float 00376 getBatteryVoltage(); 00377 00378 // Method to get history data from internal flash. Returned 00379 // pointer points to private data history data buffer. 00380 virtual 00381 uint8_t * const 00382 getHistoryData(uint32_t address, uint32_t length); 00383 00384 // Method to enable automatic reporting of count per second value. 00385 virtual 00386 void 00387 turnOnCPS(); 00388 00389 // Method to disable automatic reporting of count per second value. 00390 virtual 00391 void 00392 turnOffCPS(); 00393 00394 // Method to read the automatically transmitted CPS value. 00395 virtual 00396 uint16_t 00397 getAutoCPS(); 00398 00399 // Method to turn off the GQ GMC. 00400 virtual 00401 void 00402 turnOffPower(); 00403 00404 // Method to read configuration data. 00405 virtual 00406 void 00407 getConfigurationData(); 00408 00409 // Method to retrieve the data type logged in the history buffer. 00410 virtual 00411 enum saveDataType_t 00412 getSaveDataType(); 00413 00414 // Method to set the data type logged in the history buffer. 00415 virtual 00416 void 00417 setSaveDataType(enum saveDataType_t newSaveDataType); 00418 00419 // Method to retrieve the address in the history buffer 00420 // where the logged data begins. 00421 virtual 00422 uint32_t 00423 getDataSaveAddress(); 00424 00425 // Method to set DataSaveAddress to zero, in other words, 00426 // set the address of data logging to begin in the 00427 // history buffer at address zero. 00428 virtual 00429 void 00430 resetDataSaveAddress(); 00431 00432 // Method to write configuration data. 00433 virtual 00434 void 00435 writeConfigurationData(enum cfg_param_t cfgParameter, 00436 enum cfg_bytecnt_t cfgDataCount, 00437 uint8_t const * const cfgData); 00438 00439 // Method to erase configuration data. 00440 virtual 00441 void 00442 eraseConfigurationData(); 00443 00444 // Method to make latest changes to configuration data take effect. 00445 // Invoke this method after setting configuration data using 00446 // writeConfiguration(), setDataSaveAddress(), or setSaveDataType(). 00447 virtual 00448 void 00449 updateConfigurationData(); 00450 00451 // Public method to send key (emulate one of the 4 keys on the 00452 // front panel of the GQ GMC). 00453 virtual 00454 void 00455 sendKey(enum softkey_t key); 00456 00457 // There are no public data members 00458 00459 00460 private: 00461 00462 // PRIVATE DATA 00463 00464 // The device name of the USB port connected to the GQ GMC. 00465 std::string mUSB_device; 00466 00467 // Forced to use C style IO because C++ streams does not support 00468 // setting line discipline sufficiently on the serial port. 00469 int mUSB_serial; 00470 00471 // Error flag for indicating failure, see enumeration of error codes 00472 // declared above enum gmc_error_t. 00473 enum gmc_error_t mError_code; 00474 00475 // The failure of each command results from failing to read the 00476 // returned data. So we need a separate status for the read failure 00477 // so it can be tested privately. 00478 bool mRead_status; 00479 00480 // Special flag indicating that automatic reporting of counts per 00481 // second is turned off or on (off==false, on==true). This should 00482 // and is intended to be implemented as a mutex if and when threading 00483 // is implemented. 00484 bool mCPS_is_on; 00485 00486 // The USB port uses big endian transfer (ie, MSB transmitted 1st). 00487 // This flag indicates the endianess of the host CPU. This is set 00488 // in the constructor by calling isBigEndian() method. 00489 bool mBig_endian; 00490 00491 // This real number is the GQ GMC's firmware revision. This is needed 00492 // because the GQ GMC changed the command string for various commands 00493 // between versions of the firmware. This means that not all commands 00494 // will work with firmware prior to 2.15. 00495 float mFirmware_revision; 00496 00497 // Storage for the history data, maximum of 4K bytes to be allocated 00498 // in constructor. The user can only request a max of 4K at a time. 00499 uint8_t * mHistory_data; 00500 00501 // Declare a structure for storage of the configuration data. 00502 // This is a replica of the GQ GMC's internal configuration data. 00503 // This is referred to as the host computer's local copy of the 00504 // GQ GMC's NVM configuration data elsewhere in the documentation. 00505 // The getConfigurationData method will deposit the GQ GMC's NVM data 00506 // into this structure. All configuration data is the binary value. 00507 // Booleans are just 0 or 1. But remember that the byte order is 00508 // big endian for multibyte data. So multibyte data may require 00509 // reversing the byte order for display to a user. Those data 00510 // whose semantics are understood are documented below, otherwise 00511 // no explanation means either we have no interest or the parameter 00512 // is better left to being updated physically using the GQ GMC's 00513 // front panel keys. 00514 struct cfg_data_t 00515 { 00516 uint8_t powerOnOff; // byte 0 00517 uint8_t alarmOnOff; 00518 uint8_t speakerOnOff; 00519 uint8_t graphicModeOnOff; 00520 uint8_t backlightTimeoutSeconds; // byte 4 00521 uint8_t idleTitleDisplayMode; 00522 uint8_t alarmCPMValueHiByte; 00523 uint8_t alarmCPMValueLoByte; 00524 uint8_t calibrationCPMHiByte_0; // byte 8 00525 uint8_t calibrationCPMLoByte_0; 00526 uint8_t calibrationSvUcByte3_0; 00527 uint8_t calibrationSvUcByte2_0; 00528 uint8_t calibrationSvUcByte1_0; // byte 12 00529 uint8_t calibrationSvUcByte0_0; 00530 uint8_t calibrationCPMHiByte_1; 00531 uint8_t calibrationCPMLoByte_1; 00532 uint8_t calibrationSvUcByte3_1; // byte 16 00533 uint8_t calibrationSvUcByte2_1; 00534 uint8_t calibrationSvUcByte1_1; 00535 uint8_t calibrationSvUcByte0_1; 00536 uint8_t calibrationCPMHiByte_2; // byte 20 00537 uint8_t calibrationCPMLoByte_2; 00538 uint8_t calibrationSvUcByte3_2; 00539 uint8_t calibrationSvUcByte2_2; 00540 uint8_t calibrationSvUcByte1_2; // byte 24 00541 uint8_t calibrationSvUcByte0_2; 00542 uint8_t idleDisplayMode; 00543 uint8_t alarmValueuSvUcByte3; 00544 uint8_t alarmValueuSvUcByte2; // byte 28 00545 uint8_t alarmValueuSvUcByte1; 00546 uint8_t alarmValueuSvUcByte0; 00547 uint8_t alarmType; 00548 // saveDataType specifies both the interval of data logging where 00549 // 0 = data logging is off, 1 = once per second, 2 = once per minute, 00550 // 3 = once per hour and the type of data saved where 0 = don't care, 00551 // 1 = counts/second, 2 = counts/minute, 3 = CPM averaged over hour. 00552 // Whenever this is changed, the GQ GMC inserts a date/timestamp 00553 // into the history data buffer. 00554 uint8_t saveDataType; // byte 32 00555 uint8_t swivelDisplay; 00556 uint8_t zoomByte3; 00557 uint8_t zoomByte2; 00558 uint8_t zoomByte1; // byte 36 00559 uint8_t zoomByte0; 00560 // dataSaveAddress represents the address of the first sample following 00561 // the insertion of a date/timestamp or label tag into the data buffer. 00562 // Periodically, a label or date/timestamp will be put into the buffer 00563 // without a change made to dataSaveAddress. So you always have to be 00564 // on the lookout for 55AA sequence when parsing data buffer. But you 00565 // have to do that anyway because you might encounter double byte data. 00566 uint8_t dataSaveAddress2; 00567 uint8_t dataSaveAddress1; 00568 uint8_t dataSaveAddress0; // byte 40 00569 // dataReadAddress semantics is unknown. As far as I have seen, 00570 // its value is always zero. 00571 uint8_t dataReadAddress2; 00572 uint8_t dataReadAddress1; 00573 uint8_t dataReadAddress0; 00574 uint8_t nPowerSavingMode; // byte 44 00575 uint8_t nSensitivityMode; 00576 uint8_t nCounterDelayHiByte; 00577 uint8_t nCounterDelayLoByte; 00578 uint8_t nVoltageOffset; // byte 48 00579 uint8_t maxCPMHiByte; 00580 uint8_t maxCPMLoByte; 00581 uint8_t nSensitivityAutoModeThreshold; 00582 // saveDateTimeStamp is the date/timestamp of the logging run, 00583 // all data following up to the next date/timestamp are marked 00584 // in time by this date/timestamp, where 00585 uint8_t saveDateTimeStampByte5; // = year (last two digits) // byte 52 00586 uint8_t saveDateTimeStampByte4; // = month 00587 uint8_t saveDateTimeStampByte3; // = day 00588 uint8_t saveDateTimeStampByte2; // = hour 00589 uint8_t saveDateTimeStampByte1; // = minute // byte 56 00590 uint8_t saveDateTimeStampByte0; // = second 00591 // maxBytes is always 0xff 00592 uint8_t maxBytes; 00593 uint8_t spare[197]; // add spare to total 256 bytes 00594 } mCFG_Data; 00595 00596 // PRIVATE METHODS 00597 00598 00599 // Method to load configuration data which writes all 256 bytes 00600 // of the configuration data to the GQ GMC in sequence. This is 00601 // called by updateConfigurationData(). 00602 virtual 00603 void 00604 loadConfigurationData(); 00605 00606 // Because of the returned byte stream from the GQ GMC has no protocol, 00607 // that is, it is just a sequence of N bytes, we need a specialized 00608 // read. The write is straight forward, but is combined with the read 00609 // for reasons of code commonality. So we will call the write followed 00610 // by read as the 'communicate' method. 00611 void 00612 communicate(const std::string cmd, char * retdata, uint32_t retbytes); 00613 00614 // This is the basic method to transmit the command to the GQ GMC. 00615 // communicate() calls this to transmit command. 00616 void 00617 sendCmd(const std::string cmd); 00618 00619 // This is the basic method to read the return bytes from the command. 00620 // communicate() calls this to read the return byte stream of the 00621 // command. 00622 void 00623 readCmdReturn(char * retdata, uint32_t retbytes); 00624 00625 // This is the method to determine endianess of host CPU. This is to be 00626 // called by constructor once and once only. 00627 bool 00628 isBigEndian(void); 00629 00630 }; // end class GQGMC 00631 00632 } // end namespace GQLLC 00633 00634 // DOCUMENTATION CONTINUES IN gqgmc.cc 00635 #endif // gqgmc_hh_