arduino/esp8266
1
0
Fork 0
mirror of https://github.com/esp8266/Arduino.git synced 2025-12-24 11:21:24 +03:00
Code Activity

Merge branch 'new-extension' of https://github.com/arduino/Arduino

Browse Source
This commit is contained in:
amcewen
2011-08-27 23:53:42 +01:00
parent 6b2dec0d01 4553cee443
commit 4588120106
50 changed files with 1123 additions and 343 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
libraries/ArduinoTestSuite/examples/ATS_Write_Print/ATS_Write_Print.ino Normal file
View File

@@ -0,0 +1,61 @@
#include <ArduinoTestSuite.h>
void Test_Equal(long actual, long expected)
{
char buf[100];
boolean b = expected == actual;
ATS_PrintTestStatus("", b);
if (!b) {
Serial.print("expected '");
Serial.print(expected);
Serial.print("', actual '");
Serial.print(actual);
Serial.println("'");
}
}
void setup()
{
byte buf[5] = { 65, 66, 67, 0, 69 };
ATS_begin("Arduino", "Write & Print Return Values Test");
Test_Equal(Serial.write('a'), 1);
Test_Equal(Serial.write(byte(0)), 1);
Test_Equal(Serial.write("abc"), 3);
Test_Equal(Serial.write(""), 0);
Test_Equal(Serial.write(buf, 5), 5);
Test_Equal(Serial.print(0), 1);
Test_Equal(Serial.print(""), 0);
Test_Equal(Serial.print("abc"), 3);
Test_Equal(Serial.print(0), 1);
Test_Equal(Serial.print(1), 1);
Test_Equal(Serial.print(11), 2);
Test_Equal(Serial.print(12345), 5);
Test_Equal(Serial.print(-1), 2);
Test_Equal(Serial.print(-123), 4);
Test_Equal(Serial.println(), 2);
Test_Equal(Serial.println(""), 2);
Test_Equal(Serial.println("abc"), 5);
Test_Equal(Serial.println(0), 3);
Test_Equal(Serial.println(1), 3);
Test_Equal(Serial.println(11), 4);
Test_Equal(Serial.println(12345), 7);
Test_Equal(Serial.println(-1), 4);
Test_Equal(Serial.println(-123), 6);
ATS_end();
}
void loop() {}

23
libraries/Ethernet/Client.cpp
View File

@@ -70,19 +70,24 @@ int Client::connect(IPAddress ip, uint16_t port) {
return 1;
}
void Client::write(uint8_t b) {
if (_sock != MAX_SOCK_NUM)
send(_sock, &b, 1);
size_t Client::write(uint8_t b) {
return write(&b, 1);
}
void Client::write(const char *str) {
if (_sock != MAX_SOCK_NUM)
send(_sock, (const uint8_t *)str, strlen(str));
size_t Client::write(const char *str) {
return write((const uint8_t *) str, strlen(str));
}
void Client::write(const uint8_t *buf, size_t size) {
if (_sock != MAX_SOCK_NUM)
send(_sock, buf, size);
size_t Client::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;
}
int Client::available() {

6
libraries/Ethernet/Client.h
View File

@@ -12,9 +12,9 @@ public:
uint8_t status();
int connect(IPAddress ip, uint16_t port);
int connect(const char *host, uint16_t port);
virtual void write(uint8_t);
virtual void write(const char *str);
virtual void write(const uint8_t *buf, size_t size);
virtual size_t write(uint8_t);
virtual size_t write(const char *str);
virtual size_t write(const uint8_t *buf, size_t size);
virtual int available();
virtual int read();
virtual int read(uint8_t *buf, size_t size);

10
libraries/Ethernet/IPAddress.cpp
View File

@@ -42,13 +42,15 @@ bool IPAddress::operator==(const uint8_t* addr)
return memcmp(addr, _address, sizeof(_address)) == 0;
}
void IPAddress::printTo(Print& p) const
size_t IPAddress::printTo(Print& p) const
{
size_t n = 0;
for (int i =0; i < 3; i++)
{
p.print(_address[i], DEC);
p.print('.');
n += p.print(_address[i], DEC);
n += p.print('.');
}
p.print(_address[3], DEC);
n += p.print(_address[3], DEC);
return n;
}

2
libraries/Ethernet/IPAddress.h
View File

@@ -60,7 +60,7 @@ public:
IPAddress& operator=(const uint8_t *address);
IPAddress& operator=(uint32_t address);
virtual void printTo(Print& p) const;
virtual size_t printTo(Print& p) const;
friend class EthernetClass;
friend class UDP;

12
libraries/Ethernet/Server.cpp
View File

@@ -67,18 +67,20 @@ Client Server::available()
return Client(MAX_SOCK_NUM);
}
void Server::write(uint8_t b)
size_t Server::write(uint8_t b)
{
write(&b, 1);
}
void Server::write(const char *str)
size_t Server::write(const char *str)
{
write((const uint8_t *)str, strlen(str));
}
void Server::write(const uint8_t *buffer, size_t size)
size_t Server::write(const uint8_t *buffer, size_t size)
{
size_t n = 0;
accept();
for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
@@ -86,7 +88,9 @@ void Server::write(const uint8_t *buffer, size_t size)
if (EthernetClass::_server_port[sock] == _port &&
client.status() == SnSR::ESTABLISHED) {
client.write(buffer, size);
n += client.write(buffer, size);
}
}
return n;
}

