static void sendMsgBurst (int burstNr, int handle1, int handle2)
{
canStatus stat;
int i;
// Send a burst of messages on both channels
for (i=0; i<BURST_SIZE; i++) {
stat = canWrite(handle1,
msgs1[i].id,
msgs1[i].data,
msgs1[i].dlc,
msgs1[i].flags);
if (stat != canOK) {
printSomeStuff();
printf("line %d, burst %d, msg %d\n", __LINE__, burstNr, i);
Check("canWrite() failed", stat);
}
stat = canWrite(handle2,
msgs2[i].id,
msgs2[i].data,
msgs2[i].dlc,
msgs2[i].flags);
if (stat != canOK) {
printSomeStuff();
printf("line %d, burst %d, msg %d\n", __LINE__, burstNr, i);
Check("canWrite() failed", stat);
}
}
}
void incBusLoad (int channel, int flags, int load)
{
canHandle handle;
unsigned char msg[8] = "Kvaser!";
int i, id = 100, dlc = sizeof(msg);
canStatus stat = canERR_PARAM;
handle = canOpenChannel(channel, flags);
if (handle < 0) {
check("canOpenChannel", handle);
return;
}
stat = canBusOff(handle);
check("canBusOff", stat);
stat = canSetBusParams(handle, bitrate, 0, 0, 0, 0, 0);
check("canSetBusParams", stat);
canBusOn(handle);
for (i = 0; i < load; i++) {
stat = canWrite(handle, id, &msg, dlc, 0);
check("canWrite", stat);
}
stat = canWriteWait(handle, id, &msg, dlc, 0, -1);
check("canWriteWait", stat);
canBusOff(handle);
canClose(handle);
}
int CESDDevice::writeDevice(CProtocolMessage& rclProtocolMessage)
{
int iRetVal = 0;
long iNumberOfMessages = 1;
CMSG clESDProtocolMessage;
m_iErrorState = 0;
//debug output
printMessage(rclProtocolMessage,WRITE);
clESDProtocolMessage.id = rclProtocolMessage.m_uiMessageId;
clESDProtocolMessage.len = rclProtocolMessage.m_ucMessageLength;
if(rclProtocolMessage.m_bRTRFlag)
clESDProtocolMessage.len |= 0x10;
memcpy(clESDProtocolMessage.data, rclProtocolMessage.m_aucMessageData, rclProtocolMessage.m_ucMessageLength);
iRetVal = canWrite(m_hDevice, &clESDProtocolMessage, &iNumberOfMessages, NULL);
// iRetVal = canSend(m_hDevice, &clESDProtocolMessage, &iNumberOfMessages);
if(iRetVal != NTCAN_SUCCESS)
{
warning("can send failed Errorcode: %d", iRetVal);
m_iErrorState = getDeviceError(iRetVal);
return m_iErrorState;
}
return m_iErrorState;
}
/**
* Sets a send parameters (fmtp) for the PayloadType.
* This method is provided for applications using RTP with SDP, but
* actually the ftmp information is not used for RTP processing.
**/
void payload_type_set_send_fmtp(PayloadType *pt, const char *fmtp){
if (canWrite(pt)){
if (pt->send_fmtp!=NULL) ortp_free(pt->send_fmtp);
if (fmtp!=NULL) pt->send_fmtp=ortp_strdup(fmtp);
else pt->send_fmtp=NULL;
}
}
afs_int32
writeTape(int fid, struct tape *tapePtr, afs_int32 dumpid)
{
struct budb_tapeEntry tapeEntry;
afs_int32 code = 0, tcode;
tcode = writeStructHeader(fid, SD_TAPE);
if (tcode)
ERROR(tcode);
tapeToBudbTape(tapePtr, &tapeEntry);
tapeEntry.dump = htonl(dumpid);
if (canWrite(fid) <= 0)
ERROR(BUDB_DUMPFAILED);
if (write(fid, &tapeEntry, sizeof(tapeEntry)) != sizeof(tapeEntry))
ERROR(BUDB_DUMPFAILED);
haveWritten(sizeof(tapeEntry));
error_exit:
return (code);
}
void ossimGdalImageWriterFactory::getImageFileWritersByMimeType(ossimImageWriterFactoryBase::ImageFileWriterList& result,
const ossimString& mimeType)const
{
int c = GDALGetDriverCount();
int idx = 0;
for(idx = 0; idx < c; ++idx)
{
GDALDriverH h = GDALGetDriver(idx);
if(canWrite(h))
{
ossimString driverName = GDALGetDriverShortName(h);
driverName = "gdal_" + driverName.upcase();
ossimString metaData(GDALGetMetadataItem(h, GDAL_DMD_MIMETYPE, 0));
if(!metaData.empty())
{
if(metaData == mimeType)
{
ossimGdalWriter* writer = new ossimGdalWriter;
writer->setOutputImageType(driverName);
result.push_back(writer);
if ( driverName == "gdal_JP2KAK" )
{
// Make it lossless for starters. User can still override.
ossimKeywordlist kwl;
kwl.add("property0.name", "QUALITY");
kwl.add("property0.value", "100");
writer->loadState(kwl, NULL);
}
return;
}
}
}
}
}
afs_int32
writeVolume(struct ubik_trans *ut, int fid, struct volFragment *volFragmentPtr,
struct volInfo *volInfoPtr, afs_int32 dumpid, char *tapeName)
{
struct budb_volumeEntry budbVolume;
afs_int32 code = 0;
volsToBudbVol(volFragmentPtr, volInfoPtr, &budbVolume);
budbVolume.dump = htonl(dumpid);
strcpy(budbVolume.tape, tapeName);
writeStructHeader(fid, SD_VOLUME);
if (canWrite(fid) <= 0)
ERROR(BUDB_DUMPFAILED);
if (write(fid, &budbVolume, sizeof(budbVolume)) != sizeof(budbVolume))
ERROR(BUDB_DUMPFAILED);
haveWritten(sizeof(budbVolume));
error_exit:
return (code);
}
bool BackgroundTexturesIOPC::write(const BackgroundTexturesPC *textures)
{
if(!canWrite()) {
return false;
}
for(quint8 texID=0 ; texID<BACKGROUND_TEXTURE_PC_MAX_COUNT ; ++texID) {
quint16 exists = textures->hasTex(texID);
if(device()->write((char *)&exists, 2) != 2) {
return false;
}
if(bool(exists)) {
BackgroundTexturesPCInfos infos = textures->texInfos(texID);
quint16 size = infos.size, depth = infos.depth;
if(device()->write((char *)&size, 2) != 2 ||
device()->write((char *)&depth, 2) != 2) {
return false;
}
if(device()->write(textures->data().mid(infos.pos, infos.depth * 65536))
!= infos.depth * 65536) {
return false;
}
}
}
return true;
}
bool Fifo::tryConnect() noexcept {
if (isConnected()) {
return true;
}
if (!exists(path_.c_str())) {
if (!create(path_.c_str())) {
static bool logged{false};
if (!logged) {
VLOG(1) << "Error creating debug fifo at \"" << path_ << "\": "
<< strerror(errno) << " [" << errno << "]";
logged = true;
}
return false;
}
}
if (!isFifo(path_.c_str()) || !canWrite(path_.c_str())) {
if (!removeFile(path_.c_str()) ||
!create(path_.c_str())) {
return false;
}
}
int fd = folly::openNoInt(path_.c_str(), O_WRONLY | O_NONBLOCK);
if (fd >= 0) {
fd_.store(fd);
return true;
}
return false;
}
bool BackgroundTilesIO::write(const BackgroundTiles &tiles) const
{
if(!canWrite()) {
return false;
}
return writeData(tiles);
}
PrefsFile::PrefsFile(const QString& pFilePath, bool write)
{
m_prefsFilePath = pFilePath;
m_ioEnabled = write;
if (m_ioEnabled)
canWrite();
load();
}
int writeByte_nonblocking(char byte, uint8_t usartn)
{
if (canWrite(usartn)) {
__writeByte(byte, usartn);
return 0;
}
return -1;
}
uint8_t circularBuffer_write(CircularBuffer * buffer, char * data, uint8_t size){
uint8_t amount = 0;
while (size-amount>0 && canWrite(buffer)){
if(circularBuffer_writeByte(buffer, data[amount]) == -1)
return amount;
amount++;
}
return amount;
}
void StatisticsWindow::updateProtocol(AbstractProtocol* p)
{
if(p != nullptr)
_activeProtocol = p;
if(_window == nullptr)
{
return;
}
werase(_window);
wborder(_window, ACS_VLINE, ACS_VLINE, ACS_HLINE, ACS_HLINE, ACS_ULCORNER, ACS_URCORNER, ACS_LLCORNER, ACS_LRCORNER);
std::string tmp(" ");
for_each(_allProtocols.begin(), _allProtocols.end(), [&](std::string& s) {
if(!s.compare(_activeProtocol->getProtocolName()))
{
tmp += std::string(" < ") + s + std::string(" > ");
}
else
{
tmp += std::string(" ") + s + std::string(" ");
}
});
mvwprintw(_window, STATISTICS::PROTOCOLS_LINE, FIRST_CHAR_POS, "%s", tmp.c_str());
unsigned int line = STATISTICS::FIRST_OPERATION_LINE;
for(unsigned int i = STATISTICS::DEFAULT_GROUP; i <= _activeProtocol->getGroups(); i++)
{
if(canWrite(line))
{
mvwprintw(_window, line - (_scrollOffset.at(p)), FIRST_CHAR_POS, "%s", "Total:");
}
line++;
for(unsigned int j = _activeProtocol->getGroupBegin(i); j < _activeProtocol->getGroupBegin(i + 1); j++)
{
if(canWrite(line))
{
mvwprintw(_window, line - (_scrollOffset.at(p)), FIRST_CHAR_POS, "%s", p->printProcedure(j));
}
line++;
}
line++;
}
}
bool MemBuffer::write(const Byte* array, size_t size)
{
bool bOk = false;
if(canWrite(g_sizeBYTE*size))
{
memcpy(getBuffer(), array, size);
bOk = shiftBuffer(g_sizeBYTE*size);
}
return bOk;
}
void NetworkMessage::addU32(uint32_t value)
{
ECORR32(value);
if(canWrite(4)){
m_buffer[m_writePos++] = (uint8_t)(value);
m_buffer[m_writePos++] = (uint8_t)(value >> 8);
m_buffer[m_writePos++] = (uint8_t)(value >> 16);
m_buffer[m_writePos++] = (uint8_t)(value >> 24);
m_size += 4;
}
void enable_torque_assist() {
// Unit responds to input torque, provides output torque according to
// programmed assist curve.
char msg_buf[]={0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00};
msg_buf[0]=0x02;
check("canWrite", canWrite(h, CAN_ID, (void*)msg_buf, 8, canMSG_EXT));
check("canWriteSync", canWriteSync(h, 1000));
}
bool MemBuffer::writeByte(const Byte b)
{
bool bOk = false;
if(canWrite(g_sizeBYTE))
{
memcpy(getBuffer(), &b, g_sizeBYTE);
bOk = shiftBuffer(g_sizeBYTE);
}
return bOk;
}
afs_int32
writeText(struct ubik_trans *ut, int fid, int textType)
{
struct textBlock *tbPtr;
afs_int32 textSize, writeSize;
dbadr dbAddr;
struct block block;
afs_int32 code = 0;
/* check lock is free */
code = checkLock(textType);
if (code)
ERROR(code);
/* ensure that this block has the correct type */
code = checkText(ut, textType);
if (code) {
LogError(0, "writeText: text type %d damaged\n", textType);
ERROR(code);
}
tbPtr = &db.h.textBlock[textType];
textSize = ntohl(tbPtr->size);
dbAddr = ntohl(tbPtr->textAddr);
if (!dbAddr)
goto error_exit; /* Don't save anything if no blocks */
writeTextHeader(fid, textType);
while (dbAddr) {
code = cdbread(ut, text_BLOCK, dbAddr, (char *)&block, sizeof(block));
if (code)
ERROR(code);
writeSize = MIN(textSize, BLOCK_DATA_SIZE);
if (!writeSize)
break;
if (canWrite(fid) <= 0)
ERROR(BUDB_DUMPFAILED);
if (write(fid, &block.a[0], writeSize) != writeSize)
ERROR(BUDB_IO);
haveWritten(writeSize);
textSize -= writeSize;
dbAddr = ntohl(block.h.next);
}
error_exit:
return (code);
}
/* Can Send Function
* A function for the sending of can messages on the bus.
*/
static void canSend(uint32_t id) {
canMessage_t msg = {0, 0, 0, 0};
bool txOk = false;
msg.id = id; // arbitrary CAN message id
msg.len = 4; // data length 4
msg.dataA = 0;
msg.dataB = 0;
// Transmit message on CAN 1
txOk = canWrite(CAN_PORT_1, &msg);
}
/**
* @brief MainWindow::on_pushButton_CanSend_clicked
*/
void MainWindow::on_pushButton_CanSend_clicked()
{
// CanMsg m;
// m.dlc = ui->spinBoxDLC->value();
// m.extmsg = ui->checkBox_CanExtended->isChecked();
// if(m.extmsg)
// m.extid = ui->spinBoxCanIDHex->value();
// else
// m.stdid = ui->spinBoxCanIDHex->value();
// m.rtr = ui->checkBox_RTR->isChecked();
// if(m.dlc > 0 && ui->lineEdit_CanByte0->text() == QString("")) ui->lineEdit_CanByte0->setText("00");
// if(m.dlc > 1 && ui->lineEdit_CanByte1->text() == QString("")) ui->lineEdit_CanByte1->setText("00");
// if(m.dlc > 2 && ui->lineEdit_CanByte2->text() == QString("")) ui->lineEdit_CanByte2->setText("00");
// if(m.dlc > 3 && ui->lineEdit_CanByte3->text() == QString("")) ui->lineEdit_CanByte3->setText("00");
// if(m.dlc > 4 && ui->lineEdit_CanByte4->text() == QString("")) ui->lineEdit_CanByte4->setText("00");
// if(m.dlc > 5 && ui->lineEdit_CanByte5->text() == QString("")) ui->lineEdit_CanByte5->setText("00");
// if(m.dlc > 6 && ui->lineEdit_CanByte6->text() == QString("")) ui->lineEdit_CanByte6->setText("00");
// if(m.dlc > 7 && ui->lineEdit_CanByte7->text() == QString("")) ui->lineEdit_CanByte7->setText("00");
// bool c;
// if(m.dlc > 0) m.data.append(ui->lineEdit_CanByte0->text().toUInt(&c,16));
// if(m.dlc > 1) m.data.append(ui->lineEdit_CanByte1->text().toUInt(&c,16));
// if(m.dlc > 2) m.data.append(ui->lineEdit_CanByte2->text().toUInt(&c,16));
// if(m.dlc > 3) m.data.append(ui->lineEdit_CanByte3->text().toUInt(&c,16));
// if(m.dlc > 4) m.data.append(ui->lineEdit_CanByte4->text().toUInt(&c,16));
// if(m.dlc > 5) m.data.append(ui->lineEdit_CanByte5->text().toUInt(&c,16));
// if(m.dlc > 6) m.data.append(ui->lineEdit_CanByte6->text().toUInt(&c,16));
// if(m.dlc > 7) m.data.append(ui->lineEdit_CanByte7->text().toUInt(&c,16));
if(connected && busOn && !ui->checkBox_Silent->isChecked()){
char data[8];
int flags = 0;
data[0] = ui->lineEdit_CanByte0->text().toUInt(NULL,16);
data[1] = ui->lineEdit_CanByte1->text().toUInt(NULL,16);
data[2] = ui->lineEdit_CanByte2->text().toUInt(NULL,16);
data[3] = ui->lineEdit_CanByte3->text().toUInt(NULL,16);
data[4] = ui->lineEdit_CanByte4->text().toUInt(NULL,16);
data[5] = ui->lineEdit_CanByte5->text().toUInt(NULL,16);
data[6] = ui->lineEdit_CanByte6->text().toUInt(NULL,16);
data[7] = ui->lineEdit_CanByte7->text().toUInt(NULL,16);
if( ui->checkBox_CanExtended->isChecked() ){
flags += canMSG_EXT;
}
if(ui->checkBox_RTR->isChecked()){
flags += canMSG_RTR;
}
canWrite(canHandle, ui->spinBoxCanIDHex->value(), data, ui->spinBoxDLC->value(), flags );
}else{
QMessageBox msgBox;
msgBox.setText("Current interface status does not allow transmitting can frames.\n\n- Connected?\n- Bus On?\n- Silent?");
msgBox.exec();
}
}
qint64 QLocalSocket::writeData(const char *data, qint64 maxSize)
{
Q_D(QLocalSocket);
if (!d->pipeWriter) {
d->pipeWriter = new QWindowsPipeWriter(d->handle, this);
connect(d->pipeWriter, SIGNAL(canWrite()), this, SLOT(_q_canWrite()));
connect(d->pipeWriter, SIGNAL(bytesWritten(qint64)), this, SIGNAL(bytesWritten(qint64)));
d->pipeWriter->start();
}
return d->pipeWriter->write(data, maxSize);
}
void LeaseHolderBase::acquireBlocking() {
assertx(!canWrite());
if (m_lease.amOwner()) {
m_state = LockLevel::Write;
return;
}
m_acquired = m_lease.acquire(true);
m_state = LockLevel::Write;
}
void payload_type_append_recv_fmtp(PayloadType *pt, const char *fmtp){
if (canWrite(pt)){
if (pt->recv_fmtp==NULL)
pt->recv_fmtp=ortp_strdup(fmtp);
else{
char *tmp=ortp_strdup_printf("%s;%s",pt->recv_fmtp,fmtp);
ortp_free(pt->recv_fmtp);
pt->recv_fmtp=tmp;
}
}
}
bool MemBuffer::write(uint32_t uint32)
{
bool bOk = false;
if(canWrite(g_sizeUINT32))
{
uint32 = htonl(uint32);
memcpy(getBuffer(), &uint32, g_sizeUINT32);
bOk = shiftBuffer(g_sizeUINT32);
}
return bOk;
}
int32_t writeNTCAN(NTCAN_HANDLE handle, int32_t len, CMSG *msg)
{
NTCAN_RESULT result;
/* Writes to NTCAN device */
len |= len + (RTR_ENABLE<<4);
result = canWrite(handle, msg, &len, NULL);
if(errorCheck(CAN_WRITE,result) != 0)
{ return 1; }
printf("Message sent %d successful frames\n",len);
return 0;
}
int8_t circularBuffer_writeByte(CircularBuffer * buffer, char data){
if(canWrite(buffer) == 0)
return -1;
buffer->data[buffer->head-1] = data;
if (buffer->head == buffer->size) {
buffer->head = 1;
} else {
buffer->head++;
}
return 1;
}
//
//called when the Send button is pressed.
//
void CCanTestMFCDlg::OnSend()
{
char data[8];
int stat;
//send a can message on channel 0
stat = canWrite(m_handle, 1234, data, 8, canMSG_EXT);
if (stat < 0) {
AfxMessageBox("ERROR: canWrite().");
}
}
bool BackgroundTexturesIOPS::write(const BackgroundTexturesPS *textures)
{
if(!canWrite()) {
return false;
}
if(device()->write(textures->data()) != textures->data().size()) {
return false;
}
return true;
}
/*
* A can send function for the sending of can messages
* on the can bus.
*/
static void canSend(uint32_t id) {
canMessage_t msg = {0, 0, 0, 0};
/* Initialise the CAN message structure */
msg.id = id; // arbitrary CAN message id
msg.len = 4; // data length 4
msg.dataA = 0;
msg.dataB = 0;
// Transmit message on CAN 1
canWrite(CAN_PORT_1, &msg);
}
