object m_Data; // ユーザーデータ
public StateMachine()
{
m_Timer = TMO.TMO_FEVR;
m_TimeOut = TMO.TMO_FEVR;
m_TimeOutData = 0;
m_OnTimeOut = null;
}
public Nucleus(IKernel kernel, int sysTmrIntNo, TMO sysTmrIntv)
{
m_Kernel = kernel;
m_SysTmrIntNo = sysTmrIntNo;
m_SysTmrIntv = sysTmrIntv;
m_rsys.sysstat = SYSSTAT.TTS_INDP;
for (int i = 0; i < m_ReadyQueue.Length; i++)
{
m_ReadyQueue[i] = new LinkedList <Task>();
}
m_SysTime.Value = 0;
m_CurrentTask = null;
m_lwIP = new lwip(ip_output);
#if LWIP_STATS
stats.stats_init();
#endif
sys.sys_init(m_lwIP, this);
m_lwIP.mem_init();
lwip.memp_init();
pbuf.pbuf_init(m_lwIP);
udp.udp_init(m_lwIP);
tcp.tcp_init(m_lwIP);
}
public ER Connect(T_IPV4EP p_myaddr, T_IPV4EP p_dstaddr, TMO tmout)
{
err_t err;
ip_addr ma = new ip_addr(0);
ip_addr sa = new ip_addr(0);
ma.addr = lwip.lwip_htonl(p_myaddr.ipaddr);
err = m_lwIP.tcp.tcp_bind(m_Pcb, ma, lwip.lwip_htons(p_myaddr.portno));
if (err != err_t.ERR_OK)
{
return(ER.E_OBJ);
}
sa.addr = lwip.lwip_htonl(p_dstaddr.ipaddr);
err = m_lwIP.tcp.tcp_connect(m_Pcb, sa, lwip.lwip_htons(p_dstaddr.portno), Connected);
if (err != err_t.ERR_OK)
{
return(ER.E_OBJ);
}
Task task = m_Nucleus.GetTask(ID.TSK_SELF);
if ((tmout != 0) && (task == null))
{
return(ER.E_CTX);
}
if (task == null)
{
return(ER.E_TMOUT);
}
if (tmout == 0)
{
return(ER.E_TMOUT);
}
SetState(true, new TMO(tcp.TCP_TMR_INTERVAL), task, Intarval);
ER ret = task.Wait(m_SendTaskQueue, TSKWAIT.TTW_TCP, m_CepID, tmout);
switch (ret)
{
case ER.E_OK:
if ((m_TPcb == null) || (m_TPcb.state != tcp_state.ESTABLISHED))
{
return(ER.E_RLWAI);
}
break;
case ER.E_TMOUT:
return(ER.E_TMOUT);
default:
return(ER.E_RLWAI);
}
return(ER.E_OK);
}
protected void SetState(ST state)
{
m_State = state;
m_Timer = TMO.TMO_FEVR;
m_TimeOut = TMO.TMO_FEVR;
m_TimeOutData = 0;
m_OnTimeOut = null;
}
public ER ReceiveMessage(out T_MSG ppk_msg, TMO tmout)
{
ER ret;
ppk_msg = null;
Task task = m_Nucleus.GetTask(ID.TSK_SELF);
if ((tmout != 0) && (task == null))
{
return(ER.E_CTX);
}
//if (ppk_msg == null)
// return ER.E_PAR;
if ((m_TskQueue.First == null) && (m_MsgQueue.First != null))
{
ppk_msg = m_MsgQueue.First.Value;
m_MsgQueue.RemoveFirst();
}
else
{
if (task == null)
{
return(ER.E_TMOUT);
}
if (tmout == 0)
{
return(ER.E_TMOUT);
}
ret = task.Wait(m_TskQueue, TSKWAIT.TTW_MBX, m_MbxID, tmout);
switch (ret)
{
case ER.E_OK:
if (m_MsgQueue.First == null)
{
return(ER.E_RLWAI);
}
ppk_msg = m_MsgQueue.First.Value;
m_MsgQueue.RemoveFirst();
break;
case ER.E_TMOUT:
return(ER.E_TMOUT);
default:
return(ER.E_RLWAI);
}
}
//SetDebugInfo(ppk_msg, lpszFileName, nLine);
return(ER.E_OK);
}
protected void SetState(ST state, TMO timeOut, object timeOutData,
TTimeOutEvent onTimeOut)
{
m_State = state;
m_Timer = timeOut;
m_TimeOut = timeOut;
m_TimeOutData = timeOutData;
m_OnTimeOut = onTimeOut;
}
public ER GetMemoryBlock(out pointer p_blk, int blksz, TMO tmout)
{
ER ret;
p_blk = null;
//if (p_blk == null)
// return ER.E_PAR;
for (; ;)
{
TMemNode Node = Allocate(blksz);
if (Node != null)
{
p_blk = Node.GetData();
break;
}
if (tmout == 0)
{
return(ER.E_TMOUT);
}
Task task = m_Nucleus.GetTask(ID.TSK_SELF);
if (task == null)
{
return(ER.E_CTX);
}
task.MemoryBlockSize = blksz;
ret = task.Wait(m_TskQueue, TSKWAIT.TTW_MPL, m_MplID, tmout);
switch (ret)
{
case ER.E_OK:
continue;
case ER.E_TMOUT:
return(ER.E_TMOUT);
default:
return(ER.E_RLWAI);
}
}
#if DEBUG
string lpszFileName = "";
int nLine = 0;
_CrtMemBlockHeader.AddBlock(m_pFirstBlock, m_pLastBlock, p_blk, blksz, lpszFileName, nLine);
m_nBlockCount++;
#endif
return(ER.E_OK);
}
public ER Wait(LinkedList <Task> WaitQueue, TSKWAIT tskwait, ID wid, TMO tmout)
{
ER Result;
System.Diagnostics.Debug.Assert(m_CPUContext.IsCurrent());
if (m_rtsk.tskstat == TSKSTAT.TTS_SUS)
{
m_rtsk.tskstat = TSKSTAT.TTS_WAS;
}
else if (m_rtsk.tskstat == TSKSTAT.TTS_RUN)
{
System.Diagnostics.Debug.Assert(m_Nucleus.m_CurrentTask == this);
m_rtsk.tskstat = TSKSTAT.TTS_WAI;
m_Nucleus.m_CurrentTask = null;
}
else
{
m_rtsk.tskstat = TSKSTAT.TTS_WAI;
}
m_rtsk.tskwait = tskwait;
m_rtsk.wid = wid;
m_Nucleus.m_ReadyQueue[m_rtsk.tskpri].Remove(this);
// 待ちタスクキューへ追加
WaitQueue.AddLast(this);
// タイマー設定
SetState(false, tmout, WaitQueue, OnTimeOut);
// タスクスケジューリング
if (m_CPUContext.Dispatch())
{
if (State)
{
Result = ER.E_TMOUT;
}
else
{
Result = ER.E_OK;
}
}
else
{
m_rtsk.tskstat = TSKSTAT.TTS_RUN;
m_ReleaseWait = true;
Result = ER.E_RLWAI;
}
return(Result);
}
public ER Close(TMO tmout)
{
err_t err = m_lwIP.tcp.tcp_close(m_Pcb);
if (err == err_t.ERR_OK)
{
return(ER.E_OK);
}
else
{
return(ER.E_OBJ);
}
}
public void CallTimeOut()
{
if (m_Timer == 0)
{
// タイムアウト処理関数呼び出し
if (m_OnTimeOut != null)
{
m_OnTimeOut(m_TimeOutData);
}
// 新タイムアウト値設定
m_Timer = m_TimeOut;
}
}
public void Progress(TMO interval)
{
if (m_TimeOut == TMO.TMO_FEVR)
{
m_Timer = TMO.TMO_FEVR;
return;
}
m_Timer.Value -= interval;
if (m_Timer <= 0)
{
m_Timer.Value = 0;
}
}
public ER GetMemoryBlock(out pointer p_blk, int blksz, TMO tmout)
{
ER ret;
p_blk = null;
//if (p_blk == null)
// return ER.E_PAR;
for (; ;)
{
LinkedListNode <pointer> Node = m_MpfQueue.First;
if (Node != null)
{
p_blk = Node.Value;
m_MpfQueue.RemoveFirst();
break;
}
if (tmout == 0)
{
return(ER.E_TMOUT);
}
Task task = m_Nucleus.GetTask(ID.TSK_SELF);
if (task == null)
{
return(ER.E_CTX);
}
ret = task.Wait(m_TskQueue, TSKWAIT.TTW_MPF, m_MpfID, tmout);
switch (ret)
{
case ER.E_OK:
continue;
case ER.E_TMOUT:
return(ER.E_TMOUT);
default:
return(ER.E_RLWAI);
}
}
return(ER.E_OK);
}
public Kernel(long frequency, int sysTmrIntNo, TMO sysTmrIntv)
{
m_Nucleus = new Nucleus(this, sysTmrIntNo, sysTmrIntv);
m_Frequency = frequency;
m_OnSetEvent = null;
m_OnStart = null;
m_OnTerminate = null;
m_OnIdle = null;
m_OnOutput = null;
m_OnGetSystemTimeEvent = null;
m_Thread = null;
m_Terminate = false;
m_IntEvent = null;
m_Locked = 0;
m_TaskMode = false;
m_TlsIndex = new ThreadLocal <int>();
m_SysSem = new System.Threading.Semaphore(1, 1);
m_CallbackSem = new System.Threading.Semaphore(1, 1);
m_Lock = 0;
}
public ER Wait(TMO tmout)
{
ER ret;
Task task = m_Nucleus.GetTask(ID.TSK_SELF);
if ((tmout != 0) && (task == null))
{
return(ER.E_CTX);
}
m_Count--;
if (m_Count < 0)
{
if (tmout == 0)
{
m_Count++;
return(ER.E_TMOUT);
}
ret = task.Wait(m_TskQueue, TSKWAIT.TTW_SEM, m_SemID, tmout);
switch (ret)
{
case ER.E_OK:
return(ER.E_OK);
case ER.E_TMOUT:
m_Count++;
return(ER.E_TMOUT);
default:
return(ER.E_RLWAI);
}
}
return(ER.E_OK);
}
public ER Sleep(TMO tmout)
{
ER ret;
if (tmout == TMO.TMO_POL)
{
if (m_rtsk.wupcnt > 0)
{
m_rtsk.wupcnt--;
}
return(ER.E_OK);
}
if (m_rtsk.wupcnt <= 0)
{
ret = Wait(m_Nucleus.m_SlpTskQ, TSKWAIT.TTW_SLP, new ID(0), tmout);
switch (ret)
{
case ER.E_OK:
m_rtsk.wupcnt = 0;
return(ER.E_OK);
case ER.E_TMOUT:
return(ER.E_TMOUT);
default:
return(ER.E_RLWAI);
}
}
else
{
m_rtsk.wupcnt--;
return(ER.E_OK);
}
}
public ER SendData(T_IPV6EP p_dstaddr, pointer p_dat, int len, TMO tmout)
{
pbuf buf;
ip6_addr addr = new ip6_addr(p_dstaddr.ipaddr);
buf = m_lwIP.pbuf_alloc(pbuf_layer.PBUF_TRANSPORT, (ushort)len, pbuf_type.PBUF_POOL);
if (buf == null)
{
return(ER.E_NOMEM);
}
int pos = 0;
for (pbuf q = buf; q != null; q = q.next)
{
pointer.memcpy(q.payload, new pointer(p_dat, pos), q.len);
pos += q.len;
}
//m_lwIP.udp.udp_sendto(m_Pcb, buf, addr, p_dstaddr.portno);
return(ER.E_OK);
}
public ER ReceiveData(T_IPV6EP p_dstaddr, pointer p_dat, int len, TMO tmout)
{
ER ret;
Task task = m_Nucleus.GetTask(ID.TSK_SELF);
if ((tmout != 0) && (task == null))
{
return(ER.E_CTX);
}
if ((p_dat == null) || (len < 0))
{
return(ER.E_PAR);
}
if ((m_TskQueue.First == null) && (m_DatQueue.First != null))
{
pointer data;
lock (m_DatQueue) {
data = m_DatQueue.First.Value;
m_DatQueue.RemoveFirst();
}
int dlen = (ushort)data;
pointer.memcpy(p_dstaddr, data + sizeof(ushort), T_IPV6EP.length);
pointer.memcpy(p_dat, data + sizeof(ushort) + T_IPV6EP.length, dlen);
return((ER)dlen);
}
else
{
if (task == null)
{
return(ER.E_TMOUT);
}
if (tmout == 0)
{
return(ER.E_TMOUT);
}
ret = task.Wait(m_TskQueue, TSKWAIT.TTW_UDP, m_CepID, tmout);
switch (ret)
{
case ER.E_OK:
if (m_DatQueue.First == null)
{
return(ER.E_RLWAI);
}
lock (m_DatQueue) {
p_dat = new pointer(m_DatQueue.First.Value, 0);
m_DatQueue.RemoveFirst();
}
break;
case ER.E_TMOUT:
return(ER.E_TMOUT);
default:
return(ER.E_RLWAI);
}
}
//SetDebugInfo(p_dat, lpszFileName, nLine);
return(ER.E_OK);
}
public ER GetBuffer(ref pointer p_data, TMO tmout)
{
int result;
ER ret;
//if (p_data == null)
// return ER.E_PAR;
if ((m_SendMode != BufferMode.None) && (m_SendMode != BufferMode.ReduceCopy))
{
return(ER.E_OBJ);
}
Task task = m_Nucleus.GetTask(ID.TSK_SELF);
if ((tmout != 0) && (task == null))
{
return(ER.E_CTX);
}
// リングバッファが空っぽかループしている場合
if (m_RCSendWrPos <= m_RCSendRdPos)
{
result = m_RCSendData.Length - 1 - m_RCSendWrPos;
}
// リングバッファのループしていない区間
else
{
result = m_RCSendWrPos - m_RCSendRdPos;
}
if ((m_SendTaskQueue.First == null) && (result != 0))
{
p_data = new pointer(m_RCSendData, m_RCSendWrPos);
}
else
{
if (task == null)
{
return(ER.E_TMOUT);
}
if (tmout == 0)
{
return(ER.E_TMOUT);
}
ret = task.Wait(m_SendTaskQueue, TSKWAIT.TTW_TCP, m_CepID, tmout);
switch (ret)
{
case ER.E_OK:
// リングバッファが空っぽかループしている場合
if (m_RCSendWrPos <= m_RCSendRdPos)
{
result = m_RCSendData.Length - 1 - m_RCSendWrPos;
}
// リングバッファのループしていない区間
else
{
result = m_RCSendWrPos - m_RCSendRdPos;
}
if (result == 0)
{
return(ER.E_RLWAI);
}
p_data = new pointer(m_RCSendData, m_RCSendWrPos);
break;
case ER.E_TMOUT:
return(ER.E_TMOUT);
default:
return(ER.E_RLWAI);
}
}
m_SendMode = BufferMode.ReduceCopy;
return((ER)result);
}
public ER WaitEventFlag(ref FLGPTN p_flgptn, TMO tmout, FLGPTN waiptn, MODE wfmode)
{
ER ret;
Task task = m_Nucleus.GetTask(ID.TSK_SELF);
if ((tmout != 0) && (task == null))
{
return(ER.E_CTX);
}
//if (p_flgptn == null)
// return ER.E_PAR;
if ((wfmode & ~(MODE.TWF_ANDW | MODE.TWF_ORW | MODE.TWF_CLR)) != 0)
{
return(ER.E_PAR);
}
if ((m_TskQueue.First == null) && CheckPattern(waiptn, wfmode))
{
p_flgptn = m_FlagPattern;
if ((wfmode & MODE.TWF_CLR) != 0)
{
m_FlagPattern = 0;
}
}
else
{
if (task == null)
{
return(ER.E_TMOUT);
}
if (tmout == 0)
{
return(ER.E_TMOUT);
}
task.WaitPattern = waiptn;
task.WaitMode = wfmode;
ret = task.Wait(m_TskQueue, TSKWAIT.TTW_FLG, m_FlgID, tmout);
switch (ret)
{
case ER.E_OK:
p_flgptn = m_FlagPattern;
if (!CheckPattern(waiptn, wfmode))
{
return(ER.E_RLWAI);
}
if ((wfmode & MODE.TWF_CLR) != 0)
{
m_FlagPattern = 0;
}
break;
case ER.E_TMOUT:
return(ER.E_TMOUT);
default:
return(ER.E_RLWAI);
}
}
return(ER.E_OK);
}
public ER ReceiveBuffer(ref pointer p_data, TMO tmout)
{
int result = 0;
ER ret;
if (p_data == null)
{
return(ER.E_PAR);
}
if ((m_RecvMode != BufferMode.None) && (m_RecvMode != BufferMode.ReduceCopy))
{
return(ER.E_OBJ);
}
Task task = m_Nucleus.GetTask(ID.TSK_SELF);
if ((tmout != 0) && (task == null))
{
return(ER.E_CTX);
}
if ((m_RecvTaskQueue.First == null) && (m_RecvPBuf != null || m_RecvDataQueue.Count != 0))
{
p_data = new pointer(m_RecvPBufPos.payload, m_RecvPos);
result = m_RecvPBufPos.len - m_RecvPos;
}
else
{
if (task == null)
{
return(ER.E_TMOUT);
}
if (tmout == 0)
{
return(ER.E_TMOUT);
}
ret = task.Wait(m_RecvTaskQueue, TSKWAIT.TTW_TCP, m_CepID, tmout);
switch (ret)
{
case ER.E_OK:
if (m_RecvDataQueue.Count == 0)
{
return(ER.E_RLWAI);
}
p_data = new pointer(m_RecvPBufPos.payload, m_RecvPos);
result = m_RecvPBufPos.len - m_RecvPos;
break;
case ER.E_TMOUT:
return(ER.E_TMOUT);
default:
return(ER.E_RLWAI);
}
}
m_RecvMode = BufferMode.ReduceCopy;
return((ER)result);
}
public ER SendUrgentData(pointer data, int len, TMO tmout)
{
throw new NotImplementedException();
}
public ER Accept(TcpRep tcpRep, T_IPV4EP p_dstaddr, TMO tmout)
{
tcp_pcb_listen pcb = m_lwIP.tcp.tcp_listen(m_Pcb);
return(tcpRep.Accept(pcb, this, p_dstaddr, tmout));
}
internal ER Accept(tcp_pcb_listen pcb, TcpCep cep, T_IPV4EP p_dstaddr, TMO tmout)
{
ER ret;
m_Pcb = pcb;
m_TcpCep = cep;
tcp.tcp_accept(pcb, Accepting);
Task task = m_Nucleus.GetTask(ID.TSK_SELF);
if ((tmout != 0) && (task == null))
{
return(ER.E_CTX);
}
//if (p_dstaddr == null)
// return ER.E_PAR;
if ((m_TskQueue.First == null) && (m_AcceptQueue.First != null))
{
m_NewPcb = m_AcceptQueue.First.Value;
m_AcceptQueue.RemoveFirst();
p_dstaddr.ipaddr = lwip.lwip_ntohl(m_NewPcb.remote_ip.addr);
p_dstaddr.portno = lwip.lwip_ntohs(m_NewPcb.remote_port);
}
else
{
if (task == null)
{
return(ER.E_TMOUT);
}
if (tmout == 0)
{
return(ER.E_TMOUT);
}
ret = task.Wait(m_TskQueue, TSKWAIT.TTW_ACP, m_RepID, tmout);
switch (ret)
{
case ER.E_OK:
if (m_AcceptQueue.First == null)
{
return(ER.E_RLWAI);
}
m_NewPcb = m_AcceptQueue.First.Value;
m_AcceptQueue.RemoveFirst();
p_dstaddr.ipaddr = lwip.lwip_ntohl(m_NewPcb.remote_ip.addr);
p_dstaddr.portno = lwip.lwip_ntohs(m_NewPcb.remote_port);
break;
case ER.E_TMOUT:
return(ER.E_TMOUT);
default:
return(ER.E_RLWAI);
}
}
return(ER.E_OK);
}
public ER SendData(pointer p_data, int len, TMO tmout)
{
int result = 0;
ER ret;
if (p_data == null)
{
return(ER.E_PAR);
}
if ((m_SendMode != BufferMode.None) && (m_SendMode != BufferMode.NormalCopy))
{
return(ER.E_OBJ);
}
Task task = m_Nucleus.GetTask(ID.TSK_SELF);
if ((tmout != 0) && (task == null))
{
return(ER.E_CTX);
}
int space = tcp.tcp_sndbuf(m_TPcb);
if ((m_SendPBuf == null) && (space >= len))
{
m_SendPBuf = p_data;
m_SendPos = 0;
m_SendLen = len;
SentData(this, m_TPcb, (ushort)space);
}
else
{
if (task == null)
{
return(ER.E_TMOUT);
}
if (tmout == 0)
{
return(ER.E_TMOUT);
}
ret = task.Wait(m_SendTaskQueue, TSKWAIT.TTW_TCP, m_CepID, tmout);
switch (ret)
{
case ER.E_OK:
if (m_SendPBuf != null)
{
return(ER.E_RLWAI);
}
m_SendPBuf = p_data;
m_SendPos = 0;
m_SendLen = len;
SentData(this, m_TPcb, tcp.tcp_sndbuf(m_TPcb));
break;
case ER.E_TMOUT:
return(ER.E_TMOUT);
default:
return(ER.E_RLWAI);
}
}
m_SendMode = BufferMode.NormalCopy;
return((ER)result);
}
public abstract void Progress(TMO interval);
