Vl6180x Messwerte??

Hallo
ich hätte eine Frage
was mache ich in der Programm falsch das er mir keine 300 Messungen liefert?

//I²C Biblotheken hochladen
#include <Wire.h>
//Sensor Biblotheken  hochladen
#include <VL6180X.h>

VL6180X sensor;



void setup()
{
  
  Serial.begin(115200);

Wire.begin();


  sensor.init();
  sensor.configureDefault();

  }

//dauerschleife
void loop()
{
  
  Serial.println(sensor.readRangeSingle());
  
  //Pause von 2 ms
  delay(0);
}

er gibt mir nur 80 Messwerte in der Sekunde

Danke

Vielleicht ist ja der Default sensor.Default() auf 80 Werte pro Sekunde eingestellt?

Vielen Dank .
Wo sehe ich die Default? was da drin steht finde das nicht.

kann es sein das der Ardruino Uno langsam ist dafür?

Danke

1 #ifndef VL6180X_h 
2 #define VL6180X_h 
3 
 
4 #include <Arduino.h> 
5 
 
6 class VL6180X 
7 { 
8   public: 
9     // register addresses 
10     enum regAddr 
11     { 
12       IDENTIFICATION__MODEL_ID              = 0x000, 
13       IDENTIFICATION__MODEL_REV_MAJOR       = 0x001, 
14       IDENTIFICATION__MODEL_REV_MINOR       = 0x002, 
15       IDENTIFICATION__MODULE_REV_MAJOR      = 0x003, 
16       IDENTIFICATION__MODULE_REV_MINOR      = 0x004, 
17       IDENTIFICATION__DATE_HI               = 0x006, 
18       IDENTIFICATION__DATE_LO               = 0x007, 
19       IDENTIFICATION__TIME                  = 0x008, // 16-bit 
20 
 
21       SYSTEM__MODE_GPIO0                    = 0x010, 
22       SYSTEM__MODE_GPIO1                    = 0x011, 
23       SYSTEM__HISTORY_CTRL                  = 0x012, 
24       SYSTEM__INTERRUPT_CONFIG_GPIO         = 0x014, 
25       SYSTEM__INTERRUPT_CLEAR               = 0x015, 
26       SYSTEM__FRESH_OUT_OF_RESET            = 0x016, 
27       SYSTEM__GROUPED_PARAMETER_HOLD        = 0x017, 
28 
 
29       SYSRANGE__START                       = 0x018, 
30       SYSRANGE__THRESH_HIGH                 = 0x019, 
31       SYSRANGE__THRESH_LOW                  = 0x01A, 
32       SYSRANGE__INTERMEASUREMENT_PERIOD     = 0x01B, 
33       SYSRANGE__MAX_CONVERGENCE_TIME        = 0x01C, 
34       SYSRANGE__CROSSTALK_COMPENSATION_RATE = 0x01E, // 16-bit 
35       SYSRANGE__CROSSTALK_VALID_HEIGHT      = 0x021, 
36       SYSRANGE__EARLY_CONVERGENCE_ESTIMATE  = 0x022, // 16-bit 
37       SYSRANGE__PART_TO_PART_RANGE_OFFSET   = 0x024, 
38       SYSRANGE__RANGE_IGNORE_VALID_HEIGHT   = 0x025, 
39       SYSRANGE__RANGE_IGNORE_THRESHOLD      = 0x026, // 16-bit 
40       SYSRANGE__MAX_AMBIENT_LEVEL_MULT      = 0x02C, 
41       SYSRANGE__RANGE_CHECK_ENABLES         = 0x02D, 
42       SYSRANGE__VHV_RECALIBRATE             = 0x02E, 
43       SYSRANGE__VHV_REPEAT_RATE             = 0x031, 
44 
 
45       SYSALS__START                         = 0x038, 
46       SYSALS__THRESH_HIGH                   = 0x03A, 
47       SYSALS__THRESH_LOW                    = 0x03C, 
48       SYSALS__INTERMEASUREMENT_PERIOD       = 0x03E, 
49       SYSALS__ANALOGUE_GAIN                 = 0x03F, 
50       SYSALS__INTEGRATION_PERIOD            = 0x040, 
51 
 
52       RESULT__RANGE_STATUS                  = 0x04D, 
53       RESULT__ALS_STATUS                    = 0x04E, 
54       RESULT__INTERRUPT_STATUS_GPIO         = 0x04F, 
55       RESULT__ALS_VAL                       = 0x050, // 16-bit 
56       RESULT__HISTORY_BUFFER_0              = 0x052, // 16-bit 
57       RESULT__HISTORY_BUFFER_1              = 0x054, // 16-bit 
58       RESULT__HISTORY_BUFFER_2              = 0x056, // 16-bit 
59       RESULT__HISTORY_BUFFER_3              = 0x058, // 16-bit 
60       RESULT__HISTORY_BUFFER_4              = 0x05A, // 16-bit 
61       RESULT__HISTORY_BUFFER_5              = 0x05C, // 16-bit 
62       RESULT__HISTORY_BUFFER_6              = 0x05E, // 16-bit 
63       RESULT__HISTORY_BUFFER_7              = 0x060, // 16-bit 
64       RESULT__RANGE_VAL                     = 0x062, 
65       RESULT__RANGE_RAW                     = 0x064, 
66       RESULT__RANGE_RETURN_RATE             = 0x066, // 16-bit 
67       RESULT__RANGE_REFERENCE_RATE          = 0x068, // 16-bit 
68       RESULT__RANGE_RETURN_SIGNAL_COUNT     = 0x06C, // 32-bit 
69       RESULT__RANGE_REFERENCE_SIGNAL_COUNT  = 0x070, // 32-bit 
70       RESULT__RANGE_RETURN_AMB_COUNT        = 0x074, // 32-bit 
71       RESULT__RANGE_REFERENCE_AMB_COUNT     = 0x078, // 32-bit 
72       RESULT__RANGE_RETURN_CONV_TIME        = 0x07C, // 32-bit 
73       RESULT__RANGE_REFERENCE_CONV_TIME     = 0x080, // 32-bit 
74 
 
75       RANGE_SCALER                          = 0x096, // 16-bit - see STSW-IMG003 core/inc/vl6180x_def.h 
76 
 
77       READOUT__AVERAGING_SAMPLE_PERIOD      = 0x10A, 
78       FIRMWARE__BOOTUP                      = 0x119, 
79       FIRMWARE__RESULT_SCALER               = 0x120, 
80       I2C_SLAVE__DEVICE_ADDRESS             = 0x212, 
81       INTERLEAVED_MODE__ENABLE              = 0x2A3, 
82     }; 
83 
 
84     uint8_t last_status; // status of last I2C transmission 
85 
 
86     VL6180X(void); 
87 
 
88     void setAddress(uint8_t new_addr); 
89 
 
90     void init(void); 
91 
 
92     void configureDefault(void); 
93 
 
94     void writeReg(uint16_t reg, uint8_t value); 
95     void writeReg16Bit(uint16_t reg, uint16_t value); 
96     void writeReg32Bit(uint16_t reg, uint32_t value); 
97     uint8_t readReg(uint16_t reg); 
98     uint16_t readReg16Bit(uint16_t reg); 
99     uint32_t readReg32Bit(uint16_t reg); 
100 
 
101     void setScaling(uint8_t new_scaling); 
102     inline uint8_t getScaling(void) { return scaling; } 
103 
 
104     uint8_t readRangeSingle(void); 
105     inline uint16_t readRangeSingleMillimeters(void) { return (uint16_t)scaling * readRangeSingle(); } 
106     uint16_t readAmbientSingle(void); 
107 
 
108     void startRangeContinuous(uint16_t period = 100); 
109     void startAmbientContinuous(uint16_t period = 500); 
110     void startInterleavedContinuous(uint16_t period = 500); 
111     void stopContinuous(); 
112 
 
113     uint8_t readRangeContinuous(void); 
114     inline uint16_t readRangeContinuousMillimeters(void) { return (uint16_t)scaling * readRangeContinuous(); } 
115     uint16_t readAmbientContinuous(void); 
116 
 
117     inline void setTimeout(uint16_t timeout) { io_timeout = timeout; } 
118     inline uint16_t getTimeout(void) { return io_timeout; } 
119     bool timeoutOccurred(void); 
120 
 
121   private: 
122     uint8_t address; 
123     uint8_t scaling; 
124     uint8_t ptp_offset; 
125     uint16_t io_timeout; 
126     bool did_timeout; 
127 }; 
128 
 
129 #endif

Das ist die Bibliothek

Hast du mal das Datenblatt gelesen? http://www.st.com/resource/en/datasheet/vl6180x.pdf

Bei den Vorgaben
Timing.png
Timing1.png
finde ich 12,5 ms durchaus plausibel.

Danke
Habe gelesen.
Dachte der Uno wäre die Leistung schwach.

Danke

der hat doch für die Kommunikation 400 khz.

oliralf:
der hat doch für die Kommunikation 400 khz.

Wenn, dann ist das die Bit-Rate auf dem I2C Bus.

Was da als maximale netto Byte Daten-Rate maximal möglich ist kannst du ja ausrechnen.
Die maximale Sample-Rate liegt sicher noch darunter.

Was misst du denn, das eine höhere Auflösung als 80 Samples pro Sekunde erfordert?

Ich will ein Rotationsprüfstand messen mit einen.

WIe rechne ich die aus ?

Danke

Alle Bits der notwendige Kommunikationen zählen und dann teilen?

Glaubst du ich suche das für dich raus?

Ich habe nicht mal so einen Modul, und schon das Datenblatt überflogen.

Ok vielen Dank