NewLife
/
SmartOS
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

大部分数据操作参数可以使用Array替代ByteArray，大大减少ByteArray构造函数的执行

This commit is contained in:
nnhy 2015-11-13 11:46:00 +00:00
parent 3aa8bade6a
commit 9523a0c4e2
33 changed files with 135 additions and 120 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Drivers/Enc28j60.cpp
View File

@ -711,7 +711,7 @@ byte Enc28j60::GetRevision()
return ReadReg(EREVID); return ReadReg(EREVID);
} }
bool Enc28j60::OnWrite(const ByteArray& bs) bool Enc28j60::OnWrite(const Array& bs)
{ {
uint len = bs.Length(); uint len = bs.Length();
assert_param2(len <= MAX_FRAMELEN, "以太网数据帧超大"); assert_param2(len <= MAX_FRAMELEN, "以太网数据帧超大");
@ -743,7 +743,7 @@ bool Enc28j60::OnWrite(const ByteArray& bs)
WriteOp(ENC28J60_WRITE_BUF_MEM, 0, 0x00); WriteOp(ENC28J60_WRITE_BUF_MEM, 0, 0x00);
// 复制数据包到传输缓冲区 // 复制数据包到传输缓冲区
WriteBuffer(bs.GetBuffer(), len); WriteBuffer((const byte*)bs.GetBuffer(), len);
/* /*
仅发送复位通过SPI接口向ECON1寄存器的 TXRST 位写入1可实现仅发送复位。 仅发送复位通过SPI接口向ECON1寄存器的 TXRST 位写入1可实现仅发送复位。
@ -812,7 +812,7 @@ bool Enc28j60::OnWrite(const ByteArray& bs)
ReadBuffer((byte*)&TXStatus, sizeof(TXStatus)); ReadBuffer((byte*)&TXStatus, sizeof(TXStatus));
#if NET_DEBUG #if NET_DEBUG
byte* packet = bs.GetBuffer(); const byte* packet = (const byte*)bs.GetBuffer();
MacAddress dest = packet; MacAddress dest = packet;
MacAddress src = packet + 6; MacAddress src = packet + 6;
dest.Show(); dest.Show();
@ -934,7 +934,7 @@ bool Enc28j60::OnWrite(const ByteArray& bs)
// 从网络接收缓冲区获取一个数据包，该包开头是以太网头 // 从网络接收缓冲区获取一个数据包，该包开头是以太网头
// packet，该包应该存储到的缓冲区；maxlen，可接受的最大数据长度 // packet，该包应该存储到的缓冲区；maxlen，可接受的最大数据长度
uint Enc28j60::OnRead(ByteArray& bs) uint Enc28j60::OnRead(Array& bs)
{ {
uint rxstat; uint rxstat;
uint len; uint len;
@ -986,7 +986,7 @@ uint Enc28j60::OnRead(ByteArray& bs)
else else
{ {
// 从缓冲区中将数据包复制到packet中 // 从缓冲区中将数据包复制到packet中
ReadBuffer(bs.GetBuffer(), len); ReadBuffer((byte*)bs.GetBuffer(), len);
} }
bs.SetLength(len); bs.SetLength(len);
// 移动接收缓冲区 读指针 // 移动接收缓冲区 读指针

4
Drivers/Enc28j60.h
View File

@ -62,8 +62,8 @@ protected:
virtual bool OnOpen(); virtual bool OnOpen();
virtual void OnClose() { } virtual void OnClose() { }
virtual bool OnWrite(const ByteArray& bs); virtual bool OnWrite(const Array& bs);
virtual uint OnRead(ByteArray& bs); virtual uint OnRead(Array& bs);
}; };
#endif #endif

8
Drivers/NRF24L01.cpp
View File

@ -840,7 +840,7 @@ void NRF24L01::OnClose()
} }
// 从NRF的接收缓冲区中读出数据 // 从NRF的接收缓冲区中读出数据
uint NRF24L01::OnRead(ByteArray& bs) uint NRF24L01::OnRead(Array& bs)
{ {
// 亮灯。离开时自动熄灯 // 亮灯。离开时自动熄灯
//PortScope ps(LedRx); //PortScope ps(LedRx);
@ -883,7 +883,7 @@ uint NRF24L01::OnRead(ByteArray& bs)
debug_printf("NRF24L01::Read 实际负载%d，缓冲区大小%d，为了稳定，使用缓冲区大小\r\n", rs, len); debug_printf("NRF24L01::Read 实际负载%d，缓冲区大小%d，为了稳定，使用缓冲区大小\r\n", rs, len);
rs = len; rs = len;
} }
ReadBuf(RD_RX_PLOAD, bs.GetBuffer(), rs); // 读取数据 ReadBuf(RD_RX_PLOAD, (byte*)bs.GetBuffer(), rs); // 读取数据
} }
} }
@ -903,7 +903,7 @@ uint NRF24L01::OnRead(ByteArray& bs)
} }
// 向NRF的发送缓冲区中写入数据 // 向NRF的发送缓冲区中写入数据
bool NRF24L01::OnWrite(const ByteArray& bs) bool NRF24L01::OnWrite(const Array& bs)
{ {
// 设定小灯快闪时间，单位毫秒 // 设定小灯快闪时间，单位毫秒
if(Led) Led->Write(500); if(Led) Led->Write(500);
@ -934,7 +934,7 @@ bool NRF24L01::OnWrite(const ByteArray& bs)
uint len = bs.Length(); uint len = bs.Length();
assert_param(PayloadWidth == 0 || len <= PayloadWidth); assert_param(PayloadWidth == 0 || len <= PayloadWidth);
if(PayloadWidth > 0) len = PayloadWidth; if(PayloadWidth > 0) len = PayloadWidth;
WriteBuf(cmd, bs.GetBuffer(), len); WriteBuf(cmd, (const byte*)bs.GetBuffer(), len);
// 进入TX，维持一段时间 // 进入TX，维持一段时间
_CE = true; _CE = true;

4
Drivers/ShunCom.cpp
View File

@ -76,7 +76,7 @@ void ShunCom::ChangePower(int level)
Config = false; Config = false;
} }
bool ShunCom::OnWrite(const ByteArray& bs) bool ShunCom::OnWrite(const Array& bs)
{ {
//Led = !Led; //Led = !Led;
@ -84,7 +84,7 @@ bool ShunCom::OnWrite(const ByteArray& bs)
} }
// 引发数据到达事件 // 引发数据到达事件
uint ShunCom::OnReceive(ByteArray& bs, void* param) uint ShunCom::OnReceive(Array& bs, void* param)
{ {
//Led = !Led; //Led = !Led;
if(Led) Led->Write(1000); if(Led) Led->Write(1000);

4
Drivers/ShunCom.h
View File

@ -34,9 +34,9 @@ public:
// 电源等级变更（如进入低功耗模式）时调用 // 电源等级变更（如进入低功耗模式）时调用
virtual void ChangePower(int level); virtual void ChangePower(int level);
virtual bool OnWrite(const ByteArray& bs); virtual bool OnWrite(const Array& bs);
// 引发数据到达事件 // 引发数据到达事件
virtual uint OnReceive(ByteArray& bs, void* param); virtual uint OnReceive(Array& bs, void* param);
virtual string ToString() { return "ShunCom"; } virtual string ToString() { return "ShunCom"; }

16
Drivers/W5500.cpp
View File

@ -562,7 +562,7 @@ void W5500::SetAddress(ushort addr, byte rw, byte socket, byte block)
_spi->Write(cfg.ToByte()); _spi->Write(cfg.ToByte());
} }
bool W5500::WriteFrame(ushort addr, const ByteArray& bs, byte socket, byte block) bool W5500::WriteFrame(ushort addr, const Array& bs, byte socket, byte block)
{ {
while(_Lock != 0) Sys.Sleep(0); while(_Lock != 0) Sys.Sleep(0);
_Lock = 1; _Lock = 1;
@ -576,7 +576,7 @@ bool W5500::WriteFrame(ushort addr, const ByteArray& bs, byte socket, byte block
return true; return true;
} }
bool W5500::ReadFrame(ushort addr, ByteArray& bs, byte socket, byte block) bool W5500::ReadFrame(ushort addr, Array& bs, byte socket, byte block)
{ {
while(_Lock != 0) Sys.Sleep(0); while(_Lock != 0) Sys.Sleep(0);
_Lock = 1; _Lock = 1;
@ -1057,7 +1057,7 @@ void HardSocket::Change(const IPEndPoint& remote)
} }
// 接收数据 // 接收数据
uint HardSocket::Receive(ByteArray& bs) uint HardSocket::Receive(Array& bs)
{ {
// 读取收到数据容量 // 读取收到数据容量
ushort size = __REV16(SocRegRead2(RX_RSR)); ushort size = __REV16(SocRegRead2(RX_RSR));
@ -1092,7 +1092,7 @@ uint HardSocket::Receive(ByteArray& bs)
} }
// 发送数据 // 发送数据
bool HardSocket::Send(const ByteArray& bs) bool HardSocket::Send(const Array& bs)
{ {
/*debug_printf("%s::Send [%d]=", Protocol == 0x01 ? "Tcp" : "Udp", bs.Length()); /*debug_printf("%s::Send [%d]=", Protocol == 0x01 ? "Tcp" : "Udp", bs.Length());
bs.Show(true);*/ bs.Show(true);*/
@ -1118,8 +1118,8 @@ bool HardSocket::Send(const ByteArray& bs)
return true; return true;
} }
bool HardSocket::OnWrite(const ByteArray& bs) { return Send(bs); } bool HardSocket::OnWrite(const Array& bs) { return Send(bs); }
uint HardSocket::OnRead(ByteArray& bs) { return Receive(bs); } uint HardSocket::OnRead(Array& bs) { return Receive(bs); }
void HardSocket::ClearRX() void HardSocket::ClearRX()
{ {
@ -1296,7 +1296,7 @@ void TcpClient::RaiseReceive()
/****************************** UdpClient ************************************/ /****************************** UdpClient ************************************/
bool UdpClient::SendTo(const ByteArray& bs, const IPEndPoint& remote) bool UdpClient::SendTo(const Array& bs, const IPEndPoint& remote)
{ {
if(remote == Remote) return Send(bs); if(remote == Remote) return Send(bs);
@ -1314,7 +1314,7 @@ bool UdpClient::SendTo(const ByteArray& bs, const IPEndPoint& remote)
return rs; return rs;
} }
bool UdpClient::OnWriteEx(const ByteArray& bs, void* opt) bool UdpClient::OnWriteEx(const Array& bs, void* opt)
{ {
IPEndPoint* ep = (IPEndPoint*)opt; IPEndPoint* ep = (IPEndPoint*)opt;
if(!ep) return OnWrite(bs); if(!ep) return OnWrite(bs);

16
Drivers/W5500.h
View File

@ -68,8 +68,8 @@ public:
void ShowInfo(); void ShowInfo();
// 读写帧，帧本身由外部构造 （包括帧数据内部的读写标志） // 读写帧，帧本身由外部构造 （包括帧数据内部的读写标志）
bool WriteFrame(ushort addr, const ByteArray& bs, byte socket = 0 ,byte block = 0); bool WriteFrame(ushort addr, const Array& bs, byte socket = 0 ,byte block = 0);
bool ReadFrame(ushort addr, ByteArray& bs, byte socket = 0 ,byte block = 0); bool ReadFrame(ushort addr, Array& bs, byte socket = 0 ,byte block = 0);
// 复位 包含硬件复位和软件复位 // 复位 包含硬件复位和软件复位
void Reset(); void Reset();
@ -128,13 +128,13 @@ public:
// 应用配置，修改远程地址和端口 // 应用配置，修改远程地址和端口
void Change(const IPEndPoint& remote); void Change(const IPEndPoint& remote);
virtual bool OnWrite(const ByteArray& bs); virtual bool OnWrite(const Array& bs);
virtual uint OnRead(ByteArray& bs); virtual uint OnRead(Array& bs);
// 发送数据 // 发送数据
virtual bool Send(const ByteArray& bs); virtual bool Send(const Array& bs);
// 接收数据 // 接收数据
virtual uint Receive(ByteArray& bs); virtual uint Receive(Array& bs);
// 恢复配置 // 恢复配置
virtual void Recovery(); virtual void Recovery();
@ -177,7 +177,7 @@ class UdpClient : public HardSocket
public: public:
UdpClient(W5500* host) : HardSocket(host, 0x02) { } UdpClient(W5500* host) : HardSocket(host, 0x02) { }
virtual bool SendTo(const ByteArray& bs, const IPEndPoint& remote); virtual bool SendTo(const Array& bs, const IPEndPoint& remote);
// 中断分发 维护状态 // 中断分发 维护状态
virtual void OnProcess(byte reg); virtual void OnProcess(byte reg);
@ -185,7 +185,7 @@ public:
virtual void RaiseReceive(); virtual void RaiseReceive();
private: private:
virtual bool OnWriteEx(const ByteArray& bs, void* opt); virtual bool OnWriteEx(const Array& bs, void* opt);
}; };
#endif #endif

4
Drivers/nrf24l01.h
View File

@ -82,8 +82,8 @@ protected:
virtual bool OnOpen(); virtual bool OnOpen();
virtual void OnClose(); virtual void OnClose();
virtual bool OnWrite(const ByteArray& bs); virtual bool OnWrite(const Array& bs);
virtual uint OnRead(ByteArray& bs); virtual uint OnRead(Array& bs);
}; };
#endif #endif

