1.

INTRODUCTION

With the advent of technology & its use in every sphere of life, demand of high speed
communication networks has increased. So to makeup with this demand there is an upsurge
in applying code division multiple access (CDMA) technique to optical networks in parts. As
the Optical CDMA (OCDMA) offers higher security, flexibility & simplicity of network
control.

In conventional CDMA each user is assigned a unique spreading code which is used
to spread the data & same is used by user to distinguish his data from the data of other users
which is spreaded by other code & these codes are orthogonal codes. In Optical CDMA
(OCDMA), On-Off Keying (OOK) modulation scheme is used, which is similar to binary
unipolar encoding {0, 1}. These spreading codes are termed Optical Orthogonal Codes
(OOC). As in case of wireless communication, the spreading has been carried in time domain
only these are known as One-Dimensional OOCs (1-D OOCs).

1-D OOCs has a drawback that it requires large chip rate. For example, consider a
network of 8 users out of which 5 are active at a time & each is transmitting data at 1Gbit/sec.
if we design such a system to meet the mentioned requirement with 1-D OOC we will end up
with a chip-rate of the order of 162Gigachips/sec (162 Gcps). But using a 2-D OOC by
spreading in both time & wavelength above system can be designed with the need of just
6Gigachips/sec (6 Gcps.)

In the next section we will discuss about the bounds on the size of 1-d codes & a bit
about code construction techniques related to bounds. Later we will introduce 2-D OODs &
the bounds on the size of 2-d codes. Also we will introduce new code construction technique
based on the use of rational functions. Later we show the Matlab simulation result of auto-
correlation & cross-correlation of 2-D OOC [1].

- 19 -
2. One-Dimensional Optical Orthogonal Codes

A family of {0,1}– sequences of length n & Hamming weight w can be defined as an

(n , w ,k ) Optical Orthogonal Code (OOC) C where 1 ≤ k ≤ w ≤ n .

n −1

∑ x ( i ) y (i ⊕n τ )≤ k
i=0

For every pair of sequence {x , y } in C whenever x ≠ y or

τ ≠ 0. We have used ⊕n to denote addition modulon . & k as the maximum collision parameter

(MCP).

LetΦ (n , w , k ), denotes the largest possible cardinality of an (n , w ,k ) Optical

Orthogonal Code (OOC) [1].

2.1 Bounds on the size of 1-D OOCs

If C is an (n , w ,k ) 1-D OOC, then by including every cyclic shift of each codeword in C we

can construct a constant weight code with parameter (n , w ,k ) of size¿ n∨C∨¿. This fact
allows us to improved Johnson bounds ( J A , J B , J C ) for constant weight codes[1, 6]. The
bounds are:

1. Johnson bound A:

1 n−1 n−k
Φ ( n , w ,k ) ≤ ⌊ ⌊ ………⌊ ⌋ ⌋ ⌋ :=J A ( n , w , k ) .
w w−1 w−k

2. Improved Johnson bound B:Provided w 2> nk

w−k
Φ ( n , w ,k ) ≤ min ⁡( 1 , ⌊ ⌋) :=J B ( n , w , k ) .
w2−nk

3. Improved Johnson bound C:

- 19 -
 1 n−1 n−( l−1 )
Φ ( n , w ,k ) ≤ ⌊ ⌊ ………⌊ h ⌋ … ⌋ ⌋ :=J C ( n , w , k ) .
w w−1 w−( l−1 )

( n−l ) ( w−k )
Where h=min n−l , ⌊ ( ( w−l )2−( n−l )( k −l ) )
⌋ . & l is integer, 1 ≤l ≤ k−1 , such that

( w−l )2 > ( n−l )( k −l ) .

As Φ ( n , w ,k ) is the largest possible size of a 1-D OOC, an OOC C of size P is said to be

 Optimal when P=Φ ( n , w , k ) and

P
 Asymptotically optimal when lim ¿n →∞ =1 ¿.
Φ (n , w , k )

3. Need for 2-D OOC

