Hướng nghiên cứu trong tương lai

Một số các nhiệm vụ sau đây sẽ được thực hiện trong tương lai nhằm củng cố cho các phần đã thảo luận của luận văn này:

• Đo đạc hiệu suất của anten khi anten bị biến đổi về hình dáng và kích thước.

• Tiến hành các thực nghiệm để tối ưu hình dạng và kích thước của anten, phân tập anten thẻ và đặc tính của fading nhỏ trong các hệ thống tag RF.

TàI LIệU THAM KHảO Tiếng Việt

[1] Phan Anh: Lý thuyết anten, NXB Khoa học Kỹ thuật, Hà Nội 1997.

[2] Trần Minh Tuấn: Ứng dụng phương pháp moment trong bài toán phân tích các kết cấu điện từ phẳng được kích thích bởi sóng chạy, Luận văn tiến sỹ. ĐH Bách Khoa Hà Nội, 2004.

Tiếng Anh

[3] Bill Glover, Himanshu Bhatt (2006), RFID essentials. O’ Reilly Media, Inc.

[4] Centurion Wireless Technologies Inc. (2000), “Guidelines for wireless device antenna systems”.

[5] Edwards R. J. (1997), “RJELOOP3.EXE”.

[6] Fockens T.W.H., NEDAP R&D (2000). “Inductive Identification systems Simulator (IISim), calculation of activation and read distances of ID-systems according regular limits Version 1.1”. The Netherlands

[7] Gang Wang, Johan Siden, Peter Jonsson, Torbjorn Olsson (2002). “RFID antenna investigation at ITM department MID Sweden University”.

[8] Hongil Kwon, Bomson Lee (2005), “Meander line RFID tag at UHF band evaluated with Radar cross sections”. Kyung Hee University.

[9] Joshua David Griffin (2005), “A radio assay for the study of RFID tag antenna performance”. A thesis, Georgia Institue of Technology.

[10] Klaus Finkenzeller (2003), RFID handbook: Fundamentals and applications in Contactless smart cards and Identification. Wiley; 2 Sub edition.

[11] Markus Laudien. “RFID antenna and system design.ppt”, Ansoft Corp.

[12] Masato Takiguchi, Yoshihide Yamada (2003), “Improvement of radiation efficiencies by applying folded configurations to very small meander line antennas”. National Defense Academy.

[13] Patrick J. Sweeny ll (2005), RFID for dummies. For Dummies.

[14] Pavel V. Nikitin., Rao K.V.S., “Theory and measurement of backscattering from RFID tags”. Intermec Technologies Corporation.

[15] Russell Hornung, Jack Frankosky. “High performance laminate materials for RFID antennas”.Arlon.

[16] Seshagiri Rao K.V., Pavel V. Nikitin., Sander F. Lam. (2005), “Antenna design for UHF RFID tags : A review and a practical application”. IEEE transactions on antennas and propagation, Vol. 53, No. 12.

[17] Steve Moshier (2004),“Inductance calculator V0.4”. Software.

[18] Texas Instruments (2003). “HF antenna design notes, technical application report”. Literature Number: 11-08-26-003.

[19] Xiuping Li (2006), “RFID antenna design.ppt”, Beijing University of Posts and Telecommunications.

[20] Youbok Lee (1999), “MCRF 355/360 Applications. AN707”. Microchip Technology Inc.

[21] Youbok Lee (2003), “Antenna circuit design for RFID applications.

AN710”. Microchip Technology I.

[22] ZBA, Inc. “Antenna design guidelines”.

[23] Zhi Ning Chen (2007), Antennas for portable devices, pp. 59 - 109.

[24] Zeland Software company. IE3D simulation software

PHụ LụC 1. CHƯƠNG TRìNH C TíNH TOáN KHOảNG ĐọC CủA Hệ THốNG RFID TầN Số LF Và HF

#include <stdio.h>

#include <stddef.h>

#include <math.h>

#include <stdlib.h>

#include <string.h>

#define pi 3.1415926

#define c 299792458

#define u0 1.256637061e-6

#define FAIL 0

#define Success 1

#define TRUE 1

#define FALSE 0

#define INTRO \

---

double ActivationDistance_O(double I, double a1, double b1, double Hz1);

double CalcHlabel_O(double m2,double a2,double b2,double z2,int N);

double Calc_m_noise_O(double H_noise,double a2,double b2,double zmax,int N2);

double H_tx_O_z(double I, double a1, double b1, double z1);

double Calc_Vind(double Vchip1, double df1, double *p_Q, double *p_P_chip, double *p_mi);

void tagcalculation(double Q2, double df2, double mi2, double Hzz, double

*p_v_eff2, double *p_g_conv_lsb2, double *p_g_conv_usb2, double

*p_m_sc_lsb2, double *p_m_sc_usb2);

