risolto il problema.Oltre a dare in pasto al PID un valore -1<= x <=1, ho fatto in modo che anche il risultato fosse compreso nel range così:

Code:

float PID01::update(float angle, float setPoint){
 
  float error = (setPoint-angle);
 
  /*INTEGRAL*/
  sumI+=error;
  //limit integral
  if (sumI > MAX_I_ERROR){
    sumI = MAX_I_ERROR;
  }
  if (sumI < -MAX_I_ERROR){
    sumI = -MAX_I_ERROR;
  }
 
  /*DERIVATIVE*/
  float dTemp= (angle-oldAngle);
  oldAngle=angle;
 
  return (error*P+ sumI*I+ dTemp*D)/(P+MAX_I_ERROR*I+D*2);
}

Il valore viene poi così gestito:

Code:

enginePower[i] = pid*enginesPower+enginesPower;

in questo modo un quad a 90° avrà un motore spento e l'altro al doppio della velocità impostata.
Attualmente rimane stabile fino a poco più di mezzo stick usando solo il proporzionale (intorno al 10), credo che il resto dello stick non funzioni bene per via del fatto che io lavoro su un range ai motori che va da 30 a 180 mentre gli ESC hanno una velocità massima impostata a credo 140-150, devo fare qualche esperimento registrando l'output dei motori ma oggi non ho avuto il tempo e la voglia 

ah per ora l'output ai motori (e quindi il calcolo del PID) è fissato a 100ms, mentre "l'orizzonte" si aggiorna ogni 2ms

normalmente a un motore basta dare il giusto segnale e questo funziona. L'esc invece possiede il fail-safe, in pratica per un paio di secondi deve arrivargli il segnale basso, dopo di che l'esc "si arma" e risponde ai comandi (i miei con un beep lungo). In oltre se anzichè il segnale basso invii quello alto, in molti esc entri nella fase programmazione in cui, usando il manuale dell'esc e i beep che emette servono per indicare la selezione attuale ecc...
per esempio puoi impostare se il motore a 0 deve frenare o continuare a roteare liberamente per inerzia, frequenza di aggiornamento ecc...

secondo me più che un pid basta un poco di logica. Se i centrali sono sul bianco, sei fuori strada e devi tornare indietro.
se i laterali sono sul bianco devi fermare il motore opposto.
usando un array più vasto di sensori ( o muovendoli in qualche modo ) potresti stimare il tipo di curva che stai per affrontare e rallentare anzichè fermare il motore, e quì entra in campo il pid.

arduino non è abbastanza veloce e con troppa poca memoria per gestire immagini.
la board per la camera che usi dice: "500MHz Analog Devices Blackfin BF537 Processor", ben distanti dai 20MHz di arduino...
in compenso credo tu possa programmare il micro sulla board, che lo colleghi al modulo wireless, e al massimo arduino invia i comandi alla board per inviarli via wireless.

bèh arduino non è un host usb, ma uno slave, quindi non puoi collegarci il lettore salvo che usi una USB host shield, che tra l'altro per leggere una tastiera usb l'ho vista fatta con 2 diodi e l'usb femmina...

è possibile, con qualche circuito esterno per gestire quel numero di led.

Per la parte elativa al lettore barcode non so, mai lavorato nè ho idea di come funzionino

confermo, usa la libreria ufficiale servo.h

#include <Button.h>
vuol dire che la libreria è da cercare solo nel path dell'ide o nel compilatore.
#include "Button.h"
vuol dire di cercare prima la libreria nella cartella in cui stai compilando (ovvero quella del tuo progetto arduino)

Se non erro ne ide arduino e tanto meno il compilatore possiedono una libreria Button.h

un'altra soluzione è mettere la libreria nella cartella libraries di arduino ide, ma lo sconsiglio, meglio tenerci solo le librerie ufficiali

attachinterrupt lasciala stare, è solo un'inizio.
Gli interrupt puoi averli su TUTTI i pin tranne quelli del quarzo. Per maggiori info guarda il manuale atmega e il listato di codice che ho postato.

Una domanda, secondo voi le funzioni di distanza e luce ambientale dovrebbero ritornare un valore, oppure solo aggiornarlo in una variabile?? Cosa è meglio secondo voi?

Per questo volevo fare tutto autoguidato dagli interrupt, così non hai bisogno di queste funzioni. Crei la classe e lei inizia a fare tutto da sola.
I valori poi li salvi in una variabile privata, che può essere letta all'esterno chiamando una funzione... di solito queste funzioni (o meglio metodi) vengono chiamati getQualcosa(), per esempio nel tuo caso getDistanza(). di controparte per settare dei valori funzionali alla classe, si usa setQualcosa()

Puo' contenere una variabile che si chiama uguale alla funzione stessa?

evita, perché i nomi di funzione son comunque indirizzi... infatti puoi fare puntatori a funzione ecc...
e sono abbastanza certo che usando questi "trucchi" che si può creare un linguaggio ad oggetti a partire da uno sequenziale

puoi evitare, fai i collegamenti a mano

edit: però non so se serve qualche componenti in più tipo condensatori o resistenze...

astrobeed ammetto di non aver letto ancora gli articoli, più che altro non trovo più la discussione. Mi puoi ripostare i link?

