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; }