double z1,m_tx,m,m_carrier,I_tx,P_tx,Hnoise_tx,sb_factor,Hnoise_tx_dB,Hlimit;

/************************ defaults *********************/

double f_0 = 13560000;

double H_dBuA = 42;

double d_m = 10;

double Vmin = 3;

double Vmax;

double freq_change_over = 11240000;

double f_sc = 400000;

double N_tx = 1;

double P_chip_min = 100e-6;

double Q_0 = 70;

double mi_min = 0.8;

double C = 30e-12;

double d = 0.04;

double e = 0.04;

double Lm_tag = 0.9e-6;

double tolerance = 2;

double Lm_tx = 0.9e-6;

double Q_tx = 100;

double CNR = 150;

double B_rx = 30000;

double SNRmin = 10;

double a = 0.5;

double b = 0.5;

double z_start = 0.10;

double z_step = 0.05;

double Maxsteps = 99;

double Enoise_1Hz = 24;

double E_interference_lsb = 30;

double E_interference_usb = 30;

double V_error = 0.002;

double Vchip_start;

double V_step = 0.1;

double V_th = 1.4;

double k1 = 2.5;

double k2 = 1.5;

double MODlimit = 1e-6;

double z_min = 0.01;

int Ndf = 3;

int Nint = 100;

int p, p_max;

char filename[13]={"OUTPUT.CSV"};

/*******************************************************/

double lab_rad,p_v_eff,p_g_conv_lsb,p_g_conv_usb,p_m_sc_lsb,p_m_sc_usb,Qp;

double ResCurve1,Q_ar,Q_term, Q_chip_ar, Vchip_loop,

V_th_sq2,Vind_found,P_chipp,mip,Hlab_lsb,Hlab_usb,Vrx_corr_lsb,Vrx_corr_usb

;

FILE *fptr;

double Hmin[3],

df[3],m_sc_lsb_ar[3],m_sc_usb_ar[3],g_conv_lsb_ar[3],g_conv_usb_ar[3],Gconv_l sb_ar[3],Gconv_usb_ar[3],

SCR_lsb_ar[3],SCR_usb_ar[3],SNR_tx_lsb_ar[3],SNR_tx_usb_ar[3];

double

Hlab_lsb_ar[3],Hlab_usb_ar[3],Hlab_dB_lsb_ar[3],Hlab_dB_usb_ar[3],v_eff_ar[3], SNR_ext_lsb_ar[3],SNR_ext_usb_ar[3],SNR_interference_lsb_ar[3],SNR_interfere nce_usb_ar[3];

double zrr_SNR_tx_lsb_ar[3], zrr_SNR_tx_usb_ar[3], zrr_SNR_ext_lsb_ar[3], zrr_SNR_ext_usb_ar[3], zrr_SNR_interference_lsb_ar[3],

zrr_SNR_interference_usb_ar[3], z_max_ar[3];

double zrr_SNR_tx_lsb[3], zrr_SNR_tx_usb[3], zrr_SNR_ext_lsb[3],

zrr_SNR_ext_usb[3], zrr_SNR_interference_lsb[3], zrr_SNR_interference_usb[3];

double zrr[100],Hzrr[100],Vind[100];

double Vchip[100][3], Q[100][3], P_chip[100][3], mi[100][3],

Hlab_dB_lsb[100][3], Hlab_dB_usb[100][3], SCR_lsb[100][3], SCR_usb[100][3], SNR_tx_lsb[100][3],SNR_tx_usb[100][3];

double SNR_ext_lsb[100][3], SNR_ext_usb[100][3],

SNR_interference_lsb[100][3], SNR_interference_usb[100][3], v_eff[100][3], g_conv_lsb[100][3], g_conv_usb[100][3];

double m_sc_lsb[100][3], m_sc_usb[100][3];

char s1[40],s2[40],s3[40],s4[40];

char answer1[40],answer2[40];

int printfile;

int NotNoise;

int repeat;

int i,tol;

int NoMod[3];

int TestMode;

int Run_number = 1;

