v8.c

Linmodem is soft modem source code for embedded system

/* 
 * V8 protocol handler
 * 
 * Copyright (c) 1999,2000 Fabrice Bellard.
 *
 * This code is released under the GNU General Public License version
 * 2. Please read the file COPYING to know the exact terms of the
 * license.
 * 
 * This implementation is totally clean room. It was written by
 * reading the ITU specification and by using basic signal processing
 * knowledge.  
 */
#include "lm.h"

static void V8_mod_init(V8_mod_state *s)
{
    s->sample_rate = V8_SAMPLE_RATE;

    /* ANSam tone: 2100 Hz, amplitude modulated at 15 Hz, with phase
       reversal every 450 ms */
    s->phase = 0;
    s->phase_incr = (int) (PHASE_BASE * 2100.0 / s->sample_rate);
    s->mod_phase = 0;
    s->mod_phase_incr = (int) (PHASE_BASE * 15.0 / s->sample_rate);
    s->phase_reverse_samples = (int) (s->sample_rate * 0.450);
    s->phase_reverse_left = 0;
    /* XXX: incorrect power */
    s->amp = (int) (pow(10, s->tone_level / 20.0) * 32768.0);
}

static void V8_mod(V8_mod_state *s, s16 *samples, unsigned int nb)
{
    int amp,i;

    for(i=0;i<nb;i++) {
        /* handle phase reversal every 450 ms */
        if (s->phase_reverse_left == 0) {
            s->phase_reverse_left = s->phase_reverse_samples;
            s->phase += PHASE_BASE / 2;
        }

        amp = (dsp_cos(s->mod_phase) * (int)(0.2 * COS_BASE)) >> COS_BITS;
        amp += COS_BASE; /* between 0.8 and 1.2 */
        samples[i] = (amp * dsp_cos(s->phase)) >> COS_BITS;
        s->mod_phase += s->mod_phase_incr;
        s->phase += s->phase_incr;
    }
}

/* Recognize the V8 ANSam tone. Some other tones (in particular V21
   tone) may be added later. We compute the DFT for every interesting
   frequency and do a threshold with the power. Not the best method,
   but easy to implement and quite reliable. */

static void V8_demod_init(V8_demod_state *s)
{
    int i;

    for(i=0;i<V8_N;i++) {
        s->cos_tab[i] = (int) (cos( 2 * M_PI * i / V8_N) * COS_BASE);
        s->sin_tab[i] = (int) (sin( 2 * M_PI * i / V8_N) * COS_BASE);
    }

    s->buf_ptr = 0;
    s->v8_ANSam_detected = 0;
}

static void V8_demod(V8_demod_state *s, const s16 *samples, unsigned int nb)
{
    int i, p0, p1;

    for(i=0;i<nb;i++) {
        s->buf[s->buf_ptr++] = samples[i];
        if (s->buf_ptr >= V8_N) {
            s->buf_ptr = 0;
            dsp_sar_tab(s->buf, V8_N, 8);
            p0 = dsp_norm2(s->buf, V8_N, 0);
            p1 = compute_DFT(s->cos_tab, s->sin_tab, s->buf, DFT_COEF_2100, V8_N);
            /* XXX: this test is incorrect (not homogenous) */
            if ((p0 > 1000) && (p1 > (5*p0))) {
                /* V8 tone recognized */
                s->v8_ANSam_detected = 1;
            }
        }
    }
}

/* V8 stream decoding */
static void ci_decode(V8State *s)
{
    int data = s->rx_data[0];
    if (data == 0x83) {
        printf("CI: data call\n");
    } 
}

/* CM or JM decoding */
static void cm_decode(V8State *s)
{
    u8 *p;
    int c;

    if (s->got_cm)
        return;

    if (s->cm_count > 0) {
        /* we must receive two identical CM sequences */
        if (s->cm_count == s->rx_data_ptr &&
            !memcmp(s->cm_data, s->rx_data, s->rx_data_ptr)) {
            /* got CM !! */
            s->got_cm = 1;
            /* decode it */
            /* XXX: this decoding is sufficient for modulations, but
               not exhaustive */
            s->decoded_modulations = 0;
            p = s->cm_data;
            /* zero is used to indicate the end */
            s->cm_data[s->cm_count] = 0;

            c = *p++;
            /* call function */
            if ((c & 0xf8) != 0x80) 
                return;
            if (c != V8_CALL_FUNC_DATA)
                return;

            /* modulation */
            c = *p++;
            if ((c & 0xf8) != V8_MODN0) 
                return;

            if (c & V8_MODN0_V90)
                s->decoded_modulations |= V8_MOD_V90;
            if (c & V8_MODN0_V34)
                s->decoded_modulations |= V8_MOD_V34;

            c = *p++;
            if ((c & 0x1c) == V8_EXT) {
                /* ignored */
                c = *p++;
                if ((c & 0x1c) == V8_EXT) {
                    if (c & V8_MODN2_V23)
                        s->decoded_modulations |= V8_MOD_V23;
                    if (c & V8_MODN2_V21)
                        s->decoded_modulations |= V8_MOD_V21;
                    /* skip other extensions */
                    do {
                        c = *p++;
                    } while ((c & 0x1c) == V8_EXT);
                }
            }
            return;
        }
    }
            
    /* save the current CM sequence */
    s->cm_count = s->rx_data_ptr;
    memcpy(s->cm_data, s->rx_data, s->rx_data_ptr);
}

