[arduino] data uit een void loop gebruiken in een ander loop

[Verwijderd]

Is het op de 1 of andere manier mogelijk om de sensorcounter data weer te gebruiken in een andere void.

Ik weet het wel void returns no data.

bijvoorbeeld-
int sensorCounter = 0; // counter for the number of sensor puls
int sensorState = 0; // current state of the sensor
int lastsensorState = 0; // previous state of the sensor
const int sensorPin = 10; // the pin that the sensor is attached to

void setup()
{
LCDMenuLib_setup(_LCDMenuLib_cnt); /* Setup for LcdMenuLib */
Serial.begin(9600); /* start serial */
pinMode(sensorPin, INPUT); // initialize the sensor pin as a input:

void loop()
{
//LCDMenuLib_control_analog(); /* lcd menu control - config in tab "LCDML_control" */
//LCDMenuLib_control_digital(); /* lcd menu control - config in tab "LCDML_control" */
LCDMenuLib_control_serial(); /* lcd menu control */
LCDMenuLib_control_rotary();
LCDMenuLib_loop(); /* lcd function call */
FUNC_sensorCounter();
// Serial.println(LCDMenuLib_getActiveFuncId());
//other function


void FUNC_sensorCounter ()

{
// read the sensor input pin:
sensorState = digitalRead(sensorPin);

// compare the sensorState to its previous state
if (sensorState != lastsensorState) {
// if the state has changed, increment the counter
if (sensorState == HIGH) {
// if the current state is HIGH then the sensor
// wend from low to high:
sensorCounter++;
}
else { // if the current state is LOW then the sensor
// wend from high to low:
}
}
lastsensorState = sensorState;// save the current state as the last state,
//for next time through the loop
}

en dan weer te gebruiken in - en in meer void,s

void FUNC_Astra(void)
{
/* setup function */
if(!LCDML.FuncInit())
{


lcd.clear();
lcd.setCursor(0,0);
lcd.print(sensorCounter);
}
/* end function for callback */
if(LCDML.FuncEnd(0, 1, 1, 1, 1, 1)) /* (direct, up, down, left, right) */
{
/* do something befor this function is closed */
}


Het gaat mij alleen om de data van de sensorcounter de ik weer wil gebruiken in meerdere functie,s.
En dat is alleen maar het optellen bij elke beweging van de sensor (optical Rotary wheel) om een positie te bepalen.
En die on de fly te laten zien op het lcd.

[ Voor 35% gewijzigd door Verwijderd op 28-07-2014 01:37 ]

[Rmg]

Variabele buiten je functie declareren, best wel basic stuff eigenlijk..
http://arduino.cc/en/Tutorial/Variables
http://arduino.cc/en/Reference/scope

Zodra je globale vars in interrupts wil gebruiken moet je hier eens naar kijken http://arduino.cc/en/Reference/volatile

[ Voor 28% gewijzigd door Rmg op 28-07-2014 00:32 ]

[lordprimoz]

zoals door Rmg al is aangegeven moet je globale variabelen gebruiken.

in principe alle variabelen die je buiten een methode declareert (dus buiten bijv de loop() en de setup() etc ) zijn global en kan je in iedere methode aanroepen.

Een interrupt kan op deze manier ook bij de variabelen. Hier kan het wel eens mis gaan als je deze variabele net aan het verwerken bent in een methode en dat op dat moment net de interrupt aangeroepen wordt. Als deze interrupt de data in die variabele overschrijft krijg je dus fouten. Daarom moet je ze dan als volatile gaan declareren.

[ Voor 4% gewijzigd door lordprimoz op 28-07-2014 01:01 ]

[Verwijderd]

mm tja hoe leg ik dat uit .
Ik krijg het nummer ook wel te zien dat uit de counter komt ,maar niet on de fly (live).

Als ik naar de menu functie astra ga staat deze bijvoorbeeld op nul.
Draai ik nu ondertussen aan het encoder wheel blijft hij nul aangeven.

Verlaat ik het menu even en ga weer terug ,geeft hij b.v. 50 aan .enz... even draaien ,niks, menu verlaten,terug naar astra , 130........
De counter telt wel maar update deze niet op het lcd .

Zo werkt het ook niet ,het zelfde als boven.

volatile int sensorCounter = 0; // counter for the number of sensor puls
volatile int sensorState = 0; // current state of the sensor
volatile int lastsensorState = 0; // previous state of the sensor
const int sensorPin = 10; // the pin that the sensor is attached to

[ Voor 28% gewijzigd door Verwijderd op 28-07-2014 01:33 ]

[Sprite_tm]

Dat is waarschijnlijk omdat je menu lib er niet op gebouwd is dat z'n variabelen onder z'n kont veranderen. Ik ken de lib niet, maar waarschijnlijk word op het moment dat je het menu ingaat de string die gedisplayed word gemaakt (met de huidige samplecount erin) en naar je LCD gestuurd. Vanaf dat moment stuurt de lib niets meer, want er staat wat er moet staan.

Hoe je het moet oplossen hangt van je menu lib af; kan zijn dat je er functionaliteit voor updatende menu-items in moet hacken.

[Infant]

Hoe en wat de LCD dunctie precies doet weet ik ook niet, maar een variabele hoef je niet globaal te definieren.

Ik neem aan dat er ergens een main() is waar je programma begint, je kunt alle variabeles die je voor je sensor nodig hebt daar aan maken, en met pointers door geven. Ik heb bijv. alle 4 de variablelen in een struct geplaatst, zodat je alles met een pointer kan door geven:

C:

//Headers die jij niet nodig hebt.
#include <Windows.h>
#include <stdio.h>
#include <Math.h>

//Defines die jij niet nodig hebt.
#define HIGH 1
int digitalRead(int a){
    return rand() % 2;
}

//Types... die je wel nodig hebt
typedef struct sensor_s sensor_s;
//Declare the struct:
struct sensor_s{
    int counter;
    int state;
    int last_state;
    int pin;
};

//Declare function
void FUNC_sensorCounter(sensor_s* s);


//Een main zou je ergens moeten hebben?
int main(void){
    //Create sensor:
    sensor_s sensor;

    //Setup sensor
    sensor.counter = 0;
    sensor.state = 0;
    sensor.counter = 0;
    sensor.pin = 10;

    //While always
    while(1){
        FUNC_sensorCounter(&sensor);
        Sleep(250);
        printf("Sensor.counter: %i\n",sensor.counter);
    }
    return 1;
}

//Jouw funtie, die een pointer naar een sensor_s als argument verwacht
void FUNC_sensorCounter(sensor_s* s){
    // read the sensor input pin:
    s->state = digitalRead(s->pin);

    // compare the sensorState to its previous state
    if (s->state != s->last_state){
        // if the state has changed, increment the counter
        if (s->state == HIGH) {
            // if the current state is HIGH then the sensor
            // wend from low to high:
            s->counter++; 
        }else{ // if the current state is LOW then the sensor
        // wend from high to low:
        } 
    } 
    s->last_state = s->state;// save the current state as the last state, 
    //for next time through the loop 
} 

Nu staan alle variabelen in main gedefinieerd, en zijn dus niet globaal. Maar iedere volgende functie kun je die aan mee geven:

C:

void funct_a(sensor_s* s){
    //Naar een lokale variabele kopieren.
    sensor_s sens = *s;
    //Kopie meegeven.
    funct_a(&sens);
    //Orgineel mee geven.
    funct_a(s);
}

[Verwijderd]

Bedankt Infant ,jouw oplossing lijkt goed te werken.
Kan ik eindelijk verder na veel gepruts van mij zelf.