#4 : Wireless Forwarding Ad-hoc Network with Flooding, Gossiping, LEACH Protocols

Presentation by DoHyun. JiPresentation by DoHyun. Ji

Multimedia Networking LabMultimedia Networking LabMultimedia Networking LabMultimedia Networking Lab

SSungungKKyunyunKKwanwan U Universityniversity

http://mnet.skku.ac.kr

#4 : Wireless Forwarding Ad-hoc Network with#4 : Wireless Forwarding Ad-hoc Network withFlooding, Gossiping, LEACH ProtocolsFlooding, Gossiping, LEACH Protocols

(Hanback’s zigbeX & TinyOS ver.1.1.7)

DoHyun. JiDoHyun. Ji2007. 3. 232007. 3. 23





2 / 50

2 Gossiping ProtocolGossiping Protocol

ContentsContents

3 LEACH ProtocolLEACH Protocol

1 Flooding ProtocolFlooding Protocol





3 / 50

1. Flooding Protocol1. Flooding Protocol

Ad-hoc NetworkAd-hoc Network 특정 목적지로 데이터 전송을 위해 각 노드가 자유로운 망을 형성특정 목적지로 데이터 전송을 위해 각 노드가 자유로운 망을 형성

형성된 망을 통해 목적지 노드로 데이터 포워딩형성된 망을 통해 목적지 노드로 데이터 포워딩 , , 멀티홉 통신의 멀티홉 통신의 구현구현

특정 특정 APAP 나 기지국이 불필요하여 설치 및 운영이 간편나 기지국이 불필요하여 설치 및 운영이 간편

Flooding ProtocolFlooding Protocol 패킷 전송은 항상 패킷 전송은 항상 Broadcast Broadcast 형태로 진행형태로 진행

Implosion – Sequence Number for each PacketImplosion – Sequence Number for each Packet

TTL(Time to Live) – Hop LimitTTL(Time to Live) – Hop Limit

실제 사용은 최초 라우팅 경로 설정용실제 사용은 최초 라우팅 경로 설정용 (RIP(RIP 와 유사와 유사 ))

같은 패킷을 두 번 이상 수신할 수 있음같은 패킷을 두 번 이상 수신할 수 있음 (Overlap)(Overlap)

각 노드의 각 노드의 RF RF 출력에 의존출력에 의존

목적 노드가 데이터를 수신했음에도 계속 포워딩될 수 있음목적 노드가 데이터를 수신했음에도 계속 포워딩될 수 있음

많은 전력 소모많은 전력 소모





4 / 50


Configuration – TempMon.nConfiguration – TempMon.ncc

MakefileMakefile

includes TempMon;

includes MH;

configuration TempMon{ }

Implementation {

components Main, TempMonM, TimerC, Temp, GenericComm as Comm,QueuedSend, SimpleTime,

#ifdef FLOODING // FLOODING 이 define 된 경우

MHFloodingRouter as Router;

#endif

#ifdef GOSSIPING

MHGossipingRouter as Router;

#endif

#ifdef LEACH

MHLeachRouter as Router;

#endif

COMPONENT=TempMon

SENSORBOARD=basicsb

PFLAGS= -I. -I./Queue -DFLOODING -DSIM=10

include ../../../../apps/Makerules





5 / 50


Configuration – TempMon.nc (con’d) & headerConfiguration – TempMon.nc (con’d) & headerssMain.StdControl -> TempMonM.StdControl;

Main.StdControl -> Router.StdControl; // 라우팅 프로토콜 연결

Main.StdControl -> Comm.Control;

Main.StdControl -> QueuedSend.StdControl;

Main.StdControl -> Temp.StdControl;

Main.StdControl -> TimerC.StdControl;

Main.StdControl -> SimpleTime.StdControl;

TempMonM.ADC -> Temp.TempADC;

TempMonM.Timer -> TimerC.Timer[unique("Timer")];

TempMonM.Send -> Router.Send[AM_TEMPMONMSG]; // 전송 컴포넌트 연결

TempMonM.GlobalTime -> Router.GlobalTime;

Router.ReceiveMsg[AM_TEMPMONMSG] -> Comm.ReceiveMsg[AM_TEMPMONMSG];

}

/* tempMon.h */

enum

{

TIMER_RATE = 5000,

// Send a message every 5 seconds

AM_TEMPMONMSG = 10,

};

typedef struct TempMonMsg

{

uint16_t address;

uint32_t timestamp;

uint16_t reading;

} __attribute__ ((packed)) TempMonMsg;

/* MH.h */

...

FLOODING_MAX_HOP_COUNT = 100,

FLOODING_LOG_LENGTH = 250,

...

/* MH.h */

typedef struct MHMessage

{

uint16_t sendingNode;

uint16_t originNode;

uint16_t seqNo;

uint16_t hopCount;

uint8_t data[(TOSH_DATA_LENGTH - 8)];

} __attribute__ ((packed)) MHMessage;





6 / 50


Module – TempMonM.ncModule – TempMonM.nc

includes TempMon;

module TempMonM

{

provides

{

interface StdControl;

}

uses

{

interface Send;

interface ADC;

interface Timer;

interface GlobalTime;

}

}

implementation

