J1850 Implement

http://avrobdii.googlecode.com/svn/trunk/code/J1850.c

/*
 Copyright (C) Trampas Stern  name of author

 This program 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
 of the License, or (at your option) any later version.

 This program 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 this program; if not, write to the Free Software
 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */

/*******************************************************************
 *  File: J1850.c
 *
 *  Copyright ©,  Trampas Stern. All Rights Reserved.
 *  Date: 5/19/2006 9:34:55 PM
 *******************************************************************/
#include "scanner.h"
#include "time.h"

#define PWM_UNKNOWN 0
#define PWM_BUS_ERROR 1
#define PWM_SOF  2
#define PWM_DATA 3
#define PWM_EOD  4
#define PWM_EOF  5
#define PWM_IDLE 6

#define PWM_BIT_US 24 //us for bit time
#define PWM_EOD_US 51 //us for End of Data time
#define PWM_EOF_US 72 //us for End of Frame time
#define PWM_IDLE_US 96 //us till idle

#define TP1 8
#define TP2 16
#define TP3 24
#define TP4 48
#define TP5 72
#define TP7 32

#define PWM_OUT(x) {if (x) BIT_SET(PORTB,5); else BIT_CLEAR(PORTB,5);}
#define PWM_IN BIT_TEST(ACSR,5)

#define J1850_ARRAY_N 16
#define J1850_ARRAY_PKTS 4   //must be power of 2
UINT8 J1850Data[ J1850_ARRAY_PKTS ][ J1850_ARRAY_N ];
UINT8 J1850DataBytes[ J1850_ARRAY_PKTS ];
UINT8 J1850DataTime[ J1850_ARRAY_PKTS ];

volatile UINT8 J1850_dataRead;
volatile UINT8 J1850_dataWrite;

volatile UINT8 PWMState;

volatile UINT8 *ptrWrite;

volatile UINT8 NumPktBytes;

/****************
 Basic Operation
 The J1850 comes in two flavors a PWM (pluse width modulation) and VPW
 (variable pluse width modulation). For our initial system what we
 are going to do is have the analog comparitor trigger on rising and
 falling edges. Then we will have this trigger the timer/caputre (TC1).
 This will tell allow us to measure the pulse widths.
 *****************/

/******************************************************************
 ** J1850Init
 *
 *  DESCRIPTION:
 *
 *  Create: 5/19/2006 9:35:25 PM - Trampas Stern
 *******************************************************************/
INT J1850Init( void )
{
  //Set up data direction registers
  BIT_SET( DDRB,  ); //set OUT_VPW as output
  BIT_SET( DDRB,  ); //set OUT_PWM as output

  //ENABLE PWM
  //BIT_SET(DDRC,2); //set pin as ouput
  //BIT_CLEAR(PORTC,2); //drive pin low

  BIT_CLEAR( PORTB,  );  //Turn off OUT_VPW
  BIT_CLEAR( PORTB,  );  //Turn off OUT_PWM

  //setup the analog comparator
  ADCSRB = 0x00; //use negative input on compartor
  ACSR = 0x08;

  //Output capture mode all disconnected
  TCCR1A = 0x00;

  //noise canceler on (bit 7)
  // prescaller clk/8==tick every half microSecond
  TCCR1B = 0x82;

  //ignore the force output compare
  TCCR1C = 0x00;

  //set count to zero
  TCNT1 = 0x00;

  //The timer is reset on the rising edge of bits
  //the EOD,EOF,and Idle time are based on end of last bit
  // Thus we have to add bit time to each
  //double due to timer runing twice as fast
  OCR1A = ( PWM_EOD_US + PWM_BIT_US ) * ; //EOD time
  OCR1B = ( PWM_EOF_US + PWM_BIT_US ) * ;  //EOF time
  OCR1C = ( PWM_IDLE_US + PWM_BIT_US ) * ; //IDLE time

  TIMSK1 = 0x0E;

  J1850_dataWrite = ;
  J1850_dataRead = ;
  NumPktBytes = ;
  ptrWrite = J1850Data[ J1850_dataWrite ];
  PWMState = PWM_UNKNOWN;
  return NO_ERROR;
}

