Convolution decoding using viterbi algorithm in unetstack - viterbi

Question

I have tried to implement convolution decoding using Viterbi algorithm in unetstack. However, there are some issues that I am facing.
The data is not getting sent to node 2. (arr - line 43 of MulAgent.groovy )
In some cases getting an error-
groovy.lang.MissingMethodException:No signature of method:Script2.send() is applicable for argument types:(java.lang.Integer, java.lang.Integer)
values: [2,1010]
//where 2, 1010 are the input values that we are giving
mul-sim.groovy(first file that opens and asks for input of data)
import org.arl.fjage.Message
import org.arl.unet.*
import org.arl.mac.*
import org.arl.unet.phy.*
import org.arl.fjage.RealTimePlatform
println'''
OUTPUT TABLE
+----+----------+----------+
| | 0 | 1 |
+----+----------+----------+
| a | 00(a) | 11(b) |
+----+----------+----------+
| b | 10(c) | 01(d) |
+----+----------+----------+
| c | 11(a) | 00(b) |
+----+----------+----------+
| d | 01(c) | 10(d) |
+----+----------+----------+ '''
println '''
2-node network to perform sender - receiver operation
-----------------------------------------
Node 1 will send an encoded value to node 2
The agent MulAgent present at node 2, will decode the received data and send the value to node 1 checking
You can interact with node 1 in the console shell. For example, try:
send <to-address> , < data>
For example:
send 2, 1011
When you are done, exit the shell by pressing ^D or entering:
shutdown
'''
platform = RealTimePlatform
// run simulation forever
simulate {
node '1', address: 1, remote: 1101, location: [0, 0, 0], shell: true, stack: { container ->
container.shell.addInitrc "${script.parent}/fshrc.groovy"
}
node '2', address: 2, remote: 1102, location: [1.km, 0, 0], shell:5102, stack: { container ->
container.add 'mul', new MulAgent()
}
}
MulAgent.groovy( Agent file
//Agent for the program that contains the decoding code
import org.arl.fjage.Message
import org.arl.unet.*
import org.arl.mac.*
class MulAgent extends UnetAgent {
final static int PROTOCOL = Protocol.DATA
int received_data
int new_data
def arr = new int[4][2]
def temp = new int[2]
def code=new int[4][2]
int i
int k
int j = 0
int error_bit;
int column_error = 0
int row_error = 0
int m = 4
int n = 4
int count
void startup() {
def phy = agentForService Services.PHYSICAL
subscribe topic(phy)
}
void processMessage(Message msg) {
if (msg instanceof DatagramNtf && msg.protocol == PROTOCOL)
{
for(i=0;i<2;i++)
{
temp[i] = msg.data[i]
println "Recieved data printing in Agent is ${temp[i]}"
}
for(i=0;i<2;i++)
arr[j][i] = temp[i];
println "Array in Agent is ${arr}}"
println "Recieved data printing in Agent is ${temp}"
println "Recieved total data printing in Agent is ${temp}"
send new DatagramReq(recipient: msg.sender,to: msg.from, protocol: Protocol.MAC, data: arr[j])
j++
// start
/*******************************************************************/
/* /
/ convolution decoding using viterbi /
/ ------------------------------------------ /
/ Step 1: take input as the encoded dataword /
/ Step 2: Sub module to calculate hamming distance /
/ Step 2: code for decoding using viterbi algorithm */
/*******************************************************************/
code=arr;
int state[]=[0,,0,0,0,0,0,0] //state
int mem[]=[0,0,0,0,0,0,0,0,0,0] //memory
int path=0; //path matrix
//int data[]=[1,1,0,1]
int n,l;
for (int j=0;j<4;j++)
{ for(int i=8;i>=0;i--)
{ mem[i+i]=mem[i]; //shifting by one bit
}
for (int i=0;i<8;i++)
{ state[i]=mem[i];
}
//disp(mem);
state[i]=0; //introduce 0
mem[i]=0;
// to calculate the hamming distance
int out1=((mem[1]^mem[2]^mem[4]^mem[5]^mem[6]^mem[7]^mem[8])^ ((mem[1]^mem[2]^mem[3]^mem[5]^mem[6]^mem[7]^mem[8])); //disp(out1); //output with 0
state[i]=1; //introduce 1
mem[i]=1;
int out2=((mem[1]^mem[2]^mem[4]^mem[5]^mem[6]^mem[7]^mem[8])^ ((mem[1]^mem[2]^mem[3]^mem[5]^mem[6]^mem[7]^mem[8]));
int l=(code[j][0]^out1)+(code[j][1]^out)); //hamming distance with out1
int m=(code[j][0]^out2)+(code[j][1]^out2)); //hamming distance with out2
if(l<m) { //consider with minimum hamming distance
path=path+l;
state[1]=0;
mem[1]=0;
data[j]=0;}
else
{ path=path+m;
data[j]=1;
}
if(l<m)
{ path=path+l;
decode[k]=0;}
else if(l>m)
{ path=path+m;
decode[k]=1;
}
println"path value =$path"
int code=data;
}
def codew=new int[4][2]
codew=code;//detecting 0 bit error
int correct=0;
int detect=0;
int n;
for(i=0;i<2;i++)
if(codew[i][j])
codew[i][j]=0;
for(int i=0;i<4;i++)
if(path!=0) //one error detected
{ if(y==codew) //corrected
{ correct=correct+1;
detect=detect+1;
}
}
if(path!=0) //detected
{ if(y!=codew) //not corrected
{ detect=detect+1;
}
}
n++;
if(codew[i][j])
codew[i][j]=0;
else
codew[i][j]=1;
}
if(detect==0)
println"detection completed"
println"$code"
else if(detect!=0)
println"detection completed"
println"$code"
}
}
fshrc.groovy (the received word is encoded and sent for decoding)
import org.arl.unet.*
import org.arl.unet.phy.*
import org.arl.unet.*
import org.arl.unet.phy.*
import org.arl.unet.mac.*
//import org.arl.unet.nodeinfo.NodeInfo
//import org.arl.unet.PDU
import org.arl.fjage.*
//import static org.arl.unet.Services.*
//import static org.arl.unet.phy.Physical.*
subcribe phy
send = { addr, value ->
println "sending $value to node $addr"
def y= new int[4];
def a=new int[4];
a=[1, 1, 1, 1]
y=[0, 0, 0, 0]
int i=3
println "$value"
int x=value;
while(x!=0)
{
y[i]=x%10;
println "$y"
x=x/10;
i--;
}
def code=new int[4][2];
/*code word encoded using generator functions
g1=1101
g2=1110
*/
for(i=0;i<4;i++)
{
int bit = y[3-i];
a[3-i] = bit;
code[i][0] = a[0]^a[1]^a[3];
code[i][1] = a[0]^a[1]^a[2];
}
println"The 4 bit encoded codeword:"
//The code word is printed
println"$code"
//println "sending ${value[0]} to node $addr "
phy << new DatagramReq(to: addr, protocol: Protocol.DATA, data: code[0])
def txNtf1= receive(TxFrameNtf, 1000)
def rxNtf1 = receive({ it instanceof RxFrameNtf && it.from == addr}, 5000)
if (txNtf1 && rxNtf1 && rxNtf1.from == addr)
println "Data Received at ${rxNtf.to} from ${rxNtf.from} is: ${rxNtf.data}"
//println "sending ${value[1]} to node $addr "
phy << new DatagramReq(to: addr, protocol: Protocol.DATA, data: code[1])
def txNtf2 = receive(TxFrameNtf, 1000)
def rxNtf2 = receive({ it instanceof RxFrameNtf && it.from == addr}, 5000)
if (txNtf2 && rxNtf2 && rxNtf2.from == addr)
println "Data Received at ${rxNtf2.to} from ${rxNtf2.from} is: ${rxNtf2.data}"
// println "sending ${value[2]} to node $addr "
phy << new DatagramReq(to: addr, protocol: Protocol.DATA, data: code[2])
def txNtf3 = receive(TxFrameNtf, 1000)
def rxNtf3 = receive({ it instanceof RxFrameNtf && it.from == addr}, 5000)
if (txNtf3 && rxNtf3 && rxNtf3.from == addr)
println "Data Received at ${rxNtf3.to} from ${rxNtf3.from} is: ${rxNtf3.data}"
//println "sending ${value[3]} to node $addr "
phy << new DatagramReq(to: addr, protocol: Protocol.DATA, data: code[3])
def txNtf4 = receive(TxFrameNtf, 1000)
def rxNtf4 = receive({ it instanceof RxFrameNtf && it.from == addr}, 5000)
if (txNtf4 && rxNtf4 && rxNtf4.from == addr)
println "Data Received at ${rxNtf4.to} from ${rxNtf4.from} is: ${rxNtf4.data}"
}