We have large literature to generate 1-D OOCs & Optimum constructions are known only for
k =1 and k = 2. Most of them only uses of Johnson bound A. some may not be satisfying
Johnson bound A, but they are found optimal w.r.t. Johnson bound B[6].

Example: Consider a network of 8 users out of which 5 users are active at any
instance of time. Assuming the data transmission rate of 1Gbit/sec for each active user[1].

Designing with 1-D OOC: A natural attempt at meeting this requirement might be to
set the maximum-collision parameter (MCP) k equal to 1 and set w=5>(5−1)k where (5-
1)k, represents the maximum possible interference presented by the 4 other active users under
a uniform power assumption. When w=5 and k =1 , the Johnson bound A yields

1 n−1 n−k
Φ ( n , w ,k ) ≤ ⌊ ⌊ ………⌊ ⌋ ⌋ ⌋ :=J A ( n , w , k ) .
w w−1 w−k

1 n−1 n−1
Φ ( n , 5,1 ) ≤ ⌊ ⌊ ⌋⌋≤
w w−1 w(w−1)

From which it follows that

- 19 -
n−1>8 x 5 x 4

Orn>161. So the required chip-rate must necessarily equal or exceed 162 G chips per
second (Gcps) which is currently infeasible to implement. Even if it were feasible to
implement, the chip-rate is still large in relation to the data rate supplied to each user.

Designing with 2-D OOC: By spreading in both wavelength and time, this chip-rate
requirement can be reduced substantially to 6 G chips/sec.

4. Two-Dimensional Optical Orthogonal Codes

The advent of Wavelength-Division-Multiplexing (WDM) and dense-WDM (DWDM)

technology has made it possible to spread in both wavelength and time [34]. The corresponding
codes, are variously called, wavelength-time hopping codes, and multiple-wavelength codes.
Here we will refer to these codes as two- dimensional OOCs (2-D OOCs).

A 2-D (WxT , w , k ) OOC C is a family of {0,1}(WxT ) arrays of constant weight w.

Every pair { A , B } of arrays in C is required to satisfy:

W T −1

∑ ∑ A ( λ , t ) B ( λ ,(t ⨁T τ ¿ ))≤ k ¿
λ=1 t=0

Where either A=B ort=0. We will refer to k as the maximum collision parameter
(MCP). Note that asynchronism is present only along the time axis.

It can be shown that it is possible to construct a 2-D (WxT =6 x 6 , w=5 , k=1) OOC
of size 8. Figure below shows such a 2-D OOC. Thus in comparison with the earlier 1-D
OOC of above Example which required a chip-rate in excess of 162 Gcps, with this 2-D code,
one can accommodate the same number of users with a chip rate of 6 G-chips per second
(Gcps).

- 19 -
 A
(6 x 6,5,1) 2-D OOC. In this figure each row shows a different wavelength, and each column
is a different chip time.**the above shown codes are [AM-OPPW] .ref.[1]

4.1 Practical restrictions

Practically we considerations following restrictions on the placement of pulses within an

array. And termed them as:

 Arrays with one-pulse per wavelength (OPPW): each row of every (WxT )code
array in C is required to have Hamming weight = 1.
 Arrays with at most one-pulse per wavelength (AM-OPPW): here each row of any
(WxT ) code in C is required to have Hamming weight < 1.
 Arrays with one-pulse per time slot (OPPTS): here each column of every (WxT )
code array in C is required to have Hamming weight = 1.
 Arrays with at most one-pulse per time slot (AM-OPPTS): here each column of any
(WxT ) array in C is required to have Hamming weight < 1.

- 19 -
4.2 Optical correlator for 2-D OOC

The optical correlator can be implemented as shown in this figure.

**above code satisfies both the AM-OPPW and AM-OPPTS restrictions. ref. [1]

 Left 4 x 4 matrix represents a 2-D OOC.

 4 rectangular blocks represents optical correlator.

 Right side is received output time aligned

Each rectangular box represents an optical filter implemented using a fiber-Bragg