Nel frattempo ho fatto qualche modifica:
prima di tutto ora in pasto al pid anziché gli angoli, gli angoli / PI in modo che siano valori da -1 a 1, questo perché, matematicamente parlando, moltiplicare un numero per un numero <=1 o >1 ha due comportamenti diversi.

Poi ho limitato l'errore accumulabile dall'integrativo per evitare "eccessi"

Ora con una P = 40 trova stabilità, anche se rimane un poco inclinato.
Poi mettendo la I = 2 si raddrizza bene.
anche nelle reazioni non è una scheggia ma si comporta bene.

Il problema è che se aumento "il gas" ricomincia di nuovo a traballare,

risolvi così:

char invio[1];
invio[0] = (char)stati;
Udp.sendPacket( invio, remoteIp, remotePort);

edit: cazzata, molto meglio risolvere così (funziona lo stesso ma così il codice è più pulito):
char invio = (char)stati;
Udp.sendPacket( &invio, remoteIp, remotePort);

questa è una classe che legge quanto tempo passa a livello high 4 pin (a basso livello puoi avere interrupt su TUTTI i pin atmega)

InputPin.cpp

Code:

#include "InputPin.h"
/*
Let You read digital pin 2,4,5,6
FROM BIRONPILOT V59, tnx to ciskje
*/

//#define MAXUNSIGNEDLONGCVALUE 4294967295
#define MASKPCINT0 (1<<2)
#define MASKPCINT1 (1<<4)
#define MASKPCINT2 (1<<5)
#define MASKPCINT3 (1<<6)


//define necessary values
#define MIN_RADIO_VALUE 1100
#define MAX_RADIO_VALUE 1950
#define maxReceiverAngle 0.5f
//maxReceiverAngle is in radiant

Utils utils;

InputPin::InputPin(){
  pinMode(2, INPUT); // 3 is used for esc
  pinMode(4, INPUT);
  pinMode(5, INPUT);
  pinMode(6, INPUT);
  // interrupt on pin change FROM PCINT16 to PCINT23
  PCICR |= (1 << PCIE2);

  PCMSK2 = (1 << PCINT18) | // digital pin2
  (1 << PCINT20) | // digital pin4
  (1 << PCINT21) | // digital pin5
  (1 << PCINT22); // digital pin6
}

//putted here because interrupt dosn't want it in .h
unsigned long _startIn[4];
unsigned long _rawIn[4];
unsigned long _time;
byte _oldbit=0, _newbit, _changed;
volatile boolean _hasChanged=false;

ISR(PCINT2_vect) {
  _time=micros();
  
  _newbit=PIND;
  _changed=_newbit^_oldbit;
  
  if (_changed&MASKPCINT0){//if digital PIN2 has changed

    if (_newbit&MASKPCINT0) { //if PIN2 now is high
      _startIn[0]=_time;
    }else{
      _rawIn[0]=_time-_startIn[0];
    }
    _hasChanged=true;
  }

  if (_changed&MASKPCINT1){//if digital PIN4 has changed
    if (_newbit&MASKPCINT1)
      _startIn[1]=_time;
    else
      _rawIn[1]=_time-_startIn[1];
    _hasChanged=true;
  }
  
  if (_changed&MASKPCINT2){//if digital PIN5 has changed
    if (_newbit&MASKPCINT2)
      _startIn[2]=_time;
    else
      _rawIn[2]=_time-_startIn[2];
    _hasChanged=true;
  }

  if (_changed&MASKPCINT3){//if digital PIN6 has changed
    if (_newbit&MASKPCINT3)
      _startIn[3]=_time;
    else
      _rawIn[3]=_time-_startIn[3];
  }
  _oldbit=_newbit;
}

int InputPin::getDuration(int i){
  return _rawIn[i];
}

e poi serve il .h con tutte le dichiarazioni di classe:

Code:

#ifndef InputPin_h
#define InputPin_h


#include "WProgram.h"

class InputPin{
  
  public:
    InputPin();
    int getDuration(int); //return the raw duration of high signal, input: channel
  private:
};
#endif

è un cast no? quindi semplicemente
char invio = (char)stati;
Udp.sendPacket( invio, remoteIp, remotePort);

dunque  anche in ricezione devi cambiare
ricevuto=atoi(packetBuffer); deve essere modificato in:
ricevuto = packetBuffer[0];

NO!
tu hai 40 che è un intero.
se fai atoa() NON ottieni 40 che corrisponde alla lettera '(' ma ottieni un array di char formato dalle lettere '4', '0', '\0' (quì mi son sbagliato prima, non è \n ma \0, carattere di fine stringa), quindi hai bisogno di spazio per 3 cifre.

Per ottenere '(', non serve la funzione atoa() ma basta sbattere il valore 40 direttamente in un char (e a questo punto non ti servirebbe nemmeno il carattere di fine stringa, perchè ogni stringa sarebbe di un solo byte, ovvero un solo char)

infatti provando con "00" fa casino ed uno "0" se lo tira sempre dietro!

infatti ti ho spiegato che perchè succeda il casino vero e proprio devono esserci delle coincidenze, come l'andare a scrivere in un'altra variabile o viceversa... e non è una cosa che capita spesso, e magari alle volte capita ma con variabili che sono già state usate e quindi non crea macello, ecc...

ah e comunque se quello \0 vagante nella ram va a riscrivere una variabile del watchdog (difficile, ma possibile) sei punto e a capo, perché sarà il watchdog a impazzire. kiss