4
Message/Controller.cpp
View File

@ -51,7 +51,7 @@ void Controller::Close()
Opened = false; Opened = false;
} }
uint Controller::Dispatch(ITransport* port, ByteArray& bs, void* param, void* param2) uint Controller::Dispatch(ITransport* port, Array& bs, void* param, void* param2)
{ {
byte* buf = bs.GetBuffer(); byte* buf = bs.GetBuffer();
uint len = bs.Length(); uint len = bs.Length();
@ -170,7 +170,7 @@ bool Controller::Send(Message& msg)
// 内存流扩容以后，指针会改变 // 内存流扩容以后，指针会改变
byte* p = ms.GetBuffer();*/ byte* p = ms.GetBuffer();*/
ByteArray bs(ms.GetBuffer(), ms.Position()); Array bs(ms.GetBuffer(), ms.Position());
return Port->Write(bs, msg.State); return Port->Write(bs, msg.State);
} }

2
Message/Controller.h
View File

@ -13,7 +13,7 @@ typedef bool (*MessageHandler)(Message& msg, void* param);
class Controller class Controller
{ {
private: private:
static uint Dispatch(ITransport* port, ByteArray& bs, void* param, void* param2); static uint Dispatch(ITransport* port, Array& bs, void* param, void* param2);
protected: protected:

4
Message/DataStore.cpp
View File

@ -15,7 +15,7 @@ DataStore::DataStore() : Areas(0)
} }
// 写入数据 // 写入数据
int DataStore::Write(uint offset, const ByteArray& bs) int DataStore::Write(uint offset, const Array& bs)
{ {
uint size = bs.Length(); uint size = bs.Length();
if(size == 0) return 0; if(size == 0) return 0;
@ -36,7 +36,7 @@ int DataStore::Write(uint offset, const ByteArray& bs)
} }
// 读取数据 // 读取数据
int DataStore::Read(uint offset, ByteArray& bs) int DataStore::Read(uint offset, Array& bs)
{ {
uint size = bs.Length(); uint size = bs.Length();
if(size == 0) return 0; if(size == 0) return 0;

4
Message/DataStore.h
View File

@ -17,9 +17,9 @@ public:
DataStore(); DataStore();
// 写入数据 // 写入数据
int Write(uint offset, const ByteArray& bs); int Write(uint offset, const Array& bs);
// 读取数据 // 读取数据
int Read(uint offset, ByteArray& bs); int Read(uint offset, Array& bs);
typedef bool (*Handler)(uint offset, uint size, int mode); typedef bool (*Handler)(uint offset, uint size, int mode);
// 注册某一块区域的读写钩子函数 // 注册某一块区域的读写钩子函数

8
Net/DNS.cpp
View File

@ -227,7 +227,7 @@ bool dns_answer(Stream& ms, byte* ip_from_dns)
} }
// 分析响应 // 分析响应
bool parseDNSMSG(TDNS* hdr, const ByteArray& bs, byte* ip_from_dns) bool parseDNSMSG(TDNS* hdr, const Array& bs, byte* ip_from_dns)
{ {
Stream ms(bs); Stream ms(bs);
ms.Little = false; ms.Little = false;
@ -277,7 +277,7 @@ bool parseDNSMSG(TDNS* hdr, const ByteArray& bs, byte* ip_from_dns)
} }
// DNS查询消息 // DNS查询消息
short dns_makequery(short op, const String& name, ByteArray& bs) short dns_makequery(short op, const String& name, Array& bs)
{ {
Stream ms(bs); Stream ms(bs);
ms.Little = false; ms.Little = false;
@ -365,14 +365,14 @@ IPAddress DNS::Query(const String& domain, int msTimeout)
return ip; return ip;
} }
uint DNS::OnReceive(ITransport* port, ByteArray& bs, void* param, void* param2) uint DNS::OnReceive(ITransport* port, Array& bs, void* param, void* param2)
{ {
((DNS*)param)->Process(bs, *(const IPEndPoint*)param2); ((DNS*)param)->Process(bs, *(const IPEndPoint*)param2);
return 0; return 0;
} }
void DNS::Process(ByteArray& bs, const IPEndPoint& server) void DNS::Process(Array& bs, const IPEndPoint& server)
{ {
// 只要来自服务器的 // 只要来自服务器的
if(server.Address != Socket->Host->DNSServer) return; if(server.Address != Socket->Host->DNSServer) return;

8
Net/DNS.h
View File

@ -13,11 +13,11 @@ public:
~DNS(); ~DNS();
IPAddress Query(const String& domain, int msTimeout = 2000); // 解析 IPAddress Query(const String& domain, int msTimeout = 2000); // 解析
private: private:
static uint OnReceive(ITransport* port, ByteArray& bs, void* param, void* param2); static uint OnReceive(ITransport* port, Array& bs, void* param, void* param2);
void Process(ByteArray& bs, const IPEndPoint& server); void Process(Array& bs, const IPEndPoint& server);
ByteArray* _Buffer; ByteArray* _Buffer;
}; };