ISR( TIMER1_COMPA_vect )
{
  if ( BIT_TEST( ACSR,  ) ==  ) //passive bus state
  {
    if ( PWMState < PWM_EOD )
    {
      PWMState = PWM_EOD;
      if ( NumPktBytes >  )
      {
        J1850DataBytes[ J1850_dataWrite ] = NumPktBytes;
        J1850_dataWrite++;
        J1850_dataWrite = J1850_dataWrite & ( J1850_ARRAY_PKTS -  );
        ptrWrite = J1850Data[ J1850_dataWrite ];
      }
      NumPktBytes = ;
    }
  }
  else
  {
    PWMState = PWM_BUS_ERROR;
  }
}

ISR( TIMER1_COMPB_vect )
{
  if ( BIT_TEST( ACSR,  ) ==  ) //passive bus state
  {
    PWMState = PWM_EOF;
  }
  else
  {
    PWMState = PWM_BUS_ERROR;
  }
}

ISR( TIMER1_COMPC_vect )
{
  if ( BIT_TEST( ACSR,  ) ==  ) //passive bus state
  {
    PWMState = PWM_IDLE;
  }
  else
  {
    PWMState = PWM_BUS_ERROR;
  }
  // Note we do not want the timer to overflow so
  //  we reset it to some nominal amount.
  //TCNT1=48*2+1;
}

/******************************************************************
 ** Analog Comparator ISR
 *
 *  DESCRIPTION:
 *
 *  Create: 6/4/2006  9:21:43 AM - Trampas Stern
 *******************************************************************/
ISR( ANALOG_COMP_vect )
{
  static UINT8 data = ;
  static UINT8 bits = ;

  UINT8 t;

  //read timer1
  t = TCNT1L;
  if ( BIT_TEST( ACSR,  ) !=  )
  {
    //rising edge
    TCNT1L = 0x00;
    if ( PWMState > PWM_DATA )
    {
      J1850DataTime[ J1850_dataWrite ] = t;
    }

  }
  else  //we have falling edge
  {
    //Falling edge
    if ( t <=  && t >=  )
    {
      PWMState = PWM_DATA;
      data = data << ;
      if ( t <=  )
        data = data | 0x01;
      bits++;
      if ( bits >  )
      {
        *ptrWrite = data;
        NumPktBytes = NumPktBytes + ;
        if ( NumPktBytes < J1850_ARRAY_N )
        {
          ptrWrite++;
          //if (ptrWrite>(J1850Data + (4*16)))
          //{
          //  ptrWrite--;
          //}
        }
        bits = ;
      }
    }
    if ( t >=  && t <=  )
    {
      PWMState = PWM_SOF;
      bits = ;
    }
  }

}

/******************************************************************
 ** J1850test
 *
 *  DESCRIPTION:
 *
 *  Create: 6/4/2006  9:33:15 AM - Trampas Stern
 *******************************************************************/
INT J1850test( void )
{
  UBYTE i;

  if ( J1850_dataWrite != J1850_dataRead )
  {
    printf_P( PSTR( "\nPWMSTATE=%d\n" ), PWMState );
    printf_P( PSTR( "J1850_DATA %d(us) " ),
      J1850DataTime[ J1850_dataRead ] /  );
    for ( i = ; i < J1850DataBytes[ J1850_dataRead ]; i++ )
    {
      UINT8 d;
      d = J1850Data[ J1850_dataRead ][ i ];
      printf_P( PSTR( "%X " ), d );
    }
    J1850_dataRead++;
    J1850_dataRead = J1850_dataRead & ( J1850_ARRAY_PKTS -  );

  }

  return NO_ERROR;
}

/******************************************************************
 ** PWM_get
 *
 *  DESCRIPTION: Gets a PWM packet
 *
 *  Create: 6/11/2006 7:05:01 PM - Trampas Stern
 *******************************************************************/