6
libraries/Ethernet/Server.h
View File

@@ -14,9 +14,9 @@ public:
Server(uint16_t);
Client available();
void begin();
virtual void write(uint8_t);
virtual void write(const char *str);
virtual void write(const uint8_t *buf, size_t size);
virtual size_t write(uint8_t);
virtual size_t write(const char *str);
virtual size_t write(const uint8_t *buf, size_t size);
};
#endif

11
libraries/Ethernet/Udp.cpp
View File

@@ -102,21 +102,22 @@ int UDP::endPacket()
return sendUDP(_sock);
}
void UDP::write(uint8_t byte)
size_t UDP::write(uint8_t byte)
{
write(&byte, 1);
return write(&byte, 1);
}
void UDP::write(const char *str)
size_t UDP::write(const char *str)
{
size_t len = strlen(str);
write((const uint8_t *)str, len);
return write((const uint8_t *)str, len);
}
void UDP::write(const uint8_t *buffer, size_t size)
size_t UDP::write(const uint8_t *buffer, size_t size)
{
uint16_t bytes_written = bufferData(_sock, _offset, buffer, size);
_offset += bytes_written;
return bytes_written;
}
int UDP::parsePacket()

6
libraries/Ethernet/Udp.h
View File

@@ -67,11 +67,11 @@ public:
// Returns 1 if the packet was sent successfully, 0 if there was an error
int endPacket();
// Write a single byte into the packet
virtual void write(uint8_t);
virtual size_t write(uint8_t);
// Write a string of characters into the packet
virtual void write(const char *str);
virtual size_t write(const char *str);
// Write size bytes from buffer into the packet
virtual void write(const uint8_t *buffer, size_t size);
virtual size_t write(const uint8_t *buffer, size_t size);
// Start processing the next available incoming packet
// Returns the size of the packet in bytes, or 0 if no packets are available

3
libraries/LiquidCrystal/LiquidCrystal.cpp
View File

