gr_framer_sink_1::enter_have_header(int payload_len, int whitener_offset)

    fprintf(stderr, "@ enter_have_header (payload_len = %d) (offset = %d)\n", payload_len, whitener_offset);

  d_packet_whitener_offset = whitener_offset;

	    int payload_len;

	    int payload_offset;

	    header_payload(&payload_len, &payload_offset);

	    enter_have_header(payload_len, payload_offset);

	    // NOTE: passing header field as arg1 is not scalable

	    gr_message_sptr msg = gr_make_message(0, d_packet_whitener_offset, 0, d_packetlen_cnt);  	    

  int                d_packet_whitener_offset;  // offset into whitener string to use

  void enter_have_header(int payload_len, int whitener_offset);

  void header_payload(int *len, int *offset)

    // payload length is lower 12 bits

    // whitener offset is upper 4 bits

    *len = (d_header >> 16) & 0x0fff;

    *offset = (d_header >> 28) & 0x000f;

    def __init__(self, fg, modulator, access_code=None, msgq_limit=2, pad_for_usrp=True, use_whitener_offset=False):

        @param use_whitener_offset: If true, start of whitener XOR string is incremented each packet

        self._use_whitener_offset = use_whitener_offset

        self._whitener_offset = 0

                                           self._pad_for_usrp,

                                           self._whitener_offset)

            if self._use_whitener_offset is True:

                self._whitener_offset = (self._whitener_offset + 1) % 16

            ok, payload = packet_utils.unmake_packet(msg.to_string(), int(msg.arg1()))

def whiten(s, o):

    z = sa ^ random_mask_vec8[o:len(sa)+o]

def dewhiten(s, o):

    return whiten(s, o)        # self inverse

def make_header(payload_len, whitener_offset=0):

    # Upper nibble is offset, lower 12 bits is len

    val = ((whitener_offset & 0xf) << 12) | (payload_len & 0x0fff)

    #print "offset =", whitener_offset, " len =", payload_len, " val=", val

    return struct.pack('!HH', val, val)

                access_code=default_access_code, pad_for_usrp=True,

                whitener_offset=0):

    Build a packet, given access code, payload, and whitener offset

    @param whitener_offset        offset into whitener string to use [0-16)

    if not whitener_offset >=0 and whitener_offset < 16:

        raise ValueError, "whitener_offset must be between 0 and 15, inclusive (%i)" % (whitener_offset,)

    pkt = ''.join((packed_preamble, packed_access_code, make_header(L, whitener_offset),

                   whiten(payload_with_crc, whitener_offset), '\x55'))

def unmake_packet(whitened_payload_with_crc, whitener_offset=0):

    payload_with_crc = dewhiten(whitened_payload_with_crc, whitener_offset)

	run_length.py		\

* run_length.py: This program takes a single argument '-f FILE' and

outputs the number of runs of similar bits within the file. It is

useful as a diagnostic tool when experimenting with line coding or

whitening algorithms.

    parser.add_option("","--from-file", default=None,

                      help="use file for packet contents")

    if options.from_file is not None:

        source_file = open(options.from_file, 'r')

        if options.from_file is None:

            data = (pkt_size - 2) * chr(pktno & 0xff) 

        else:

            data = source_file.read(pkt_size - 2)

            if data == '':

                break;

        payload = struct.pack('!H', pktno) + data

        send_pkt(payload)

        n += len(payload)

#!/usr/bin/env python

#

# Copyright 2007 Free Software Foundation, Inc.

# 

# This file is part of GNU Radio

# 

# GNU Radio is free software; you can redistribute it and/or modify

# it under the terms of the GNU General Public License as published by

# the Free Software Foundation; either version 2, or (at your option)

# any later version.

# 

# GNU Radio is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU General Public License for more details.

# 

# You should have received a copy of the GNU General Public License

# along with GNU Radio; see the file COPYING.  If not, write to

# the Free Software Foundation, Inc., 51 Franklin Street,

# Boston, MA 02110-1301, USA.

# 

from optparse import OptionParser

import sys

def main():

    parser = OptionParser()

    parser.add_option("-f", "--file", default=None,

                      help="Choose file to read data from.")

    (options, args) = parser.parse_args()

    if options.file == None:

        print "Must specify file to read from using '-f'."

        sys.exit(1)

    print "Using", options.file, "for data."

    f = open(options.file, 'r')

    runs = []

    count = 0

    current = 0

    bytes = 0

    bits = 0

    for ch in f.read():

        x = ord(ch)

        bytes = bytes + 1

        for i in range(7,-1,-1):

            bits = bits + 1

            t = (x >> i) & 0x1

            if t == current:

                count = count + 1

            else:

                if count > 0:

                    if len(runs) < count:

                        for j in range(count - len(runs)):

                            runs.append(0);

                    runs[count-1] = runs[count-1] + 1

                current = 1-current;

                count = 1

    # Deal with last run at EOF

    if len(runs) < count and count > 0:

        for j in range(count - len(runs)):

            runs.append(0);

    runs[count-1] = runs[count-1] + 1

    chk = 0

    print "Bytes read: ", bytes

    print "Bits read:  ", bits

    print

    for i in range(len(runs)):

        chk = chk + runs[i]*(i+1)

        print "Runs of length", i+1, ":", runs[i]

    print

    print "Sum of runs:", chk, "bits"

    print

    print "Maximum run length is", len(runs), "bits"

if __name__ == "__main__":

    main()

        self._use_whitener_offset = options.use_whitener_offset # increment start of whitener XOR data

                          pad_for_usrp=True,

                          use_whitener_offset=options.use_whitener_offset)

        expert.add_option("","--use-whitener-offset", action="store_true", default=False,

                          help="make sequential packets use different whitening")