ATmega 16 AVRGCC SRF02 Distanzmessung

[Achmed B. (xeno1987)]

Liebe Gemeinde,

Ich komme gerade nicht weiter. Wenn ich vom ADC Wandler den Wert become 
der dann zwischen 0-1023 liegt und dann in cm umgerechnet warden soll 
und zwar für 15cm bis 50cm. Kann ich da einfach als Formel das 
proportional nehmen oder muss ich da noch was beachten?

Hier mein bisheriger Code(bzw. der mir zur Verfügung gestellte)

•

#include <util/twi.h>



////////////////////////////////////////////////////////////
// Interne-Routinen:
////////////////////////////////////////////////////////////

/*   Gibt 1 zurück, falls TWINT gesetzt wird.
  Falls nach 40000 Schleifendurchgängen TWINT
  noch nicht gesetzt wurde, gibt 0 zurück.
  */  
int twi_wait4TWINT() {
  uint16_t x=0;
  while (x < 40000) { 
    x++; 
    if ( TWCR & (1<<TWINT) ) {  return 1; }    
  }
  return 0;
}

/*  Gibt 0 zurück, falls der Parameter status nicht
  in den oberen 5 Bytes von TWSR zu finden ist. 
  Sonst, wenn alles in Ordnung ist 1. 
  */
int twi_check( uint8_t status ) {
  return ((TWSR & 0xF8) == status );
}


////////////////////////////////////////////////////////////
// Init-, Start- und Stop-Routinen:
////////////////////////////////////////////////////////////

/*   Setzt die Geschwindikeit des Busses abhängig von der 
  CPU-Geschwindigkeit. */
void twi_init() {

  TWBR = 2;
  TWSR = 0;
  //==> SLCfreq==50KHz bei 1MHz CPU-Takt
}


/*  Leitet einen TWI (I2C) Sende- oder Empfangsvorgang ein.
  Falls erfolgreich, gibt 1 zurück sonst 0; */
int twi_start() {

  // Setze Start-Condition:
  TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN);

  // Warte auf das TWINT-Flag:
  //twi_wait4TWINT();
  
  while(!(TWCR & (1 << TWINT))) ;

  // Gebe den Status zurück:
  return ((TWSR & 0xF8) == TW_START);
}


int twi_rep_start(){
  // Setze Start-Condition:
  TWCR = (1<<TWINT)|(1<<TWSTA)|(1<<TWEN);

  // Warte: auf das TWINT-Flag:
  twi_wait4TWINT();

  // Gebe den Status zurück:
  return twi_check(TW_REP_START);
}


/*  Beendet einen TWI (I2C) Sende- oder Empfangsvorgang. */
void twi_stop(){
  TWCR = (1<<TWINT)|(1<<TWSTO)|(1<<TWEN);
}


////////////////////////////////////////////////////////////
// Sende-Routinen:
////////////////////////////////////////////////////////////

int twi_sla_w(uint8_t slave_adress){

  TWDR = slave_adress;          // Slave Adresse in das Data Register schreiben
  TWCR = (1<<TWINT) | (1<<TWEN);      // Adresse senden.

  // Warten auf das TWINT-Flag
  twi_wait4TWINT();


  return twi_check(TW_MT_SLA_ACK);
}

int twi_sla_r(uint8_t slave_adress){

  TWDR = slave_adress;          // Slave Adresse in das Data Register schreiben
  TWCR = (1<<TWINT)|(1<<TWEN);      // Adresse senden.

  // Warten auf das TWINT-Flag
  twi_wait4TWINT();

  return twi_check(TW_MR_SLA_ACK);
}

int twi_send(uint8_t data){

  TWDR = data;              // Datum in das Data Register schreiben
  TWCR = (1<<TWINT)|(1<<TWEN);      // Datum Senden.

  // Warten auf das TWINT-Flag
  twi_wait4TWINT();

  return twi_check(TW_MT_DATA_ACK);
}


////////////////////////////////////////////////////////////
// Empfangs-Routine:
////////////////////////////////////////////////////////////

