From 9ab8eaa0209fc696fc65798752ec74b6c0c4ff0b Mon Sep 17 00:00:00 2001 From: Mark Qvist Date: Sun, 6 Apr 2014 23:10:05 +0200 Subject: [PATCH] More commenting --- Modem/afsk.c | 74 ++++++++++++++++++++++++++++++++++++++++++++++------ 1 file changed, 66 insertions(+), 8 deletions(-) diff --git a/Modem/afsk.c b/Modem/afsk.c index 8681e5e..2075130 100644 --- a/Modem/afsk.c +++ b/Modem/afsk.c @@ -415,7 +415,16 @@ static void afsk_txStart(Afsk *afsk) { uint8_t afsk_dac_isr(Afsk *afsk) { // Check whether we are at the beginning of a sample if (afsk->sampleIndex == 0) { + // If we are, we should figure out what we are + // actually going to modulate and transmit :) if (afsk->txBit == 0) { + // txBit is a bitmask that is ANDed to the + // byte we are sending. It is bitshifted one + // position left each time we shift the next + // bit. If it is 0, we know we are at the + // beginning of the next byte, and nothing + // has been transmitted yet. + // If TX FIFO is empty and tail-length has decremented to 0 // we are done, stop the IRQ and reset if (fifo_isempty(&afsk->txFifo) && afsk->tailLength == 0) { @@ -427,12 +436,18 @@ uint8_t afsk_dac_isr(Afsk *afsk) { // Reset the bitstuff counter if we have just sent // a bitstuffed byte if (!afsk->bitStuff) afsk->bitstuffCount = 0; - // Reset bitstuff indicator to true + // Reset bitstuff indicator to true, signifying + // that it's ok to bit stuff. afsk->bitStuff = true; // Check if we are in preamble or tail if (afsk->preambleLength == 0) { + // We are not in preamble if (fifo_isempty(&afsk->txFifo)) { + // If the TX buffer is empty, we must + // be in the TX tail then. + // Decrement the tail counter and send + // a HDLC_FLAG afsk->tailLength--; afsk->currentOutputByte = HDLC_FLAG; } else { @@ -442,36 +457,74 @@ uint8_t afsk_dac_isr(Afsk *afsk) { afsk->currentOutputByte = fifo_pop(&afsk->txFifo); } } else { + // We are in preamble. We'll decrement + // the preamble counter and transmit a + // HDLC_FLAG afsk->preambleLength--; afsk->currentOutputByte = HDLC_FLAG; } - // Handle escape sequences + // This handles escape sequences and control + // characters. First we check if the current + // byte is an escape character. If it is, we + // know the next byte, even though it looks + // like an HDLC control character, in fact is + // not. Therefore we'll fetch it and transmit + // it as data using bit stuffing. if (afsk->currentOutputByte == AX25_ESC) { + // First make sure that the TX buffer is + // not empty for some strange reason if (fifo_isempty(&afsk->txFifo)) { AFSK_DAC_IRQ_STOP(); afsk->sending = false; LED_TX_OFF(); return 0; } else { + // If it is not, fetch the next byte afsk->currentOutputByte = fifo_pop(&afsk->txFifo); } } else if (afsk->currentOutputByte == HDLC_FLAG || afsk->currentOutputByte == HDLC_RESET) { + // If there was not an escape character and + // this byte is an HDLC control character, + // we know that it is an _actual_ control + // character, and we indicate that it should + // not be bitstuffed. afsk->bitStuff = false; } } - // Start with LSB mask + // Since we are at the beginning of a byte, + // we'll initialize the txBit mask to: + // 00000001. It will then be bit-shifted one + // position to the left each time we send the + // next bit. By ANDing this mask to the byte + // we are sending, we can quickly figure out + // what tone we should transmit. For example: + // + // If we are sending bit number 4 of the + // byte: 01101011 + // The bit mask would be: 00001000 + // If we AND the byte and the + // mask, we get: 00001000 + // Since this is not zero, we know we should + // transmit a one. afsk->txBit = 0x01; } - // Check for bit stuffing + // First we need to check for bit-stuffing if (afsk->bitStuff && afsk->bitstuffCount >= BIT_STUFF_LEN) { + // If we are allowed to bit-stuff, and we have + // reached the maximum number of consecutive + // ones, we'll reset the bit-stuff counter and + // insert a zero into the bitstream afsk->bitstuffCount = 0; afsk->phaseInc = SWITCH_TONE(afsk->phaseInc); } else { - // We are using NRZI so if we want to transmit a 1 + // If we don't need to bit-stuff now, we can get + // on with the actual transmission. + // + // We are using NRZ so if we want to transmit a 1 // the modulated signal will stay the same. For a 0 - // we make the signal transition + // we make the signal transition. if (afsk->currentOutputByte & afsk->txBit) { // We don't do anything, aka stay on the same // tone as before. We have sent one 1, so we @@ -485,14 +538,19 @@ uint8_t afsk_dac_isr(Afsk *afsk) { afsk->phaseInc = SWITCH_TONE(afsk->phaseInc); } - // Move on to the next bit + // Bitshift the mast to allow for the next + // bit in the byte to be transmitted afsk->txBit <<= 1; } + // We set sampleIndex to DAC_SAMPLESPERBIT, + // so we will transmit this bit for the number + // of samples one bit requires to transmit at + // the chosen bitrate. afsk->sampleIndex = DAC_SAMPLESPERBIT; } - // Retrieve af new sample index and DAC it + // Retrieve af new sample and DAC it afsk->phaseAcc += afsk->phaseInc; afsk->phaseAcc %= SIN_LEN; afsk->sampleIndex--;