size_t WiFiClient::write(const uint8_t *buf, size_t size) {
if (_sock >= MAX_SOCK_NUM)
{
setWriteError();
return 0;
}
if (size==0)
{
setWriteError();
return 0;
}
if (!ServerDrv::sendData(_sock, buf, size))
{
setWriteError();
return 0;
}
if (!ServerDrv::checkDataSent(_sock))
{
setWriteError();
return 0;
}
return size;
}
size_t WiFiClient::write(const uint8_t *buf, size_t size)
{
sint16 err;
if (_socket < 0 || size == 0) {
setWriteError();
return 0;
}
// Network led ON.
m2m_periph_gpio_set_val(M2M_PERIPH_GPIO16, 0);
m2m_wifi_handle_events(NULL);
while ((err = send(_socket, (void *)buf, size, 0)) < 0) {
// Exit on fatal error, retry if buffer not ready.
if (err != SOCK_ERR_BUFFER_FULL) {
setWriteError();
m2m_periph_gpio_set_val(M2M_PERIPH_GPIO16, 1);
return 0;
}
m2m_wifi_handle_events(NULL);
}
// Network led OFF.
m2m_periph_gpio_set_val(M2M_PERIPH_GPIO16, 1);
return size;
}
size_t Keyboard_::write(uint8_t c)
{
// Keydown
{
KeyReport keys = {0};
if (_keyMap)
_keyMap->charToKey(c,&keys);
else
{
if (c >= 128) {
setWriteError();
return 0;
}
c = pgm_read_byte(_asciimap + c);
if (!c) {
setWriteError();
return 0;
}
if (c & 0x80)
{
keys.modifiers |= KEY_MODIFIER_LEFT_SHIFT;
c &= 0x7F;
}
keys.keys[0] = c;
}
sendReport(&keys);
}
// Keyup
{
KeyReport keys = {0};
sendReport(&keys);
}
return 1;
}
size_t EthernetClient::write(const uint8_t *buf, size_t size) {
if (_sock == MAX_SOCK_NUM) {
setWriteError();
return 0;
}
if (!send(_sock, buf, size)) {
setWriteError();
return 0;
}
return size;
}
size_t File::write(const uint8_t *buf, size_t size) {
size_t t;
if (!_file) {
setWriteError();
return 0;
}
_file->clearWriteError();
t = _file->write(buf, size);
if (_file->getWriteError()) {
setWriteError();
return 0;
}
return t;
}
size_t EthernetClient::write(const uint8_t *buf, size_t size)
{
if (sockindex >= MAX_SOCK_NUM) return 0;
if (Ethernet.socketSend(sockindex, buf, size)) return size;
setWriteError();
return 0;
}
size_t USBSerial::write(uint8_t c)
{
/* only try to send bytes if the high-level CDC connection itself
is open (not just the pipe) - the OS should set lineState when the port
is opened and clear lineState when the port is closed.
bytes sent before the user opens the connection or after
the connection is closed are lost - just like with a UART. */
// TODO - ZE - check behavior on different OSes and test what happens if an
// open connection isn't broken cleanly (cable is yanked out, host dies
// or locks up, or host virtual serial port hangs)
if (LineState > 0) {
Endpoint_SelectEndpoint(CDC_TX_EPADDR);
if (!Endpoint_IsReadWriteAllowed()) {
Endpoint_ClearIN();
while (!Endpoint_IsINReady() && USB_DeviceState == DEVICE_STATE_Configured) {
USB_USBTask();
}
}
set_blink_LED();
Endpoint_Write_8(c);
return 1;
} else {
setWriteError();
return 0;
}
}
size_t WiFiClient::write(const uint8_t *buf, size_t size) {
if (!ServerDrv::sendData(_sock, buf, size)) {
setWriteError();
return 0;
}
return size;
}
// must be called in:
// slave tx event callback
// or after beginTransmission(address)
size_t TwoWire::write(uint8_t data)
{
int master, writeLenght;
master = transmitting;
writeLenght = txBufferLength;
if(master){
// in master transmitter mode
// don't bother if buffer is full
if(writeLenght >= BUFFER_LENGTH){
setWriteError();
return 0;
}
// put byte in tx buffer
txBuffer[txBufferIndex] = data;
++txBufferIndex;
// update amount in buffer
txBufferLength = txBufferIndex;
}else{
// in slave send mode
// reply to master
twi_transmit(&data, 1);
}
return 1;
}
// System Control
// k is one of the SYSTEM_CONTROL defines which come from the HID usage table "Generic Desktop Page (0x01)"
// in "HID Usage Tables" (HUT1_12v2.pdf)
size_t Keyboard_::systemControl(uint8_t k)
{
if(k <= 16)
{
u16 mask = 0;
u8 m[2];
if(k > 0)
{
mask = 1 << (k - 1);
}
m[0] = LSB(mask);
m[1] = MSB(mask);
HID_SendReport(HID_REPORTID_SYSTEMCONTROL,m,sizeof(m));
// these are all OSCs, so send a clear to make it possible to send it again later
m[0] = 0;
m[1] = 0;
HID_SendReport(HID_REPORTID_SYSTEMCONTROL,m,sizeof(m));
return 1;
}
else
{
setWriteError();
return 0;
}
}
// must be called in:
// slave tx event callback
// or after beginTransmission(address)
size_t TwoWire::write(uint8_t data)
{
if(transmitting) {
// in master transmitter mode
// don't bother if buffer is full
if(TX_BUFFER_FULL) {
setWriteError();
return 0;
}
// put byte in tx buffer
txBuffer[txWriteIndex] = data;
txWriteIndex = (txWriteIndex + 1) % BUFFER_LENGTH;
} else {
// in slave send mode
// reply to master
if(TX_BUFFER_FULL) {
I2CSlaveDataPut(SLAVE_BASE, txBuffer[txReadIndex]);
txReadIndex = (txReadIndex + 1) % BUFFER_LENGTH;
}
txBuffer[txWriteIndex] = data;
txWriteIndex = (txWriteIndex + 1) % BUFFER_LENGTH;
}
return 1;
}
size_t Keyboard_::press1(uint8_t k, bool shift)
{
uint8_t i;
if (k >= 128 && k < 136) { // it's a modifier key
_keyReport.modifiers |= (1<<(k-128));
k = 0;
} else {
if (shift) { // it's a capital letter or other character reached with shift
_keyReport.modifiers |= 0x02; // the left shift modifier
}
}
// Add k to the key report only if it's not already present
// and if there is an empty slot.
if (_keyReport.keys[0] != k && _keyReport.keys[1] != k &&
_keyReport.keys[2] != k && _keyReport.keys[3] != k &&
_keyReport.keys[4] != k && _keyReport.keys[5] != k) {
for (i=0; i<6; i++) {
if (_keyReport.keys[i] == 0x00) {
_keyReport.keys[i] = k;
break;
}
}
if (i == 6) {
setWriteError();
return 0;
}
}
sendReport(&_keyReport);
return 1;
}
// ------------------------------------------------------------------------------------------------------
// Write - write data to Tx buffer
// return: #bytes written = success, 0=fail
// parameters:
// data = data byte
//
size_t i2c_t3::write(uint8_t data)
{
if(i2c->txBufferLength < I2C_TX_BUFFER_LENGTH)
{
i2c->txBuffer[i2c->txBufferLength++] = data;
return 1;
}
setWriteError();
return 0;
}
//force a write without bothering to check if the serial port is open
size_t Serial_::WRITE(uint8_t c)
{
int r = USB_Send(CDC_TX,&c,1);
if (r > 0) {
return r;
} else {
setWriteError(2);
return 0;
}
}
// press() adds the specified key (printing, non-printing, or modifier)
// to the persistent key report and sends the report. Because of the way
// USB HID works, the host acts like the key remains pressed until we
// call release(), releaseAll(), or otherwise clear the report and resend.
size_t Keyboard_::press(uint8_t k)
{
uint8_t i;
if (k >= 136) { // it's a non-printing key (not a modifier)
k = k - 136;
}
else if (k >= 128) { // it's a modifier key
_keyReport.modifiers |= (1<<(k-128));
k = 0;
}
else { // it's a printing key
k = pgm_read_byte(_asciimap + k);
if (!k) {
setWriteError();
return 0;
}
if (k & 0x80) { // it's a capital letter or other character reached with shift
_keyReport.modifiers |= 0x02; // the left shift modifier
k &= 0x7F;
}
}
// Add k to the key report only if it's not already present
// and if there is an empty slot.
if (_keyReport.keys[0] != k && _keyReport.keys[1] != k &&
_keyReport.keys[2] != k && _keyReport.keys[3] != k &&
_keyReport.keys[4] != k && _keyReport.keys[5] != k) {
for (i=0; i<6; i++) {
if (_keyReport.keys[i] == 0x00) {
_keyReport.keys[i] = k;
break;
}
}
if (i == 6) {
setWriteError();
return 0;
}
}
sendReport(&_keyReport);
return 1;
}
size_t WiFiEspClient::write(const uint8_t *buf, size_t size)
{
if (_sock >= MAX_SOCK_NUM or size==0)
{
setWriteError();
return 0;
}
bool r = EspDrv::sendData(_sock, buf, size);
if (!r)
{
setWriteError();
LOGERROR1(F("Failed to write to socket"), _sock);
delay(4000);
stop();
return 0;
}
return size;
}
size_t SendOnlySoftwareSerial::write(uint8_t b)
{
if (_tx_delay == 0) {
setWriteError();
return 0;
}
// By declaring these as local variables, the compiler will put them
// in registers _before_ disabling interrupts and entering the
// critical timing sections below, which makes it a lot easier to
// verify the cycle timings
volatile uint8_t *reg = _transmitPortRegister;
uint8_t reg_mask = _transmitBitMask;
uint8_t inv_mask = ~_transmitBitMask;
uint8_t oldSREG = SREG;
bool inv = _inverse_logic;
uint16_t delay = _tx_delay;
if (inv)
b = ~b;
cli(); // turn off interrupts for a clean txmit
// Write the start bit
if (inv)
*reg |= reg_mask;
else
*reg &= inv_mask;
tunedDelay(delay);
// Write each of the 8 bits
for (uint8_t i = 8; i > 0; --i)
{
if (b & 1) // choose bit
*reg |= reg_mask; // send 1
else
*reg &= inv_mask; // send 0
tunedDelay(delay);
b >>= 1;
}
// restore pin to natural state
if (inv)
*reg &= inv_mask;
else
*reg |= reg_mask;
SREG = oldSREG; // turn interrupts back on
tunedDelay(_tx_delay);
return 1;
}
// ------------------------------------------------------------------------------------------------------
// Write Array - write length number of bytes from data array to Tx buffer
// return: #bytes written = success, 0=fail
// parameters:
// data = pointer to uint8_t array of data
// length = number of bytes to write
//
size_t i2c_t3::write(const uint8_t* data, size_t quantity)
{
if(i2c->txBufferLength < I2C_TX_BUFFER_LENGTH)
{
size_t avail = I2C_TX_BUFFER_LENGTH - i2c->txBufferLength;
uint8_t* dest = i2c->txBuffer + i2c->txBufferLength;
if(quantity > avail)
{
quantity = avail; // truncate to space avail if needed
setWriteError();
}
for(size_t count=quantity; count; count--)
*dest++ = *data++;
i2c->txBufferLength += quantity;
return quantity;
}
setWriteError();
return 0;
}
size_t Serial_::write(const uint8_t *buffer, size_t size)
{
uint32_t r = usb.send(CDC_ENDPOINT_IN, buffer, size);
if (r > 0) {
return r;
} else {
setWriteError();
return 0;
}
}
// press() adds the specified key (printing, non-printing, or modifier)
// to the persistent key report and sends the report. Because of the way
// USB HID works, the host acts like the key remains pressed until we
// call release(), releaseAll(), or otherwise clear the report and resend.
size_t USBKeyboard::press(uint16_t key, uint16_t modifiers)
{
bool doReport = false;
if (key >= KEY_LEFTCTRL && key <= KEY_RIGHTGUI)
{
// it's a modifier key
keyReport.modifiers |= (1 << (key - KEY_LEFTCTRL));
key = 0;
doReport = true;
}
if (key > KEY_KPHEX)
return 0;
if (modifiers) {
if (modifiers > MOD_RESERVED && modifiers <= (MOD_RESERVED | 0xFF)) {
modifiers &= 0x00FF;
keyReport.modifiers |= modifiers;
doReport = true;
} else {
modifiers = 0;
}
}
// Add key to the keyReport only if it's not already present
// and if there is an empty slot.
if (key && keyReport.keys[0] != key && keyReport.keys[1] != key &&
keyReport.keys[2] != key && keyReport.keys[3] != key &&
keyReport.keys[4] != key && keyReport.keys[5] != key)
{
uint8_t i;
for (i = 0; i < 6; i++)
{
if (keyReport.keys[i] == 0x00)
{
keyReport.keys[i] = key;
doReport = true;
break;
}
}
if (i == 6)
{
setWriteError();
return 0;
}
}
if (doReport) {
sendReport();
return 1;
}
return 0;
}
size_t WiFiClient::write(const uint8_t *buf, size_t size) {
if (_sock < 0)
{
setWriteError();
return 0;
}
if (size==0)
{
setWriteError();
return 0;
}
if (!clientdrv.sendData(_sock, buf, size))
{
setWriteError();
_is_connected = false;
return 0;
}
return size;
}
size_t TwoWire::write(uint8_t data)
{
if (transmitting || slave_mode) {
if (txBufferLength >= BUFFER_LENGTH+1) {
setWriteError();
return 0;
}
txBuffer[txBufferLength++] = data;
return 1;
}
return 0;
}
size_t WiFiEspClient::printFSH(const __FlashStringHelper *ifsh, bool appendCrLf)
{
size_t size = strlen_P((char*)ifsh);
if (_sock >= MAX_SOCK_NUM or size==0)
{
setWriteError();
return 0;
}
bool r = EspDrv::sendData(_sock, ifsh, size, appendCrLf);
if (!r)
{
setWriteError();
LOGERROR1(F("Failed to write to socket"), _sock);
delay(4000);
stop();
return 0;
}
return size;
}
size_t DefaultKeyboardAPI::add(ConsumerKeycode k)
{
// No 2 byte keys are supported
if(k > 0xFF){
setWriteError();
return 0;
}
// Place the key inside the reserved keyreport position.
// This does not work on Windows.
_keyReport.reserved = k;
return 1;
}
size_t Serial_::write(uint8_t c)
{
/* only try to send bytes if the high-level CDC connection itself
is open (not just the pipe) - the OS should set lineState when the port
is opened and clear lineState when the port is closed.
bytes sent before the user opens the connection or after
the connection is closed are lost - just like with a UART. */
// TODO - ZE - check behavior on different OSes and test what happens if an
// open connection isn't broken cleanly (cable is yanked out, host dies
// or locks up, or host virtual serial port hangs)
if (_usbLineInfo.lineState > 0) {
int r = USB_Send(CDC_TX,&c,1);
if (r > 0) {
return r;
} else {
setWriteError();
return 0;
}
}
setWriteError();
return 0;
}
size_t TwoWire::write(const uint8_t *data, size_t quantity)
{
if (transmitting || slave_mode) {
size_t avail = BUFFER_LENGTH+1 - txBufferLength;
if (quantity > avail) {
quantity = avail;
setWriteError();
}
memcpy(txBuffer + txBufferLength, data, quantity);
txBufferLength += quantity;
return quantity;
}
return 0;
}
size_t TwoWire::write(uint8_t data){
if(transmitting){
if(txBufferLength >= BUFFER_LENGTH){
setWriteError();
return 0;
}
txBuffer[txBufferIndex] = data;
++txBufferIndex;
txBufferLength = txBufferIndex;
} else {
// i2c_slave_transmit(&data, 1);
}
return 1;
}
size_t SoftwareSerial::write(uint8_t b)
{
if (_tx_delay == 0)
{
setWriteError();
return 0;
}
io_DisableINT();
// Write the start bit
tx_pin_write(_inverse_logic ? HIGH : LOW);
tunedDelay(_tx_delay);
// Write each of the 8 bits
if (_inverse_logic)
{
for (byte mask = 0x01; mask; mask <<= 1)
{
if (b & mask) // choose bit
tx_pin_write(LOW); // send 1
else
tx_pin_write(HIGH); // send 0
tunedDelay(_tx_delay);
}
tx_pin_write(LOW); // restore pin to natural state
}
else
{
for (byte mask = 0x01; mask; mask <<= 1)
{
if (b & mask) // choose bit
tx_pin_write(HIGH); // send 1
else
tx_pin_write(LOW); // send 0
tunedDelay(_tx_delay);
}
tx_pin_write(HIGH); // restore pin to natural state
}
io_RestoreINT();
tunedDelay(_tx_delay);
return 1;
}
// must be called in:
// slave tx event callback
// or after beginTransmission(address)
size_t TwoWire::write(uint8_t data)
{
if(transmitting_slave)
{
if(slaveBufferLength >= BUFFER_LENGTH)
{
setWriteError(1);
return 0;
}
slaveBuffer[slaveBufferLength++] = data;
return 1;
}
else if(transmitting_master)
{
if(txBufferLength >= BUFFER_LENGTH)
{
setWriteError(1);
return 0;
}
txBuffer[txBufferLength++] = data;
return 1;
}
return 0;
}
// must be called in:
// slave tx event callback
// or after beginTransmission(address)
size_t TwoWire::write(const uint8_t *data, size_t quantity)
{
if(transmitting){
// in master transmitter mode
for(size_t i = 0; i < quantity; ++i){
write(data[i]);
}
}else{
// in slave send mode
// reply to master
//twi_transmit(data, quantity);
setWriteError();
return 0;
}
return quantity;
}
