CX ilmamääräanturin korjaus

[koe]

CX T2:sen MAF anturin potikan kaari on siinä määrin ruvella että tyhjäkäynti huojui ja kun vuosi takaperin kävin katsastuksessa niin potikan sormi sattui ruven kohdalle josta sitten seurasi aivan hylkyrajalla olleet HC päästöt.

Tein siihen sellaisen korjauksen että läpän asento tunnistetaan hall-sensorilla jota mikrokontrolleri lukee. MCU lukee myös akkujännitettä ja imuilmaa mittaavaa lämpövastusta. Softalla asetetaan ulos ECUlle lähtevät lämpötila- ja asentojännitteet sopiviin arvoihin. Eli softalla matkitaan potikka/vastusverkko/lämpövastus -häkkyrän toimintaa. Lämpöjännitteen pitää olla oikeassa suhteessa akkujännitteeseen ja asentojännitteen sopivassa suhteessa lämpöjännitteeseen. MCU:ssa ei ole DA muunninta, joten se on erillisenä (tupla). Ja koska DA muunnin ei anna maksimissaan ulos kuin karvan alta käyttöjännitteen (5V) niin muuntimen perässä on operaatiovahvistin (tupla) jolla jännitteet saadaan riittävän ylös. Lämpöjännite on huoneen lämmössä normi akkujännitteellä 8V luokkaa.

Jonkun sortin haaste oli alkuperäisten arvojen mittaaminen. Lämpöä aistivassa osuudessa on kaksi kiinteää vastusta joiden arvot sai mitattua suoraan. Sen lisäksi piti selvittää miten potikka ja sen rinnalla oleva vastusrimpsu reagoi läpän asentoon. Sitä en saanut suoraan mitattua, "auto range" yleismittari oli aivan kuutamolla. Resistanssikäyrän sai selville syöttämällä sisään vakio jännitettä, mittaamalla ulos tulevan jännitteen ja sitten R = U/I. Kun laittoi pisteet kuvaan niin siitä oli helppo oikoa rypyt ja ruvet pois.

Lisäksi systeemissä on pari nappulaa millä vaihdetaan näytön tilaa ja merkataan asennusvaiheessa läpän ääriasennot. Ja potikat joilla voidaan muotoilla käyrää.

Näyttöä ja nappuloita ei ajossa tarvitse, ne olisi kannattanut ehkä laittaa erilliseen koteloon ja irroitettavaksi. Pienemmän laatikon saisi helpommin pois silmistä. Tuokin kyllä mahtui etukulmaan ilmanputsarin eteen. Hyvä ettei näy, meni kaikki reiät sen verran vinoon. Ei ollut porauspäivä kun niitä kairasin. On kaikin puolin kovin itsetehdyn näköinen, mutta ei haittaa, se on itse tehty.

Kävin katsastuksessa, HC arvot oli ok. Eikä läppä (kierrokset) enää vaeltele tyhjäkäynnillä omia aikojaan. Kun ei jättänyt matkalle niin kait tuo toimii. Tosin pieni jännitysmomentti varmaan säilyy tovin.

K-a-r-i

[Risto]

Mainiota & onnittelurt! Toteutit sen mistä varovasti olen haaveillut. Mun uudempi T2 nykii kiihdyttäessä ja olen järkeillyt juuri tuon liukuvastuksen kulumisen ongelmaksi. Yhden jo hankin eBaystä, mutta taisi olla huonompi.

Ahneushan tässä heräsi - itsellä on selkeä tarve ainakin yhdelle, kenties toisenkin saisi joskus ajokuntoon. Minkähänlaisia tekijäoikeuksia tuohon pidät, josko askartelisin samanlaisen? Tai oikeastaan selkeämmin: millähän hintaa moisen tekisit?

kyselee Risto

[ds-jekkeri]

Kova mies ja viitseliäs projekti. Tuollaisen laitteen hinta jollain firmalla teetettynä olisi ainakin 5000, todnäk yli 10.

[koe]

Minkähänlaisia tekijäoikeuksia tuohon pidät, josko askartelisin samanlaisen? Tai oikeastaan selkeämmin: millähän hintaa moisen tekisit?

