Beispiel #1
0
static int
brl_construct (BrailleDisplay *brl, char **parameters, const char *device) {
  if (!isSerialDevice(&device)) {
     unsupportedDevice(device);
     return 0;
  }

  if ((serialDevice = serialOpenDevice(device))) {
    if (serialRestartDevice(serialDevice, serialBaud)) {
      static const unsigned char request[] = {BNO_DESCRIBE};
      charactersPerSecond = serialBaud / 10;
      if (writePacket(brl, request, sizeof(request)) != -1) {
        while (serialAwaitInput(serialDevice, 100)) {
          ResponsePacket response;
          int size = getPacket(&response);
          if (size) {
            if (response.data.code == BNI_DESCRIBE) {
              statusCells = response.data.values.description.statusCells;
              brl->textColumns = response.data.values.description.textCells;
              brl->textRows = 1;
              brl->keyBindings = "keys";

              if ((statusCells == 5) && (brl->textColumns == 30)) {
                statusCells -= 2;
                brl->textColumns += 2;
              }
              dataCells = brl->textColumns * brl->textRows;
              cellCount = statusCells + dataCells;

              makeOutputTable(dotsTable_ISO11548_1);
              makeInputTable();

              if ((cellBuffer = malloc(cellCount))) {
                memset(cellBuffer, 0, cellCount);
                statusArea = cellBuffer;
                dataArea = statusArea + statusCells;
                refreshCells(brl);
                persistentKeyboardMode = KBM_NAVIGATE;
                temporaryKeyboardMode = persistentKeyboardMode;
                persistentRoutingOperation = BRL_BLK_ROUTE;
                temporaryRoutingOperation = persistentRoutingOperation;
                return 1;
              } else {
                logSystemError("cell buffer allocation");
              }
            } else {
              logUnexpectedPacket(response.bytes, size);
            }
          }
        }
      }
    }
    serialCloseDevice(serialDevice);
    serialDevice = NULL;
  }
  return 0;
}
void Driver::cleanComChannel()
{
    try
    {
        writePacket(reinterpret_cast<uint8_t const*>("\r"), 1, 100);
        readConfigurationAck();
    }
    catch (std::runtime_error e) {}
}
bool SeaNet::isFullDuplex(int timeout)
{
    std::vector<uint8_t> packet = SeaNetPacket::createPaket(device_type,mtSendBBUser);
    writePacket(&packet[0],packet.size());
    waitForPacket(mtBBUserData,timeout);
    BBUserData settings;
    sea_net_packet.decodeBBUserData(settings);
    return settings.full_duplex;
}
Beispiel #4
0
void
DebugNet::writeBreakpointHit(uint32_t coreId, uint32_t userData)
{
   auto pak = new DebugPacketBpHit();
   pak->coreId = coreId;
   pak->userData = userData;
   populateDebugPauseInfo(pak->info);
   writePacket(pak);
}
void SeaNet::getVersion(VersionData &version,int timeout)
{
    std::vector<uint8_t> send_packet = SeaNetPacket::createPaket(device_type,mtSendVersion);
    writePacket(&send_packet[0],send_packet.size());

    //wait until we received a mtVersionData package
    waitForPacket(mtVersionData,timeout);
    sea_net_packet.decodeVersionData(version);
}
static void
loopTruthTable(TruthTable truthset[])
{
    for(int i = 0; truthset[i].packet != NULL; i++)
    {
        writePacket(&truthset[i]);
    }

}
Beispiel #7
0
void secPack(int fd, void *secpack) {
    LOG(LOGLEVEL_INFO, "Sending secpack...\n");

    writePacket(fd, 0x204, secpack, 0x800);
    char buffer[PACKET_SIZE(SECPACK_REPLY_PACKET_SIZE)];
    size_t rlength = readPacket(fd, WRITE_TIMEOUT, buffer, sizeof(buffer));
    SecpackReplyPacket *reply = verifyPacket(buffer, rlength);
    LOG(LOGLEVEL_DEBUG, "Secpack returns: unknown1=%d unknown2=0x%x\n", reply ? reply->unknown1 : 0, reply ? reply->unknown2 : 0);
}
Beispiel #8
0
void seekBaseband(int fd, unsigned int offset) {
    LOG(LOGLEVEL_INFO, "Seeking to 0x%08x...\n", offset);

    writePacket(fd, 0x802, &offset, sizeof(offset));
    char buffer[PACKET_SIZE(SEEK_REPLY_PACKET_SIZE)];
    size_t length = readPacket(fd, DEFAULT_TIMEOUT, buffer, sizeof(buffer));
    LOG(LOGLEVEL_DEBUG, "Seek returns:\n");
    LOGDO(LOGLEVEL_DEBUG, printBuffer(verifyPacket(buffer, length), SEEK_REPLY_PACKET_SIZE));
}
Beispiel #9
0
	void resume()
	{
		assert(paused);
		paused = false;

		ZhttpResponsePacket p;
		p.type = ZhttpResponsePacket::KeepAlive;
		writePacket(p);
	}
