Flooding: Each node floods a packet to all it neighbor nodes. These packets cont

Question

Flooding:

Each node floods a packet to all it neighbor nodes.

These packets continue to flood until it reaches it's final destination.

Must work as pings and ping replies.

Only use information accessible from the packet and it's headers.

CODE:

Node.nc

#include <Timer.h>

#include "includes/command.h"

#include "includes/packet.h"

#include "includes/CommandMsg.h"

#include "includes/sendInfo.h"

#include "includes/channels.h"

module Node{

uses interface Boot;

uses interface SplitControl as AMControl;

uses interface Receive;

uses interface SimpleSend as Sender;

uses interface CommandHandler;

}

implementation{

pack sendPackage;

// Prototypes

void makePack(pack *Package, uint16_t src, uint16_t dest, uint16_t TTL, uint16_t Protocol, uint16_t seq, uint8_t *payload, uint8_t length);

event void Boot.booted(){

call AMControl.start();

dbg(GENERAL_CHANNEL, "Booted ");

}

event void AMControl.startDone(error_t err){

if(err == SUCCESS){

dbg(GENERAL_CHANNEL, "Radio On ");

}else{

//Retry until successful

call AMControl.start();

}

}

event void AMControl.stopDone(error_t err){}

event message_t* Receive.receive(message_t* msg, void* payload, uint8_t len){

dbg(GENERAL_CHANNEL, "Packet Received ");

if(len==sizeof(pack)){

pack* myMsg=(pack*) payload;

dbg(GENERAL_CHANNEL, "Package Payload: %s ", myMsg->payload);

return msg;

}

dbg(GENERAL_CHANNEL, "Unknown Packet Type %d ", len);

return msg;

}

event void CommandHandler.ping(uint16_t destination, uint8_t *payload){

dbg(GENERAL_CHANNEL, "PING EVENT ");

makePack(&sendPackage, TOS_NODE_ID, destination, 0, 0, 0, payload, PACKET_MAX_PAYLOAD_SIZE);

call Sender.send(sendPackage, destination);

}

event void CommandHandler.printNeighbors(){}

event void CommandHandler.printRouteTable(){}

event void CommandHandler.printLinkState(){}

event void CommandHandler.printDistanceVector(){}

event void CommandHandler.setTestServer(){}

event void CommandHandler.setTestClient(){}

event void CommandHandler.setAppServer(){}

event void CommandHandler.setAppClient(){}

void makePack(pack *Package, uint16_t src, uint16_t dest, uint16_t TTL, uint16_t protocol, uint16_t seq, uint8_t* payload, uint8_t length){

Package->src = src;

Package->dest = dest;

Package->TTL = TTL;

Package->seq = seq;

Package->protocol = protocol;

memcpy(Package->payload, payload, length);

}

}

NodeC.nc

#include <Timer.h>

#include "includes/CommandMsg.h"

#include "includes/packet.h"

configuration NodeC{

}

implementation {

components MainC;

components Node;

components new AMReceiverC(AM_PACK) as GeneralReceive;

Node -> MainC.Boot;

Node.Receive -> GeneralReceive;

components ActiveMessageC;

Node.AMControl -> ActiveMessageC;

components new SimpleSendC(AM_PACK);

Node.Sender -> SimpleSendC;

components CommandHandlerC;

Node.CommandHandler -> CommandHandlerC;

}

Explanation / Answer

Here we already know

Node.nc and NodeC.nc

SimpleSend:

interface SimpleSend

{

command error_t send(pack msg, uint16_t dest );

}

Receive:

command error_t receive(pack* package)

CommandHandler

interface CommandHandler{

// Events

event void ping(uint16_t destination, uint8_t *payload);

event void printNeighbors();

event void printRouteTable();

event void printLinkState();

event void printDistanceVector();

event void setTestServer();

event void setTestClient();

event void setAppServer();

event void setAppClient();

}

enum{

CMD_PACKET_HEADER_LENGTH = 3,

CMD_PACKET_MAX_PAYLOAD_SIZE = 28 - CMD_PACKET_HEADER_LENGTH,

};

typedef nx_struct CommandMsg

{

nx_uint16_t dest;

nx_uint8_t id;

nx_uint8_t payload[CMD_PACKET_MAX_PAYLOAD_SIZE];

}

CommandMsg;

enum{

AM_COMMANDMSG=99

};

Channel.h:

char COMMAND_CHANNEL[]="command";

char GENERAL_CHANNEL[]="general";

char NEIGHBOR_CHANNEL[]="neighbor";

char FLOODING_CHANNEL[]="flooding";

char ROUTING_CHANNEL[]="routing";

char TRANSPORT_CHANNEL[]="transport";

char HASHMAP_CHANNEL[]="hashmap";

SendInfo.h

enum

{

SEND_BUFFER_SIZE=128

};

typedef struct sendInfo{

pack packet;

uint16_t src;

uint16_t dest;

}sendInfo;

int main()

{

printf("Hello World");

return 0;

}

SoketStore.h

enum{

MAX_NUM_OF_SOCKETS = 10,

ROOT_SOCKET_ADDR = 255,

ROOT_SOCKET_PORT = 255,

SOCKET_BUFFER_SIZE = 128,

};

enum socket_state{

CLOSED,

LISTEN,

ESTABLISHED,

SYN_SENT,

SYN_RCVD,

};

typedef nx_uint8_t nx_socket_port_t;

typedef uint8_t socket_port_t;

// socket_addr_t is a simplified version of an IP connection.

typedef nx_struct socket_addr_t{

nx_socket_port_t port;

nx_uint16_t addr;

}socket_addr_t;

// File descripter id. Each id is associated with a socket_store_t

typedef uint8_t socket_t;

// State of a socket.

typedef struct socket_store_t{

uint8_t flag;

enum socket_state state;

socket_port_t src;

socket_addr_t dest;

// This is the sender portion.

uint8_t sendBuff[SOCKET_BUFFER_SIZE];

uint8_t lastWritten;

uint8_t lastAck;

uint8_t lastSent;

// This is the receiver portion

uint8_t rcvdBuff[SOCKET_BUFFER_SIZE];

uint8_t lastRead;

uint8_t lastRcvd;

uint8_t nextExpected;

uint16_t RTT;

uint8_t effectiveWindow;

}socket_store_t;

type.h

enum{

AM_FLOODING=10

};

Related Questions

Navigate

• Browse (All)
• Browse F
• Subjects

---

---

Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.