En pidä mitään tekijänoikeuksia tuohon. Ja vähän niinkuin open source softa tyyliin; laitetaan jakoon sellaisena kun on, toimii tai sitten ei

Jos on tarvetta niin minulta saa kyllä sähköpiirrustukset ja softat (sorsat tai binäärin tai valmiiksi lutikalle poltettuna). Ja neuvoja, tai ainakin kommentteja omista kokemuksista tuota puuhatessa. Tuon juottelu on suhteellisen suoraviivaista, vaikka se hieman sekavalta näyttääkin. Alkaa kyllä maistua puulta jossain vaiheessa. Ota vaan kolvi käteen, et halua minun sitä tekevän (myyrän näkö ja peukalo keskellä kämmentä). Hall-anturi on kiinni läpän akselissa rattailla jotka löysin entisen printterin sisuksista. Noin muuten taisi keskeisimmät viritykset näkyä kuvista.

En ole elektroniikka expertti, joten jollakulla sitä puolta ymmärtävällä voi olla jotain sanottavaa ratkaisun järkevyydestä.

Elektroniikkakomponentit ei ole kovin kalliita. Taisi hall anturi olla hieman alle 20 Eur ja LCD samaa luokkaa. Muut kilkkeet sitten euroja tai muutamia. Lähinnä ajan takaa että suhteellisen halpa kokeilu, jos ei laske tunteja. Tuossa käytetään samaa MCU:ta mikä on Arduino Unossa.

Komponentit (poislukien vastukset ja konkat) oli noi:


ATMEL ATMEGA328P-PU MCU, 8BIT, ATMEGA, 20MHZ, DIP-28
http://fi.farnell.com/atmel/atmega328p- ... dp/1715487" onclick="window.open(this.href);return false;

TEXAS INSTRUMENTS LM258P Operational Amplifier, Dual, 700 kHz, 2 Amplifier, 0.3 V/µs, 3V to 32V, ± 1.5V to ± 16V, DIP
http://fi.farnell.com/texas-instruments ... dp/2323283" onclick="window.open(this.href);return false;

BI TECHNOLOGIES / TT ELECTRONICS 6127V1A180L.5 SENSOR, HALL, 0.2V, +20V TO -10V, 180DEG
http://fi.farnell.com/bi-technologies-t ... dp/2319661" onclick="window.open(this.href);return false;

MICROCHIP MCP4822-E/P Digital to Analogue Converter, Dual, AEC-Q100, 12 bit, Serial, 2.7V to 5.5V, DIP, 8 Pins
http://fi.farnell.com/microchip/mcp4822 ... dp/1439413" onclick="window.open(this.href);return false;

TEXAS INSTRUMENTS LM2574N-5.0/NOPB Buck (Step Down) Switching Regulator, Fixed, 4V-40V In, 5V And 0.5A Out, DIP-8
http://fi.farnell.com/texas-instruments ... dp/1469169" onclick="window.open(this.href);return false;

MULTICOMP MCSCH895-331KU INDUCTOR, 330µH, 10%, RADIAL LEADED
http://fi.farnell.com/multicomp/mcsch89 ... dp/1864386" onclick="window.open(this.href);return false;

MULTICOMP 1N5817 Schottky Rectifier, Single, 20 V, 1 A, DO-41, 2 Pins, 450 mV
http://fi.farnell.com/multicomp/1n5817/ ... dp/7429282" onclick="window.open(this.href);return false;

MIDAS MC21605C6W-BNMLWS Alphanumeric LCD, 16 x 2, White on Blue, 5V, SPI, English, Japanese, Transmissive
http://fi.farnell.com/midas/mc21605c6w- ... dp/2425692" onclick="window.open(this.href);return false;



Alla maistiaiset (keskeiset osat) koodista. Ja jossain alempana huonolla resoluutiolla sähkökuva.

Koodi: Valitse kaikki

#include <SPI.h>
#include <EEPROM.h>

#include "Logging.h"

#include "CxMafSensor.h"
#include "CxMafSensorPinDef.h"
#include "PositionSensor.h"

