Hallo jim_quakenbush

Ich habe da ein paar Fragen zu Deiner geänderten adc_read - Funktion; ich hab' da mal ein paar Messungen bei mir mit der Fkt aus der NiboLib und deiner geänderten gemacht:

weisser Boden (weisses Blatt Papier):

Originalwerte (NiboLib):

Front_rechts zwischen 245 - 256
Front_links zwischen 226 -238
Linie_links zwischen 289 - 294
Linie_rechts zwischen 261 - 267

geaenderte ADC-Lib (Deine geaendert adc-Fkt - 5mal einlesen, keine Korrektur)

Front_rechts zwischen 49 - 50
Front_links zwischen 45- 48
Linie_links zwischen 53 - 54
Linie_rechts zwischen 42 - 43

Schwarzer Boden (schwarzes Blatt Papier:)

Originalwerte (NiboLib):

Front_rechts zwischen 5 - 11
Front_links zwischen 3 - 6
Linie_links zwischen 5 - 6
Linie_rechts zwischen 5 - 6

geaenderte ADC-Lib (Deine geaendert adc-Fkt - 5mal einlesen, keine Korrektur)

Front_rechts zwischen 4 - 5
Front_links zwischen 4 - 5
Linie_links zwischen 2 - 3
Linie_rechts zwischen 2 - 3

Die Werte sind Dezimal-Werte, keine Hex-Werte


wie man sieht, ist der Messbereich zwischen weiss und schwarz bei mir um den Faktor 5 kleiner, wenn ich Deine geänderte adc_read fkt verwende - ist das auch so bei Dir? Du hast doch den NIBO tiefer gelegt (die Räder sind kleiner und die Höhe des vorderen Schleifers hast Du doch auch verringert). Welche Werte misst Du bei rein weissem Untergrund (weisses Papier) und bei schwarzem Untergrund (schwarzes Papier)?

Egon

Hallo Egon,

kannst mich übrigens ruhig "Dieter" nennen, wie Dir aus div. Post's bekannt sein dürfte ...

Ich hatte den Nibo2 tiefer gelegt - habe das aber für das Projekt, aus Gründen der Vergleichbarkeit, rückgängig gemacht. Die Werte sollten also - im Rahmen der gegebenen Bauteil-Toleranzen - vergleichbar sein. Die Resonanz war leider - wie bekannt - recht gering, aber so ist es halt im Leben ...

Ich nutzte grundsätzlich workwinds ADC-Routine aus der Lib (bzw. ADC.C) - wende die jedoch etwas anders an. workwind nimmt den ermittelten Wert und führt damit in FLOOR.C div. Berechnungen - unter Berücksichtigung der Kalibrierung - durch. Hierbei macht er aus dem eigentlichen Messwert eine Rechengröße, welche "verhältnismässig" zum Messwert passt.

Für die Linienerkennung benötige ich (aus meiner Sicht) aber diese Rechengrösse nicht. Zu Beginn der "Fahrt zur Linienfolge" werden die Sensoren auf "Linie" und "Feld" kalibriert (die jeweiligen Werte werden ermittelt und mit einem Toleranzfaktor multipliziert gespeichert) und als Vergleichswerte für die Linienerkennung genutzt. Da reichen mir die "Roh-Werte" der ADC-Umwandlung vollkommen aus.

Geändert habe ich nur, dass die 1. Messung nach einem Kanalwechsel (es gibt nur einen ADC-Wandler im ATMEGA und die Eingänge werden jeweils mit diesem ADC-Wandler wechselweise verbunden) verworfen wird. Das empfiehlt AVR in einer App.-Note - ist auch nachvollziehbar, da ein Eingangswechsel auch einen Pegelwechsel mit entsprechendem Einschwingen mit sich bringt. Also verwerfe ich die erste Messung und bilde zusätzlich den Mittelwert aus 5 aufeinanderfolgenden Messungen (die Messungen schwanken leicht an der/den letzen Stelle(n) - das versuche ich damit auszugleichen).

Dir meine Werte zu nennen, welche übrigens auch in etwa in dem Bereich liegen den Du gemessen hast, bringt nichts da die Bauteil-Toleranzen und die Reflektionsfähigkeit verwendeter Materialien (-> Elektrolutz - Schwarz ist nicht gleich Schwarz ...) entsprechende Unterschiede verursachen.

Aus welchem Grund genau workwind die Rechengrößen erzeugt soll er mal selbst beantworten ...

Wie ich schon in einem älteren Post geschrieben habe ist die Positionierung der CNY70-Sensoren aus meiner Sicht sehr Sub-optimal. Diese werden weit außerhalb des optimalen Bereichs (bezogen auf den Abstand zur Reflektionsfläche) betrieben. Ist halt - Konstruktionsbedingt - ein Kompromiss, der sicher einen Grund hat. Wenn man präzisere Werte (mit höherer Differenzierung) haben will muss man sich halt einen anderen Weg überlegen (z.B. de Nibo2 "tiefer legen", um die Sensoren näher an die Reflektionsfläche zu bringen).