Beispiel #10
0
// Send a Midi PROGRAM CHANGE message to given channel, with program ID 0-127
void USBMidi::sendProgramChange(unsigned int channel, unsigned int program)
{
    outPacket.p.cable=DEFAULT_MIDI_CABLE;
    outPacket.p.cin=CIN_PROGRAM_CHANGE;
    outPacket.p.midi0=MIDIv1_PROGRAM_CHANGE |(channel & 0x0f);
    outPacket.p.midi1=program;
    writePacket(outPacket.i);
    
}
Beispiel #11
0
// Returns a packet read from the serial connection
ARCPOPacket& readPacket(ARCPOPacket& pPacket) {
    char vReadChar;
    boolean vStarterRead = false;
    mPacketRead = false;

    if (Serial.available() > 0) {
        //wait to make sure everything will be there
        //at 9600 bps, one need (1/9600) * 8 bits * 64 byte = 0.053 sec. We wait 0.1 sec to be sure.
        delay(100);

        while(Serial.available() > 0) {
            vReadChar = Serial.read();

            //search the start
            if (vReadChar == '$') {
                vStarterRead = true;
            }
            else {
                //confirm the start
                if (vStarterRead && vReadChar == '*') {
                    vStarterRead = false;
                    pPacket = readPacketInternal(pPacket);
                    mPacketRead = true;
                }
                else {
                    //crap in  the buffer, clean until next starter or empty
                    vStarterRead = false;
                }
            }
        }
    }
#ifdef ARCPO_Lib_DEBUGMODE
    else {
        Serial.print ("DBG: readPacket : no data => ");
        Serial.println ((int)Serial.available());
    }
#endif

    if (mPacketRead && pPacket.ExpectAcknowledge == 1) {
#ifdef ARCPO_Lib_DEBUGMODE
        Serial.print ("Acknowledgement -->");
#endif
        //acknowledge packet
        ARCPOPacket vPacketAck;
        vPacketAck.ID = pPacket.ID;
        vPacketAck.Type = 255;
        vPacketAck.SubType = 255;
        vPacketAck.ExpectAcknowledge = 255;
        vPacketAck.Content[0] = 'A';
        vPacketAck.Content[1] = 'C';
        vPacketAck.Content[2] = 'K';
        vPacketAck.Content[3] = 0;
        writePacket(vPacketAck);
    }

    return pPacket;
}
Beispiel #12
0
// Send a Midi SONG SELECT message, with a song ID of 0-127 (always for all channels)
void USBMidi::sendSongSelect(unsigned int song)
{
    outPacket.p.cable=DEFAULT_MIDI_CABLE;
    outPacket.p.cin=CIN_2BYTE_SYS_COMMON;
    outPacket.p.midi0=MIDIv1_SONG_SELECT;
    outPacket.p.midi1= (uint8) song & 0x07F;
    writePacket(outPacket.i);
    
}
Beispiel #13
0
	void pause()
	{
		assert(!doReq);
		pausing = true;

		ZhttpResponsePacket p;
		p.type = ZhttpResponsePacket::HandoffStart;
		writePacket(p);
	}
Beispiel #14
0
// Send a Midi AFTER TOUCH message to given channel, with velocity 0-127
void USBMidi::sendAfterTouch(unsigned int channel, unsigned int velocity)
{
    outPacket.p.cable=DEFAULT_MIDI_CABLE;
    outPacket.p.cin=CIN_CHANNEL_PRESSURE;
    outPacket.p.midi0=MIDIv1_CHANNEL_PRESSURE |(channel & 0x0f);
    outPacket.p.midi1=velocity;
    writePacket(outPacket.i);
    
}
/*
 * Acknowledge a received packet
 */