4
Net/Dhcp.cpp
View File

@ -194,7 +194,7 @@ void Dhcp::PareOption(Stream& ms)
} }
} }
uint Dhcp::OnReceive(ITransport* port, ByteArray& bs, void* param, void* param2) uint Dhcp::OnReceive(ITransport* port, Array& bs, void* param, void* param2)
{ {
/*IPEndPoint* ep = (IPEndPoint*)param2; /*IPEndPoint* ep = (IPEndPoint*)param2;
if(ep) if(ep)
@ -208,7 +208,7 @@ uint Dhcp::OnReceive(ITransport* port, ByteArray& bs, void* param, void* param2)
return 0; return 0;
} }
void Dhcp::Process(ByteArray& bs, const IPEndPoint& ep) void Dhcp::Process(Array& bs, const IPEndPoint& ep)
{ {
DHCP_HEADER* dhcp = (DHCP_HEADER*)bs.GetBuffer(); DHCP_HEADER* dhcp = (DHCP_HEADER*)bs.GetBuffer();
if(!dhcp->Valid()) return; if(!dhcp->Valid()) return;

4
Net/Dhcp.h
View File

@ -35,8 +35,8 @@ public:
EventHandler OnStop; EventHandler OnStop;
private: private:
static uint OnReceive(ITransport* port, ByteArray& bs, void* param, void* param2); static uint OnReceive(ITransport* port, Array& bs, void* param, void* param2);
void Process(ByteArray& bs, const IPEndPoint& ep); void Process(Array& bs, const IPEndPoint& ep);
}; };
#endif #endif

16
Net/ITransport.cpp
View File

@ -53,7 +53,7 @@ void ITransport::Close()
} }
// 发送数据 // 发送数据
bool ITransport::Write(const ByteArray& bs) bool ITransport::Write(const Array& bs)
{ {
// 特别是接口要检查this指针 // 特别是接口要检查this指针
assert_ptr(this); assert_ptr(this);
@ -64,7 +64,7 @@ bool ITransport::Write(const ByteArray& bs)
} }
// 发送数据 // 发送数据
bool ITransport::Write(const ByteArray& bs, void* opt) bool ITransport::Write(const Array& bs, void* opt)
{ {
// 特别是接口要检查this指针 // 特别是接口要检查this指针
assert_ptr(this); assert_ptr(this);
@ -75,7 +75,7 @@ bool ITransport::Write(const ByteArray& bs, void* opt)
} }
// 接收数据 // 接收数据
uint ITransport::Read(ByteArray& bs) uint ITransport::Read(Array& bs)
{ {
// 特别是接口要检查this指针 // 特别是接口要检查this指针
assert_ptr(this); assert_ptr(this);
@ -96,14 +96,14 @@ void ITransport::Register(TransportHandler handler, void* param)
} }
// 引发数据到达事件 // 引发数据到达事件
uint ITransport::OnReceive(ByteArray& bs, void* param) uint ITransport::OnReceive(Array& bs, void* param)
{ {
if(_handler) return _handler(this, bs, _param, param); if(_handler) return _handler(this, bs, _param, param);
return 0; return 0;
} }
bool ITransport::OnWriteEx(const ByteArray& bs, void* opt) bool ITransport::OnWriteEx(const Array& bs, void* opt)
{ {
return OnWrite(bs); return OnWrite(bs);
} }
@ -134,10 +134,10 @@ void PackPort::Set(ITransport* port)
bool PackPort::OnOpen() { return Port->Open(); } bool PackPort::OnOpen() { return Port->Open(); }
void PackPort::OnClose() { Port->Close(); } void PackPort::OnClose() { Port->Close(); }
bool PackPort::OnWrite(const ByteArray& bs) { return Port->Write(bs); } bool PackPort::OnWrite(const Array& bs) { return Port->Write(bs); }
uint PackPort::OnRead(ByteArray& bs) { return Port->Read(bs); } uint PackPort::OnRead(Array& bs) { return Port->Read(bs); }
uint PackPort::OnPortReceive(ITransport* sender, ByteArray& bs, void* param, void* param2) uint PackPort::OnPortReceive(ITransport* sender, Array& bs, void* param, void* param2)
{ {
assert_ptr(param); assert_ptr(param);

24
Net/ITransport.h
View File

@ -6,7 +6,7 @@
class ITransport; class ITransport;
// 传输口数据到达委托。传入数据缓冲区地址和长度，如有反馈，仍使用该缓冲区，返回数据长度 // 传输口数据到达委托。传入数据缓冲区地址和长度，如有反馈，仍使用该缓冲区，返回数据长度
typedef uint (*TransportHandler)(ITransport* port, ByteArray& bs, void* param, void* param2); typedef uint (*TransportHandler)(ITransport* port, Array& bs, void* param, void* param2);
// 帧数据传输接口 // 帧数据传输接口
// 实现者确保数据以包的形式传输，屏蔽数据的粘包和拆包 // 实现者确保数据以包的形式传输，屏蔽数据的粘包和拆包
@ -34,12 +34,10 @@ public:
void Close(); void Close();
// 发送数据 // 发送数据
bool Write(const ByteArray& bs); bool Write(const Array& bs);
bool Write(const ByteArray& bs, void* opt); bool Write(const Array& bs, void* opt);
// 接收数据 // 接收数据
uint Read(ByteArray& bs); uint Read(Array& bs);
// 控制命令
int Control(int cmd, int arg);
// 注册回调函数 // 注册回调函数
virtual void Register(TransportHandler handler, void* param = NULL); virtual void Register(TransportHandler handler, void* param = NULL);
@ -53,15 +51,15 @@ public:
protected: protected:
virtual bool OnOpen() { return true; } virtual bool OnOpen() { return true; }
virtual void OnClose() { } virtual void OnClose() { }
virtual bool OnWrite(const ByteArray& bs) = 0; virtual bool OnWrite(const Array& bs) = 0;
virtual bool OnWriteEx(const ByteArray& bs, void* opt); virtual bool OnWriteEx(const Array& bs, void* opt);
virtual uint OnRead(ByteArray& bs) = 0; virtual uint OnRead(Array& bs) = 0;
// 是否有回调函数 // 是否有回调函数
bool HasHandler() { return _handler != NULL; } bool HasHandler() { return _handler != NULL; }
// 引发数据到达事件 // 引发数据到达事件
virtual uint OnReceive(ByteArray& bs, void* param); virtual uint OnReceive(Array& bs, void* param);
}; };
// 数据口包装 // 数据口包装
@ -83,10 +81,10 @@ protected:
virtual bool OnOpen(); virtual bool OnOpen();
virtual void OnClose(); virtual void OnClose();
virtual bool OnWrite(const ByteArray& bs); virtual bool OnWrite(const Array& bs);
virtual uint OnRead(ByteArray& bs); virtual uint OnRead(Array& bs);
static uint OnPortReceive(ITransport* sender, ByteArray& bs, void* param, void* param2); static uint OnPortReceive(ITransport* sender, Array& bs, void* param, void* param2);
}; };
#endif #endif

6
Net/Net.h
View File

@ -127,10 +127,10 @@ public:
IPEndPoint Remote; // 远程地址 IPEndPoint Remote; // 远程地址
// 发送数据 // 发送数据
virtual bool Send(const ByteArray& bs) = 0; virtual bool Send(const Array& bs) = 0;
virtual bool SendTo(const ByteArray& bs, const IPEndPoint& remote) { return Send(bs); } virtual bool SendTo(const Array& bs, const IPEndPoint& remote) { return Send(bs); }
// 接收数据 // 接收数据
virtual uint Receive(ByteArray& bs) = 0; virtual uint Receive(Array& bs) = 0;
}; };
#endif #endif

8
Queue.cpp
View File

@ -55,7 +55,7 @@ byte Queue::Pop()
#pragma arm section code #pragma arm section code
uint Queue::Write(const ByteArray& bs) uint Queue::Write(const Array& bs)
{ {
/* /*
1，数据写入队列末尾 1，数据写入队列末尾
@ -64,7 +64,7 @@ uint Queue::Write(const ByteArray& bs)
4，如果队列过小，很有可能后来数据会覆盖前面数据 4，如果队列过小，很有可能后来数据会覆盖前面数据
*/ */
byte* buf = bs.GetBuffer(); byte* buf = (byte*)bs.GetBuffer();
uint len = bs.Length(); uint len = bs.Length();
uint rs = 0; uint rs = 0;
@ -101,7 +101,7 @@ uint Queue::Write(const ByteArray& bs)
return rs; return rs;
} }
uint Queue::Read(ByteArray& bs) uint Queue::Read(Array& bs)
{ {
if(_size == 0) return 0; if(_size == 0) return 0;
@ -117,7 +117,7 @@ uint Queue::Read(ByteArray& bs)
4，如果队列过小，很有可能后来数据会覆盖前面数据 4，如果队列过小，很有可能后来数据会覆盖前面数据
*/ */
byte* buf = bs.GetBuffer(); byte* buf = (byte*)bs.GetBuffer();
uint len = bs.Capacity(); uint len = bs.Capacity();
if(len > _size) len = _size; if(len > _size) len = _size;

4
Queue.h
View File

@ -28,8 +28,8 @@ public:
void Push(byte dat); void Push(byte dat);
byte Pop(); byte Pop();
uint Write(const ByteArray& bs); // 批量写入 uint Write(const Array& bs); // 批量写入
uint Read(ByteArray& bs); // 批量读取 uint Read(Array& bs); // 批量读取
}; };
#endif #endif