Gruß
Dieter

Hallo, Dieter

Die Kalibrierung der CNY70 Sensoren ist in der Regel notwendig, da die Streuung der Kennwerte bei dem Bauteil recht groß isst. Kommt ein empfindlicher Phototransistor mit einer effizienten LED zusammen, ergibt sich ein recht hohes Signal, bei einem nicht so empfindlichen Transistor und einer eher normalen LED ergibt sich ein normal hohes Signal. Der Unterschied bei den CNY70 Sensoren kann bis zu einem Faktor zwei betragen. Wenn bei Deinem Roboter die Roh-Signale in etwa gleich hoch sind, hast Du Glück und benötigst keine Kalibrierung. Der Austausch der Programme mit anderen ist dann natürlich nicht so einfach. Daher die Kalibrierung... Die Berechnungen sind jedoch optimiert und benötigen wenig Rechenleistung. "Böse" Operationen (Division) fallen nur bei der eigentlichen Kalibrierung an, während der Messungen ergeben sich nur Multiplikationen und Additionen und Shift-Operationen die in wenigen Zyklen abgearbeitet werden können.
Die Kalibrierung rechnet nebenbei auch den Umgebungslicht-Einfluss zu einem großen Teil heraus und normalisiert schwarz auf den Wert 0 und weiss auf den Wert 256

Weitere Infos im NIBO-Wiki:
www.nibo-roboter.de/wiki/NIBO_2/Bodensensoren

Gruß,
workwind

Hi @ all

Ich bin ebenfalls ein Neuling was das Programmieren angeht und stehe nun vor dem Problem, dass ich es nicht schaffe das mein Roboter der Linie folgen kann und wollte nun fragen ob jemand so freundlich sein könnte den Quellcode für die Spurhaltung hier posten könnte allerdings ohne download würde mir sehr freuen da es recht wichtig ist
Vielen danke im voraus

Erneut hi @ all

Ich habe es nun geschafft das mein Roboter einer Schwarzen Linie folgen kann.
Allerdings macht er dies manchmal noch recht ruckartig und es kann passieren das er von der Linie abkommt und er soll eine strecke abfahren und am ende im Ziel stehen bleiben aber aufgrund der ruckartigen Bewegungen bleibt er stehen sobald keiner der beiden Sensoren die Schwarzen Linie noch erfassen kann.
kann mir jemand sagen, wie ich es schaffe dass er Sauberer und ohne von der Linie zu kommen fährt?

hier Mein Quellcode:

#include <niboconfig.h>
#include <display.h>
#include <gfx.h>
#include <copro.h>
#include <delay.h>
#include <iodefs.h>
#include <bot.h>
#include <avr/interrupt.h>
#include <spi.h>
#include <stdio.h>
#include <leds.h>

#include <floor.h>
#include "pwm.h"
#include "adc.h"


#include <avr/interrupt.h>
#include <stdint.h>
#include <avr/pgmspace.h>


#define sense 19



int main()
{
sei();
bot_init();
spi_init();
floor_init();
display_init();
gfx_init();
leds_init();
pwm_init();

gfx_move (22, 0);
gfx_set_proportional (1);
gfx_print_text ("Linie folgen");
gfx_set_proportional (0);

gfx_move (5, 10);
gfx_print_char ('R');

gfx_move (118, 10);
gfx_print_char ('L');


copro_ir_startMeasure();
delay (10);
copro_setSpeedParameters(5, 6, 7);
while (1==1)
{

floor_update();
copro_update();
char text [20]="-- -- -- -- --";

// Bodensensoren

floor_update();
copro_update();
sprintf(text, "%02x %02x %02x %02x",
(uint16_t) (floor_relative[FLOOR_RIGHT]/,
(uint16_t) (floor_relative[FLOOR_LEFT]/,
(uint16_t) (floor_relative[LINE_RIGHT]/,
(uint16_t) (floor_relative[LINE_LEFT]/);
gfx_move(22, 30);
gfx_print_text(text);




if ((floor_relative[LINE_LEFT])<sense && (floor_relative[LINE_RIGHT])<sense)
{

copro_setSpeed(20,20);

}

if ((floor_relative[LINE_LEFT])>sense && (floor_relative[LINE_RIGHT])<sense)
{

copro_setSpeed(15,0);

}

if ((floor_relative[LINE_LEFT])<sense && (floor_relative[LINE_RIGHT])>sense)
{

copro_setSpeed(0,15);

}
if ((floor_relative[LINE_LEFT])>sense && (floor_relative[LINE_RIGHT])>sense)
{

copro_setSpeed(0,0);

}
// Spannung

bot_update();
float volt = 0.0166 * bot_supply - 1.19;
sprintf(text, "%3.1fV", (double)volt);
gfx_move(30, 10);
gfx_set_proportional (1);
gfx_print_text("supply: ");
gfx_set_proportional (0);
gfx_print_text(text);

}
return 0;
}