static void ackPacket(uint8_t ack  /* ack return value */
                      )
{
    gPacket.data[PACKET_DESTINATION] = gPacket.data[PACKET_SOURCE];
    gPacket.data[PACKET_SOURCE] = gPacket.myAddr;
    gPacket.data[PACKET_COMMAND] = ack;
    gPacket.length = 6;
    writePacket();
}
Beispiel #16
0
static int
writeLocation (BrailleDisplay *brl) {
  unsigned char packet[2];
  unsigned char *byte = packet;

  *byte++ = statusCells[gscScreenCursorRow];
  *byte++ = statusCells[gscScreenCursorColumn];

  return writePacket(brl, packet, byte-packet);
}
Beispiel #17
0
// Send a Midi VELOCITY CHANGE message to a given channel, with given note 0-127,
// and new velocity 0-127
// Note velocity change == polyphonic aftertouch.
// Note aftertouch == channel pressure.
void USBMidi::sendVelocityChange(unsigned int channel, unsigned int note, unsigned int velocity)
{
    outPacket.p.cable=DEFAULT_MIDI_CABLE;
    outPacket.p.cin=CIN_AFTER_TOUCH;
    outPacket.p.midi0=MIDIv1_AFTER_TOUCH |(channel & 0x0f);
    outPacket.p.midi1=note;
    outPacket.p.midi2=velocity;
    writePacket(outPacket.i);
    
}
void SeaNet::reboot(int timeout)
{
    LOG_DEBUG_S << "rebooting device" ;
    std::vector<uint8_t> packet = SeaNetPacket::createPaket(device_type,mtReBoot);
    writePacket(&packet[0],packet.size());
    clear();

    //now wait for an alive message
    waitForPacket(mtAlive,timeout);
}
Beispiel #19
0
	void respond()
	{
		state = Connected;

		ZhttpResponsePacket out;
		out.code = responseCode;
		out.reason = responseReason;
		out.headers = responseHeaders;
		writePacket(out);
	}