{

norace uint16_t sensorReading; // 각 센싱 프로세스를 고정

bool sendBusy; // 전송 상태 변수

TOS_Msg mhMsg; // 전송될 데이터의 메시지 타잎

command result_t StdControl.init(){ ... }

command result_t StdControl.start() {

call ADC.getData(); // ADC 읽어오기

return call Timer.start(TIMER_REPEAT, TIMER_RATE);

}

event result_t Timer.fired(){

call ADC.getData(); // ADC 읽어오기

// 모든 노드의 글로벌 시간이 동기화 되었을때만 전송

if (call GlobalTime.isSynchronised() == SUCCESS)

{

post sendData();

}

return SUCCESS;

}





7 / 50


Module – TempMonM.nc (con’d)Module – TempMonM.nc (con’d)

task void sendData()

{

uint16_t length;

TempMonMsg *pDataMsg = (TempMonMsg *) call Send.getBuffer(&mhMsg, &length);

// 전송중에는 보내지 않음

if (sendBusy == TRUE) { return; }

// 전송용 메시지에 데이터 담기

pDataMsg->address = TOS_LOCAL_ADDRESS;

pDataMsg->timestamp = call GlobalTime.getGlobalTime();

pDataMsg->reading = sensorReading;

// 실제 전송

if ((call Send.send(&mhMsg, sizeof(TempMonMsg))) == SUCCESS) {

atomic sendBusy = TRUE;

dbg(DBG_TEMP, "TempMonM - Message sent successfully\n");

}

else {

dbg(DBG_TEMP, "TempMonM - Message not sent\n");

}

}





8 / 50


Configuration – MHFloodingRouter.nConfiguration – MHFloodingRouter.nccincludes MH;

configuration MHFloodingRouter{

provides {


interface Receive[uint8_t id]; // 수신용 인터페이스

interface Send[uint8_t id];

interface Intercept[uint8_t id];

interface GlobalTime; // 각 모트가 sync 해야할 글로벌 타임

}

uses { interface ReceiveMsg[uint8_t id]; }

}

implementation

{

components MHEngineM, MHFloodingPSM, GenericComm as Comm, QueuedSend, TimerC, SimpleTime, TimeSyncM, LedsC;

StdControl = MHEngineM.StdControl; // 멀티홉에 필수적인 MHEngine, 기타 컴포넌트들

Receive = MHEngineM.Receive; // 모든 인터페이스를 멀티홉 처리를 담당하는 MHEngine 에 연결

Send = MHEngineM.Send;

ReceiveMsg = MHEngineM.ReceiveMsg;

Intercept = MHEngineM.Intercept;

GlobalTime = TimeSyncM.GlobalTime;

MHEngineM.CommStdControl -> Comm.Control;





9 / 50


Configuration – MHFloodingRouter.nc (con’Configuration – MHFloodingRouter.nc (con’d)d) #ifdef SIM

MHEngineM.SimTimer -> TimerC.Timer[unique("Timer")];

#endif

MHEngineM.SubControl -> QueuedSend.StdControl;

MHEngineM.SendMsg -> QueuedSend.SendMsg;

MHEngineM.SubControl -> MHFloodingPSM.StdControl;

MHEngineM.RouteSelect -> MHFloodingPSM.RouteSelect; // Flooding 프로토콜이 구현된 MHFlooingPSM 에 연결

MHEngineM.Leds -> LedsC.Leds;

TimeSyncM.Leds -> LedsC.Leds; // LED

MHEngineM.SubControl -> TimeSyncM.StdControl;

TimeSyncM.Timer -> TimerC.Timer[unique("Timer")]; // Timer

TimeSyncM.Time -> SimpleTime.Time;

TimeSyncM.ReceiveMsg -> Comm.ReceiveMsg[AM_TIMESYNC]; // 수신한 메시지 큐

TimeSyncM.SendMsg -> QueuedSend.SendMsg[AM_TIMESYNC]; // 보낼 메시지 큐

MHEngineM.GlobalTime -> TimeSyncM.GlobalTime; // 노드간의 sync 를 위한 변수

}





10 / 50


Module – MHFloodingPSM.nc (con’d)Module – MHFloodingPSM.nc (con’d)

includes AM;

includes MH;

module MHFloodingPSM{ provides { interface StdControl; interface RouteSelect; } } // RouteSelect 인터페이스 사용

implementation{

typedef struct LogEntry{

uint16_t id; // 로그 기록용 구조체

uint16_t seqno; // seq 번호

} LogEntry;

enum{

MAX_HOP_COUNT = FLOODING_MAX_HOP_COUNT, // 최대 Hop count 설정

MAX_SEQ_NO = 30000, // 최대 Sequence 번호 설정

LOG_LENGTH = FLOODING_LOG_LENGTH // 최대 Log 길이 설정

};

uint16_t seqNo; // Sequence 번호 변수

LogEntry messageLog[LOG_LENGTH]; // 로그 기록용 구조체 배열

uint16_t entries; // 로그 엔트리 개수 기록 변수

uint16_t index; // 로그 기록용 인덱스 변수





11 / 50



static uint16_t getSeqNo() { // 다음 Sequence 번호 가져오기

uint16_t temp = seqNo++;

seqNo = seqNo % MAX_SEQ_NO;

return temp;

}

static void addLogEntry(uint16_t id, uint16_t seqno) { // 새로운 로그 기록

if (entries < LOG_LENGTH) {

entries++;

}

messageLog[index].id = id;

messageLog[index++].seqno = seqno;

index = index % LOG_LENGTH;

}

static bool inLog(uint16_t id, uint16_t seqno) { // 로그 검색 , 기존에 전송한 패킷인지 검사

int i;

for (i = 0; i < entries; i++) {

if ((messageLog[i].id == id) && (messageLog[i].seqno == seqno)) { return TRUE; }

}

return FALSE;

}





12 / 50



command result_t StdControl.init()

{

seqNo = 0;

entries = 0;

index = 0; // 각 변수 초기화

return SUCCESS;

}

command result_t StdControl.start() { return SUCCESS; }

command result_t StdControl.stop() { return SUCCESS; }

command bool RouteSelect.isActive() {

return TRUE; // Flooding 이 진행중일때는 항상 True 리턴

}

command result_t RouteSelect.initializeFields(TOS_MsgPtr msg, uint8_t id)

{ // 새로운 패킷의 초기화 ( 목적지 주소 , 홉 Count 기록 )

MHMessage *pMHMsg = (MHMessage *) &msg->data[0];

pMHMsg->originNode = pMHMsg->sendingNode = TOS_LOCAL_ADDRESS;

pMHMsg->hopCount = 0;

return SUCCESS;

}





13 / 50



command result_t RouteSelect.selectRoute(TOS_MsgPtr msg, uint8_t id){

MHMessage *pMHMsg = (MHMessage *) &msg->data[0]; // 데이터를 메시지 구조체에 저장

if ((pMHMsg->originNode == TOS_LOCAL_ADDRESS) && (pMHMsg->hopCount == 0)) {

pMHMsg->seqNo = getSeqNo(); // 패킷이 local 노드에서 생성된 경우

} else if (inLog(pMHMsg->originNode, pMHMsg->seqNo) == FALSE) {

pMHMsg->sendingNode = TOS_LOCAL_ADDRESS; // 패킷이 다른 노드에서 전달 되어온 경우

pMHMsg->hopCount++; /// 홉 증가

} else { // 비정상 패킷

dbg(DBG_TEMP, "MHFloodingPSM - Failed to select route for duplicate packet\n");

return FAIL;

}

if (TOS_LOCAL_ADDRESS == BASE_STATION_ADDRESS) {

msg->addr = TOS_UART_ADDR; // 자신이 sink( 수집 ) 노드인경우 메시지의 목적지 주소를 UART(Serial) 로 변경

} else {

msg->addr = TOS_BCAST_ADDR; // 그 외는 Broadcast

}

if (pMHMsg->hopCount < MAX_HOP_COUNT || msg->addr == TOS_UART_ADDR) {

addLogEntry(pMHMsg->originNode, pMHMsg->seqNo); // TTL 이 유효하거나 , 자신이 sink 노드인경우 로그에 추가

dbg(DBG_TEMP, "MHFloodingPSM - Route selected\n");

return SUCCESS;

}

dbg(DBG_TEMP, "MHFloodingPSM - Failed to select route\n"); // 위의 경우에 속하지 않으면 (TTL 이 만료 )

return FAIL; // 패킷 폐기

}





14 / 50


Result – Run TinyViz using double cygwin windowsResult – Run TinyViz using double cygwin windows

On first cygwin windowOn first cygwin window

On Second cygwin window (after executing #1)On Second cygwin window (after executing #1)





15 / 50


Result (con’d) - TinyVizResult (con’d) - TinyViz





16 / 50

2. Gossiping Protocol2. Gossiping Protocol Gossiping ProtocolGossiping Protocol

Many Problems in Flooding ProtocoMany Problems in Flooding Protocoll

확률적 패킷 전송확률적 패킷 전송

1Hop 1Hop 이내에 이내에 Advertise Advertise 패킷 전송패킷 전송

Unicast Packet ForwardingUnicast Packet Forwarding

Best Case : Best Case : 최소 노드를 거쳐서 패킷 전송최소 노드를 거쳐서 패킷 전송

Worst Case : Worst Case : 패킷의 손실패킷의 손실

Multi-Advertise Multi-Advertise 패킷 기법패킷 기법

Delivery Ratio Delivery Ratio 고려고려 (Flooding ≥ Gossiping)(Flooding ≥ Gossiping)





17 / 50

2. Gossiping Protocol2. Gossiping Protocol Configuration – TempMon.nConfiguration – TempMon.n

cc

MakefileMakefile

includes TempMon;

includes MH;


Implementation {


#ifdef FLOODING


#endif

#ifdef GOSSIPING // GOSSIPING 이 define 된 경우


#endif

#ifdef LEACH


#endif

COMPONENT=TempMon

SENSORBOARD=basicsb

PFLAGS= -I. -I./Queue -DGOSSIPING -DSIM=10






18 / 50

2. Gossiping Protocol2. Gossiping Protocol Configuration – TempMon.nc (con’d) & headerConfiguration – TempMon.nc (con’d) & header

ssMain.StdControl -> TempMonM.StdControl;












}

/* tempMon.h */

enum

{

TIMER_RATE = 5000,


AM_TEMPMONMSG = 10,

};


{

uint16_t address;

uint32_t timestamp;

uint16_t reading;


/* MH.h */

...

GOSSIPING_MAX_HOP_COUNT = 250,

GOSSIPING_NEIGHBOUR_TABLE_SIZE = 32,

GOSSIPING_ROUTE_UPDATE_RATE = 10000,

...

/* MH.h */


{



uint16_t seqNo;

uint16_t hopCount;







19 / 50

2. Gossiping Protocol2. Gossiping Protocol Configuration – MHGossipingRouter.ncConfiguration – MHGossipingRouter.nc

includes MH;

configuration MHGossipingRouter {

provides {


interface Receive[uint8_t id];




}


}

implementation{

components MHEngineM, MHGossipingPSM, GenericComm as Comm, QueuedSend, TimerC, RandomLFSR, SimpleTime,

TimeSyncM, LedsC;

StdControl = MHEngineM.StdControl;

Receive = MHEngineM.Receive;










20 / 50

2. Gossiping Protocol2. Gossiping Protocol Configuration – MHGossipingRouter.nc (con’d)Configuration – MHGossipingRouter.nc (con’d)

#ifdef SIM


#endif



MHEngineM.SubControl -> MHGossipingPSM.StdControl;

MHEngineM.RouteSelect -> MHGossipingPSM.RouteSelect; // Gossiping 프로토콜 컴포넌트에 연결



MHEngineM.GlobalTime -> TimeSyncM.GlobalTime;

MHGossipingPSM.Timer -> TimerC.Timer[unique("Timer")];

MHGossipingPSM.ReceiveMsg -> Comm.ReceiveMsg[AM_MHMESSAGE];

MHGossipingPSM.SendMsg -> QueuedSend.SendMsg[AM_MHMESSAGE];

MHGossipingPSM.Random -> RandomLFSR.Random;

MHGossipingPSM.Leds -> LedsC.Leds;

TimeSyncM.Leds -> LedsC.Leds;

TimeSyncM.Timer -> TimerC.Timer[unique("Timer")];


TimeSyncM.ReceiveMsg -> Comm.ReceiveMsg[AM_TIMESYNC];

TimeSyncM.SendMsg -> QueuedSend.SendMsg[AM_TIMESYNC];

}





21 / 50

2. Gossiping Protocol2. Gossiping Protocol Module – MHGossipingPSM.ncModule – MHGossipingPSM.nc

includes AM;

includes MH;

module MHGossipingPSM

{

provides

{


interface RouteSelect;

}

uses

{

interface Timer;

interface ReceiveMsg;

interface SendMsg;

interface Random;

interface Leds;

}

}





22 / 50

2. Gossiping Protocol2. Gossiping Protocol Module – MHGossipingPSM.nc (con’d)Module – MHGossipingPSM.nc (con’d)

implementation{

typedef struct RoutePacket {

uint16_t nodeID;

} __attribute__ ((packed)) RoutePacket;

typedef struct NeighbourTable { // 이웃들의 정보를 기록할 구조체

uint16_t nodeID; // 노드 ID

uint16_t receivedCount; // 수신한 메시지 카운트

uint16_t timerTicks; // 최종 패킷을 받은 후 경과한 시간 (Tick)

bool nodeAlive; // 노드의 상태 (Alive or Dead)

uint16_t strength; // 연결 (Link) 강도

} NeighbourTable;

enum {

MAX_HOP_COUNT = GOSSIPING_MAX_HOP_COUNT, // 최대 Hop count 설정

NEIGHBOUR_TABLE_SIZE = GOSSIPING_NEIGHBOUR_TABLE_SIZE, // 이웃 노드 Table 크기

NEIGHBOUR_DEAD_TICKS = 5, // 죽은 이웃 노드 감지 시간

ROUTE_UPDATE_RATE = GOSSIPING_ROUTE_UPDATE_RATE // 라우팅 테이블 갱신률

};

TOS_Msg routeMsg; // 라우팅될 메시지를 담을 구조체

bool sendRouteBusy; // 전송 플래그 (Busy or Not)

NeighbourTable neighbourTable[NEIGHBOUR_TABLE_SIZE]; // 이웃 노드 기록 Table 구조체 배열

uint16_t entries; // 현재 기록된 이웃 수





23 / 50


static void updateTableEntry(uint16_t id, uint16_t strength) {

int entryIndex, lowestStrengthIndex, nodeDeadIndex;

uint16_t lowestStrength = 0;

lowestStrengthIndex = nodeDeadIndex = entries;

for (entryIndex = 0; entryIndex < entries; entryIndex++) { // 테이블 검색

if (neighbourTable[entryIndex].nodeID == id) { // 이미 존재하는 경우

break;

}

else if ((neighbourTable[entryIndex].nodeAlive == FALSE) && (nodeDeadIndex == entries)) {

nodeDeadIndex = entryIndex; // 해당 이웃 노드가 죽은 경우

}

else if ((neighbourTable[entryIndex].strength < lowestStrength) || (lowestStrengthIndex == entries)) {

lowestStrengthIndex = entryIndex; // 가장 신호가 약한 노드 골라내기

lowestStrength = neighbourTable[entryIndex].strength;

}

}





24 / 50


if (entryIndex < entries) { // 이웃 테이블의 엔트리 갱신

dbg(DBG_TEMP, "MHGossipingPSM - Updating entry for node %i in neighbour table\n", id);

neighbourTable[entryIndex].receivedCount++;

neighbourTable[entryIndex].timerTicks = 0;

neighbourTable[entryIndex].nodeAlive = TRUE;

neighbourTable[entryIndex].strength = strength;

} else if (nodeDeadIndex != entries) { // 죽은 노드는 다른 노드로 대체

dbg(DBG_TEMP, "MHGossipingPSM - Replacing dead node %i for node %i in neighbour table\n",

neighbourTable[nodeDeadIndex].nodeID, id);

neighbourTable[nodeDeadIndex].nodeID = id;

neighbourTable[nodeDeadIndex].receivedCount = 1;

………………………………...

} else if (entries < NEIGHBOUR_TABLE_SIZE) { // 아직 테이블이 가득차지 않았다면 새로운 엔트리 추가

dbg(DBG_TEMP, "MHGossipingPSM - Adding entry for node %i in neighbour table\n", id);

neighbourTable[entries].nodeID = id;

………………………………..

} else if (strength > lowestStrength) { // 신호 세기가 약한 노드는 다른 노드로 대체

{

dbg(DBG_TEMP, "MHGossipingPSM - Replacing node %i for node %i in neighbour table\n",

…………………………………

}

}





25 / 50


task void updateTable() { // 테이블 갱신

int i;


if (neighbourTable[i].nodeAlive == TRUE) { // 무한 Tick 현상을 제거하기 위해 살아있는 노드만 갱신

neighbourTable[i].timerTicks++;

if (neighbourTable[i].timerTicks >= NEIGHBOUR_DEAD_TICKS) {

dbg(DBG_TEMP, "MHGossipingPSM - Setting node %i as dead in neighbour table\n", neighbourTable[i].nodeID);

neighbourTable[i].nodeAlive = FALSE;

}

}

}

}

task void advertise() { // 주기적 advertise 패킷 전송

RoutePacket *pRP = (RoutePacket *) &routeMsg.data[0];

uint8_t length = sizeof(RoutePacket);

if (sendRouteBusy == TRUE) { return; } // 채널이 사용중일때는 전송 중지

pRP->nodeID = TOS_LOCAL_ADDRESS;

if (call SendMsg.send(TOS_BCAST_ADDR, length, &routeMsg) == SUCCESS) { // 전송하기

atomic { call Leds.redToggle(); } // 전송중일때는 빨간 LED 깜빡이기

dbg(DBG_TEMP, "MHGossipingPSM - Advertising presence\n");

atomic sendRouteBusy = TRUE;

}

}





26 / 50


command result_t StdControl.init() {

entries = 0;

sendRouteBusy = FALSE;

call Random.init(); // 각 변수 초기화

return SUCCESS;

}

command result_t StdControl.start() { return call Timer.start(TIMER_REPEAT, ROUTE_UPDATE_RATE); }

command result_t StdControl.stop() { return call Timer.stop(); }

command bool RouteSelect.isActive() { // 이웃에서 작동중인 노드의 존재 유무 검사

int i;

bool alive = FALSE;


if (neighbourTable[i].nodeAlive == TRUE) {

alive = TRUE;

break;

}

}

return alive;

}





27 / 50


command result_t RouteSelect.selectRoute(TOS_MsgPtr msg, uint8_t id) {


if (pMHMsg->sendingNode != TOS_LOCAL_ADDRESS) {

pMHMsg->sendingNode = TOS_LOCAL_ADDRESS; pMHMsg->hopCount++; // 다른 노드로부터 패킷을 수신한 경우

}


msg->addr = TOS_UART_ADDR; // 패킷이 local 노드에서 생성된 경우 , 목적지 주소를 UART(Serial) 로 설정

}

else if (entries > 0) { // 외부의 패킷이면 이웃 entry 에서 한 노드를 랜덤하게 선택한다

uint16_t num = call Random.rand() % entries; int i;

for (i = 0; i < entries; i++) { // 살아있는 노드인경우 현재 메시지의 다음 경로로 지정

if (neighbourTable[num].nodeAlive == TRUE) { msg->addr = neighbourTable[num].nodeID; break; }

else { num++; num = num % entries; }

} // 엔트리 검색에서 라우팅이 가능한 어떤 노드도 발견하지 못한 경우

if (i == entries) { dbg(DBG_TEMP, "MHGossipingPSM - Failed to select route\n"); return FAIL; }

}

else { dbg(DBG_TEMP, "MHGossipingPSM - Failed to select route\n"); return FAIL; }

if (pMHMsg->hopCount < MAX_HOP_COUNT || msg->addr == TOS_UART_ADDR) { // TTL 유효 or UART

dbg(DBG_TEMP, "MHGossipingPSM - Route selected\n"); // 라우팅 성공

return SUCCESS;

}

dbg(DBG_TEMP, "MHGossipingPSM - Failed to select route - hop count exceeded\n");

return FAIL; // 패킷 폐기

}





28 / 50


command result_t RouteSelect.initializeFields(TOS_MsgPtr msg, uint8_t id) {



pMHMsg->hopCount = 0; // 메시지의 각 필드 초기화

return SUCCESS;

}

event result_t Timer.fired() { // 타이머 만료시

post updateTable(); // 이웃 테이블 갱신

post advertise();

return SUCCESS;

}

event TOS_MsgPtr ReceiveMsg.receive(TOS_MsgPtr m) { // 메시지를 수신했을 때 (Advertise)

RoutePacket *pRP = (RoutePacket *) m->data;

atomic { call Leds.redToggle(); } // 빨간 LED 깜빡이기

dbg(DBG_TEMP, "MHGossipingPSM - Advertisment received from node %i\n", pRP->nodeID);

updateTableEntry(pRP->nodeID, m->strength);

return m;

}

event result_t SendMsg.sendDone(TOS_MsgPtr msg, result_t success) { // 라우팅 메시지가 본내진 경우

atomic sendRouteBusy = FALSE;

return SUCCESS;

}





29 / 50

2. Gossiping Protocol2. Gossiping Protocol Result - TinyVizResult - TinyViz





30 / 50

3. LEACH Protocol3. LEACH Protocol

LEACH ProtocolLEACH Protocol Low-Energy Adaptive Clustering HierarchyLow-Energy Adaptive Clustering Hierarchy

인접 노드들끼리 대표 노드인접 노드들끼리 대표 노드 (coordinator) (coordinator) 선출선출

센싱 데이터는 대표 노드를 통해서만 전송센싱 데이터는 대표 노드를 통해서만 전송

모든 노드들이 전송에 참여하지 않아도 됨모든 노드들이 전송에 참여하지 않아도 됨

Best Case : Best Case : 높은 높은 Delivery RatioDelivery Ratio

대표 노드는 전력 소모가 심하므로 주기적으로 대표 노드 변경대표 노드는 전력 소모가 심하므로 주기적으로 대표 노드 변경

Worst Case : Worst Case : 대표 노드가 대표 노드가 Sink Sink 노드와 전송이 불가능한 상황노드와 전송이 불가능한 상황

모든 노드가 전송 전력을 최대로 설정한다는 가정의 한계모든 노드가 전송 전력을 최대로 설정한다는 가정의 한계

대표 노드간의 대표 노드간의 MH MH 구성 또는 대표노드와 구성 또는 대표노드와 Sink Sink 노드간 노드간 Topology Topology 구성이 요구됨구성이 요구됨 ..





31 / 50


Configuration – TempMon.nConfiguration – TempMon.ncc

MakefileMakefile

includes TempMon;

includes MH;


Implementation {


#ifdef FLOODING


#endif

#ifdef GOSSIPING


#endif

#ifdef LEACH // LEACH 가 define 된 경우


#endif

COMPONENT=TempMon

SENSORBOARD=basicsb

PFLAGS= -I. -I./Queue -DLEACH -DLEACH_PROBABILITY=25 -DSIM=10






32 / 50


Configuration – TempMon.nc (con’d) & headerConfiguration – TempMon.nc (con’d) & headerssMain.StdControl -> TempMonM.StdControl;












}

/* tempMon.h */

enum

{

TIMER_RATE = 5000,


AM_TEMPMONMSG = 10,

};


{

uint16_t address;

uint32_t timestamp;

uint16_t reading;


/* MH.h */

...

LEACH_ROUTE_UPDATE_RATE = 10000, // 10 sec

LEACH_ROUND_LENGTH = 600000, // 10 min

LEACH_NEIGHBOUR_TABLE_SIZE = 32

...

/* MH.h */


{



uint16_t seqNo;

uint16_t hopCount;







33 / 50


Configuration – MHLeachRouter.ncConfiguration – MHLeachRouter.nc

includes MH;

configuration MHLeachRouter {

provides {


interface Receive[uint8_t id];




}


}

Implementation {

components MHEngineM, MHLeachPSM, GenericComm as Comm, QueuedSend,

TimerC, RandomLFSR, SimpleTime, TimeSyncM, LedsC; // MHEngine, MHLeachPSM 컴포넌트 연결

StdControl = MHEngineM.StdControl;

Receive = MHEngineM.Receive;










34 / 50


Configuration – MHLeachRouter.nc (con’d)Configuration – MHLeachRouter.nc (con’d)

#ifdef SIM


#endif



MHEngineM.SubControl -> MHLeachPSM.StdControl;

MHEngineM.RouteSelect -> MHLeachPSM.RouteSelect; // Leach 프로토콜이 구현된 MHLeachPSM 에 연결

MHLeachPSM.StatusTimer -> TimerC.Timer[unique("Timer")];

MHLeachPSM.RoundTimer -> TimerC.Timer[unique("Timer")];

MHLeachPSM.ReceiveMsg -> Comm.ReceiveMsg[AM_MHMESSAGE];

MHLeachPSM.SendMsg -> QueuedSend.SendMsg[AM_MHMESSAGE]; // 메시지 큐

MHLeachPSM.Random -> RandomLFSR.Random; // 랜덤값 발생


TimeSyncM.Leds -> LedsC.Leds;

MHLeachPSM.Leds -> LedsC.Leds;


TimeSyncM.Timer -> TimerC.Timer[unique("Timer")];


TimeSyncM.ReceiveMsg -> Comm.ReceiveMsg[AM_TIMESYNC];

TimeSyncM.SendMsg -> QueuedSend.SendMsg[AM_TIMESYNC]; // 메시지 큐

MHEngineM.GlobalTime -> TimeSyncM.GlobalTime;

}





35 / 50


Module – MHLeachPSM.ncModule – MHLeachPSM.nc

includes AM;

includes MH;

module MHLeachPSM

{

provides

{


interface RouteSelect; // Leach 프로토콜 Router 인터페이스

}

uses

{

interface Timer as RoundTimer;

interface Timer as StatusTimer;

interface ReceiveMsg;

interface SendMsg;

interface Random;

interface Leds;

}

}





36 / 50


Module – MHLeachPSM.nc (con’d)Module – MHLeachPSM.nc (con’d)

implementation

{

typedef struct RoutePacket

{ // 라우팅할 패킷 구조체

uint16_t addr; // Broadcast 주소로 지정된 패킷은 상태 구분 메시지로 간주

uint16_t nodeID; // 특적 목적지가 지정된 패킷은 Fowarding 요청으로 간주

uint16_t depth;

uint8_t round;

bool isClusterHead; // cluster coordinator 여부를 가지는 플래그

bool becomeClusterHead; // cluster coordinator 가 되는 노드가 가지는 플래그

} __attribute__ ((packed)) RoutePacket;

typedef struct NeighbourTable

{

uint16_t nodeID;

bool isClusterHead; // 이웃 노드 라우팅 테이블

uint16_t depth; // 라우팅 계층의 깊이

uint8_t timerTicks;

bool nodeAlive; // 노드가 살아있는지 여부

uint16_t strength; // 신호의 세기

} NeighbourTable;





37 / 50



enum {

ROUND_LENGTH = LEACH_ROUND_LENGTH,

ROUTE_UPDATE_RATE = LEACH_ROUTE_UPDATE_RATE,

NEIGHBOUR_TABLE_SIZE = LEACH_NEIGHBOUR_TABLE_SIZE,

NEIGHBOUR_DEAD_TICKS = 5,

TIMEOUT_TICKS = 5, // cluster coordinator 가 되기전까지의 대기시간 (Tick 단위 )

PARENT_INVALID = 0xeeee,

INFINITY = 0xffff,

ROUND_INVALID = 0xff,

PROBABILITY = LEACH_PROBABILITY // 확률 설정

};

uint8_t round; // Current LEACH round

uint16_t parentID;

bool isClusterHead;

uint16_t depth; // 라우팅 트리에서의 깊이

uint8_t ticks; // cluster coordinator 없이 전송한 시간 (누적 )

TOS_Msg routeMsg; // 라우팅 정보를 저장할 메시지 구조체

bool sendRouteBusy; // 노드의 전송 상태 플래그 (Busy or not)

uint16_t addr;

NeighbourTable neighbours[NEIGHBOUR_TABLE_SIZE]; // 이웃 노드의 라우팅 정보를 저장하는 테이블 배열

uint16_t tableEntries;





38 / 50



static void updateTable() { // 라우팅 테이블 업데이트

int i;

for (i = 0; i < tableEntries; i++)

{

// 노드가 살아있는 경우만 테이블 갱신 , 무한 tick 현상 예방

if (neighbours[i].nodeAlive == TRUE)

{

neighbours[i].timerTicks++;

if (neighbours[i].timerTicks >= NEIGHBOUR_DEAD_TICKS)

dbg(DBG_TEMP, "MHLeachPSM - Setting node %i as dead in neighbour table\n",

neighbours[i].nodeID);

neighbours[i].nodeAlive = FALSE;

}

}

}





39 / 50



static void updateTableEntry(uint16_t id, uint16_t treeDepth, bool isHead, uint16_t strength) {

int i; // 테이블에서 엔트리를 검색 , 죽은 노드와 가장 높은 Hop 노드는 걸러냄

uint16_t maxLeafDepth, maxHeadDepth;

int maxLeafIndex, maxHeadIndex, nodeDead;

maxLeafDepth = maxHeadDepth = 0; // sink 노드 ( ID = 0 ) 만이 Depth 가 0

maxLeafIndex = maxHeadIndex = nodeDead = tableEntries;

for (i = 0; i < tableEntries; i++) {

if (neighbours[i].nodeID == id) { break; } // 노드가 엔트리를 가진경우

else if ((neighbours[i].nodeAlive == FALSE) && (nodeDead == tableEntries)) {

nodeDead = i; // 노드가 죽은경우

}

else if ((neighbours[i].isClusterHead == TRUE) && (neighbours[i].depth > maxHeadDepth)) {

maxHeadDepth = neighbours[i].depth; // 노드가 cluster coordinator 인 동시에 Depth 가 가장 큰 경우

maxHeadIndex = i;

}

else if (neighbours[i].depth > maxLeafDepth) { // 노드가 leaf 노드인 동시에 Depth 가 가장 큰 경우

maxLeafDepth = neighbours[i].depth;

maxLeafIndex = i;

}

}





40 / 50



if (i < tableEntries) { // 테이블 업데이트

dbg(DBG_TEMP, "MHLeachPSM - Updating node %i in neighbour table\n", id);

neighbours[i].isClusterHead = isHead; neighbours[i].depth = treeDepth;

neighbours[i].timerTicks = 0; neighbours[i].nodeAlive = TRUE; neighbours[i].strength = strength;

}

else if (nodeDead != tableEntries) { // 죽은 노드 엔트리 교체

neighbours[nodeDead].nodeID, id);

}

else if (tableEntries < NEIGHBOUR_TABLE_SIZE) { // 테이블에 여유 공간이 있는 경우

neighbours[tableEntries].nodeID = id;

}

else if ((isHead == TRUE) && (maxLeafIndex != tableEntries)) { // leaf 노드와 cluster coordinator 교체

neighbours[maxLeafIndex].nodeID, id);

}

else if ((maxLeafIndex != tableEntries) && (maxLeafDepth > treeDepth)) { // leaf 노드중 더 낮은 깊이의 노드로 교체

neighbours[maxLeafIndex].nodeID, id);

}

else if ((isHead == TRUE) && (maxHeadIndex != tableEntries) && (maxHeadDepth > treeDepth)) {

neighbours[maxHeadIndex].nodeID = id // cluster coordinator 노드를 sink 노드에 더 가까운 노드로 교체

}

}





41 / 50



static void selectParent() { // 각 노드의 부모노드 선택

int i;

uint16_t minLeafDepth, minHeadDepth;

int minLeafIndex, minHeadIndex;

ticks++;

minLeafDepth = minHeadDepth = INFINITY;

minLeafIndex = minHeadIndex = tableEntries;

for (i = 0; i < tableEntries; i++) {

if ((neighbours[i].isClusterHead == TRUE) && (neighbours[i].depth < minHeadDepth)) {

minHeadDepth = neighbours[i].depth; // 노드가 cluster coordinator 인 동시에 가장 낮은 깊이일 때

minHeadIndex = i;

}

else if (neighbours[i].depth < minLeafDepth) { // 노드가 leaf 노드인 동시에 가장 낮은 깊이일 때

minLeafDepth = neighbours[i].depth;

minLeafIndex = i;

}

}





42 / 50



if (minHeadIndex != tableEntries) { // 가장 낮은 깊이의 cluster coordinator

parentID = neighbours[minHeadIndex].nodeID;

depth = neighbours[minHeadIndex].depth + 1; ticks = 0;

dbg(DBG_TEMP, "MHLeachPSM - New parent selected (ID: %i)\n", parentID);

return;

}

else if (ticks >= TIMEOUT_TICKS) { // leaf 노드로부터의 연결이 timeout 된 경우

if (minLeafIndex != tableEntries) {

atomic addr = neighbours[minLeafIndex].nodeID; // 매 time tick 마다 대표가 될 적절한 노드가 있는지 검사

}

ticks = 0; // timeout reset

}

parentID = PARENT_INVALID;

dbg(DBG_TEMP, "MHLeachPSM - Could not select new parent\n");

depth = INFINITY;

}





43 / 50



static void nextRound() { round = (round + 1) % ROUND_INVALID; } // 다음 노드 찾기

static bool isNewRound(uint8_t r) {

// 비정상적인 노드 advertising

if (r == ROUND_INVALID) { return FALSE; }

// 아직 round 배정을 받지 못한 경우

else if (round == ROUND_INVALID) { return TRUE; }

else {

uint8_t previous;

if (round == 0) { previous = ROUND_INVALID - 1; }

else {

previous = round--;

}

if ((r != round) && (r != previous)) { return TRUE; }

else { return FALSE; }

}

}





44 / 50



task void advertise() {

RoutePacket *pRP = (RoutePacket *) &routeMsg.data[0]; // 라우팅 정보 저장용 패킷 구조체 포인팅

uint8_t length = sizeof(RoutePacket);

if (sendRouteBusy == TRUE) { return; } // 노드가 전송중일때는 전종 작업 중단

pRP->addr = addr;

atomic addr = TOS_BCAST_ADDR; // broadcast

pRP->nodeID = TOS_LOCAL_ADDRESS; // local 주소 지정

pRP->depth = depth;

pRP->round = round;

pRP->isClusterHead = isClusterHead;

if (pRP->addr != TOS_BCAST_ADDR) { // forwarding 요청에 대한 필드 설정

dbg(DBG_TEMP, "MHLeachPSM - Requesting node %i become a cluster head\n", pRP->addr);

pRP->becomeClusterHead = TRUE;

}

else { pRP->becomeClusterHead = FALSE; } // 포워딩 되므로 cluster coordinator 가 아님

if (call SendMsg.send(TOS_BCAST_ADDR, length, &routeMsg) == SUCCESS) {

atomic { call Leds.redToggle(); } // RF 전송중에는 빨간 LED 깜박이기

dbg(DBG_TEMP, "MHLeachPSM - Advertising presence (Cluster Head: %i)\n", (int) isClusterHead);

atomic sendRouteBusy = TRUE; // 전송중 플래그 활성화

}

}





45 / 50



static void init() {

tableEntries = 0;

ticks = 0;

addr = TOS_BCAST_ADDR; // Normal route packet - no forwarding request


round = 0;

parentID = TOS_UART_ADDR; // 메시지의 목적지가 자기자신 (Local) 인 경우 UART(Serial) 전송

isClusterHead = TRUE;

depth = 0;

}

else {

round = ROUND_INVALID;

parentID = PARENT_INVALID;

isClusterHead = FALSE;

depth = INFINITY;

}

}





46 / 50



static void startNewRound(uint8_t r) { // 새로운 round[cluster coordinator 변경 ] 시작

// 노드 상태에 따라 결정 , ( 확률 , 난수 )

uint16_t probability = ((uint16_t) PROBABILITY) * (0xffff / 100);

uint16_t randNo = call Random.rand();

bool clusterStatus = randNo < probability;

dbg(DBG_TEMP, "MHLeachPSM - Round %i started (Cluster Head: %i)\n", r, (int) clusterStatus);

atomic {

round = r;

ticks = 0;

tableEntries = 0;

parentID = PARENT_INVALID; // 대표 노드이므로

depth = INFINITY;

addr = TOS_BCAST_ADDR;

isClusterHead = clusterStatus;

}

}





47 / 50



command result_t StdControl.init() {

init(); return call Random.init(); // 초기화

}

command result_t StdControl.start() {

// sink 노드부터 cluster coordinator round 시작


call RoundTimer.start(TIMER_REPEAT, ROUND_LENGTH); // sink 노드인경우

}

return call StatusTimer.start(TIMER_REPEAT, ROUTE_UPDATE_RATE);

}

command result_t StdControl.stop() {

call RoundTimer.stop();

return call StatusTimer.stop();

}

command bool RouteSelect.isActive() {

if (parentID != PARENT_INVALID) {

return TRUE;

}

return FALSE;

}





48 / 50



command result_t RouteSelect.selectRoute(TOS_MsgPtr msg, uint8_t id) {

MHMessage *pMHMsg = (MHMessage *) &msg->data[0]; // MH 메시지 전송용 구조체 포인터

// 패킷이 자기 자신으로부터 생겨난 경우 ↓

if ((pMHMsg->originNode == TOS_LOCAL_ADDRESS) && (pMHMsg->hopCount == 0)) {

if (parentID != PARENT_INVALID) { // 부모노드는 없음

dbg(DBG_TEMP, "MHLeachPSM - Routing to node %i\n", parentID);

msg->addr = parentID;

return SUCCESS;

}

}

else { // 자신이 아닌 다른 곳에서 온 패킷인 경우

if ((isClusterHead == TRUE) && (parentID != PARENT_INVALID)) { // 대표노드일때만

pMHMsg->sendingNode = TOS_LOCAL_ADDRESS;

pMHMsg->hopCount++; // hop count 올리기

dbg(DBG_TEMP, "MHLeachPSM - Routing to node %i\n", parentID);

msg->addr = parentID;

return SUCCESS;

}

dbg(DBG_TEMP, "MHLeachPSM - Could not select route\n");

return FAIL;

}

}





49 / 50



command result_t RouteSelect.initializeFields(TOS_MsgPtr msg, uint8_t id) {

MHMessage *pMHMsg = (MHMessage *) &msg->data[0]; // MH 메시지용 자료 형변환


pMHMsg->hopCount = 0; // 메시지에 기본값들 부여 , TTL =0

return SUCCESS;

}

event result_t RoundTimer.fired() { // 라우팅 타이머 만료시

dbg(DBG_TEMP, "MHLeachPSM - Round Timer fired\n");

nextRound(); // 새로운 대표노드 선택

return SUCCESS;

}

event result_t StatusTimer.fired() { // 노드 상태 타이머 만료시

if ((TOS_LOCAL_ADDRESS != BASE_STATION_ADDRESS) && (round != ROUND_INVALID)) {

updateTable(); selectParent();

}

post advertise();

return SUCCESS;

}

event result_t SendMsg.sendDone(TOS_MsgPtr msg, result_t success) {

atomic sendRouteBusy = FALSE; // 전송 완료시

return SUCCESS;

}





50 / 50



event TOS_MsgPtr ReceiveMsg.receive(TOS_MsgPtr m) {

atomic { call Leds.redToggle(); } // 전송중에는 빨간 LED 깜박이기

if (TOS_LOCAL_ADDRESS != BASE_STATION_ADDRESS) { // sink 노드는 다른 노드의 정보가 불필요

RoutePacket *pRP = (RoutePacket *) m->data;

if (pRP->round != ROUND_INVALID) { // 비정상적인 round 인 경우

if (isNewRound(pRP->round) == TRUE) {

startNewRound(pRP->round); // 새로운 round 시작

}

else if (pRP->addr == TOS_LOCAL_ADDRESS) { // 패킷이 현재 노드에 forwarding 요청을 하는경우

isClusterHead = pRP->becomeClusterHead;

if (pRP->becomeClusterHead == TRUE) { // cluster coordinator 로 설정되었을 때

dbg(DBG_TEMP, "MHLeachPSM - Becoming cluster head at request of node %i\n",

pRP->nodeID);

}

}

dbg(DBG_TEMP, "MHLeachPSM - Received advert (Origin ID: %i, Cluster Head: %i,Depth: %i)\n",

pRP->nodeID, (int) pRP->isClusterHead, pRP->depth);

updateTableEntry(pRP->nodeID, pRP->depth, pRP->isClusterHead, m->strength);

}

}

return m;

}





51 / 50


Result - TinyVizResult - TinyViz





E N D

Date post:	16-Jan-2016
Category:	Documents
Upload:	candy
View:	96 times
Download:	0 times

#4 : Wireless Forwarding Ad-hoc Network with Flooding, Gossiping, LEACH Protocols

Documents