/*  Liest ein Byte vom Bus. 

  Parameter:
  int ack     - ACK-Bit
  uint8_t* data  - Unter *data wird das gelesene Byte gespeichert

  Falls ack!=0 wird der Empfang mit einem  ACK-Bit bestätigt 
  (== Erwarte nächstes Byte). Sonst wird das Bit nicht gesetzt 
  (== Transmission beendet).

  Rückgabewert:
  Die Methode gibt eine 0 zurück falls ein Fehler auftritt. Sonst eine 1.
  Ein Fehler tritt auf wenn:
    - data==0 (null-pointer)
    - Lesen nicht erfolgreich war.

  Falls das Lesen nicht erfolgreich war, wird *data auf 0x00 gesetzt.
  
*/
int twi_read(int ack, uint8_t* data){

  // Falls data ein 0-Pointer ist, beende:
  if (data==0) { return 0; }

  // Starte den Lesevorgang:
  if (ack) {                // ACK Senden
    TWCR = (1<<TWINT)|(1<<TWEN)|(1<<TWEA);
  } else {                // NACK Senden
    TWCR = (1<<TWINT)|(1<<TWEN);
  }

  // Warten auf das TWINT-Flag
  twi_wait4TWINT();

  // Überprüfe den Status des Lesevorgangs:
  int status = 0;
  if (ack) {   
    status = twi_check(TW_MR_DATA_ACK); 
  } else {
    status = twi_check(TW_MR_DATA_NACK);
  }

  // Falls lesen erfolgreich, übergebe es an die
  // *data-Variable. Sonst setze *data auf 0:
  if (status) {
    // Lese das Datenregister:
    *data = TWDR;
  } else {
    *data = 0;
  }


  // gebe den Status zurück:
  return status;

}

•

#include <stdlib.h>
#include <avr/io.h>
#include <stdio.h>
#ifndef F_CPU
#    define F_CPU 1000000UL
#endif
#include <util/delay.h>
#include <util/twi.h>

#include "iti_twi.h"
#include "uart.h"

extern void check3();
uint16_t adc_get();

// Please, DO NOT change anything above this line

/**************************************************************************************************
 * TODO:
 *
 * Try to to carry out step-by-step the following tasks. At the end of each
 * task compile, flash and run the code to check whether it works.
 *
 * 1. Program the port B as digital output completing the functions led_init() and led_display()
 *   Set CHECK to 1, and test the code!
 *
 * 2. Now perform an ADC conversion writing the code in the functions adc_init() and adc_get()
 *   Set CHECK to 2, and test the code!
 * 
 * 3. Get familiar with the I2C bus, writing the code to read and write a register on an external
      device; complete the functions twi_writeregister(...) and twi_readregister(...)
 *   Set CHECK to 3, and test the code!
 * 
 * 4. Finally, put all together!
 *      Set CHECK to 0. Then, scroll down to the marked position and write a C-code that 
 *      performs the following operations. Then compile, flash and see everything working...hopefully!
 *
 *      a. initialize all the require peripherals (LEDs, ADC, TWI)
 *   while(1) {
 *    b. read the ADC connected to the potentiometer
 *       c. display its raw value on the led bar
 *     d. write a formula to convert this value from the range 0..1023 into the range 15..50
 *      e. use the last converted value (in the range 15..50) as obstacle collision threshold:
 *         - below this value the LEDs on the display start blinking alerting 
 *           about the presence of a very close object!
 *         (to make the led blinking, shut them off for 150 ms, then on again)
 *         - use printf to display the actual distance on the monitor
 *   }
 *
 * HINT: printf can help you while debugging your code
 *
 **************************************************************************************************/


// Set the next constant to check your code. Then compile, flash and see what happens...

#define CHECK   0

//-------------------------------------------------------------------------------------------------


/**
 * This function initializes the PORTB as digital output.
 * Port B is connected directly to the LEDs bar.
 * All the 8-bits are required as output.
 * 
 * 
 * Paramter:
 *   -
 * 
 * Return:
 *   -
 */
void led_init() {
  // TODO: Configure port B as digital output
  DDRB = 0xFF;
  
}

/**
 * This function sets the PORTB in order to drive the led bar. The number
 * of contiguous led to switch on is proportional to the value passed as paramter. 
 * Such value has to be in the range 0-1023. All the leds are off only 
 * when the input value == 0, while any other value will turn on a number 
 * of leds proportional to the value itself. For example, if the value is 123
 * the led bar display the led0 on. If it is 300, led0 and led1 are on. 
 * And so on...
 * 
 * Paramter:
 *   - uint16_t value, the number in the range 0-1023 to display on the led bar
 * 
 * Return:
 *   -
 */