Beispiel #20
0
// Send a Midi SONG POSITION message, with a 14-bit position (always for all channels)
void USBMidi::sendSongPosition(unsigned int position)
{
    outPacket.p.cable=DEFAULT_MIDI_CABLE;
    outPacket.p.cin=CIN_3BYTE_SYS_COMMON;
    outPacket.p.midi0=MIDIv1_SONG_POSITION_PTR;
    outPacket.p.midi1= (uint8) position & 0x07F;
    outPacket.p.midi2= (uint8)  (position<<7) & 0x7f;
    writePacket(outPacket.i);
    
}
Beispiel #21
0
// Send a Midi PITCH CHANGE message, with a 14-bit pitch (always for all channels)
void USBMidi::sendPitchChange(unsigned int pitch)
{
    outPacket.p.cable=DEFAULT_MIDI_CABLE;
    outPacket.p.cin=CIN_PITCH_WHEEL;
    outPacket.p.midi0=MIDIv1_PITCH_WHEEL;
    outPacket.p.midi1= (uint8) pitch & 0x07F;
    outPacket.p.midi2= (uint8)  (pitch<<7) & 0x7f;
    writePacket(outPacket.i);
    
}
Beispiel #22
0
void endSecPack(int fd) {
    LOG(LOGLEVEL_INFO, "Ending secpack...\n");

    unsigned short unknown = 0;
    writePacket(fd, 0x205, &unknown, sizeof(unknown));
    char buffer[PACKET_SIZE(sizeof(unsigned short))];
    size_t rlength = readPacket(fd, DEFAULT_TIMEOUT, buffer, sizeof(buffer));
    unsigned short *ret = verifyPacket(buffer, rlength);
    LOG(LOGLEVEL_DEBUG, "End secpack returns: %d\n", ret ? *ret : 0);
}
bool PcapFileWriterDevice::writePackets(const RawPacketVector& packets)
{
	for (RawPacketVector::ConstVectorIterator iter = packets.begin(); iter != packets.end(); iter++)
	{
		if (!writePacket(**iter))
			return false;
	}

	return true;
}
Beispiel #24
0
// Send a Midi CC message to a given channel, as a given controller 0-127, with given
//  value 0-127
void USBMidi::sendControlChange(unsigned int channel, unsigned int controller, unsigned int value)
{
    outPacket.p.cable=DEFAULT_MIDI_CABLE;
    outPacket.p.cin=CIN_CONTROL_CHANGE;
    outPacket.p.midi0=MIDIv1_CONTROL_CHANGE |(channel & 0x0f);
    outPacket.p.midi1=controller;
    outPacket.p.midi2=value;
    writePacket(outPacket.i);
    
}
Beispiel #25
0
// Send Midi NOTE ON message to a given channel, with note 0-127 and velocity 0-127
void USBMidi::sendNoteOn(unsigned int channel, unsigned int note, unsigned int velocity)
{
    outPacket.p.cable=DEFAULT_MIDI_CABLE;
    outPacket.p.cin=CIN_NOTE_ON;
    outPacket.p.midi0=MIDIv1_NOTE_ON|(channel & 0x0f);
    outPacket.p.midi1=note;
    outPacket.p.midi2=velocity;
    writePacket(outPacket.i);
    
}
Beispiel #26
0
static int
refreshCells (BrailleDisplay *brl) {
  unsigned char buffer[1 + cellCount];
  unsigned char *byte = buffer;

  *byte++ = BN_REQ_WRITE;
  byte = translateOutputCells(byte, cellBuffer, cellCount);

  return writePacket(brl, buffer, byte-buffer);
}
int ModbusClientV1::SetNumberOfBalls(int numOfBalls)
{
	RSPacket::PacketStruct p =
	{ 0 };
	fillTheCommonPacketHeader(p, RS_CMD_SET_NUM_OF_BALLS);
	p.data[0] = numOfBalls;
	if (writePacket(&p, RS_PACKET_HEADER_SIZE + 2)
			== (RS_PACKET_HEADER_SIZE + 2))
		return 0;
	return -1;
}
Beispiel #28
0
void writeBaseband(int fd, void *data, size_t length) {
    LOG(LOGLEVEL_STATUS, "Writing %lu bytes to flash...\n", length);

    writePacket(fd, 0x804, data, length);
    char buffer[PACKET_SIZE(sizeof(unsigned short))];
    size_t rlength = readPacket(fd, WRITE_TIMEOUT, buffer, sizeof(buffer));
    unsigned short *ret = verifyPacket(buffer, rlength);
    if (ret && *ret) {
        LOG(LOGLEVEL_ERROR, "Write returns error: %d\n", *ret);
    }
}
Beispiel #29
0
int clientVerifyFile(BIO *conn, char *filename) {
	//check our records
	FILERECORD *record = getRecord(filename);
	if(record == NULL) {
		fprintf(stderr, "No records stored for %s\n", filename);
		return -1;
	}

	//see if we have an "unused" salt and digest on record
	int index = record->hashIndex[0];
	if(index == NUM_HASHES) {
		fprintf(stderr, "All stored digests for this file have been consumed.\n");
		fprintf(stderr, "Type \"refresh %s\" to download the file and generate new digests.\n", filename);
		return -1;
	}

	unsigned char *hash = record->hashData[index];
	unsigned char *salt = hash + HASH_LENGTH;

	//send the code which triggers the server to call serverVerifyFile()
	if(writeInt(conn, VERIFY_FILE_CODE) == -1) return -1;

	//send the filename
	if(writeString(conn, filename) < 1) return -1;

	//send the salt
	if(writePacket(conn, (char *)salt, SALT_LENGTH) < 1) return -1;

	//wait for the server to indicate if a digest is coming or not
	int status = readInt(conn);
	//if the file does not exist
	if(status == 5) return 5;
	//if server failed to calculate digest
	if(status == -1) return -1;
	
	//receive the digest
	char serverHash[MD5_DIGEST_LENGTH];
	status = readPacket(conn, serverHash, sizeof(serverHash));
	if(status < 1) return -1;
	
	//check it against our stored digest
	if(memcmp(serverHash, hash, sizeof(serverHash)) != 0) {
		printf("The file digest does not match our records.\n");
	}
	else printf("The file digest matches our records.\n");

	++index;
	printf("You have consumed %d of %d stored digests.\n", index, NUM_HASHES);

	//update the hashIndex for this file
	updateHashIndex(filename, index);	

	return 0;
}
Beispiel #30
0
static int
writeVisualText (BrailleDisplay *brl) {
  unsigned char bytes[brl->textColumns];
  int i;

  for (i=0; i<brl->textColumns; ++i) {
    wchar_t character = visualText[i];
    bytes[i] = iswLatin1(character)? character: '?';
  }

  return writePacket(brl, 2, bytes, brl->textColumns);
}