static const double  RES_TOT_18C =
  RES1_OHM + RPOT_TOT_OHM +
  1 / (1.0 / RES2_OHM + 1.0 / (76.0 + RTEMP_ADJUSTMENT));

static const double VREF_18C_127V = 12.7 * RPOT_TOT_OHM / RES_TOT_18C;


namespace Cx {

/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

CxMafSensor::CxMafSensor()
  :
  m_ledOn( false ),
  m_prevTime( 0 ),
  m_airTempSensor( 
    Util::ResistanceSensor::TOP_SENSOR,
    OPERATING_VOLTAGE, AIR_TEMP_FIXED_RESISTANCE
  ),

  m_airTempConverter( 94, 11.5, 68, 21, 31, 45 ),
  m_displayMode( BASIC ),
  m_calibrationState( IDLE ),
  m_opampOutToDacInConverter( 1.22, 400, 10.74, 3596 ),
  m_minPosAdValue( MIN_POS_DEF_ADVALUE ),
  m_maxPosAdValue( MAX_POS_DEF_ADVALUE ),
  m_posSensorValue( 0 ),
  m_xPos( 0.0 ),
  m_temperatureCelcius( 0.0 ),
  m_temperatureOhm( 0 ),
  m_battSensorValue( 0 ),
  m_batteryVoltage( 0.0 ),
  m_vPos( 0.0 ),
  m_vRef( 0.0 ),
  m_adjustmentVoltLow( 0.0 ),
  m_adjustmentVoltHigh( 0.0 ),
  m_adjustmentVoltRef( 0.0 )
{
  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::Setup()
{
  delay( 100 );

  pinMode( LED_PIN, OUTPUT);
  digitalWrite( LED_PIN, LOW );

  pinMode( DAC_SS_PIN, OUTPUT );
  digitalWrite( DAC_SS_PIN, HIGH );

  SPI.begin();

  m_lcd.Init( LCD_SS_PIN, LCD_REG_SELECT_PIN );
  m_dac.Init( DAC_SS_PIN );
  m_displaySelectButton.Init( DISPLAY_SELECT_PIN );
  m_calibrationButton.Init( CALIBRATION_PIN );

  uint16_t minPos = 0;
  uint16_t maxPos = 0;

  EEPROM.get( 0, minPos );
  EEPROM.get( sizeof( minPos ), maxPos );

  if ( 0xFFFF == minPos ){ minPos = m_minPosAdValue; }
  if ( 0xFFFF == maxPos ){ maxPos = m_maxPosAdValue; }

  if ( m_minPosAdValue < m_maxPosAdValue ){
    m_minPosAdValue = minPos;
    m_maxPosAdValue = maxPos;
  }

  EEPROM.put( 0, m_minPosAdValue );
  EEPROM.put( sizeof( m_minPosAdValue ), m_maxPosAdValue );

  return;
}



/*--------------------------------------------------------------------*//**
 * Called in busy loop
 *//*--------------------------------------------------------------------*/

void CxMafSensor::DoThings()
{
  UpdatePosition();
  UpdateAirTemp();
  UpdateBatteryVoltage();

  CalculateOutVoltages();

  UpdateAdjustments();
  AdjustRefVolt();
  AdjustPosVolt();

  WriteDac();

  CalibratePositionRange();
  UpdateDisplay();

  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::CalibratePositionRange()
{
  if ( CALIBRATE != m_displayMode ){
    m_calibrationState = IDLE;
    return;
  }

  if ( true != m_calibrationButton.IsClicked() ){ return; }

  switch( m_calibrationState ){
    case  IDLE :
      m_calibrationState = WAITING_MIN_VALUE;
      break;

    case  WAITING_MIN_VALUE :
      // if ( m_posSensorValue < m_maxPosAdValue ){
      m_minPosAdValue    = m_posSensorValue;
      // }
      m_calibrationState = WAITING_MAX_VALUE;
      break;

    case  WAITING_MAX_VALUE :
      // if ( m_posSensorValue > m_minPosAdValue ){
        m_maxPosAdValue    = m_posSensorValue;
      // }
      m_calibrationState = IDLE;

      EEPROM.put( 0, m_minPosAdValue );
      EEPROM.put( sizeof( m_minPosAdValue ), m_maxPosAdValue );

      break;
  }

  return;
}


/*--------------------------------------------------------------------*//**
 * This is for development time calibration
 *//*--------------------------------------------------------------------*/

void CxMafSensor::DirectPosToDac()
{
  uint32_t daValue = (m_posSensorValue * 0xFFFUL) / 1023UL;

  m_dac.SetValue( daValue, 0 );
  m_dac.SetValue( daValue, 1 );

  m_lcd.SetPosition( 0, 0 );
  m_lcd.print( m_posSensorValue );
  m_lcd.print( "  " );

  m_lcd.SetPosition( 0, 8 );
  m_lcd.print( (int)daValue );
  m_lcd.print( "   " );

  m_lcd.SetPosition( 1, 0 );
  m_lcd.print( m_batteryVoltage, 1 );
  m_lcd.print( "V  " );

  #ifdef __x86_64__
    LOG_STDOUT(
      "\n 0123456789ABCDEF\n" << 
      "\"" << m_lcd.m_screen[ 0 ] << "\"\n" <<
      "\"" << m_lcd.m_screen[ 1 ] << "\""
    );
  #endif

  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::WriteDac()
{
  uint16_t vRefDac = ConvertOpampOutToDacIn( m_vRef );
  uint16_t vPosDac = ConvertOpampOutToDacIn( m_vPos );

  #if (false)
    LOG_STDOUT(
      "\nvRef=" << m_vRef << ", vRefDac=" << vRefDac <<
      "\nvPos=" << m_vPos << ", vRefDac=" << vPosDac
    );
  #endif

#if ( true )
  m_dac.SetValue( vRefDac, 0 );
  m_dac.SetValue( vPosDac, 1 );
#else
  // for testing with only one DAC output
  m_dac.SetValue( vRefDac, 1 ); 
  m_dac.SetValue( vPosDac, 0 );
#endif

  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

uint16_t  CxMafSensor::ConvertOpampOutToDacIn( double a_volt )
{
  return m_opampOutToDacInConverter.GetValue( a_volt );
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::UpdatePosition()
{
  m_posSensorValue = 
    m_posValueSuppressor.SetValue( analogRead( POS_SENSOR_ANALOG_IN_PIN ) );

  uint16_t posSensorVal = m_posSensorValue;

  if ( m_minPosAdValue < m_maxPosAdValue ){
    if ( posSensorVal < m_minPosAdValue ){ posSensorVal = m_minPosAdValue; }
    if ( posSensorVal > m_maxPosAdValue ){ posSensorVal = m_maxPosAdValue; }
  }
  else{
    // Inverted range; i.e. min pos value > max pos value
    if ( posSensorVal > m_minPosAdValue ){ posSensorVal = m_minPosAdValue; }
    if ( posSensorVal < m_maxPosAdValue ){ posSensorVal = m_maxPosAdValue; }
  }


  double posPercentage =
           double( posSensorVal - m_minPosAdValue )
              /
           double( m_maxPosAdValue - m_minPosAdValue );

  double  subRangeBeginPercentage = 0.0;
  double  subRangeEndPercentage   = 1.0;
  double  subRangeBeginXPos       = 0.0;
  double  subRangeEndXPos         = 110.0;

  if ( 0.063 >= posPercentage ){
    subRangeBeginPercentage = 0.0;
    subRangeEndPercentage   = 0.063;
    subRangeBeginXPos       = 0.0;
    subRangeEndXPos         = 10.0;
  }
  else if ( 0.133 >= posPercentage ){
    subRangeBeginPercentage = 0.063;
    subRangeEndPercentage   = 0.133;
    subRangeBeginXPos       = 10.0;
    subRangeEndXPos         = 20.0;
  }
  else{
    subRangeBeginPercentage = 0.133;
    subRangeEndPercentage   = 1.0;
    subRangeBeginXPos       = 20.0;
    subRangeEndXPos         = 110.0;
  }

  int16_t rangeLen     = m_maxPosAdValue - m_minPosAdValue;
  double  subRangeXLen = subRangeEndXPos - subRangeBeginXPos;

  int16_t subRangeBeginPos =
            subRangeBeginPercentage * rangeLen + m_minPosAdValue;

  int16_t subRangeEndPos =
            subRangeEndPercentage * rangeLen + m_minPosAdValue;

  int16_t subRangeLen = subRangeEndPos - subRangeBeginPos;
  int16_t posInSubRange = posSensorVal - subRangeBeginPos;

  double posSubRangePercentage = double( posInSubRange ) / subRangeLen;

  m_xPos = subRangeBeginXPos + posSubRangePercentage * subRangeXLen;

  #if ( false )
    LOG_STDOUT(
      "\nm_posSensorValue      = " << m_posSensorValue << 
      "\nposPercentage         = " << posPercentage <<
      "\nposInSubRange         = " << posInSubRange <<
      "\nsubRangeBeginPos      = " << subRangeBeginPos <<
      "\nsubRangeEndPos        = " << subRangeEndPos <<
      "\nsubRangeBeginXPos     = " << subRangeBeginXPos <<
      "\nposSubRangePercentage = " << posSubRangePercentage <<
      "\nxPos                  = " << m_xPos
    );
  #endif

  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::UpdateAirTemp()
{
  long sensorValue  =
    m_tempValueSuppressor.SetValue(
      analogRead( AIR_THERMISTOR_ANALOG_IN_PIN )
    );

  m_temperatureOhm  = m_airTempSensor.GetResistance( sensorValue );

  // LOG_STDOUT("m_temperatureOhm=" << m_temperatureOhm );
  // LOG_STDOUT( "sensorValue=" << sensorValue );

  m_temperatureCelcius = m_airTempConverter.GetValue( m_temperatureOhm );

  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::UpdateAdjustments()
{
  UpdateAdjustment( ADJUST_LOW_PIN,  m_adjustmentVoltLow );
  UpdateAdjustment( ADJUST_HIGH_PIN, m_adjustmentVoltHigh );
  UpdateAdjustment( ADJUST_REF_PIN,  m_adjustmentVoltRef );
  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::UpdateAdjustment(
  uint16_t   a_pin,
  double    &a_adjVolt
){
  int  adValue  = analogRead( a_pin );

  if ( 12 > adValue ){ adValue = 12; }          // allow it get to both ends
  else if ( 1012 < adValue ){ adValue = 1012; } // i.e. 500 to both dirs

  a_adjVolt =
    ADJUSTMENT_MAX_VOLT *
    (double( adValue ) - double( ADJUSTMENT_MID_AD_VALUE ) )
      /
    500.0;

  #if ( false )
    LOG_STDOUT(
      "pin=" << a_pin << ", adValue=" << adValue << ", adjV=" << a_adjVolt
    );
  #endif

  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::CalculateOutVoltages()
{
  PositionSensor posSen;

  double  rPos = posSen.GetResistenceForVisualPosition( m_xPos );
  double  rTot =
    RES1_OHM + RPOT_TOT_OHM +
    1 / (1.0 / RES2_OHM + 1.0 / (m_temperatureOhm + RTEMP_ADJUSTMENT));


  #if (false)
    LOG_STDOUT(
      m_xPos << ": batt=" << m_batteryVoltage  << 
      ", rTot=" << rTot << ", rPos=" << rPos
    );
  #endif

  m_vPos = m_batteryVoltage * rPos / rTot;
  m_vRef = m_batteryVoltage * RPOT_TOT_OHM / rTot;

  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::AdjustRefVolt()
{
  double adjustScale = m_vRef / VREF_18C_127V;
  m_vRef = m_vRef + m_adjustmentVoltRef * adjustScale;
  // LOG_STDOUT( "adjustScale=" << adjustScale );

  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::AdjustPosVolt()
{
  double adjustScale = m_vRef / VREF_18C_127V;
  double lowEndScale  = ( 110.0 - m_xPos ) / 110.0;
  double highEndScale = ( 110.0 - ( 110.0 - m_xPos )) / 110.0;

  m_vPos =
    m_vPos +
    m_adjustmentVoltLow * lowEndScale * adjustScale +
    m_adjustmentVoltHigh * highEndScale * adjustScale;

  if ( m_vPos > m_vRef ){ m_vPos = m_vRef; }

  #if ( false )
    LOG_STDOUT(
      "\nadjustScale       =" << adjustScale <<
      "\nlowEndScale       =" << lowEndScale <<
      "\nhighEndScale      =" << highEndScale <<
      "\nadjustmentVoltLow =" << m_adjustmentVoltLow <<
      "\nadjustmentVoltHigh=" << m_adjustmentVoltHigh
    );
  #endif

  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::UpdateBatteryVoltage()
{
  m_battSensorValue =
    m_battValueSuppressor.SetValue( 
      analogRead( BATTERY_VOLTAGE_ANALOG_IN_PIN )
    );

  double adVolt     = ( m_battSensorValue / 1023.0) * OPERATING_VOLTAGE;
  m_batteryVoltage   = 
    adVolt * ( BATT_VOLT_BOTTOM_RESISTANCE + BATT_VOLT_TOP_RESISTANCE )
      /
    BATT_VOLT_BOTTOM_RESISTANCE;

  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::UpdateDisplay()
{
  if ( true == m_displaySelectButton.IsClicked() ){
    m_displayMode = Mode( uint8_t(m_displayMode) + 1 );
    if ( DEBUG < m_displayMode ){ m_displayMode = BASIC; }
    m_lcd.ClearDisplay();
  }

  switch( m_displayMode ){
    case BASIC     : ShowBasicDisplay(); break;
    case ADJUST    : ShowAdjustmentDisplay(); break;
    case CALIBRATE : ShowCalibrationDisplay(); break;
    case DEBUG      : ShowDebugDisplay(); break;
  }


  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::ShowBasicDisplay()
{
  m_lcd.SetPosition( 0, 0 );
  m_lcd.print( m_xPos, 1 );
  m_lcd.print( "  " );

  m_lcd.SetPosition( 0, 6 );
  m_lcd.print( m_batteryVoltage, 1 );
  m_lcd.print( "V " );

  m_lcd.SetPosition( 0, 12 );
  m_lcd.print( (int)m_temperatureCelcius );
  m_lcd.print( "C " );

  m_lcd.SetPosition( 1, 0 );
  m_lcd.print( "r:" );
  m_lcd.print( m_vRef, 2 );
  m_lcd.print( "V " );

  m_lcd.SetPosition( 1, 8 );
  m_lcd.print( "p:" );
  m_lcd.print( m_vPos, 2 );
  m_lcd.print( "V " );

  return;
}


/*--------------------------------------------------------------------*//**
 * In 10mV, i.e. 1V -> 100
 *//*--------------------------------------------------------------------*/

void CxMafSensor::ShowAdjustmentDisplay()
{
  m_lcd.SetPosition( 0, 0 );
  m_lcd.print( "Low  High  Ref  " );

  m_lcd.SetPosition( 1, 0 );
  m_lcd.print( int(m_adjustmentVoltLow * 100.0)  );
  m_lcd.print( "  " );

  m_lcd.SetPosition( 1, 5 );
  m_lcd.print( int(m_adjustmentVoltHigh * 100.0) );
  m_lcd.print( "  " );

  m_lcd.SetPosition( 1, 11 );
  m_lcd.print( int(m_adjustmentVoltRef * 100.0) );
  m_lcd.print( "  " );

  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::ShowCalibrationDisplay()
{
  m_lcd.SetPosition( 0, 0 );
  m_lcd.print( "minPos  maxPos" );

  m_lcd.SetPosition( 1, 0 );
  if ( WAITING_MIN_VALUE == m_calibrationState ){
    m_lcd.print( "?" );
    m_lcd.print( m_posSensorValue );
  }
  else{
    m_lcd.print( m_minPosAdValue );
  }

  m_lcd.print( "  " );

  m_lcd.SetPosition( 1, 8 );
  if ( WAITING_MAX_VALUE == m_calibrationState ){
    m_lcd.print( "?" );
    m_lcd.print( m_posSensorValue );
  }
  else{
    m_lcd.print( m_maxPosAdValue );
  }

  m_lcd.print( "  " );

  return;
}


/*--------------------------------------------------------------------*//**
 *
 *//*--------------------------------------------------------------------*/

void CxMafSensor::ShowDebugDisplay()
{
  m_lcd.SetPosition( 0, 0 );
  m_lcd.print( m_posSensorValue );
  m_lcd.print( " " );

  m_lcd.SetPosition( 0, 5 );
  m_lcd.print( m_temperatureOhm );
  m_lcd.print( "ohm " );

  m_lcd.SetPosition( 0, 12 );
  m_lcd.print( m_battSensorValue );
  m_lcd.print( " " );

  return;
}



} // end of namespace
    
//*** end of file ***

K-a-r-i

[koe]

Tuollaisen laitteen hinta jollain firmalla teetettynä olisi ainakin 5000, todnäk yli 10.

Niinpä, tolla 5000 ja 80 tuntihinnalla (suht tyyppillinen mitä sähkärit tai autohuollot velottaa?) päästään reiluun 60 tuntiin. Vajaa kaksi viikkoa. Jos tyhjiltä pitää aloittaa niin kiire voi tulla. Selkeesti harrasteprojekti; tehdään itse tunteja laskematta ja tietämättä mitä lopulta valmistuu. Vai saisko jossain ammattioppilaitoksissa teetettyä oppilastyönä.

K-a-r-i

[jean-michel]

Tämä on kyllä upea suoritus ja erityisesti tiedon jako kaupan päälle.

Joskus on tullut turattua koulussa intelin 196 prossun kanssa ja kokemus on edelleen traumaattisena mielessä, en koskisi pitkällä haarakepilläkään, saatikka voisi kuvitella suunnittelevani tyhjästä tuollaista.

Ihminen kykenee vaikka mihin jos vain on tarve olemassa ja ajatus kasalla miten sinne pääsee. Toivottavasti nyt kun vinkit on netissä, ottaa Alvadi onkeensa ja tilaa tuhat paketoitua vastaavaa tuotetta kiinasta eurolla.

Cx elää nyt ikuisesti, kun myös kampiakselin asentotunnistimeen on modausohje uk saitilla, jonne en nyt juuri muista linkkiä. Asentotunnistimen sai ulkomaan saitin mukaan aikaan fordin vastaavasta osasta hiukan kauluksen tasoa muuttamalla tms.

[koe]

Jaetaan tietoa vielä sen verran että kinuskit pääsee helpommin työhön käsiksi Alla keskeisimmät tiedot alkuperäisestä.

Koodi: Valitse kaikki

    Vref              not                  Vin (batt)
     (8)           connected                (16)
      |                |                      |
      |    ,------,    |     ,------,         |
  ,---'----|  R1  |----|-----|  R2  |---------|
  |        '------'    |     '------'         |
  |                    |                      |
  |                    |     ,---/--,         |
  |                    '-----|  Rt  |---------'
  |                          '-/----'
  |          ,-------------------------------,
  '----------|           Rpos                |-------,
             '-------------------------------'       |
                            A                        |
                            |                        |
                           (7)                     (gnd)
                           Vpos                      

  R1 = 148 ohm (alkujaan 150?)
  R2 = 150 ohm

  - Rt, ilman lämpötila. Vastus on herkkä virralle, pitää huomioida
    MCU:n etuvastuksen mitoituksessa/softassa.
     temp/C   ohm
     13       100
     18       85
     21       79
     25       67
     30       59
     35       48
     40       41
     45       37

  - Rpos. Potikan ja vastusverkon yhdistelmä. Huom; 0-10 ja 10-20
    välit ovat lyhyempiä kuin muut. Pitää huomioida softassa.
     ohm   pos
      80   0
      80   5
      80   10
      95   15
     145   20
     187   25
     218   30
     247   35
     268   40
     288   45
     306   50
     321   55
     330   60
     337   65
     343   70
     346   75
     349   80
     352   85
     355   90
     356   95
     357   100
     358   105
     359   110

Noi potikan asennot viittaa liitteenä olevan kuvan punaisiin täpliin. Isot päättyy nollaan, pienet vitoseen. Liitteenä lähinnä viihteen vuoksi käyrän malli tietyissä olosuhteissa. Samassa kuvassa siistitty alkuperäinen, laskennallinen, prototyyppi ja autoon päätynyt.

K-a-r-i

[koe]

Enemmissä ajoissa tuli esiin sellaisia ilmiöitä että lämpimällä koneella (tyhjäkäyntikiekat tonnin tuntumassa) autoa oli hankala saada liikkeelle sammumatta. Vapaalla kun polkaisi niin näki että ennenkuin kierrokset nousi niin ne tippui jonnekin lähemmä 500 kiekkaa. Ja ajossa (pari tuhatta kiekkaa) kun polkaisi kaasua reippaammin niin auto potkaisi kerran ennenkuin alkoi käyttäytyä pyydetyllä tavalla. Kuulosti/tuntui melkein mekaaniseltä välykseltä.

Kun katsoin miten ilmamääräläppä liikkuu niin siinä ei ollut mitään viivettä, joten heräsi epäilys että softa ei pysy läpän vauhdissa. Kävi ilmi että softa pyörähtää vain noin 30 kertaa sekunnissa. Lisäksi mitatuista arvoista (asento, lämpötila, akkujännite) laskettiin liukuvaa keskiarvoa viimeisen kymmenen mittauksen yli ja keskiarvoja käytettiin ulos annettavan jännitteen laskennassa. Toi keskiarvoilu oli alkujaan rauhoittamaan eetteripyörteistä johtuvaa vähiten merkitsevien numeroiden heiluntaa näytöllä (jäänne tutkiskeluvaiheesta).

Joten epäilin että kun kaasua polkaisi ripeämmin, niin seos meni hetkellisesti siinä määrin laihalle että alkoi pykiä. Asentojännite laahasi jäljessä ja moottori kuvitteli saavansa vähemmän ilmaa mitä oikeasti sai.

Poistin keskiarvon laskennan ja hioin softaa sen verran että nyt pyörähtää noin 140 kertaa sekunnissa. Ongelmat poistuivat. Lisäksi verrattuna kuluneeseen alkuperäiseen pienen nopeuden ja matalien kierrosten käytös on parantunut. Alkujaan meno kävi hytkyväksi jos ykkösellä tai kakkosella pienillä kierroksilla lisäsi kaasua varomattomasti. Nyt toimii ok, murisee niinkuin kuuluukin.

Samalla poistin käytöstä käyränmuotoilupotikat. Niitä ei nyt tarvittu. Ja kun softa tuli tehtyä siten että potikoiden arvot otettiin huomioon aina, vaikka ei oltaisi "säätötilassa" niin säädöt saattoivat lipua itsekseen pieleen tärinän tai tallipeikon toimesta. Ja sitä koteloa paikalleen tunkiessa ne aina pyörähti, joten piti säätää uusiksi paikallaan. Tarttee tuo aktivoida sitten jos tulee tarvetta. Ja muuttaa samalla sellaiseksi että arvot luetaan vain sopivassa tilassa ja talletetaan käyttöä varten.

Pieni sattumus tapahtui tuota tehdessä. Kun yritin uudella softalla käynnistää niin hörähti mutta sammui. Laitoin vanhan softan takaisin ja sama juttu. Varsinainen sattumus oli että kun kalibroin läpän ääriasennot niin syötin akusta suoraa virtaa ilmamäärämittarin liittimen valittuihin pinneihin (se kun ei saa jännitettä jos kone on sammuksissa) ja hyvästä lunttilapusta huolimatta laiton piuhat ensin +/- -piikkien sijaan jännitteen ulosantipiikkeihin. Mittasin että asentojännitettä ei tule ulos. DA muunnin kyllä operaatiovahvistimelle syötti mitä pitikin. Joten operaatiovahvistimen toinen kanava oli kärvähtänyt. Kun vaihdoin uuden tilalle niin alkoi pelittää.

K-a-r-i