void led_display(uint16_t value) {
  // TODO:
  // 1. If the input value is 0, set port B to 0.
  // 2. Otherwise, set to digital one a contiguos number of bit -in the port B-
  //    proportional to the input value.
  if(value == 0) PORTB = 0x00;

  else if((value <= 127) && (value > 0)) PORTB = (1<<PB0);
  
  else if((value <= 255) && (value > 127)) PORTB = (1<<PB0) | (1<<PB1);
  
  else if((value <= 383) && (value > 255)) PORTB = (1<<PB0) | (1<<PB1) | (1<<PB2);
  
  else if((value <= 511) && (value > 383)) PORTB = (1<<PB0) | (1<<PB1) | (1<<PB2) | (1<<PB3);
  
  else if((value <= 639) && (value > 511)) PORTB = (1<<PB0) | (1<<PB1) | (1<<PB2) | (1<<PB3) | (1<<PB4);
  
  else if((value <= 767) && (value > 639)) PORTB = (1<<PB0) | (1<<PB1) | (1<<PB2) | (1<<PB3) | (1<<PB4) | (1<<PB5);
  
  else if((value <= 895) && (value > 767)) PORTB = (1<<PB0) | (1<<PB1) | (1<<PB2) | (1<<PB3) | (1<<PB4) | (1<<PB5) | (1<<PB6);    

  else if((value <= 1023) && (value > 895)) PORTB = (1<<PB0) | (1<<PB1) | (1<<PB2) | (1<<PB3) | (1<<PB4) | (1<<PB5) | (1<<PB6) | (1<<PB7);    

}


/**
 * Initialize the ADC.
 * 
 * Params:
 *  - 
 * 
 * Return:
 *  -
 */
void adc_init() {
  // TODO:
  // 1. Enable the ADC by setting the bit ADEN in the register ADCSRA, 
  //    and configure the prescaler with a  division factor of 128
  //    selecting ADPS2:0 as mentioned in the Atmega16 datasheet.
  
  ADCSRA = (1<<ADEN) | (1<<ADPS0) | (1<<ADPS1) | (1<<ADPS2);

  
  // 2. Set REFS1:0 in the ADMUX register to select the supply voltage 
  //    (VCC) as reference voltage (AVCC) for the ADC: set REFS1:0 to 01

  ADMUX = (1<<REFS0) | (0<<REFS1);

  // 3. Perform a dummy reading to clear the ADC before the first real
  //    reading, and ignore the result.

  adc_get();
}

/**
 * Get a value from the ADC.
 * 
 * Params:
 *  - 
 * 
 * Return:
 *  - the raw value read on the ADC.
 */
uint16_t adc_get() {
  // TODO:
  // 1. Set the bit ADSC to start a conversion, but be careful not to 
  //    alter other bits set before during the initialization!

  ADCSRA = (1<<ADSC);
  
  // 2. Wait until the ADSC bit is cleared up again: that means the
  //    conversion is done.

  while(ADSC != 0);
  
  // 3. Return the value you can read in the register ADCW.

  return ADCW;
}

/**
 * Write a byte in a specific register of a TWI device.
 *
 *  Params: 
 *  uint8_t twi_addr,   the addresse of the TWI device to communicate with
 *  uint8_t reg,    the number of the register in the TWI device to write to
 *  uint8_t data,    data byte to be written
 *
 *  Return:
 *  - the status of the sending operation 
*/
uint8_t twi_writeregister(uint8_t twi_addr, uint8_t reg, uint8_t data) {

  uint8_t ret = 0;

  //TODO:
  // 1. Start the TWI communication, waiting until started

  twi_start();

  // 2. Write the address of the TWI device to communicate with

  twi_sla_w(twi_addr);

  // 3. Send the number of the register in the TWI device to write to
  
  twi_sla_r(reg);

  // 4. Send the data byte, saving the status of the operation in the variable ret

  twi_send(data);
  reg = twi_wait4TWINT();

  // 5. Stop the TWI communication, then return

  twi_stop();

  return ret;
}

