etherlabmaster: comparison tools/Master.cpp

equal deleted inserted replaced

-:fce58ba8a912
+:ef1266652c4d
 int slavePosition,
 bool force,
 const vector<string> &commandArgs
 )
 {
-ec_ioctl_sii_t data;
+ec_ioctl_slave_sii_t data;
 ec_ioctl_slave_t slave;
 unsigned int i;
 uint16_t alias;
 stringstream err, strAlias;
 int number;
 throw MasterException(err.str());
 }
 open(ReadWrite);
-if (ioctl(fd, EC_IOCTL_SET_DEBUG, debugLevel) < 0) {
+if (ioctl(fd, EC_IOCTL_MASTER_DEBUG, debugLevel) < 0) {
 stringstream err;
 err << "Failed to set debug level: " << strerror(errno);
 throw MasterException(err.str());
 }
 }
 const string &dataTypeStr,
 const vector<string> &commandArgs
 )
 {
 stringstream strIndex, strSubIndex, strValue, err;
-ec_ioctl_sdo_download_t data;
+ec_ioctl_slave_sdo_download_t data;
 unsigned int i, number;
 const CoEDataType *dataType = NULL;
 if (slavePosition < 0) {
 err << "'sdo_download' requires a slave! Please specify --slave.";
 if (!(dataType = findDataType(dataTypeStr))) {
 err << "Invalid data type '" << dataTypeStr << "'!";
 throw MasterException(err.str());
 }
 } else { // no data type specified: fetch from dictionary
-ec_ioctl_sdo_entry_t entry;
+ec_ioctl_slave_sdo_entry_t entry;
 unsigned int entryByteSize;
 open(ReadWrite);
 try {
 throw MasterException(err.str());
 }
 open(ReadWrite);
-if (ioctl(fd, EC_IOCTL_SDO_DOWNLOAD, &data) < 0) {
+if (ioctl(fd, EC_IOCTL_SLAVE_SDO_DOWNLOAD, &data) < 0) {
 stringstream err;
 err << "Failed to download Sdo: ";
 if (errno == EIO && data.abort_code) {
 err << "Abort code 0x" << hex << setfill('0')
 << setw(8) << data.abort_code;
 const vector<string> &commandArgs
 )
 {
 stringstream strIndex, strSubIndex;
 int sval;
-ec_ioctl_sdo_upload_t data;
+ec_ioctl_slave_sdo_upload_t data;
 unsigned int i, uval;
 const CoEDataType *dataType = NULL;
 if (slavePosition < 0) {
 stringstream err;
 stringstream err;
 err << "Invalid data type '" << dataTypeStr << "'!";
 throw MasterException(err.str());
 }
 } else { // no data type specified: fetch from dictionary
-ec_ioctl_sdo_entry_t entry;
+ec_ioctl_slave_sdo_entry_t entry;
 unsigned int entryByteSize;
 open(Read);
 try {
 data.target = new uint8_t[data.target_size + 1];
 open(Read);
-if (ioctl(fd, EC_IOCTL_SDO_UPLOAD, &data) < 0) {
+if (ioctl(fd, EC_IOCTL_SLAVE_SDO_UPLOAD, &data) < 0) {
 stringstream err;
 err << "Failed to upload Sdo: ";
 if (errno == EIO && data.abort_code) {
 err << "Abort code 0x" << hex << setfill('0')
 << setw(8) << data.abort_code;
 /****************************************************************************/
 void Master::siiRead(int slavePosition)
 {
-ec_ioctl_sii_t data;
+ec_ioctl_slave_sii_t data;
 ec_ioctl_slave_t slave;
 unsigned int i;
 if (slavePosition < 0) {
 stringstream err;
 data.offset = 0;
 data.nwords = slave.sii_nwords;
 data.words = new uint16_t[data.nwords];
-if (ioctl(fd, EC_IOCTL_SII_READ, &data) < 0) {
+if (ioctl(fd, EC_IOCTL_SLAVE_SII_READ, &data) < 0) {
 stringstream err;
 delete [] data.words;
 err << "Failed to read SII: " << strerror(errno);
 throw MasterException(err.str());
 }
 bool force,
 const vector<string> &commandArgs
 )
 {
 stringstream err;
-ec_ioctl_sii_t data;
+ec_ioctl_slave_sii_t data;
 ifstream file;
 unsigned int byte_size;
 const uint16_t *categoryHeader;
 uint16_t categoryType, categorySize;
 uint8_t crc;
 }
 // send data to master
 open(ReadWrite);
 data.offset = 0;
-if (ioctl(fd, EC_IOCTL_SII_WRITE, &data) < 0) {
+if (ioctl(fd, EC_IOCTL_SLAVE_SII_WRITE, &data) < 0) {
 stringstream err;
 err << "Failed to write SII: " << strerror(errno);
 throw MasterException(err.str());
 }
 }
 void Master::writeSlaveAlias(
 uint16_t slavePosition,
 uint16_t alias
 )
 {
-ec_ioctl_sii_t data;
+ec_ioctl_slave_sii_t data;
 ec_ioctl_slave_t slave;
 stringstream err;
 uint8_t crc;
 open(ReadWrite);
 data.offset = 0;
 data.nwords = 8;
 data.words = new uint16_t[data.nwords];
 // read first 8 SII words
-if (ioctl(fd, EC_IOCTL_SII_READ, &data) < 0) {
+if (ioctl(fd, EC_IOCTL_SLAVE_SII_READ, &data) < 0) {
 delete [] data.words;
 err << "Failed to read SII: " << strerror(errno);
 throw MasterException(err.str());
 }
 // write new checksum into first byte of word 7
 *(uint8_t *) (data.words + 7) = crc;
 // write first 8 words with new alias and checksum
-if (ioctl(fd, EC_IOCTL_SII_WRITE, &data) < 0) {
+if (ioctl(fd, EC_IOCTL_SLAVE_SII_WRITE, &data) < 0) {
 delete [] data.words;
 err << "Failed to write SII: " << strerror(errno);
 throw MasterException(err.str());
 }
 /****************************************************************************/
 void Master::outputDomainData(unsigned int domainIndex)
 {
 ec_ioctl_domain_t domain;
-ec_ioctl_data_t data;
+ec_ioctl_domain_data_t data;
 unsigned char *processData;
 unsigned int i;
 getDomain(&domain, domainIndex);
 void Master::showDomain(unsigned int domainIndex)
 {
 ec_ioctl_domain_t domain;
 unsigned char *processData;
-ec_ioctl_data_t data;
+ec_ioctl_domain_data_t data;
 unsigned int i, j;
 ec_ioctl_domain_fmmu_t fmmu;
 unsigned int dataOffset;
 getDomain(&domain, domainIndex);
 bool quiet,
 bool withHeader
 )
 {
 ec_ioctl_slave_t slave;
-ec_ioctl_sync_t sync;
+ec_ioctl_slave_sync_t sync;
-ec_ioctl_pdo_t pdo;
+ec_ioctl_slave_sync_pdo_t pdo;
-ec_ioctl_pdo_entry_t entry;
+ec_ioctl_slave_sync_pdo_entry_t entry;
 unsigned int i, j, k;
 getSlave(&slave, slavePosition);
 if (withHeader)
 bool quiet,
 bool withHeader
 )
 {
 ec_ioctl_slave_t slave;
-ec_ioctl_sdo_t sdo;
+ec_ioctl_slave_sdo_t sdo;
-ec_ioctl_sdo_entry_t entry;
+ec_ioctl_slave_sdo_entry_t entry;
 unsigned int i, j, k;
 const CoEDataType *d;
 getSlave(&slave, slavePosition);
 /****************************************************************************/
 void Master::generateSlaveXml(uint16_t slavePosition)
 {
 ec_ioctl_slave_t slave;
-ec_ioctl_sync_t sync;
+ec_ioctl_slave_sync_t sync;
-ec_ioctl_pdo_t pdo;
+ec_ioctl_slave_sync_pdo_t pdo;
 string pdoType;
-ec_ioctl_pdo_entry_t entry;
+ec_ioctl_slave_sync_pdo_entry_t entry;
 unsigned int i, j, k;
 getSlave(&slave, slavePosition);
 cout
 }
 }
 /****************************************************************************/
-void Master::getData(ec_ioctl_data_t *data, unsigned int domainIndex,
+void Master::getData(ec_ioctl_domain_data_t *data, unsigned int domainIndex,
 unsigned int dataSize, unsigned char *mem)
 {
 data->domain_index = domainIndex;
 data->data_size = dataSize;
 data->target = mem;
-if (ioctl(fd, EC_IOCTL_DATA, data) < 0) {
+if (ioctl(fd, EC_IOCTL_DOMAIN_DATA, data) < 0) {
 stringstream err;
 err << "Failed to get domain data: " << strerror(errno);
 throw MasterException(err.str());
 }
 }
 }
 /****************************************************************************/
 void Master::getSync(
-ec_ioctl_sync_t *sync,
+ec_ioctl_slave_sync_t *sync,
 uint16_t slaveIndex,
 uint8_t syncIndex
 )
 {
 sync->slave_position = slaveIndex;
 sync->sync_index = syncIndex;
-if (ioctl(fd, EC_IOCTL_SYNC, sync)) {
+if (ioctl(fd, EC_IOCTL_SLAVE_SYNC, sync)) {
 stringstream err;
 err << "Failed to get sync manager: ";
 if (errno == EINVAL)
 err << "Either slave " << slaveIndex << " does not exist, "
 << "or it contains less than " << (unsigned int) syncIndex + 1
 }
 /****************************************************************************/
 void Master::getPdo(
-ec_ioctl_pdo_t *pdo,
+ec_ioctl_slave_sync_pdo_t *pdo,
 uint16_t slaveIndex,
 uint8_t syncIndex,
 uint8_t pdoPos
 )
 {
 pdo->slave_position = slaveIndex;
 pdo->sync_index = syncIndex;
 pdo->pdo_pos = pdoPos;
-if (ioctl(fd, EC_IOCTL_PDO, pdo)) {
+if (ioctl(fd, EC_IOCTL_SLAVE_SYNC_PDO, pdo)) {
 stringstream err;
 err << "Failed to get Pdo: ";
 if (errno == EINVAL)
 err << "Either slave " << slaveIndex << " does not exist, "
 << "or it contains less than " << (unsigned int) syncIndex + 1
 }
 /****************************************************************************/
 void Master::getPdoEntry(
-ec_ioctl_pdo_entry_t *entry,
+ec_ioctl_slave_sync_pdo_entry_t *entry,
 uint16_t slaveIndex,
 uint8_t syncIndex,
 uint8_t pdoPos,
 uint8_t entryPos
 )
 entry->slave_position = slaveIndex;
 entry->sync_index = syncIndex;
 entry->pdo_pos = pdoPos;
 entry->entry_pos = entryPos;
-if (ioctl(fd, EC_IOCTL_PDO_ENTRY, entry)) {
+if (ioctl(fd, EC_IOCTL_SLAVE_SYNC_PDO_ENTRY, entry)) {
 stringstream err;
 err << "Failed to get Pdo entry: ";
 if (errno == EINVAL)
 err << "Either slave " << slaveIndex << " does not exist, "
 << "or it contains less than " << (unsigned int) syncIndex + 1
 }
 /****************************************************************************/
 void Master::getSdo(
-ec_ioctl_sdo_t *sdo,
+ec_ioctl_slave_sdo_t *sdo,
 uint16_t slaveIndex,
 uint16_t sdoPosition
 )
 {
 sdo->slave_position = slaveIndex;
 sdo->sdo_position = sdoPosition;
-if (ioctl(fd, EC_IOCTL_SDO, sdo)) {
+if (ioctl(fd, EC_IOCTL_SLAVE_SDO, sdo)) {
 stringstream err;
 err << "Failed to get Sdo: ";
 if (errno == EINVAL)
 err << "Either slave " << slaveIndex << " does not exist, "
 << "or it contains less than " << sdoPosition + 1 << " Sdos!"
 }
 /****************************************************************************/
 void Master::getSdoEntry(
-ec_ioctl_sdo_entry_t *entry,
+ec_ioctl_slave_sdo_entry_t *entry,
 uint16_t slaveIndex,
 int sdoSpec,
 uint8_t entrySubindex
 )
 {
 entry->slave_position = slaveIndex;
 entry->sdo_spec = sdoSpec;
 entry->sdo_entry_subindex = entrySubindex;
-if (ioctl(fd, EC_IOCTL_SDO_ENTRY, entry)) {
+if (ioctl(fd, EC_IOCTL_SLAVE_SDO_ENTRY, entry)) {
 stringstream err;
 err << "Failed to get Sdo entry: ";
 err << strerror(errno);
 throw MasterException(err.str());
 }

changeset 1079	ef1266652c4d
parent 1073	f3c50aa42b6c
child 1082	ff06c58e269c