static void put_bit(void *opaque, int bit)
{
    V8State *s = opaque;
    int new_state, i;

    /* wait ten ones & synchro */
    s->bit_sync = ((s->bit_sync << 1) | bit) & ((1 << 20) - 1);
    if (s->bit_sync == ((V8_TEN_ONES << 10) | V8_CI_SYNC)) {
        new_state = V8_CI_SYNC;
        goto data_init;
    } else if (s->bit_sync == ((V8_TEN_ONES << 10) | V8_CM_SYNC)) {
        new_state = V8_CM_SYNC;
    data_init:
        /* debug */
        if (s->data_state == V8_CI_SYNC) {
            printf("CI: ");
        } else if (s->data_state == V8_CM_SYNC) {
            if (s->calling)
                printf("JM: ");
            else
                printf("CM: ");
        }
        for(i=0;i<s->rx_data_ptr;i++) printf(" %02x", s->rx_data[i]);
        printf("\n");
        
        /* decode previous sequence */
        switch(s->data_state) {
        case V8_CI_SYNC:
            ci_decode(s);
            break;
        case V8_CM_SYNC:
            cm_decode(s);
            break;
        }
        s->data_state = new_state;
        s->bit_buf = 0;
        s->bit_cnt = 0;
        s->rx_data_ptr = 0;
    }
    
    /* parse octets with 1 bit start, 1 bit stop */
    if (s->data_state) {
        s->bit_buf = ((s->bit_buf << 1) | bit) & ((1 << 10) - 1);
        s->bit_cnt++;
        /* start, stop ? */
        if ((s->bit_buf & 0x201) == 0x001 && s->bit_cnt >= 10) {
            int data;
            /* store the available data */
            data = (s->bit_buf >> 1) & 0xff;
            printf("got data: %d %02x\n", s->data_state, data);
            /* CJ detection */
            if (data == 0) {
                if (++s->data_zero_count == 3) {
                    s->got_cj = 1;
                    printf("got CJ\n");
                }
            } else {
                s->data_zero_count = 0;
            }

            if (s->rx_data_ptr < (sizeof(s->rx_data)-1)) {
                s->rx_data[s->rx_data_ptr++] = data;
            }
            
            s->bit_cnt = 0;
        }
    }
}

static void v8_decode_init(V8State *s)
{
    V21_demod_init(&s->v21_rx, s->calling, put_bit, s);
    s->data_state = 0;
    s->bit_sync = 0;
    s->cm_count = 0;
    s->got_cm = 0;

    s->got_cj = 0;
    s->data_zero_count = 0;
    s->rx_data_ptr = 0;
}


static int get_bit(void *opaque)
{
    V8State *s = opaque;
    int bit;

    bit = sm_get_bit(&s->tx_fifo);
    if (bit < 0)
        bit = 1;
    return bit;
}

static void v8_put_byte(V8State *s, int data)
{
    /* insert start & stop bits */
    sm_put_bits(&s->tx_fifo, ((data & 0xff) << 1) | 1, 10);
}


void V8_init(V8State *sm, int calling, int mod_mask)
{
    sm->debug_laststate = -1;
    sm->calling = calling;
    if (sm->calling) {
        sm->state = V8_WAIT_1SECOND;
        sm_set_timer(&sm->v8_start_timer, 1000);
    } else {
        /* wait 200 ms */
        sm_set_timer(&sm->v8_connect_timer, 200);
        sm->state = V8_WAIT;
    }
    sm_init_fifo(&sm->rx_fifo, sm->rx_buf, sizeof(sm->rx_buf));
    sm_init_fifo(&sm->tx_fifo, sm->tx_buf, sizeof(sm->tx_buf));
    sm->modulation_mask = mod_mask;
}

/* send CM or JM */