@@ -258,8 +258,9 @@ inline void LiquidCrystal::command(uint8_t value) {
send(value, LOW);
}
inline void LiquidCrystal::write(uint8_t value) {
inline size_t LiquidCrystal::write(uint8_t value) {
send(value, HIGH);
return 1; // assume sucess
}
/************ low level data pushing commands **********/

2
libraries/LiquidCrystal/LiquidCrystal.h
View File

@@ -79,7 +79,7 @@ public:
void createChar(uint8_t, uint8_t[]);
void setCursor(uint8_t, uint8_t);
virtual void write(uint8_t);
virtual size_t write(uint8_t);
void command(uint8_t);
private:
void send(uint8_t, uint8_t);

26
libraries/SD/File.cpp
View File

@@ -58,19 +58,27 @@ boolean File::isDirectory(void) {
}
void File::write(uint8_t val) {
if (_file)
_file->write(val);
size_t File::write(uint8_t val) {
return write(&val, 1);
}
void File::write(const char *str) {
if (_file)
_file->write(str);
size_t File::write(const char *str) {
return write((const uint8_t *) str, strlen(str));
}
void File::write(const uint8_t *buf, size_t size) {
if (_file)
_file->write(buf, 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->writeError()) {
setWriteError();
return 0;
}
return t;
}
int File::peek() {

6
libraries/SD/SD.h
View File

@@ -32,9 +32,9 @@ public:
File(SdFile f, char *name); // wraps an underlying SdFile
File(void); // 'empty' constructor
~File(void); // destructor
virtual void write(uint8_t);
virtual void write(const char *str);
virtual void write(const uint8_t *buf, size_t size);
virtual size_t write(uint8_t);
virtual size_t write(const char *str);
virtual size_t write(const uint8_t *buf, size_t size);
virtual int read();
virtual int peek();
virtual int available();

8
libraries/SD/utility/SdFat.h
View File

@@ -141,7 +141,7 @@ class SdFile : public Print {
* Set writeError to false before calling print() and/or write() and check
* for true after calls to print() and/or write().
*/
bool writeError;
//bool writeError;
/**
* Cancel unbuffered reads for this file.
* See setUnbufferedRead()
@@ -283,9 +283,9 @@ class SdFile : public Print {
}
/** \return SdVolume that contains this file. */
SdVolume* volume(void) const {return vol_;}
void write(uint8_t b);
int16_t write(const void* buf, uint16_t nbyte);
void write(const char* str);
size_t write(uint8_t b);
size_t write(const void* buf, uint16_t nbyte);
size_t write(const char* str);
void write_P(PGM_P str);
void writeln_P(PGM_P str);
//------------------------------------------------------------------------------

15
libraries/SD/utility/SdFile.cpp
View File

@@ -1121,7 +1121,7 @@ uint8_t SdFile::truncate(uint32_t length) {
* for a read-only file, device is full, a corrupt file system or an I/O error.
*
*/
int16_t SdFile::write(const void* buf, uint16_t nbyte) {
size_t SdFile::write(const void* buf, uint16_t nbyte) {
// convert void* to uint8_t* - must be before goto statements
const uint8_t* src = reinterpret_cast<const uint8_t*>(buf);
@@ -1210,8 +1210,9 @@ int16_t SdFile::write(const void* buf, uint16_t nbyte) {
writeErrorReturn:
// return for write error
writeError = true;
return -1;
//writeError = true;
setWriteError();
return 0;
}
//------------------------------------------------------------------------------
/**
@@ -1219,8 +1220,8 @@ int16_t SdFile::write(const void* buf, uint16_t nbyte) {
*
* Use SdFile::writeError to check for errors.
*/
void SdFile::write(uint8_t b) {
write(&b, 1);
size_t SdFile::write(uint8_t b) {
return write(&b, 1);
}
//------------------------------------------------------------------------------
/**
@@ -1228,8 +1229,8 @@ void SdFile::write(uint8_t b) {
*
* Use SdFile::writeError to check for errors.
*/
void SdFile::write(const char* str) {
write(str, strlen(str));
size_t SdFile::write(const char* str) {
return write(str, strlen(str));
}
//------------------------------------------------------------------------------
/**

11
libraries/SoftwareSerial/SoftwareSerial.cpp
View File

@@ -42,7 +42,6 @@ http://arduiniana.org.
#include <avr/pgmspace.h>
#include "Arduino.h"
#include "SoftwareSerial.h"
#include "icrmacros.h"
//
// Lookup table
//
@@ -441,10 +440,12 @@ int SoftwareSerial::available()
return (_receive_buffer_tail + _SS_MAX_RX_BUFF - _receive_buffer_head) % _SS_MAX_RX_BUFF;
}
void SoftwareSerial::write(uint8_t b)
size_t SoftwareSerial::write(uint8_t b)
{
if (_tx_delay == 0)
return;
if (_tx_delay == 0) {
setWriteError();
return 0;
}
uint8_t oldSREG = SREG;
cli(); // turn off interrupts for a clean txmit
@@ -485,6 +486,8 @@ void SoftwareSerial::write(uint8_t b)
SREG = oldSREG; // turn interrupts back on
tunedDelay(_tx_delay);
return 1;
}
void SoftwareSerial::flush()

2
libraries/SoftwareSerial/SoftwareSerial.h
View File

@@ -89,7 +89,7 @@ public:
bool overflow() { bool ret = _buffer_overflow; _buffer_overflow = false; return ret; }
int peek();
virtual void write(uint8_t byte);
virtual size_t write(uint8_t byte);
virtual int read();
virtual int available();
virtual void flush();

69
libraries/SoftwareSerial/icrmacros.h
View File

@@ -1,69 +0,0 @@
/*
icrmacros.h
A place to put useful ICR (interrupt change register) macros
If you want to support non-Arduino processors you can extend or replace
this file.
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
The latest version of this library can always be found at
http://arduiniana.org.
*/
// Abstractions for maximum portability between processors
// These are macros to associate pins to pin change interrupts
#if !defined(digitalPinToPCICR) // Courtesy Paul Stoffregen
#if defined(__AVR_ATmega168__) || defined(__AVR_ATmega328P__)
#define digitalPinToPCICR(p) (((p) >= 0 && (p) <= 21) ? (&PCICR) : ((uint8_t *)0))
#define digitalPinToPCICRbit(p) (((p) <= 7) ? 2 : (((p) <= 13) ? 0 : 1))
#define digitalPinToPCMSK(p) (((p) <= 7) ? (&PCMSK2) : (((p) <= 13) ? (&PCMSK0) : (((p) <= 21) ? (&PCMSK1) : ((uint8_t *)0))))
#define digitalPinToPCMSKbit(p) (((p) <= 7) ? (p) : (((p) <= 13) ? ((p) - 8) : ((p) - 14)))
#elif defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
// Specifically for the Arduino Mega 2560 (or 1280 on the original Arduino Mega)
// A majority of the pins are NOT PCINTs, SO BE WARNED (i.e. you cannot use them as receive pins)
// Only pins available for RECEIVE (TRANSMIT can be on any pin):
// (I've deliberately left out pin mapping to the Hardware USARTs - seems senseless to me)
// Pins: 10, 11, 12, 13, 50, 51, 52, 53, 62, 63, 64, 65, 66, 67, 68, 69
#define digitalPinToPCICR(p) ( (((p) >= 10) && ((p) <= 13)) || \
(((p) >= 50) && ((p) <= 53)) || \
(((p) >= 62) && ((p) <= 69)) ? (&PCICR) : ((uint8_t *)0) )
#define digitalPinToPCICRbit(p) ( (((p) >= 10) && ((p) <= 13)) || (((p) >= 50) && ((p) <= 53)) ? 0 : \
( (((p) >= 62) && ((p) <= 69)) ? 2 : \
0 ) )
#define digitalPinToPCMSK(p) ( (((p) >= 10) && ((p) <= 13)) || (((p) >= 50) && ((p) <= 53)) ? (&PCMSK0) : \
( (((p) >= 62) && ((p) <= 69)) ? (&PCMSK2) : \
((uint8_t *)0) ) )
#define digitalPinToPCMSKbit(p) ( (((p) >= 10) && ((p) <= 13)) ? ((p) - 6) : \
( ((p) == 50) ? 3 : \
( ((p) == 51) ? 2 : \
( ((p) == 52) ? 1 : \
( ((p) == 53) ? 0 : \
( (((p) >= 62) && ((p) <= 69)) ? ((p) - 62) : \
0 ) ) ) ) ) )
#else
#error This processor is not supported by SoftwareSerial
#endif
#endif

13
libraries/Wire/Wire.cpp
View File

@@ -124,13 +124,14 @@ uint8_t TwoWire::endTransmission(void)
// must be called in:
// slave tx event callback
// or after beginTransmission(address)
void TwoWire::write(uint8_t data)
size_t TwoWire::write(uint8_t data)
{
if(transmitting){
// in master transmitter mode
// don't bother if buffer is full
if(txBufferLength >= BUFFER_LENGTH){
return;
setWriteError();
return 0;
}
// put byte in tx buffer
txBuffer[txBufferIndex] = data;
@@ -142,12 +143,13 @@ void TwoWire::write(uint8_t data)
// reply to master
twi_transmit(&data, 1);
}
return 1;
}
// must be called in:
// slave tx event callback
// or after beginTransmission(address)
void TwoWire::write(const uint8_t *data, size_t quantity)
size_t TwoWire::write(const uint8_t *data, size_t quantity)
{
if(transmitting){
// in master transmitter mode
@@ -159,14 +161,15 @@ void TwoWire::write(const uint8_t *data, size_t quantity)
// reply to master
twi_transmit(data, quantity);
}
return quantity;
}
// must be called in:
// slave tx event callback
// or after beginTransmission(address)
void TwoWire::write(const char *data)
size_t TwoWire::write(const char *data)
{
write((uint8_t*)data, strlen(data));
return write((uint8_t*)data, strlen(data));
}
// must be called in:

6
libraries/Wire/Wire.h
View File

@@ -52,9 +52,9 @@ class TwoWire : public Stream
uint8_t endTransmission(void);
uint8_t requestFrom(uint8_t, uint8_t);
uint8_t requestFrom(int, int);
virtual void write(uint8_t);
virtual void write(const char *);
virtual void write(const uint8_t *, size_t);
virtual size_t write(uint8_t);
virtual size_t write(const char *);
virtual size_t write(const uint8_t *, size_t);
virtual int available(void);
virtual int read(void);
virtual int peek(void);