grating or an optical micro-resonator. This filter reflects light of the wavelength shown
alongside the box and allows light of all other wavelengths to pass through.

Filters placed further along the reflection path will suffer an increased delay and in
this manner, the placement of the filters can be adjusted to bring the pulses of all the different
wavelengths in the desired code matrix into time alignment at the output of the correlator.

- 19 -
4.3 Bounds on the Size of a 2-D OCDMA Code

For a given set of values of W , T , w , k , let Φ ( WxT , w , k ) denote the largest possible
cardinality of a ( W , T , w , k ) 2-D OOC code[1, 6]. We define optimal and asymptotically
optimum 2-D OOCs as was done in the case of 1-D OOCs in Section 2.1 of this report.

4.3.1 Johnson bound

If C is a (WxT , w , k ) 2-D OOC, then by including every column-cyclic shift of each

codeword in C one can construct a constant weight code using any mapping that reorders the
elements of a WxT array to form a 1-D string of length WT . The resultant constant weight
code has parameters (WT , w , k ¿ and size =T ∨C∨¿. This observation allows us to translate
bounds on constant weight codes to bounds on 2-D OOCs as it is done in Section 2.1.

These referred as Johnson Bound for unrestricted 2-D OOCs.

4. Johnson bound A:

W WT −1 WT −k
Φ ( WxT , w , k ) ≤ ⌊ ⌊ ……… ⌊ ⌋ ⌋ ⌋ :=J A ( WxT , w , k ) .
w w−1 w−k

5. Improved Johnson bound B: Provided w 2> nk

W (w−k )
Φ ( WxT , w , k ) ≤ min ⁡(W , ⌊ ⌋ ):=J B (WxT , w , k ) .
w 2−WT k

6. Improved Johnson bound C:

W WT −1 WT − (l−1 )
Φ ( WxT , w , k ) ≤ ⌊ ⌊ ……… ⌊ h ⌋ … ⌋ ⌋ :=J C ( WxT , w , k ) .
w w−1 w−( l−1 )

( WT −l ) ( w−k )
(
Where h=min WT −l, ⌊
( w−l )2− (WT −l )( k −l ) )
⌋ . & l is integer, 1 ≤l ≤ k−1 ,

Such that ( w−l )2 > ( WT −l ) ( k−l ) . [1, 6].

- 19 -
Theorem 1. When n=WT the bound J i, i∈ { A , B , C } on the size of a (WT , w , k ) 2-D OOC
satisfies the following inequality compared to the bound on the size of (WT , w , k ) 1-D OOC:

W J i (WT , w , k ) ≤ J i ( WxT , w , k ) ≤ W J i ( WT , w , k ) +( W −1)

where J i( WT , w ,k ) denotes the upper bound for 1-D OOC stated in equations (1),(2),(3),
and Ji(WxT,w,k) denoted the upper bound for 2-D OOC stated in equations (4),(5),(6).

**By going to 2-D case, we gain an increase in family size by a factor of Λ.

5. 2-D OOC Code Construction using Rational Functions

A 2-D OOC can be regarded as the graph of a function W =f ( t ) , 0< t<T −1 , 0<W <W =1 ,

mapping time into wavelength or vice-versa,t=f ( λ). We define an operator Sτ such that

Sτ (•, f (•)), is a τ unit cyclic shifted version of the graph,( • , f ( •) ), along the time axis, t.

This definition shows that the construction is a valid OOC with MCP equal to k

If the equation Sτ ( x , f ( x ) )=( x , f ( x )) has maximum k solutions for any f and g when either

f ≠ g orτ ≠ 0.

5.1 Rational Function Construction

Here we use rational functions over GF ( q )to construct 2-D OOCs[2]. The no of rational

f (x )
functions over GF ( q )is given by c ( t ) , if is satisfying following conditions:
g ( x)

 f and g are both nonzero and of degree ≤ t ,

 f and g are relatively prime,

f (x )
 ≠ a ,for any a (integer) and
g ( x)

- 19 -
  f is monic.

& c ( t ) is given as

2 t−1
c ( t ) = q 2−q , t=1,2,3,4,5,6
{ ≥ q −q2 t −6 /7 ,t ≥ 7
t+1

The above conditions guaranteed that each function is counted only once.

f (x )
*in this counting we have discarded the constant rational functions =constant . Two
g ( x)

elements [ ab] ,[ dc ] are equal provided there exist an element n such that[ ab]=n[ dc ].
Theorem 2. If f ( x )=x 2 +a1 x+ a0 with a 1 , a0 ∈GF (q) is a primitive polynomial overGF ( q ),

0 −a0
Then Γ = [ 1 −a1 ]
is a matrix having the property that the smallest exponent i for which

Γ [a , b] =n[a , b] for somen ∈GF ( q ), is i=( q +1 ) .

i t t

It follows that the elements of P1 ( GF ( q ) ) can be arranged so as to form an orbit of size

(q + l):

P1 ( GF ( q ) )= Γ i a i=0,1 , … , q ; a ∈ P1 ( GF ( q ) )
{ [ ]|
b []
b }

5.1.1 Construction

Mapping Wavelength to Time, T =q+ 1, q a Power of a Prime:

Let1<W < q, and W ϵ some subset of GF (q) of sizeW . Here we consider rational functions

f (λ)
t
g ( λ) mapping wavelength into time. Associate to each time slot t, the th element of a cyclic
representation of P1 (GF ( q)). Let us define:

- 19 -
 Where, given a rational function, the operator N divides out the common factors
between numerator and denominator and in addition, scales the two so as to make the
numerator monic[1, 2, 4].

Considering f and g are relatively prime, anda 0 ≠ 0, it is obvious that the operator Nresults in
some rational function which satisfies the conditions of section 5.

We need to discard all rational functions which are of the form:

We note that such a rational function doesn't exist since it means that for certain

for some 0< k <q which

is impossible by Theorem 2. Amongst the functions satisfying the conditions of section 5, we

have discarded all constant functions, but as this step is unnecessary here, we can add them
back.

For any0< k <q , we declare two rational functions to be

equivalent. Then the different code matrices correspond to choosing precisely one polynomial

from each equivalence class. For each polynomial f ( . ) the ( WxT ) code array C is given by

'
. This results in a ( Wx ( q+1 ) , W , 2 k ) 2-D OOC with

c (k )'
size, +1and k =2 k ' ≤ W ≤ q .
q+1

Mapping Time to Wavelength, Λ=q+1 , q a Power of a Prime:

Let T ∨(q−1), and βϵGF (q)have multiplicative orderT . Take the wavelengths as

P 1(GF (q))(the order of elements doesn't matter). Here we consider rational functions

- 19 -
mapping time into wavelength. Let us associate to time slott, the element β t . We define two

Fk
rational functions in to be equivalent if

f ( x)
for some . First discard all rational functions g ( x )

which satisfy = for i≠ 0 . The number of remaining

rational functions is computed in[4] as: .

Choosing one function from each of the remaining equivalence classes and

associating to it, the ( WxT ) code array C by letting

where and

results in a 2-D OOC of size

[1, 2, 4].

6. Simulation

We verify the auto-correlation & cross-correlation properties of 2-D OOC codes by using
MATLAB .The two codes are chosen form the 8 codes shown earlier in this report.
Simulation is done two parts 1.corconv.m to find convolution. & 2.ocdma.m to generate
code, correlate & plot them.

This is represented as matrix as

1 0 0 0 0 0

code1=
0
1
1
1
1
[ 0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
]
0 0 0 0 1 0

code5=
0
0
1
0
0
[ 0
0
0
0
0
0
0
0
1
0
0
0
0
0
0
0
0
0
0
0
1
0
0
0
1
] - 19 -
ref. [1]

**Vertical columns are representing time slot & horizontal rows are representing
wavelengths

**other 6 codes are generated in the same manner.

6.1 Simulation result

- 19 -
 The 8 figures are correlation of code1 with code1 to code8 resp.

- 19 -
6.2 Matlab code

circonv.m
function[C] = circonv(A,B,N)
if nargin~=3,
error('CIRCONV uses exactly 3 input arguments');
end
if N<=0,
error('N must be great than zero.');
end
if size(A,2)>1,
A=A';
end
if size(B,2)>1,
B=B';
end

- 19 -
if N>length(A),
A=[A ; zeros(N-length(A),1)];
end
if N>length(B),
B=[B ; zeros(N-length(B),1)];
end
A = A(1:N);
B = B(1:N);
FoldAddTable = A*B';
FoldAddTable = fliplr(FoldAddTable);
C=zeros(1,N);
C(N) = sum( diag(FoldAddTable,0) );
for x=1:(N-1),
C(x)= sum( diag(FoldAddTable, N-x) ) + sum( diag(FoldAddTable, -x) );
end

ocdma.m
clear all
clc
size=15;
%% code1
code11=zeros(1,6);code11(1,1)=1;
code12=zeros(1,6);
code13=zeros(1,6);code13(1,1)=1;
code14=zeros(1,6);code14(1,1)=1;
code15=zeros(1,6);code15(1,1)=1;
code16=zeros(1,6);code16(1,1)=1;
code1=[code11;code12;code13;code14;code15;code16];
%% icode1
icode11=fliplr(code11);
icode12=fliplr(code12);
icode13=fliplr(code13);
icode14=fliplr(code14);
icode15=fliplr(code15);
icode16=fliplr(code16);
icode1=fliplr(code1);
%% code2
code21=zeros(1,6);code21(1,5)=1;
code22=zeros(1,6);code22(1,2)=1;
code23=zeros(1,6);code23(1,6)=1;
code24=zeros(1,6);code24(1,3)=1;
code25=zeros(1,6);
code26=zeros(1,6);code26(1,4)=1;
code2=[code21;code22;code23;code24;code25;code26];

- 19 -
%% icode2
icode21=fliplr(code21);
icode22=fliplr(code22);
icode23=fliplr(code23);
icode24=fliplr(code24);
icode25=fliplr(code25);
icode26=fliplr(code26);
icode2=fliplr(code2);
%% code3
code31=zeros(1,6);code31(1,6)=1;
code32=zeros(1,6);code32(1,4)=1;
code33=zeros(1,6);code33(1,3)=1;
code34=zeros(1,6);code34(1,2)=1;
code35=zeros(1,6);code35(1,1)=1;
code36=zeros(1,6);
code3=[code31;code32;code33;code34;code35;code36];
%% icode3
icode31=fliplr(code31);
icode32=fliplr(code32);
icode33=fliplr(code33);
icode34=fliplr(code34);
icode35=fliplr(code35);
icode36=fliplr(code36);
icode3=fliplr(code3);
%% code4
code41=zeros(1,6);
code42=zeros(1,6);code42(1,6)=1;
code43=zeros(1,6);code43(1,1)=1;
code44=zeros(1,6);code44(1,5)=1;
code45=zeros(1,6);code45(1,2)=1;
code46=zeros(1,6);code46(1,3)=1;
code4=[code41;code42;code43;code44;code45;code46];
%% icode4
icode41=fliplr(code41);
icode42=fliplr(code42);
icode43=fliplr(code43);
icode44=fliplr(code44);
icode45=fliplr(code45);
icode46=fliplr(code46);
icode4=fliplr(code4);
%% code5
code51=zeros(1,6);code51(1,5)=1;
code52=zeros(1,6);code52(1,6)=1;
code53=zeros(1,6);

- 19 -
code54=zeros(1,6);code54(1,1)=1;
code55=zeros(1,6);code55(1,3)=1;
code56=zeros(1,6);code56(1,6)=1;
code5=[code51;code52;code53;code54;code55;code56];
%% icode5
icode51=fliplr(code51);
icode52=fliplr(code52);
icode53=fliplr(code53);
icode54=fliplr(code54);
icode55=fliplr(code55);
icode56=fliplr(code56);
icode5=fliplr(code5);
%% code6
code61=zeros(1,6);code61(1,1)=1;
code62=zeros(1,6);
code63=zeros(1,6);ode63(1,5)=1;
code64=zeros(1,6);code64(1,6)=1;
code65=zeros(1,6);code65(1,4)=1;
code66=zeros(1,6);code66(1,2)=1;
code6=[code61;code62;code63;code64;code65;code66];
%% icode6
icode61=fliplr(code61);
icode62=fliplr(code62);
icode63=fliplr(code63);
icode64=fliplr(code64);
icode65=fliplr(code65);
icode66=fliplr(code66);
icode6=fliplr(code6);
%% code7
code71=zeros(1,6);code71(1,3)=1;
code72=zeros(1,6);
code73=zeros(1,6);code73(1,2)=1;
code74=zeros(1,6);code74(1,4)=1;
code75=zeros(1,6);code72(1,5)=1;
code76=zeros(1,6);code76(1,1)=1;
code7=[code71;code72;code73;code74;code75;code76];
%% icode7
icode71=fliplr(code71);
icode72=fliplr(code72);
icode73=fliplr(code73);
icode74=fliplr(code74);
icode75=fliplr(code75);
icode76=fliplr(code76);
icode7=fliplr(code7);

- 19 -
%% code7
code71=zeros(1,6);code71(1,3)=1;
code72=zeros(1,6);
code73=zeros(1,6);code73(1,2)=1;
code74=zeros(1,6);code74(1,4)=1;
code75=zeros(1,6);code72(1,5)=1;
code76=zeros(1,6);code76(1,1)=1;
code7=[code71;code72;code73;code74;code75;code76];
%% code8
code81=zeros(1,6);code81(1,2)=1;
code82=zeros(1,6);code82(1,1)=1;
code83=zeros(1,6);code83(1,4)=1;
code84=zeros(1,6);
code85=zeros(1,6);code84(1,6)=1;
code86=zeros(1,6);code86(1,5)=1;
code8=[code81;code82;code83;code84;code85;code86];
%% icode8
icode81=fliplr(code81);
icode82=fliplr(code82);
icode83=fliplr(code83);
icode84=fliplr(code84);
icode85=fliplr(code85);
icode86=fliplr(code86);
icode8=fliplr(code8);
%% autocorelation code1 & code1
ac_code11=circonv(code11,icode11,size);
ac_code12=circonv(code12,icode12,size);
ac_code13=circonv(code13,icode13,size);
ac_code14=circonv(code14,icode14,size);
ac_code15=circonv(code15,icode15,size);
ac_code16=circonv(code16,icode16,size);
ac_code1=sum([ac_code11;ac_code12;ac_code13;ac_code14;ac_code15;ac_code16]);
figure,plot(ac_code1);
axis([0,12,0,6]);
title('autocorelation of code1 with code1');
xlabel('time');ylabel('corelated output');
%% crosscorelation code1 & code2
ac_code21=circonv(code11,icode21,size);
ac_code22=circonv(code12,icode22,size);
ac_code23=circonv(code13,icode23,size);
ac_code24=circonv(code14,icode24,size);
ac_code25=circonv(code15,icode25,size);
ac_code26=circonv(code16,icode26,size);
ac_code2=sum([ac_code21;ac_code22;ac_code23;ac_code24;ac_code25;ac_code26]);

- 19 -
figure,plot(ac_code2);
axis([0,12,0,6]);
title('autocorelation of code1 with inverted code2');
xlabel('time');ylabel('corelated output');
%% crosscorelation code1 & code3
ac_code31=circonv(code11,icode31,size);
ac_code32=circonv(code12,icode32,size);
ac_code33=circonv(code13,icode33,size);
ac_code34=circonv(code14,icode34,size);
ac_code35=circonv(code15,icode35,size);
ac_code36=circonv(code16,icode36,size);
ac_code3=sum([ac_code31;ac_code32;ac_code33;ac_code34;ac_code35;ac_code36]);
figure,plot(ac_code3);
axis([0,12,0,6]);
title('autocorelation of code1 with inverted code3');
xlabel('time');ylabel('corelated output');
%% crosscorelation code1 & code4
ac_code41=circonv(code11,icode41,size);
ac_code42=circonv(code12,icode42,size);
ac_code43=circonv(code13,icode43,size);
ac_code44=circonv(code14,icode44,size);
ac_code45=circonv(code15,icode45,size);
ac_code46=circonv(code16,icode46,size);
ac_code4=sum([ac_code41;ac_code42;ac_code43;ac_code44;ac_code45;ac_code46]);
figure,plot(ac_code4);
axis([0,12,0,6]);
title('autocorelation of code1 with inverted code4');
xlabel('time');ylabel('corelated output');
%% crosscorelation code1 & code5
ac_code51=circonv(code11,icode51,size);
ac_code52=circonv(code12,icode52,size);
ac_code53=circonv(code13,icode53,size);
ac_code54=circonv(code14,icode54,size);
ac_code55=circonv(code15,icode55,size);
ac_code56=circonv(code16,icode56,size);
ac_code5=sum([ac_code51;ac_code52;ac_code53;ac_code54;ac_code55;ac_code56]);
figure,plot(ac_code5);
axis([0,12,0,6]);
title('autocorelation of code1 with inverted code5');
xlabel('time');ylabel('corelated output');
%% crosscorelation code1 & code6
ac_code61=circonv(code11,icode61,size);
ac_code62=circonv(code12,icode62,size);
ac_code63=circonv(code13,icode63,size);

- 19 -
ac_code64=circonv(code14,icode64,size);
ac_code65=circonv(code15,icode65,size);
ac_code66=circonv(code16,icode66,size);
ac_code6=sum([ac_code61;ac_code62;ac_code63;ac_code64;ac_code65;ac_code66]);
figure,plot(ac_code6);
axis([0,12,0,6]);
title('autocorelation of code1 with inverted code6');
xlabel('time');ylabel('corelated output');
%% crosscorelation code1 & code7
ac_code71=circonv(code11,icode71,size);
ac_code72=circonv(code12,icode72,size);
ac_code73=circonv(code13,icode73,size);
ac_code74=circonv(code14,icode74,size);
ac_code75=circonv(code15,icode75,size);
ac_code76=circonv(code16,icode76,size);
ac_code7=sum([ac_code71;ac_code72;ac_code73;ac_code74;ac_code75;ac_code76]);
figure,plot(ac_code7);
axis([0,12,0,6]);
title('autocorelation of code1 with inverted code7');
xlabel('time');ylabel('corelated output');
%% crosscorelation code1 & code8
ac_code81=circonv(code11,icode81,size);
ac_code82=circonv(code12,icode82,size);
ac_code83=circonv(code13,icode83,size);
ac_code84=circonv(code14,icode84,size);
ac_code85=circonv(code15,icode85,size);
ac_code86=circonv(code16,icode86,size);
ac_code8=sum([ac_code81;ac_code82;ac_code83;ac_code84;ac_code85;ac_code86]);
figure,plot(ac_code8);
axis([0,12,0,6]);
title('autocorelation of code1 with inverted code8');
xlabel('time');ylabel('corelated output');
% crosscorelation of code1 with code2 - code8 is completed

7. Conclusion

We have studied about bounds on the size of codes in 1-D & 2-D OOC & compare
them with suitable example. In 1-D the required chip size is very large but the same
requirement can be fulfilled at very low chip rate by using 2-D OOC, Not only the chip rate is
reduced but the size of code family also increases.

- 19 -
 Various algorithms have been proposed for the generation of 2-D OOC, But are
incapable of determining all the possible codes that are given by Johnson’s bounds.

We are required to find a generalized scheme which can determine all the possible
combinations of 2-D orthogonal codes for a given values of( n , w , k ).

- 19 -