ofdm_c.txt

用c语言实现OFDM 的调制 相当有用的程序

448 // configure given width, offset, and modulation 
449 int 
450 ofdm_mod_random(unsigned char *data, int ncarriers, int offset, int nifft, int modulation) 
451 { 
452     int i,j,c,d; 
453     unsigned char modmod; 
454  
455     i = 0; 
456     modulation &= 0x3; 
457     modulation |= 0x8; 
458  
459     modmod = (modulation << 4) | modulation; 
460  
461     data[i++] = OFDM_MOD_ID; 
462     data[i++] = ncarriers/2; 
463  
464     // c = leftmost carrier 
465     c = offset - (ncarriers/2); 
466  
467     for (j=0; j<ncarriers; j+=2) { 
468         // address 
469         d = (c + nifft) % nifft; 
470         data[i++] = d; 
471         //printf("c %d  d %d\n", c, d); 
472         data[i++] = modmod; 
473         c+=2; 
474     } 
475      
476     return i; 
477 } 
478  
479 // configure for 802.11a 
480 // 64 carriers centered at zero 
481 int 
482 ofdm_mod_80211a(unsigned char *data, int modulation) 
483 { 
484     int i, j; 
485     unsigned char modmod; 
486  
487     i = 0; 
488     modulation &= 0x3; 
489     modulation |= 0x8; 
490  
491     modmod = (modulation << 4) | modulation; 
492  
493     data[i++] = OFDM_MOD_ID; 
494     data[i++] = 64/2; 
495  
496     // carriers 0,1,2,...,31 
497     for (j=0; j<32; j+=2) { 
498         data[i++] = j; 
499         // pilots tones 
500         if ((j == 6) || (j == 20)) 
501             data[i++] = ((0x8 | BPSK) << 4) | modulation; 
502         else 
503             data[i++] = modmod; 
504     } 
505  
506     // carriers 224,225,...,255 (-32,-31,...,-1) 
507     for (j=224; j<256; j+=2) { 
508         data[i++] = j; 
509         // pilot tones 
510         if ((j == 234) || (j == 248)) 
511             data[i++] = ((0x8 | BPSK) << 4) | modulation; 
512         else 
513             data[i++] = modmod; 
514     } 
515      
516     return i; 
517 } 
518  
519  
520 // reset modulation 
521 int 
522 ofdm_mod_zeros(unsigned char *data) 
523 { 
524     int i, j; 
525     unsigned char mod; 
526  
527     i = 0; 
528     data[i++] = OFDM_MOD_ID; 
529     data[i++] = 128; 
530      
531     // carriers 1, 2, ..., 26 
532     for (j=0; j<256; j+=2) { 
533         data[i++] = j; 
534         data[i++] = 0; 
535     } 
536  
537     return i; 
538 } 
539  
540 #include "ieee80211a_orig.h" 
541  
542 unsigned char bits[1024*16]; 
543  
544 //return number of words written to ret 
545 unsigned int 
546 prepare_data(unsigned char *pkt, int pkt_len, unsigned char *ret, int rate) 
547 { 
548     int i, j; 
549     int nbytes;//, nbits; 
550     int crc, data_size; 
551     unsigned char *signal, *data, *p; 
552     unsigned char *longp, *shortp; 
553  
554     // compute crc32 
555     crc = crc32(0L, Z_NULL, 0); 
556     crc = crc32(crc, pkt, pkt_len); 
557  
558     // append crc to packet 
559     memcpy(pkt+pkt_len, &crc, 4); 
560     nbytes = pkt_len + 4; 
561  
562     // convert to array of bytes with one bit per byte 
563     //nbits = nbytes * 8; 
564     //ofdm_bytes_to_syms(pkt, bits, nbits); 
565  
566     // get the frame pieces 
567     shortp = ieee80211a_short_preamble(2); 
568     longp = ieee80211a_long_preamble(1); 
569     signal = ieee80211a_signal_symbol(rate, nbytes); 
570     data = ieee80211a_data_symbols(pkt, nbytes, &data_size, rate); 
571  
572     // 
573     // build the frame 
574     // 
575     i = 0; 
576  
577     // ifft_size 
578     ret[i++] = OFDM_NCARRIERS_ID; 
579     ret[i++] = 64; 
580  
581     // setup modulators 
582     i += ofdm_mod_80211a(ret+i, BPSK); 
583  
584     // short preamble 
585     ret[i++] = OFDM_DATA_ID; 
586     ret[i++] = 128; 
587     memcpy(ret+i, shortp, 128); 
588     i+= 128; 
589  
590     // long preamble 
591     ret[i++] = OFDM_GUARD_ID; 
592     ret[i++] = 128; 
593     ret[i++] = OFDM_DATA_ID; 
594     ret[i++] = 64; 
595     memcpy(ret+i, longp, 64); 
596     i+= 64; 
597     ret[i++] = OFDM_GUARD_ID; 
598     ret[i++] = 0; 
599     ret[i++] = OFDM_DATA_ID; 
600     ret[i++] = 64; 
601     memcpy(ret+i, longp, 64); 
602     i+= 64; 
603  
604     // signal symbol 
605     ret[i++] = OFDM_GUARD_ID; 
606     ret[i++] = 64; 
607     ret[i++] = OFDM_DATA_ID; 
608     ret[i++] = 64; 
609     memcpy(ret+i, signal, 64); 
610     i += 64; 
611  
612     // write data symbols 
613     i += ofdm_mod_80211a(ret+i, rate); 
614     p = data; 
615     for (j=0; j<data_size/64; j++) { 
616         ret[i++] = OFDM_DATA_ID; 
617         ret[i++] = 64; 
618         memcpy(ret+i, p, 64); 
619         i += 64; 
620         p += 64; 
621     } 
622  
623     free(data); 
624     free(signal); 
625  
626     return i; 
627 } 
628  
629 void 
630 test(void) 
631 { 
632  
633     int i,j,e,r,l; 
634     int rate = QAM64_23; 
635     unsigned int n, inbytes, outbytes; 
636     unsigned char mac_hdr[] = { 
637         0x04, 0x02, 0x00, 0x2e, 0x00, 
638         0x60, 0x08, 0xcd, 0x37, 0xa6, 
639         0x00, 0x20, 0xd6, 0x01, 0x3c, 
640         0xf1, 0x00, 0x60, 0x08, 0xad, 
641         0x3b, 0xaf, 0x00, 0x00, 
642     }; 
643     unsigned char *msg; 
644     unsigned char *pkt_in; 
645     unsigned char *data_symbols, *signal_symbol; 
646     unsigned char *pkt_out; 
647  
648     inbytes = 240; 
649     pkt_in = malloc(inbytes+4); 
650     msg = read_input("/dev/urandom", inbytes); 
651     memcpy(pkt_in, msg, inbytes); 
652  
653     //n = inbytes*8; 
654     //unsigned char *syms = malloc(n); 
655     //n = ofdm_bytes_to_syms(pkt_in, syms, n); 
656  
657     n = inbytes; 
658  
659     signal_symbol = ieee80211a_signal_symbol(rate, inbytes); 
660     data_symbols = ieee80211a_data_symbols(pkt_in, n, &n, rate); 
661  
662     e = ieee80211a_decode_signal_symbol(signal_symbol, &r, &l, &i);     
663     if (rate !=r) 
664         printf("rate %x != %x\n", r, rate); 
665     if (inbytes != l) 
666         printf("len %x != %x\n", l, inbytes); 
667     if (e)  
668         printf("header parity check failed\n"); 
669      
670     pkt_out = ieee80211a_decode_data_symbols(data_symbols, n/64, &n, rate); 
671  
672     unsigned char *data0, *data1; 
673     int ndata0, ndata1; 
674     data0 = pkt_in; 
675     data1 = pkt_out; 
676     ndata0 = inbytes; 
677  
678     e = 0; 
679     for (n=0; n<ndata0; n++) { 
680         if (data0[n] != data1[n]) { 
681             printf("%d  %x != %x\n", n, data0[n], data1[n]); 
682             e++; 
683         }  
684         //else printf("%d  %x == %x\n", n, data0[n], data1[n]); 
685     } 
686     printf("test: %d out of %d bytes correct\n", ndata0-e, ndata0); 
687     return; 
688 } 
689  
690 void 
691 fwrite_test_packet(char *filename, int rate, int nsyms) 
692 { 
693     unsigned char *msg, *pkt; 
694     int nbytes, size; 
695     unsigned char *data; 
696  
697     int i,j; 
698     FILE *f, *fdata; 
699  
700     unsigned char mac_hdr[] = { 
701         0x04, 0x02, 0x00, 0x2e, 0x00, 
702         0x60, 0x08, 0xcd, 0x37, 0xa6, 
703         0x00, 0x20, 0xd6, 0x01, 0x3c, 
704         0xf1, 0x00, 0x60, 0x08, 0xad, 
705         0x3b, 0xaf, 0x00, 0x00, 
706     }; 
707  
708     data = (unsigned char *)malloc(5000); 
709     nbytes = 0; 
710  
711     printf("generating %d symbols for %s\n", nsyms, rate_to_char[rate]); 
712  
713     //size = ((nsyms*rate_to_dbps[rate])/8) - (24+4+3); 
714     size = 100; 
715     msg = read_input("test.txt", size); 
716     printf("read %d bytes from input\n", size); 
717  
718     pkt = (unsigned char *)malloc(size+24+4); 
719     memcpy(pkt, mac_hdr, 24); 
720     nbytes = 24; 
721  
722     //size = 73; 
723     //msg = read_input("zulu.bin", size); 
724     //pkt = (unsigned char *)malloc(size+4); 
725  
726     //size = 141 - 4; 
727     //msg = read_input("ethereal.bin", size); 
728     //pkt = (unsigned char *)malloc(size+4); 
729      
730     //size = 1500; 
731     //msg = read_input("/dev/urandom", size); 
732     //pkt = (unsigned char *)malloc(size+nbytes+4); 
733  
734     memcpy(pkt+nbytes, msg, size); 
735     nbytes += size; 
736  
737     size = prepare_data(pkt, nbytes, data, rate); 
738  
739     // 
740     // perform ofdm modulation 
741     // 
742     //ofdm_init_modulation(); 
743     //fftw_complex *complex_samples = malloc(1024*32*sizeof(fftw_complex)); 
744     //ofdm_modulate_ieee80211a(data, complex_samples, size, &size); 
745      
746     // write ofdm frame to disk 
747     if (filename) 
748         f = fopen(filename, "w"); 
749     else 
750         f = fopen("ofdm.bin", "w"); 
751  
752     //fwrite(complex_samples, 256/*size*/, sizeof(fftw_complex), f); 
753     fwrite(data, 1, size, f); 
754  
755     fdata = fopen("dataTx.dat","w"); 
756     for (i=0; i<nbytes; i++) 
757         fprintf(fdata,"%0.2x\n", pkt[i]); 
758     fclose(fdata); 
759  
760  
761 #if 0 
762  
763     unsigned char *pktout, *data_symbols, *signal_symbol; 
764     signal_symbol = ieee80211a_signal_symbol(rate, nbytes); 
765     data_symbols = ieee80211a_data_symbols(pkt, nbytes, &size, rate); 
766     pktout = ieee80211a_decode_data_symbols(data_symbols, size/64, &size, rate); 
767 #endif 
768  
769  out: 
770     free(pkt); 
771     free(msg); 
772     free(data); 
773     //free(complex_samples); 
774 } 
775  
776 void 
777 check(void) 
778 { 
779     unsigned char *msg, *pkt; 
780     int size, size2; 
781     unsigned int nbytes; 
782     unsigned char *data, *data2; 
783  
784     int i,j; 
785     FILE *f; 
786  
787     unsigned char mac_hdr[] = { 
788         0x04, 0x02, 0x00, 0x2e, 0x00, 
789         0x60, 0x08, 0xcd, 0x37, 0xa6, 
790         0x00, 0x20, 0xd6, 0x01, 0x3c, 
791         0xf1, 0x00, 0x60, 0x08, 0xad, 
792         0x3b, 0xaf, 0x00, 0x00, 
793     }; 
794  
795     data = (unsigned char *)malloc(5000); 
796     data2 = (unsigned char *)malloc(5000); 
797     nbytes = 0; 
798  
799     size = 72; 
800     msg = read_input("msg.txt", size); 
801     pkt = (unsigned char *)malloc(size+24+4); 
802     memcpy(pkt, mac_hdr, 24); 
803     nbytes = 24; 
804  
805     memcpy(pkt+nbytes, msg, size); 
806     nbytes += size; 
807  
808     int mbit[16] = { 
809         0, 0, 0, 0, 0, 0, 0, 0, 
810         48, 24, 12, 6, 54, 36, 18, 9}; 
811  
812     ofdm_init_modulation(); 
813     fftw_complex *samples = malloc(1024*32*sizeof(fftw_complex)); 
814          
815     // for each rate 
816     for (i=8; i<16; i++) { 
817  
818         // test modulation vs. frozen hand checked version 
819         size = prepare_data(pkt, nbytes, data, i); 
820         size2 = prepare_data_orig(pkt, nbytes, data2, i); 
821          
822         assert(size == size2); 
823         for (j=0; j<size; j++) { 
824             if (data[j] != data2[j]) 
825                 printf("rate %d size %d: %d\t%x != %x\n", mbit[i], size, j, data[j], data2[j]); 
826             //else printf("rate %d size %d: %d\t%x == %x\n", mbit[i], size, j, data[j], data2[j]); 
827             //assert(data[j] == data2[j]); 
828         } 
829          
830         // now test demodulation 
831         ofdm_modulate_ieee80211a(data, samples, size, &size); 
832         unsigned char *d = ofdm_demodulate_ieee80211a(samples, size); 
833  
834         int k = 0; 
835         for (j=0; j<nbytes; j++) { 
836             if (d[j] != pkt[j]) { 
837                 printf("rate %d  %d   %x != %x\n", mbit[i], i, d[j], pkt[j]); 
838                 k++; 
839             } 
840             //else printf("%d   %x == %x\n", i, d[i], pkt[i]); 
841         } 
842         printf("%d of %d bytes correct\n", nbytes-k, nbytes); 
843  
844     } 
845  
846     free(samples); 
847     free(pkt); 
848     free(msg); 
849     free(data); 
850     free(data2); 
851 } 
852  
853 test_speed(void) 
854 { 
855     int pkt_size = 100; 
856     int data_size; 
857     unsigned char *pkt = malloc(pkt_size+4); /* room for crc32 */ 
858     unsigned char *data = malloc(1024*32); 
859     fftw_complex *samples = malloc(1024*32*sizeof(fftw_complex)); 
860     unsigned int i, j, reps, foo; 
861     double sec, usec; 
862     struct timeval tv0, tv1; 
863  
864     ofdm_init_modulation(); 
865  
866     for (j=8; j<16; j++) { 
867         reps = 3000; 
868          
869         gettimeofday(&tv0,0); 
870         for (i=0; i<reps; i++) { 
871             data_size = prepare_data(pkt, pkt_size, data, j); 
872             ofdm_modulate_ieee80211a(data, samples, data_size, &foo); 
873         } 
874         gettimeofday(&tv1,0); 
875          
876         sec = tv1.tv_sec - tv0.tv_sec; 
877         usec = tv1.tv_usec - tv0.tv_usec; 
878         sec = sec + (usec/1000000); 
879  
880         int mbit[16] = { 
881             0, 0, 0, 0, 0, 0, 0, 0, 
882             48, 24, 12, 6, 54, 36, 18, 9}; 
883          
884         printf("%d \t%d in %f\n\t%f Mbit/sec\n", mbit[j], 
885                pkt_size*reps, sec, ((pkt_size*reps*8)/sec)/1000000.0); 
886     } 
887     free(data); 
888     free(pkt); 
889 } 
890  
891 int 
892 ofdm_random_symbol(int ncarriers, char *out) 
893 { 
894     int i;