int main(void) {

printf(INTRO);

printf("Parameter: default/last value:\n\n");

printf("Name CSV outputfile: : %s\n",filename);

gets(s1);

if (strlen(s1)) strcpy(filename,s1);

if ((fptr = fopen(filename, "w"))== NULL) {

fclose( fptr );

return FAIL;

}

/* MAIN PROGRAM LOOP */

do {

/* Input parameters */

printf(" Run number: %3d\n",Run_number);

/* printf("Program in testmode? (Y/N): %s\n",answer1);

gets(s2);

if (strlen(s2)) strcpy(answer1,s2);

if (strcmp(answer1,"y")==0 || strcmp(answer1,"Y")==0) TestMode = TRUE;

else TestMode = FALSE; */

printf("Working frequency in MHz : %8.2f\n",f_0/1e6);

gets(s1);

if (strlen(s1)) f_0 = atof(s1)*1e6;

printf("The magnetic field strength limit in dBàA/m :

%8.1f\n",H_dBuA);

gets(s1);

if (strlen(s1)) H_dBuA = atof(s1);

printf("The measuring distance in meter : %8.1f\n",d_m);

gets(s1);

if (strlen(s1)) d_m = atof(s1);

printf("The effective receiver noise bandwidth (kHz) :

%8.1f\n",B_rx/1e3);

gets(s1);

if (strlen(s1)) B_rx = atof(s1)*1e3;

printf("The Signal to Noise Ratio needed for detection :

%8.1f\n",SNRmin);

gets(s1);

if (strlen(s1)) SNRmin = atof(s1);

printf("The length of tx/rx loop : %8.2f\n",a);

gets(s1);

if (strlen(s1)) a = atof(s1);

printf("The width of tx/rx loop : %8.2f\n",b);

gets(s1);

if (strlen(s1)) b = atof(s1);

printf("The selfinductance per meter tx/rx coil : %8.1e\n",Lm_tx);

gets(s1);

if (strlen(s1)) Lm_tx = atof(s1);

printf("The Q-factor of the tx/rx coil : %8.1f\n",Q_tx);

gets(s1);

if (strlen(s1)) Q_tx = atof(s1);

printf("The Tx Carrier to Noise Ratio in dBc/Hz : %8.1f\n",CNR);

gets(s1);

if (strlen(s1)) CNR = atof(s1);

printf("The minimum tag voltage : %8.1f\n",Vmin);

gets(s1);

if (strlen(s1)) Vmin = atof(s1);

Vmax = 2 * Vmin;

printf("The maximum tag voltage : %8.1f\n",Vmax);

gets(s1);

while (Vmax <= Vmin) {

printf("The maximum voltage must be higher than the minimum voltage.\n");

printf("Enter again: ");

gets(s1);

if (strlen(s1)) Vmax = atof(s1);

}

printf("Subcarrier frequency in kHz : %8.2f\n",f_sc/1e3);

gets(s1);

if (strlen(s1)) f_sc = atof(s1)*1e3;

printf("The the power dissipation of the chip at Vmin in àW :

%8.1f\n",P_chip_min*1e6);

gets(s1);

if (strlen(s1)) P_chip_min = atof(s1)*1e-6;

printf("The modulation depth : %8.1f\n",mi_min);

gets(s1);

if (strlen(s1)) mi_min = atof(s1);

printf("The tag tuning capacitor in pf : %8.1e\n",C*1e12);

gets(s1);

if (strlen(s1)) C = atof(s1)/1e12;

printf("The length of the coil of the tag d : %8.3f\n",d);

gets(s1);

if (strlen(s1)) d = atof(s1);

printf("The width of the coil of the tag e : %8.3f\n",e);

gets(s1);

if (strlen(s1)) e = atof(s1);

printf("The selfinductance per meter label coil : %8.1e\n",Lm_tag);

gets(s1);

if (strlen(s1)) Lm_tag = atof(s1);

printf("The Q-factor of the coil of the tag : %8.3f\n",Q_0);

gets(s1);

if (strlen(s1)) Q_0 = atof(s1);

printf("The frequency tolerance of the tag circuit coil in percents:

%8.1f\n",tolerance);

gets(s1);

if (strlen(s1)) tolerance = atof(s1);

printf("The external noise level in dBàV/m/Hz :

%8.1f\n",Enoise_1Hz);

gets(s1);

if (strlen(s1)) Enoise_1Hz = atof(s1);

printf("The external interference level in lower sideband in dBàV/m:

%8.1f\n",E_interference_lsb);

gets(s1);

if (strlen(s1)) E_interference_lsb = atof(s1);

printf("The external interference level in upper sideband in dBàV/m:

%8.1f\n",E_interference_usb);

gets(s1);

if (strlen(s1)) E_interference_usb = atof(s1);

printf("The start reading range in m : %8.2f\n",z_start);

gets(s1);

if (strlen(s1)) z_start = atof(s1);

printf("The reading range step in m : %8.2f\n",z_step);

gets(s1);

if (strlen(s1)) z_step = atof(s1);

/* Start of calculations */

V_th_sq2 = V_th/sqrt(2.0);

df[0]=0;

df[1]=-tolerance*f_0/100;

df[2]= tolerance*f_0/100;

fprintf(fptr,"\n =============== Start of Run number %3d

===============\n\n",Run_number);

/* Calculation the maximal magnetic dipole moment of the reader antenna loop */

lab_rad = c/(2*pi*f_0);

Hlimit = pow(10,H_dBuA/20)/1e6;

if (d_m > lab_rad*2.354) {

printf("The field strength at the measuring position is maximal in\n");

printf("the coplanar direction.\n\n");

fprintf(fptr, "The field strength at the measuring position is maximal in\n");

fprintf(fptr, "the coplanar direction.\n\n");

m_tx =

Hlimit*4*pi*lab_rad*lab_rad*d_m*d_m*d_m/sqrt(lab_rad*lab_rad*lab_rad*lab_r ad-lab_rad*lab_rad*d_m*d_m+d_m*d_m*d_m*d_m);

} else {

printf("The field strength at the measuring position is maximal in\n");

printf("the coaxial direction.\n\n");

fprintf(fptr, "The field strength at the measuring position is maximal in\n");

fprintf(fptr, "the coaxial direction.\n\n");

m_tx =

Hlimit*lab_rad*2*pi*d_m*d_m*d_m/(sqrt(lab_rad*lab_rad+d_m*d_m));

}

/* Calculation of maximal antenna current and transmitter power */

I_tx = m_tx/(a*b);

/* Calculation of equivalent homogeneous field strength of transmitter noise */

Hnoise_tx=2*(a + b)*Lm_tx*I_tx/(u0*a*b*Q_tx*pow(10,CNR/20));

Hnoise_tx_dB = 20*log10(Hnoise_tx*1e6);

/* Compute the Q_chip of the chip */

Q_chip_ar=2*pi*f_0*C*Vmin*Vmin/P_chip_min;

Q_ar=Q_0*Q_chip_ar/(Q_0+Q_chip_ar);

Q_term=Q_ar*Q_ar*(1-mi_min/2.0)*(1-mi_min/2.0);

/* For the three cases: frequency deviation is 0, -df, +df: */

for (tol=0; tol<Ndf;tol++) {

/* Compute the ResCurve1 for the Hmin calculation */

ResCurve1=sqrt(1+Q_ar*Q_ar*((f_0+df[tol])/f_0-

f_0/(f_0+df[tol]))*((f_0+df[tol])/f_0-f_0/(f_0+df[tol])))*f_0/(f_0+df[tol]);

/* Compute the Hmin of the tag */

Hmin[tol] = Vmin*(sqrt(C*Lm_tag*2*(d+e))/(Q_ar*u0*d*e))*ResCurve1;

/* Compute the effective volume of the tag */

v_eff_ar[tol]=Q_ar*d*d*e*e*u0/(Lm_tag*2*(d+e))/sqrt(1+Q_ar*Q_ar*((f_0+df[tol ])/f_0-f_0/(f_0+df[tol]))*((f_0+df[tol])/f_0-f_0/(f_0+df[tol])));

/* Compute the conversion gain of the tag */

g_conv_lsb_ar[tol]=(mi_min/pi)/sqrt(1+Q_term*((f_0-f_sc-df[tol])/f_0- f_0/(f_0-f_sc-df[tol]))*((f_0-f_sc-df[tol])/f_0-f_0/(f_0-f_sc-df[tol])));

g_conv_usb_ar[tol]=(mi_min/pi)/sqrt(1+Q_term*((f_0+f_sc-df[tol])/f_0- f_0/(f_0+f_sc-df[tol]))*((f_0+f_sc-df[tol])/f_0-f_0/(f_0+f_sc-df[tol])));

Gconv_lsb_ar[tol] = 20*log10(g_conv_lsb_ar[tol]);

Gconv_usb_ar[tol] = 20*log10(g_conv_usb_ar[tol]);

/* Compute the magnetic dipole moment of the tag signal */

m_sc_lsb_ar[tol] = g_conv_lsb_ar[tol]*v_eff_ar[tol]*Hmin[tol];

m_sc_usb_ar[tol] = g_conv_usb_ar[tol]*v_eff_ar[tol]*Hmin[tol];

}

printf("Results of the activation range calculation:\n\n");

printf("Tx max Antenna Current : %8.2f", I_tx), printf(" A.\n");

printf("Tx output power : %8.2f", P_tx), printf(" W.\n");

printf("Hnoise_tx 1 Hz : %8.2f", Hnoise_tx_dB), printf(" dBàA/m.\n");

printf("Q_chip@Hmin : %8.2f\n\n", Q_chip_ar);

printf("Frequency tolerance : 0 - +\n\n");

printf("Hmin : %8.3f %8.3f %8.3f", Hmin[0],Hmin[1],Hmin[2]), printf(" A/m.\n");

printf("V_eff : %8.3f %8.3f %8.3f",

v_eff_ar[0]*1e3,v_eff_ar[1]*1e3,v_eff_ar[2]*1e3), printf(" l.\n");

printf("Gconv_lsb : %8.3f %8.3f %8.3f",

Gconv_lsb_ar[0],Gconv_lsb_ar[1],Gconv_lsb_ar[2]), printf(" dB.\n");

printf("Gconv_usb : %8.3f %8.3f %8.3f",

Gconv_usb_ar[0],Gconv_usb_ar[1],Gconv_usb_ar[2]), printf(" dB.\n");

printf("m_sc_lsb : %8.3f %8.3f %8.3f",

m_sc_lsb_ar[0]*1e6,m_sc_lsb_ar[1]*1e6,m_sc_lsb_ar[2]*1e6), printf(" àA.m².\n");

printf("m_sc_usb : %8.3f %8.3f %8.3f",

m_sc_usb_ar[0]*1e6,m_sc_usb_ar[1]*1e6,m_sc_usb_ar[2]*1e6), printf("

àA.m².\n\n");

fprintf(fptr, "Input parameters:\n\n");

fprintf(fptr, "Working frequency [MHz] , %8.2f\n",f_0/1e6);

fprintf(fptr, "H_max [dBàA/m] , %8.1f\n",H_dBuA);

fprintf(fptr, "d_measuring [m] , %8.1f\n",d_m);

fprintf(fptr, "Receiver BW [kHz] , %8.1f\n",B_rx/1e3);

fprintf(fptr, "SNRmin [dB] , %8.1f\n",SNRmin);

fprintf(fptr, "Length tx/rx loop [m] , %8.2f\n",a);

fprintf(fptr, "Width tx/rx loop [m] , %8.2f\n",b);

fprintf(fptr, "Lm_tx [H/m] , %8.1e\n",Lm_tx);

fprintf(fptr, "Q_tx , %8.1f\n",Q_tx);

fprintf(fptr, "CNR (tx) [dB/Hz] , %8.1f\n",CNR);

fprintf(fptr, "Vmin [Vrms] , %8.1f\n",Vmin);

fprintf(fptr, "Vmax [Vrms] , %8.1f\n",Vmax);

fprintf(fptr, "Subcarrier frequency [kHz] , %8.2f\n",f_sc/1e3);

fprintf(fptr, "Power dissipation chip at Vmin [àW] , %8.1f\n",P_chip_min*1e6);

fprintf(fptr, "Modulation index , %8.1f\n",mi_min);

fprintf(fptr, "C_tag tuning [pf] , %8.1e\n",C*1e12);

fprintf(fptr, "Length tag coil d , %8.3f\n",d);

fprintf(fptr, "Width tag coil e , %8.3f\n",e);

fprintf(fptr, "LM_tag [H/m] , %8.1e\n",Lm_tag);

fprintf(fptr, "Q-factor tagcoil , %8.3f\n",Q_0);

fprintf(fptr, "Tolerance tag [perc.] , %8.1e\n",tolerance);

fprintf(fptr, "Ext. Noise [dBàV/m/Hz] , %8.1f\n",Enoise_1Hz);

fprintf(fptr, "Ext. Interference LSB [dBàV/m/Hz] ,

%8.1f\n",E_interference_lsb);

fprintf(fptr, "Ext. Interference USB [dBàV/m/Hz] ,

%8.1f\n",E_interference_usb);

fprintf(fptr, "Start reading range [m] , %8.2f\n",z_start);

fprintf(fptr, "Step reading range [m] , %8.2f\n\n",z_step);

fprintf(fptr, "Results of the activation range calculation:\n\n");

fprintf(fptr, "Tx max Antenna Current [A] , %8.2f\n", I_tx);

fprintf(fptr, "Tx output power [W] , %8.2f\n", P_tx);

fprintf(fptr, "Hnoise_tx in 1 Hz [dBàA/m] , %8.2f\n\n", Hnoise_tx_dB);

fprintf(fptr, "Q_chip@Hmin , %8.2f\n\n", Q_chip_ar);

fprintf(fptr, "Frequency tolerance , 0, -, +\n\n");

fprintf(fptr, "Hmin [A/m] , %8.2f, %8.2f, %8.2f\n", Hmin[0],Hmin[1],Hmin[2]);

fprintf(fptr, "V_eff [l] , %8.2f, %8.2f, %8.2f\n", v_eff_ar[0]*1e3,v_eff_ar[1]*1e3,v_eff_ar[2]*1e3);

fprintf(fptr, "Gconv_lsb [dB] , %8.2f, %8.2f, %8.2f\n", Gconv_lsb_ar[0],Gconv_lsb_ar[1],Gconv_lsb_ar[2]);

fprintf(fptr, "Gconv_usb [dB] , %8.2f, %8.2f, %8.2f\n", Gconv_usb_ar[0],Gconv_usb_ar[1],Gconv_usb_ar[2]);

fprintf(fptr, "m_sc_lsb [àA.m²] , %8.2f, %8.2f, %8.2f\n", m_sc_lsb_ar[0]*1e6,m_sc_lsb_ar[1]*1e6,m_sc_lsb_ar[2]*1e6);

fprintf(fptr, "m_sc_usb [àA.m²] , %8.2f, %8.2f, %8.2f\n\n", m_sc_usb_ar[0]*1e6,m_sc_usb_ar[1]*1e6,m_sc_usb_ar[2]*1e6);

/* Calculation of maximal activation range */

for (tol=0; tol<Ndf; tol++) {

z_max_ar[tol]=ActivationDistance_O(I_tx,a,b,Hmin[tol]);

if (fabs(z_max_ar[tol]) <= z_min) z_max_ar[tol] = 0;

}

printf("Activation distance : %8.2f %8.2f %8.2f", z_max_ar[0],z_max_ar[1],z_max_ar[2]), printf(" m.\n\n");

fprintf(fptr, "Activation distance [m] , %8.2f, %8.2f, %8.2f\n", z_max_ar[0],z_max_ar[1],z_max_ar[2]);

/* Calculation of the correctionfactors for the calculation of the inducted voltage in the transmitter antennaloop

for high subcarrierfrequencies with respect to the effect of Q_tx.

*/

Vrx_corr_lsb =20*log10(fabs(((f_0-f_sc)/f_0)/sqrt(1+Q_tx*Q_tx*((f_0- f_sc)/f_0-f_0/(f_0-f_sc))*((f_0-f_sc)/f_0-f_0/(f_0-f_sc)))));

Vrx_corr_usb

=20*log10(fabs(((f_0+f_sc)/f_0)/sqrt(1+Q_tx*Q_tx*((f_0+f_sc)/f_0- f_0/(f_0+f_sc))*((f_0+f_sc)/f_0-f_0/(f_0+f_sc)))));

/* Calculation of field strength of tag return signal H_eh at the maximal activation range */

for (tol=0; tol<Ndf; tol++) {

if (fabs(z_max_ar[tol])> z_min) {

Hlab_lsb_ar[tol] =CalcHlabel_O(m_sc_lsb_ar[tol],a,b,z_max_ar[tol],Nint);

if (TestMode == TRUE) printf("Hlab_lsb_ar[tol]: %8.2e / %d \n", Hlab_lsb_ar[tol], tol);

Hlab_usb_ar[tol] =CalcHlabel_O(m_sc_usb_ar[tol],a,b,z_max_ar[tol],Nint);

if (TestMode == TRUE) printf("Hlab_usb_ar[tol]: %8.2e / %d\n", Hlab_usb_ar[tol], tol);

} else {

Hlab_lsb_ar[tol] = 1e-12;

Hlab_usb_ar[tol] = 1e-12;

}

Hlab_dB_lsb_ar[tol] = 20*log10(fabs(Hlab_lsb_ar[tol])*1e6);

Hlab_dB_usb_ar[tol] = 20*log10(fabs(Hlab_usb_ar[tol])*1e6);

SCR_lsb_ar[tol] =

20*log10(fabs(a*b*u0*Q_tx*Hlab_lsb_ar[tol]/(2*(a+b)*Lm_tx*N_tx*I_tx)))+Vrx _corr_lsb;

SCR_usb_ar[tol] =

20*log10(fabs(a*b*u0*Q_tx*Hlab_usb_ar[tol]/(2*(a+b)*Lm_tx*N_tx*I_tx)))+Vrx _corr_usb;

SNR_tx_lsb_ar[tol] = CNR + SCR_lsb_ar[tol] - Vrx_corr_lsb - 10*log10(B_rx);

SNR_tx_usb_ar[tol] = CNR + SCR_usb_ar[tol] - Vrx_corr_usb - 10*log10(B_rx);

SNR_ext_lsb_ar[tol] = Hlab_dB_lsb_ar[tol] - (Enoise_1Hz-51.5) - 10*log10(B_rx);

SNR_ext_usb_ar[tol] = Hlab_dB_usb_ar[tol] - (Enoise_1Hz-51.5) - 10*log10(B_rx);

SNR_interference_lsb_ar[tol] = Hlab_dB_lsb_ar[tol] - (E_interference_lsb - 51.5);

SNR_interference_usb_ar[tol] = Hlab_dB_usb_ar[tol] - (E_interference_usb - 51.5);

}

printf("H_eh LSB: %8.2f %8.2f %8.2f",

Hlab_dB_lsb_ar[0],Hlab_dB_lsb_ar[1],Hlab_dB_lsb_ar[2]), printf(" dBàA/m.\n");

printf("SCR LSB: %8.2f %8.2f %8.2f",

SCR_lsb_ar[0],SCR_lsb_ar[1],SCR_lsb_ar[2]), printf(" dB.\n");

printf("SNR_tx LSB: %8.2f %8.2f %8.2f",

SNR_tx_lsb_ar[0],SNR_tx_lsb_ar[1],SNR_tx_lsb_ar[2]), printf(" dB.\n");

printf("H_eh USB: %8.2f %8.2f %8.2f",

Hlab_dB_usb_ar[0],Hlab_dB_usb_ar[1],Hlab_dB_usb_ar[2]), printf("

dBàA/m.\n");

printf("SCR USB: %8.2f %8.2f %8.2f",

SCR_usb_ar[0],SCR_usb_ar[1],SCR_usb_ar[2]), printf(" dB.\n");

printf("SNR_tx USB: %8.2f %8.2f %8.2f",

SNR_tx_usb_ar[0],SNR_tx_usb_ar[1],SNR_tx_usb_ar[2]), printf(" dB.\n");

printf("SNR_ext LSB: %8.2f %8.2f %8.2f",

SNR_ext_lsb_ar[0],SNR_ext_lsb_ar[1],SNR_ext_lsb_ar[2]), printf(" dB.\n");

printf("SNR_ext USB: %8.2f %8.2f %8.2f",

SNR_ext_usb_ar[0],SNR_ext_usb_ar[1],SNR_ext_usb_ar[2]), printf(" dB.\n");

printf("SNR_interference LSB: %8.2f %8.2f %8.2f",

SNR_interference_lsb_ar[0],SNR_interference_lsb_ar[1],SNR_interference_lsb_ar[

2]), printf(" dB.\n");

printf("SNR_interference USB: %8.2f %8.2f %8.2f",

SNR_interference_usb_ar[0],SNR_interference_usb_ar[1],SNR_interference_usb_a r[2]), printf(" dB.\n\n");

fprintf(fptr, "H_eh LSB [dBàA/m] , %8.2f, %8.2f, %8.2f\n", Hlab_dB_lsb_ar[0],Hlab_dB_lsb_ar[1],Hlab_dB_lsb_ar[2]);

fprintf(fptr, "SCR LSB [dB] , %8.2f, %8.2f, %8.2f\n", SCR_lsb_ar[0],SCR_lsb_ar[1],SCR_lsb_ar[2]);

fprintf(fptr, "SNR_tx LSB [dB] , %8.2f, %8.2f, %8.2f\n", SNR_tx_lsb_ar[0],SNR_tx_lsb_ar[1],SNR_tx_lsb_ar[2]);

fprintf(fptr, "H_eh USB [dBàA/m] , %8.2f, %8.2f, %8.2f\n", Hlab_dB_usb_ar[0],Hlab_dB_usb_ar[1],Hlab_dB_usb_ar[2]);

fprintf(fptr, "SCR USB [dB] , %8.2f, %8.2f, %8.2f\n", SCR_usb_ar[0],SCR_usb_ar[1],SCR_usb_ar[2]);

fprintf(fptr, "SNR_tx USB [dB] , %8.2f, %8.2f, %8.2f\n", SNR_tx_usb_ar[0],SNR_tx_usb_ar[1],SNR_tx_usb_ar[2]);

fprintf(fptr, "SNR_ext LSB [dB] , %8.2f, %8.2f, %8.2f\n", SNR_ext_lsb_ar[0],SNR_ext_lsb_ar[1],SNR_ext_lsb_ar[2]);

fprintf(fptr, "SNR_ext USB [dB] , %8.2f, %8.2f, %8.2f\n", SNR_ext_usb_ar[0],SNR_ext_usb_ar[1],SNR_ext_usb_ar[2]);

fprintf(fptr, "SNR_interference LSB [dB] , %8.2f, %8.2f, %8.2f\n", SNR_interference_lsb_ar[0],SNR_interference_lsb_ar[1],SNR_interference_lsb_ar[

2]);

fprintf(fptr, "SNR_interference USB [dB] , %8.2f, %8.2f, %8.2f\n", SNR_interference_usb_ar[0],SNR_interference_usb_ar[1],SNR_interference_usb_a r[2]);

/* Start of calculations for signal strength at reading ranges within activation range

*/

printf("\nResults of the reading range calculation:\n");

printf("\nEquivalent homogeneous tag signal magnetic field strength [dBàA/m]:\n\n");

printf("Frequency tolerance: 0 - +\n\n");

printf("Step Range Hzrr [ LSB / USB ] [ LSB / USB ] [ LSB / USB ]\n\n");

NoMod[0]=FALSE; NoMod[1]=FALSE; NoMod[2]=FALSE;

p = 0;

while (NoMod[0]==FALSE || NoMod[1]==FALSE || NoMod[2]==FALSE)

{

zrr[p] = z_start + p*z_step;

Hzrr[p] = H_tx_O_z(I_tx, a, b, zrr[p]);

Vind[p] = d*e*u0*Hzrr[p]/sqrt(C*Lm_tag*2*(d+e));

printf("%3d %6.2f %6.3f ", p, zrr[p], Hzrr[p]);

if (TestMode == TRUE) printf("Hzrr[p] =%8.4f, Vind[p] =%8.4f, Vind_found

=%8.2f:\n", Hzrr[p],Vind[p],Vind_found);

for (tol=0; tol<Ndf; tol++) {

Vind_found = 0;

NoMod[tol] = FALSE;

Vchip_loop = Vmin; /*initialisation of the loop */

while (fabs(Vind_found-Vind[p])>fabs(Vind[p]*V_error)) {

Vind_found = Calc_Vind(Vchip_loop, df[tol], &Qp, &P_chipp, &mip);

Vchip_loop = Vchip_loop * (1+ 1.0*(Vind[p] - Vind_found)/(Vind[p]+Vind_found));

if (TestMode == TRUE) printf("Vchip_loop =%8.4f, Vind_found =%8.2f, mip =%8.2f :", Vchip_loop, Vind_found, mip);

}

Vchip[p][tol] = Vchip_loop / (1+ 0.2*(Vind[p] - Vind_found)/Vind[p]);

Q[p][tol] = Qp;

P_chip[p][tol] = P_chipp;

mi[p][tol] = mip;

if (mip < MODlimit) NoMod[tol] = TRUE;

tagcalculation(Q[p][tol], df[tol], mi[p][tol], Hzrr[p], &p_v_eff,

&p_g_conv_lsb, &p_g_conv_usb, &p_m_sc_lsb, &p_m_sc_usb);

v_eff[p][tol] = p_v_eff;

g_conv_lsb[p][tol] = p_g_conv_lsb;

g_conv_usb[p][tol] = p_g_conv_usb;

m_sc_lsb[p][tol] = p_m_sc_lsb;

m_sc_usb[p][tol] = p_m_sc_usb;

if (TestMode == TRUE) printf("\nm_sc_lsb[p][tol] =%8.4e, m_sc_usb[p][tol] =%8.2e :", m_sc_lsb[p][tol], m_sc_usb[p][tol]);

/* Calculation of the equivalent homogeneous tag signal field strength at the reading range zrr */

Hlab_lsb = CalcHlabel_O(m_sc_lsb[p][tol],a,b,zrr[p],Nint);

Hlab_usb = CalcHlabel_O(m_sc_usb[p][tol],a,b,zrr[p],Nint);

if (NoMod[tol] == TRUE) {

Hlab_lsb = 1e-12;

Hlab_usb = 1e-12;

if (TestMode == TRUE) printf("Hlab_lsb =%8.4e, Hlab_usb =%8.2e :\n", Hlab_lsb, Hlab_usb);

Hlab_dB_lsb[p][tol] = 20*log10(fabs(Hlab_lsb)*1e6);

Hlab_dB_usb[p][tol] = 20*log10(fabs(Hlab_usb)*1e6);

/* Calculation of the Signal to Carrier ratio at the reading range zrr */

SCR_lsb[p][tol] =

20*log10(a*b*u0*Q_tx*Hlab_lsb/(2*(a+b)*Lm_tx*N_tx*I_tx)) + Vrx_corr_lsb;

SCR_usb[p][tol] =

20*log10(a*b*u0*Q_tx*Hlab_usb/(2*(a+b)*Lm_tx*N_tx*I_tx)) + Vrx_corr_usb;

/* Calculation of the Signal to transmitter noise ratio at the reading range zrr

*/

SNR_tx_lsb[p][tol] = CNR + SCR_lsb[p][tol] - Vrx_corr_lsb - 10*log10(B_rx);

SNR_tx_usb[p][tol] = CNR + SCR_usb[p][tol] - Vrx_corr_usb - 10*log10(B_rx);

/* Calculation of the Signal to external Noise ratio at the reading range zrr */

SNR_ext_lsb[p][tol] = Hlab_dB_lsb[p][tol] - (Enoise_1Hz-51.5) - 10*log10(B_rx);

SNR_ext_usb[p][tol] = Hlab_dB_usb[p][tol] - (Enoise_1Hz-51.5) - 10*log10(B_rx);

/* Calculation of the Signal to Interference ratio at the reading range zrr */

SNR_interference_lsb[p][tol] = Hlab_dB_lsb[p][tol] - (E_interference_lsb - 51.5);

SNR_interference_usb[p][tol] = Hlab_dB_usb[p][tol] - (E_interference_usb - 51.5);

}

/* Printing data */

for (tol=0; tol<Ndf; tol++) {

if (NoMod[tol] == FALSE)

printf("[%6.2f %6.2f ] ", Hlab_dB_lsb[p][tol],Hlab_dB_usb[p][tol]);

else

printf("No tag modulation ");

}

printf("\n");

p++;

if (p > Maxsteps) {

printf("Calculation halted because of too many steps\n\n");

break;

} }