/**
 * Read a byte from a specific register of a TWI device.
 *
 *  Params: 
 *  uint8_t twi_addr,   the addresse of the TWI device to communicate with
 *  uint8_t reg,    the number of the register in the TWI device to read from
 *  uint8_t *data,    pointer to a variable the incoming data is written to
 *
 *  Return:
 *  - the status of the reading operation 
*/
uint8_t twi_readregister(uint8_t twi_addr, uint8_t reg, uint8_t* data) {

  uint8_t ret = 0;

  //TODO:
  // 1. Start the TWI communication, waiting until started

  twi_start();

  // 2. Write the address of the TWI device to communicate with

  twi_sla_w(twi_addr);

  // 3. Send the number of the register in the TWI device to read from

  twi_sla_r(reg);

  // 4. Stop the communication

  twi_stop();

  // 5. Restart the TWI communication as before

  twi_rep_start();

  // 6. Put the read-address of the TWI device on the bus, remembering to set its LSB to 1

  twi_addr |= 0x01;  // setzen des untersten bits
  twi_sla_w(twi_addr);

  // 7. Read the byte from the bus into the pointed variable data. Perform the reading without ACK!
  //    Store in the variable ret the status of the reading operation.

  twi_read(0,data);
  ret = twi_wait4TWINT();

  // 8. Stop the TWI communication, then return
  
  twi_stop();
  
  return ret;
}



int main ( void ) {
// Please, DO NOT edit the next 26 lines, or the CHECK will not work properly
uart_init();
#if CHECK == 1
    uint16_t val = 0;
    led_init();
    while(1) {
      led_display(val);
      val++;
      val &= 0x3FF;
      _delay_ms(1);
    }
#elif CHECK == 2
    uint16_t raw;
    led_init();
    adc_init();
    while(1) {
      raw = adc_get();
      led_display(raw);
      _delay_ms(80);
    }
#elif CHECK == 3
    led_init();
    twi_init();
    while(1) {
      check3();
    }
#else
// ********************************************************************
// Put the code for the last task (4.) here:

uint16_t adcValue = 0;

// Initializing LED, ADC, TWI

  led_init();
  adc_init();
  twi_init();

  while(1){

    adcValue = adc_get();
    led_display(adcValue);


  }


// ********************************************************************
#endif
  return 0;
}

vg

[Karl H. (kbuchegg)]

Achmed Binto schrieb:
> Liebe Gemeinde,
>
> Ich komme gerade nicht weiter. Wenn ich vom ADC Wandler den Wert become
> der dann zwischen 0-1023 liegt und dann in cm umgerechnet warden soll
> und zwar für 15cm bis 50cm. Kann ich da einfach als Formel das
> proportional nehmen

Das kommt drauf an, was der ADC Wert physikalisch repräsentiert.
Das Datenblatt des Sensors müsste dir doch eigentlich darüber Auskunft 
geben, was die Spannung darstellt und wie sie in eine Entfernung 
umzurechnen ist.

[Achmed B. (xeno1987)]

hi,

im datenblatt steht dazu leider nichts drin. Nur dass man per command 
register wahl die einheiten festlegen kann, aber ich soll ja ne 
umrechnung machen.

[Stefan E. (sternst)]

Achmed Binto schrieb:
> Wenn ich vom ADC Wandler den Wert become
> der dann zwischen 0-1023 liegt und dann in cm umgerechnet warden soll

Seit wann hat denn ein SRF02 überhaupt irgendeinen Analogausgang?

[Achmed B. (xeno1987)]

hi,

ich hatte mich falsch ausgedrückt, der cm wert von dem sensor ist schon 
richtig, es ging hier um die umrechnung des gelesenen wertes vom 
potentiometer.

Aufgabenstellung:

Im fertigen System misst der ATmega16 eine durch einen einstellbaren 
Spannungsteiler erzeugte Analoge Spannung und stellt den gemessen Wert 
auf einer LED Leiste dar, wobei die Zahl der leuchtenden Dioden 
proportional zum eingestellten Spannungswert sein soll. Dieser 
Spannungswert wird dann in einem Abstand zwischen 15 und 50 cm 
umgerechnet der als Schwellwert für die Abstandsmessung dient. Wenn ein 
Objekt näher an den Abstandssensor heran kommt als durch diesen 
Schwellwert definiert, so soll die LED Leiste zu blinken beginnen.