7
SerialPort.cpp
View File

@ -225,7 +225,7 @@ uint SerialPort::SendData(byte data, uint times)
} }
// 向某个端口写入数据。如果size为0，则把data当作字符串，一直发送直到遇到\0为止 // 向某个端口写入数据。如果size为0，则把data当作字符串，一直发送直到遇到\0为止
bool SerialPort::OnWrite(const ByteArray& bs) bool SerialPort::OnWrite(const Array& bs)
{ {
if(!bs.Length()) return true; if(!bs.Length()) return true;
#ifdef STM32F0 #ifdef STM32F0
@ -286,7 +286,7 @@ void SerialPort::OnTxHandler()
#pragma arm section code #pragma arm section code
// 从某个端口读取数据 // 从某个端口读取数据
uint SerialPort::OnRead(ByteArray& bs) uint SerialPort::OnRead(Array& bs)
{ {
uint count = 0; uint count = 0;
uint len = Rx.Length(); uint len = Rx.Length();
@ -467,7 +467,8 @@ extern "C"
if(_printf_sp) if(_printf_sp)
{ {
_printf_sp->Write(ByteArray(ch, 1)); byte b = ch;
_printf_sp->Write(Array(&b, 1));
} }
isInFPutc = false; isInFPutc = false;

4
SerialPort.h
View File

@ -90,8 +90,8 @@ protected:
virtual bool OnOpen(); virtual bool OnOpen();
virtual void OnClose(); virtual void OnClose();
virtual bool OnWrite(const ByteArray& bs); virtual bool OnWrite(const Array& bs);
virtual uint OnRead(ByteArray& bs); virtual uint OnRead(Array& bs);
private: private:
static void OnHandler(ushort num, void* param); static void OnHandler(ushort num, void* param);

4
Spi.cpp
View File

@ -272,7 +272,7 @@ ushort Spi::Write16(ushort data)
} }
// 批量读写。以字节数组长度为准 // 批量读写。以字节数组长度为准
void Spi::Write(const ByteArray& bs) void Spi::Write(const Array& bs)
{ {
for(int i=0; i<bs.Length(); i++) for(int i=0; i<bs.Length(); i++)
{ {
@ -280,7 +280,7 @@ void Spi::Write(const ByteArray& bs)
} }
} }
void Spi::Read(ByteArray& bs) void Spi::Read(Array& bs)
{ {
for(int i=0; i<bs.Length(); i++) for(int i=0; i<bs.Length(); i++)
{ {

8
Spi.h
View File

@ -29,7 +29,7 @@ public:
// 使用端口和最大速度初始化Spi，因为需要分频，实际速度小于等于该速度 // 使用端口和最大速度初始化Spi，因为需要分频，实际速度小于等于该速度
Spi(SPI_TypeDef* spi, uint speedHz = 9000000, bool useNss = true); Spi(SPI_TypeDef* spi, uint speedHz = 9000000, bool useNss = true);
~Spi(); ~Spi();
void Init(SPI_TypeDef* spi, uint speedHz = 9000000, bool useNss = true); void Init(SPI_TypeDef* spi, uint speedHz = 9000000, bool useNss = true);
void SetPin(Pin clk = P0, Pin miso = P0, Pin mosi = P0, Pin nss = P0); void SetPin(Pin clk = P0, Pin miso = P0, Pin mosi = P0, Pin nss = P0);
@ -42,9 +42,9 @@ public:
ushort Write16(ushort data); ushort Write16(ushort data);
// 批量读写。以字节数组长度为准 // 批量读写。以字节数组长度为准
void Write(const ByteArray& bs); void Write(const Array& bs);
void Read(ByteArray& bs); void Read(Array& bs);
void Start(); // 拉低NSS，开始传输 void Start(); // 拉低NSS，开始传输
void Stop(); // 拉高NSS，停止传输 void Stop(); // 拉高NSS，停止传输
}; };

10
TinyIP/Tcp.cpp
View File

@ -204,7 +204,7 @@ void TcpSocket::OnDataReceive(TCP_HEADER& tcp, uint len)
byte* data = tcp.Next(); byte* data = tcp.Next();
// 触发ITransport接口事件 // 触发ITransport接口事件
ByteArray bs(data, len); Array bs(data, len);
uint len2 = OnReceive(bs, NULL); uint len2 = OnReceive(bs, NULL);
// 如果有返回，说明有数据要回复出去 // 如果有返回，说明有数据要回复出去
if(len2) if(len2)
@ -364,7 +364,7 @@ bool TcpSocket::Disconnect()
return SendPacket(*tcp, 0, TCP_FLAGS_ACK | TCP_FLAGS_PUSH | TCP_FLAGS_FIN); return SendPacket(*tcp, 0, TCP_FLAGS_ACK | TCP_FLAGS_PUSH | TCP_FLAGS_FIN);
} }
bool TcpSocket::Send(const ByteArray& bs) bool TcpSocket::Send(const Array& bs)
{ {
if(!Enable) if(!Enable)
{ {
@ -424,7 +424,7 @@ bool TcpSocket::Send(const ByteArray& bs)
return wait; return wait;
} }
uint TcpSocket::Receive(ByteArray& bs) uint TcpSocket::Receive(Array& bs)
{ {
return 0; return 0;
} }
@ -498,12 +498,12 @@ bool TcpSocket::Connect(IPAddress& ip, ushort port)
return false; return false;
} }
bool TcpSocket::OnWrite(const ByteArray& bs) bool TcpSocket::OnWrite(const Array& bs)
{ {
return Send(bs); return Send(bs);
} }
uint TcpSocket::OnRead(ByteArray& bs) uint TcpSocket::OnRead(Array& bs)
{ {
// 暂时不支持 // 暂时不支持
return 0; return 0;

8
TinyIP/Tcp.h
View File

@ -39,9 +39,9 @@ public:
bool Disconnect(); // 关闭Socket bool Disconnect(); // 关闭Socket
// 发送数据 // 发送数据
virtual bool Send(const ByteArray& bs); virtual bool Send(const Array& bs);
// 接收数据 // 接收数据
virtual uint Receive(ByteArray& bs); virtual uint Receive(Array& bs);
// 收到Tcp数据时触发，传递结构体和负载数据长度。返回值指示是否向对方发送数据包 // 收到Tcp数据时触发，传递结构体和负载数据长度。返回值指示是否向对方发送数据包
typedef bool (*TcpHandler)(TcpSocket& socket, TCP_HEADER& tcp, byte* buf, uint len); typedef bool (*TcpHandler)(TcpSocket& socket, TCP_HEADER& tcp, byte* buf, uint len);
@ -67,8 +67,8 @@ protected:
virtual bool OnOpen(); virtual bool OnOpen();
virtual void OnClose(); virtual void OnClose();
virtual bool OnWrite(const ByteArray& bs); virtual bool OnWrite(const Array& bs);
virtual uint OnRead(ByteArray& bs); virtual uint OnRead(Array& bs);
}; };
#endif #endif

10
TinyIP/Udp.cpp
View File

@ -73,7 +73,7 @@ void UdpSocket::OnProcess(IP_HEADER& ip, UDP_HEADER& udp, Stream& ms)
assert_param2(len <= ms.Remain(), "UDP数据包不完整"); assert_param2(len <= ms.Remain(), "UDP数据包不完整");
// 触发ITransport接口事件 // 触发ITransport接口事件
ByteArray bs(data, len); Array bs(data, len);
uint len2 = OnReceive(bs, &CurRemote); uint len2 = OnReceive(bs, &CurRemote);
// 如果有返回，说明有数据要回复出去 // 如果有返回，说明有数据要回复出去
//if(len2) Write(data, len2); //if(len2) Write(data, len2);
@ -129,7 +129,7 @@ void UdpSocket::SendPacket(UDP_HEADER& udp, uint len, IPAddress& ip, ushort port
} }
// 发送UDP数据到目标地址 // 发送UDP数据到目标地址
bool UdpSocket::Send(const ByteArray& bs) bool UdpSocket::Send(const Array& bs)
{ {
//if(ip.IsAny()) ip = Remote.Address; //if(ip.IsAny()) ip = Remote.Address;
//if(!port) port = Remote.Port; //if(!port) port = Remote.Port;
@ -151,17 +151,17 @@ bool UdpSocket::Send(const ByteArray& bs)
return true; return true;
} }
bool UdpSocket::OnWrite(const ByteArray& bs) bool UdpSocket::OnWrite(const Array& bs)
{ {
return Send(bs); return Send(bs);
} }
uint UdpSocket::Receive(ByteArray& bs) uint UdpSocket::Receive(Array& bs)
{ {
return 0; return 0;
} }
uint UdpSocket::OnRead(ByteArray& bs) uint UdpSocket::OnRead(Array& bs)
{ {
// 暂时不支持 // 暂时不支持
return 0; return 0;

8
TinyIP/Udp.h
View File

@ -25,9 +25,9 @@ public:
UdpHandler OnReceived; UdpHandler OnReceived;
// 发送数据 // 发送数据
virtual bool Send(const ByteArray& bs); virtual bool Send(const Array& bs);
// 接收数据 // 接收数据
virtual uint Receive(ByteArray& bs); virtual uint Receive(Array& bs);
virtual string ToString(); virtual string ToString();
@ -38,8 +38,8 @@ protected:
virtual bool OnOpen(); virtual bool OnOpen();
virtual void OnClose(); virtual void OnClose();
virtual bool OnWrite(const ByteArray& bs); virtual bool OnWrite(const Array& bs);
virtual uint OnRead(ByteArray& bs); virtual uint OnRead(Array& bs);
}; };
#endif #endif

6
TinyNet/Tiny.cpp
View File

@ -9,7 +9,7 @@
#include "Net\Zigbee.h" #include "Net\Zigbee.h"
#include "TinyNet\TinyClient.h" #include "TinyNet\TinyClient.h"
uint OnSerial(ITransport* transport, ByteArray& bs, void* param, void* param2) uint OnSerial(ITransport* transport, Array& bs, void* param, void* param2)
{ {
debug_printf("OnSerial len=%d \t", bs.Length()); debug_printf("OnSerial len=%d \t", bs.Length());
bs.Show(true); bs.Show(true);
@ -67,7 +67,7 @@ ITransport* Create2401(SPI_TypeDef* spi_, Pin ce, Pin irq, Pin power, bool power
return nrf; return nrf;
} }
uint OnZig(ITransport* port, ByteArray& bs, void* param, void* param2) uint OnZig(ITransport* port, Array& bs, void* param, void* param2)
{ {
debug_printf("配置信息\r\n"); debug_printf("配置信息\r\n");
bs.Show(true); bs.Show(true);
@ -106,7 +106,7 @@ ITransport* CreateShunCom(COM_Def index, int baudRate, Pin rst, Pin power, Pin s
debug_printf("进入配置模式\r\n"); debug_printf("进入配置模式\r\n");
byte buf[] = {0xFE, 0x00, 0x21, 0x15, 0x34}; byte buf[] = {0xFE, 0x00, 0x21, 0x15, 0x34};
zb.Write(ByteArray(buf, ArrayLength(buf)));*/ zb.Write(CArray(buf));*/
/*ByteArray bs; /*ByteArray bs;
int n=10000; int n=10000;

4
TokenNet/Token.cpp
View File

@ -120,7 +120,7 @@ TinyServer* Token::CreateServer(ITransport* port)
return server; return server;
} }
uint OnSerial(ITransport* transport, ByteArray& bs, void* param, void* param2) uint OnSerial(ITransport* transport, Array& bs, void* param, void* param2)
{ {
debug_printf("OnSerial len=%d \t", bs.Length()); debug_printf("OnSerial len=%d \t", bs.Length());
bs.Show(true); bs.Show(true);
@ -181,7 +181,7 @@ ITransport* Token::Create2401(SPI_TypeDef* spi_, Pin ce, Pin irq, Pin power, boo
return nrf; return nrf;
} }
uint OnZig(ITransport* port, ByteArray& bs, void* param, void* param2) uint OnZig(ITransport* port, Array& bs, void* param, void* param2)
{ {
debug_printf("配置信息\r\n"); debug_printf("配置信息\r\n");
bs.Show(true); bs.Show(true);

13
Type.cpp
View File

@ -66,8 +66,8 @@ const String Type::Name() const
int Array::Length() const { return _Length; } int Array::Length() const { return _Length; }
// 数组最大容量。初始化时决定，后面不允许改变 // 数组最大容量。初始化时决定，后面不允许改变
int Array::Capacity() const { return _Capacity; } int Array::Capacity() const { return _Capacity; }
// 缓冲区 // 缓冲区。按字节指针返回
void* Array::GetBuffer() const { return _Arr; } byte* Array::GetBuffer() const { return (byte*)_Arr; }
int memlen(const void* data) int memlen(const void* data)
{ {
@ -272,6 +272,15 @@ void Array::SetItemAt(int i, const void* item)
memcpy((byte*)_Arr + _Size * i, item, _Size); memcpy((byte*)_Arr + _Size * i, item, _Size);
} }
// 重载索引运算符[]，返回指定元素的第一个字节
byte& Array::operator[](int i) const
{
assert_param2(_Arr && i >= 0 && i < _Length, "数组下标越界");
byte* buf = (byte*)_Arr;
return buf[i * _Size];
}
// 检查容量。如果不足则扩大，并备份指定长度的数据 // 检查容量。如果不足则扩大，并备份指定长度的数据
bool Array::CheckCapacity(int len, int bak) bool Array::CheckCapacity(int len, int bak)
{ {

11
Type.h
View File

@ -87,6 +87,7 @@ public:
virtual T& operator[](int i) const = 0; virtual T& operator[](int i) const = 0;
}; };
// 数组。包括指针和最大长度，支持实际长度
class Array : public Object class Array : public Object
{ {
protected: protected:
@ -102,8 +103,8 @@ public:
int Length() const; int Length() const;
// 数组最大容量。初始化时决定，后面不允许改变 // 数组最大容量。初始化时决定，后面不允许改变
int Capacity() const; int Capacity() const;
// 缓冲区 // 缓冲区。按字节指针返回
void* GetBuffer() const; byte* GetBuffer() const;
Array(void* data, int len = 0); Array(void* data, int len = 0);
Array(const void* data, int len = 0); Array(const void* data, int len = 0);
@ -130,6 +131,9 @@ public:
// 设置指定位置的值，不足时自动扩容 // 设置指定位置的值，不足时自动扩容
virtual void SetItemAt(int i, const void* item); virtual void SetItemAt(int i, const void* item);
// 重载索引运算符[]，返回指定元素的第一个字节
byte& operator[](int i) const;
friend bool operator==(const Array& bs1, const Array& bs2); friend bool operator==(const Array& bs1, const Array& bs2);
friend bool operator!=(const Array& bs1, const Array& bs2); friend bool operator!=(const Array& bs1, const Array& bs2);
protected: protected:
@ -138,6 +142,9 @@ protected:
virtual void* Alloc(int len); virtual void* Alloc(int len);
}; };
// 使用常量数组来定义一个指针数组
#define CArray(arr) (Array(arr, ArrayLength(arr)))
// 数组 // 数组
/* /*
数组是指针和长度的封装。 数组是指针和长度的封装。