A module to communicate TDMA with perl.


See the sub-modules,


It may also be useful to view the various cryptograhic modules which can be useful with this set of modules, as well as Time::HiRes

TDMA in a Nutshell

The key to managing data sharing is the Time Division Multiple Access (TDMA) process, a frequency-hopped, time-sequenced transmission scheme. As many as 32 subscribers in each net are assigned time slots within a cycle (or "epoch") that is 12.8 minutes long. Each epoch is subdivided into 64 frames, each of which consists of 1,536 frames of 7.8125 milliseconds each. One of the participants maintains the "clock" to ensure fidelity. Up to 128 sub-nets can be formed simultaneously.

 JTIDS-Link 16, US Navy Warfighter's Encyclopedia
 (see references)

TDMA in (a whole lot of) Detail

TDMA is the division of a day into multiple epochs, which are further subdivided into frames, which are then subdivided again, into slots.

The basic formula is thus:

        1 TDMA Day   = 112.5 Epochs
        1 TDMA Epoch = 64 frames
        1 TDMA Frame = 1536 Slots
        1 TDMA Slot  = 0.0078125 seconds (1/128 second)

        # Thus, walking back up the hierarchy, we see that:
        1 TDMA Frame = 12 seconds
        1 TDMA Epoch = 12.8 minutes (768 seconds)
        1 TDMA Day   = 1440 minutes
        # It may also be helpful to know that
        1 TDMA Epoch = 98,304 slots

The basic unit of communication in the TDMA network is the slot. The amount of data that can be communicated in a slot (1/128 second) of course varies from network to network. If we assume a transmit rate in the HF spectrum, we might be transmitting in the range of 9600bps (which is pretty typical, but for example's sake, we'll use an easier number). If instead we transmit at 16,000 bits per second, that boils down to:

        125 bits per slot
        192,000 bits per frame
        294,912,000 bits per epoch
        33,177,600,000 bits per day
        # Now, let's do the important math for digital communication
        ~15 bytes per slot
        2,400 bytes per frame
        36,864,000 bytes per epoch
        4,147,200,000 bytes per day

So while on the surface, it seems that a relatively sedate rate of communication (16kbit), over relatively mundane technology (HF radio), it is still possible to transmit a large amount of data to a large amount of people (since there is no limit to the number of receivers).

TDMA has a number of qualities that make it very useful. First, as long as everyone in the "loop" has the correct time, everyone knows what data they should be looking at. They can also correlate this with cryptology and hop frequencies during transmission (or, tcp ports if you like, for a wire-based TDMA), making the protocol very difficult to listen in on, and also very difficult to jam.

Additional measures can be taken to make TDMA further robust or more secure, but they are beyond the scope of this document. You may find more at Data::TDMA::Constants

TDMA however is generally not applied to on-wire technology, and is instead broadcast over radio networks. Many assumptions could be made about its application to on-wire technology, such as encryption and evasion. Substantially more data can be communicated over e.g., gigabit ethernet. At this point, the processor and memory (and network transit time) become the serious bottlenecks.


Since our TDMA object is going to be full of days, we're going to give you a way to pull out the day you want. There are a number of ways to do this.

        # Your TDMA object should be viewed as a I<conversation> rather
        # than a transaction. It is an object that I<contains> transactions.
        # So its instantiation should begin with a fresh "Day" object.
        my $now    = time();
        my $today  = Data::TDMA::Day->new( $now, $now + 86400 );
        my $tdma   = Data::TDMA->new( $today );
        # From here, you can interrogate your $day objects. Hopefully
        # you don't have too many, because memory will get full. Fast.
        my $days = $tdma->get_days();

        # If you want to know what epoch was at a given time (because
        # knowing the given day is just about useless), you need to
        # feed this sub a $day object and a time.
        my $epoch = $tdma->time_to_epoch( $day, $time + $delta );
        # The same is true of course for the slot and frame:
        my $slot  = $tdma->time_to_slot( $day, $time + $delta );
        my $frame = $tdma->time_to_frame( $day, $time + $delta );

        # In essence, you could iterate over a set of days, finding
        # the particular frames or slots you wanted, but that's really
        # up to how you want to run your protocol.



It would be very nice if the code understood how to fork as many times as the user specified so that e.g., Apple's new eight-core machines could use all eight cores to assemble their widget and then put it on the line. Of course, that would be complex, and complexity is the arch-enemy of stability (or readability, even).

Link16 and its associated friends like JTIDS were compromised during a military intelligence leak with China involving an arms sale to Taiwan, which was managed by Lockheed Martin MS2 in San Diego.

Link16 also suffered a major blow when planners in congress for military expenditures failed to understand that Link16 was not just an obsolete way to talk to F-16's and wouldn't work on F-22's. Indeed, Link-16, or TDMA, as it is more properly known, can and will work on any network in which there is reliable transit (such as tcpip) or packetform protocol that has internal checksums.

It is now being referred to as MIL-STD 6016 and STANAG 5516.

Be not confused. You hold in your hands cool software. And shame on Lockheed. Really.


        Jane A. Avriette

2 POD Errors

The following errors were encountered while parsing the POD:

Around line 40:

=cut found outside a pod block. Skipping to next block.

Around line 70:

=cut found outside a pod block. Skipping to next block.