INT pwm_get( UINT8 *ptr, UINT8 count, UINT16 time_out_ms )
{
  TIME ptrTime;
  UINT8 i = ;
  //get current time
  GetTime( &ptrTime );

  while ( !done )
  {
    if ( J1850_dataWrite != J1850_dataRead )
    {
      //printf_P(PSTR("\nPWMSTATE=%d\n",PWMState);
      //printf_P(PSTR("J1850_DATA %d(us) ",J1850DataTime[J1850_dataRead]/2);
      for ( i = ; i < J1850DataBytes[ J1850_dataRead ] && i < count; i++ )
      {
        //UINT8 d;
        *ptr++ = J1850Data[ J1850_dataRead ][ i ];
        //printf_P(PSTR("%X ",d);
      }
      J1850_dataRead++;
      J1850_dataRead = J1850_dataRead & ( J1850_ARRAY_PKTS -  );

    }

    //check timne
    if ( GetElaspMs( ptrTime ) > time_out_ms )
    {
      done = ;
    }
  } //while

  return i;
}

/******************************************************************
 ** pwm_put
 *
 *  DESCRIPTION:
 *
 *  Create: 6/11/2006 7:10:50 PM - Trampas Stern
 *******************************************************************/
INT pwm_put( UINT8 *data, UINT8 count, UINT16 time_out_ms )
{

  TIME ptrTime;
  UINT8 done = ;
  UINT8 i = ;
  INT8 bit;
  UINT8 time;
  //get current time
  GetTime( &ptrTime );

  while ( !done )
  {
    //first check that the PWM bus is idle
    if ( PWMState >= PWM_IDLE )
    {
      //disable the receive ISRs
      TIMSK1 = 0x00;
      ACSR = 0x00;

      //Transmit SOF
      TCNT1L = 0x00;
      PWM_OUT(  );
      while ( TCNT1L < TP7 )
        ;
      if ( PWM_IN !=  )
      {
        //enable reciever
        ACSR = 0x08;
        TIMSK1 = 0x0E;
        return ;
      }
      while ( TCNT1L < ( TP7 *  ) )
        ;
      //drive low
      PWM_OUT(  );
      while ( TCNT1L < ( TP4 *  ) )
        ;
      TCNT1L = 0x00;
      PWM_OUT(  );

      //now lets drive the bits
      for ( i = ; i < count; i++ )
      {
        UINT8 t;
        t = *data++;
        for ( bit = ; bit >= ; bit-- )
        {
          UINT8 b;
          b = ( t >> bit ) & 0x01;
          time = TP1;
          if ( b ==  )
          {
            time = TP2;
          }
          while ( TCNT1L < ( time ) )
            ;
          if ( PWM_IN !=  )
          {
            //drive low
            PWM_OUT(  );
            //enable reciever
            ACSR = 0x08;
            TIMSK1 = 0x0E;
            return ;
          }
          while ( TCNT1L < ( time *  ) )
            ;
          PWM_OUT(  );
          while ( TCNT1L < ( TP3 *  ) )
            ;
          TCNT1L = 0x00;
          PWM_OUT(  );
        }
      }
    } //if PWMstate
    //check time
    if ( GetElaspMs( &ptrTime ) > time_out_ms )
    {
      done = ;
    }
  } //while(!done)
  //drive low
  PWM_OUT(  );
  //enable reciever
  ACSR = 0x08;
  TIMSK1 = 0x0E;
  return i;
}

//does CRC calculations
UINT8 crc( UINT8 *data, UINT8 len )
{
  UINT8 result;
  UINT8 i;
  UINT8 mask;
  UINT8 j;
  UINT8 temp;
  UINT8 poly;

  result = 0xFF;
  for ( i = ; i < len; i++ )
  {
    mask = 0x80;
    temp = data[ i ];
    for ( j = ; j < ; j++ )
    {
      if ( temp & mask )   //bit is 1
      {
        poly = 0x1c;
        if ( result & 0x80 )
        {
          poly = ;
        }
        result = ( ( result <<  ) | 0x01 ) ^ poly;

      }
      else
      {
        poly = ;
        if ( result & 0x80 )
        {
          poly = 0x1D;
        }
        result = ( ( result <<  ) ) ^ poly;

      }
      mask = mask >> ;
    }
  }
  return ~result;
}