Significato del simbolo ->

International Italiano Software
1

Salve,sto approfondendo il linguaggio per Arduino,e vorrei padroneggiare un po' la struttura delle librerie.
Possiedo una piattaforma robotica Alphabot,con relativi programmi e librerie.
Nell libreria destinata al controllo dei motori,ho trovato un simbolo del quale non sono riuscito a trovare la spiegazione nel sito Arduino,vale a dire il simbolo ->
Qualcuno puo' dare qualche spiegazione ?
E' la prima volta che riporto un codice in questa sede,se ho commesso qualche irregolarita
indicatemela pure.
Riporto per intero il file Alphabot.cpp :

#include "AlphaBot.h"

#define DefaultSpeed 255                                                    //Fissa la velocita.

char AlphaBot::LSpeed = DefaultSpeed;
char AlphaBot::RSpeed = DefaultSpeed;

//  Default Arduino Car pin define
AlphaBot::AlphaBot()
{  
  LMotorSpeedPin = 5;             //Left Motor Speed pin (ENA)          //Pin per PWM
  LMotorForward = A0;             //Motor-L forward (IN1)               //Pin per abilitazione e scelta del verso.
  LMotorBackward = A1;            //Motor-L backward (IN2)
  
  RMotorSpeedPin = 6;             //Right Motor Speed pin (ENB)         //Pin per PWM
  RMotorForward = A3;             //Motor-R forward (IN4)
  RMotorBackward = A2;            //Motor-R backward (IN3)
  
  pinMode(LMotorSpeedPin,OUTPUT);                     
  pinMode(LMotorForward,OUTPUT);      
  pinMode(LMotorBackward,OUTPUT);
  
  pinMode(RMotorSpeedPin,OUTPUT);       
  pinMode(RMotorForward,OUTPUT);     
  pinMode(RMotorBackward,OUTPUT);  

}

//AlphaBot::AlphaBot(int LSpeedPin = 5,int L1 = A0,int L2 = A1 ,int RSpeedPin = 6,int R1 = A3,int R2 = A2)

AlphaBot::AlphaBot(int LSpeedPin,int L1,int L2,int RSpeedPin,int R1,int R2)
{
  this->LMotorSpeedPin = LSpeedPin;             
  this->LMotorForward = L1;                
  this->LMotorBackward = L2;
  
  this->RMotorSpeedPin = RSpeedPin;       
  this->RMotorForward = R1;           
  this->RMotorBackward = R2;       
  
  pinMode(LMotorSpeedPin,OUTPUT);                     
  pinMode(LMotorForward,OUTPUT);      
  pinMode(LMotorBackward,OUTPUT);
  
  pinMode(RMotorSpeedPin,OUTPUT);       
  pinMode(RMotorForward,OUTPUT);     
  pinMode(RMotorBackward,OUTPUT); 
}


//drive the left motor run forward
void AlphaBot::LeftMotorForward(char inLSpeed = LSpeed)
{
  analogWrite(LMotorSpeedPin,inLSpeed);                
  digitalWrite(LMotorForward,HIGH);  					
  digitalWrite(LMotorBackward,LOW); 
}

//drive the left motor run backward
void AlphaBot::LeftMotorBackward(char inLSpeed = LSpeed)
{
  analogWrite(LMotorSpeedPin,inLSpeed);                
  digitalWrite(LMotorForward,LOW);  					
  digitalWrite(LMotorBackward,HIGH); 
}

//drive the left motor stop
void AlphaBot::LeftMotorStop()
{
  digitalWrite(LMotorSpeedPin,LOW);               
}

//drive the right motor run forward
void AlphaBot::RightMotorForward(char inRSpeed = RSpeed)
{
  analogWrite(RMotorSpeedPin,inRSpeed);               
  digitalWrite(RMotorForward,HIGH);   				  
  digitalWrite(RMotorBackward,LOW);
}

//drive the right motor run backward
void AlphaBot::RightMotorBackward(char inRSpeed = RSpeed)
{
  analogWrite(RMotorSpeedPin,inRSpeed);               
  digitalWrite(RMotorForward,LOW);   				   
  digitalWrite(RMotorBackward,HIGH);
}

bool AlphaBot::MotorRun(int LS,int RS)
{ 
  if(LS >= 0 && LS <= 255)
  {
    LeftMotorForward(LS);
  }
  if(LS < 0 && LS >= -255)
  {
    LeftMotorBackward(abs(LS));
  }
  
  if(RS >= 0 && RS <= 255)
  {
    RightMotorForward(RS);
  }
  if(RS < 0 && RS >= -255)
  {
    RightMotorBackward(abs(RS));
  }
  if (RS > 255 || RS < -255 || LS > 255 || LS < -255)
  {
    return false;
  }
  
  return true;
}

//drive the right motor stop
void AlphaBot::RightMotorStop()
{
  digitalWrite(RMotorSpeedPin,LOW);             
}

//drive the car run forward
void AlphaBot::Forward()
{
  LeftMotorForward();
  RightMotorForward();
}

//drive the car run forward
void AlphaBot::Forward(unsigned int DelayMS)
{
  Forward();  
  delay(DelayMS);
  Brake();
}

//drive the car run backward
void AlphaBot::Backward()
{
  LeftMotorBackward();
  RightMotorBackward();
}

void AlphaBot::Backward(unsigned int DelayMS)
{
  Backward();  
  delay(DelayMS);
  Brake();
}

//drive the car turn left
void AlphaBot::Left()
{
  LeftMotorStop();
  RightMotorForward();
}

void AlphaBot::Left(unsigned int DelayMS)
{
  Left();  
  delay(DelayMS);
  Brake();
}

//drive the car turn right
void AlphaBot::Right()
{
  RightMotorStop();
  LeftMotorForward();
}

void AlphaBot::Right(unsigned int DelayMS)
{
  Right();  
  delay(DelayMS);
  Brake();
}

//drive the car left circle
void AlphaBot::LeftCircle()
{
  LeftMotorBackward();
  RightMotorForward();
}

void AlphaBot::LeftCircle(unsigned int DelayMS)
{
  LeftCircle();  
  delay(DelayMS);
  Brake();
}

//drive the car Right circle
void AlphaBot::RightCircle()
{
  LeftMotorForward();
  RightMotorBackward();
}

void AlphaBot::RightCircle(unsigned int DelayMS)
{
  RightCircle();  
  delay(DelayMS);
  Brake();
}

//drive the car brake
void AlphaBot::Brake()
{
   LeftMotorStop();
   RightMotorStop();
}

//reset the speed of the car
void AlphaBot::SetSpeed(char LSpeed,char RSpeed)
{
  this->LSpeed = LSpeed;
  this->RSpeed = RSpeed;
  analogWrite(RMotorSpeedPin,RSpeed);  
  analogWrite(LMotorSpeedPin,LSpeed);   
}

//reset the speed of the car
void AlphaBot::SetSpeed(char Speed)
{
  this->LSpeed = Speed;
  this->RSpeed = Speed;
  analogWrite(RMotorSpeedPin,RSpeed);  
  analogWrite(LMotorSpeedPin,LSpeed); 
}

void AlphaBot::SetRSpeed(char Speed)
{
  this->RSpeed = Speed;
  analogWrite(RMotorSpeedPin,RSpeed);                
}

void AlphaBot::SetLSpeed(char Speed)
{
  this->LSpeed = Speed;
  analogWrite(LMotorSpeedPin,LSpeed);                  
}
2

Ciao

in QUESTO link mi sembra spiegato bene.

3

se ricordo bene non è strettamente necessario, ma solo comodo da usare
in questo senso, riprendendo gli esempi di quel sito:
questo:

// Assigning memory to struct variable emp 
    emp = (struct student*) 
        malloc(sizeof(struct student)); 
  
    // Assigning value to age variable 
    // of emp using arrow operator 
    emp->age = 18;

si può scrivere così:

// Assigning memory to struct variable emp 
    emp = (struct student*) 
        malloc(sizeof(struct student)); 
  
    // Assigning value to age variable 
    // of emp using dot operator 
    (*emp).age = 18;

ovvero l'elemento "student" puntato dal puntatore "emp" ha membro "age" uguale a 18
le parentesi servono per "indicare" che il puntatore è solo "emp"
se scrivessi* emp.age=18
significherebbe
l'elemento puntato dal membro "age" dell'oggetto "emp"
invece deve significare
il membro "age" dell'oggetto "student" puntato da "emp"

4

Scusate la mia ignoranza ma come ho detto sto approfondendo.
So che se p e' un pointer,allora p rappresenta il contenuto dell'indirizzo puntato da p.
Ma non so cosa significhi il segno * nel caso student compreso nell'esempio citato.
Non ho trovato neanche malloc tra le istruzioni descritte nel sito.

5

Laverdure:
Ma non so cosa significhi il segno * nel caso student* compreso nell'esempio citato.

Sono argomenti (anche malloc) che nel reference Arduino non sono trattati in quanto considerati "avanzati", si trovano invece in qualsiasi tutorial/reference C/C++

int* dato_p;        // puntatore a intero
int  dato = 12345;

void setup() 
{
    dato_p = &dato; // 'dato_p' punta a 'dato'
    *dato_p = 120;  // modifica la variabile 'dato'
}

void loop() {}

Per il resto x->y equivale a (*x).y

struct dati {
    int  a;
    int  b;
    char c;
} pippo;

dati* pippo_p = &pippo;   // puntatore a 'pippo' di tipo 'dati'

void setup() 
{
    pippo.a      = 12;   // accesso diretto a membro struttura
    (*pippo_p).b = 13;   // accesso tramite puntatore
    pippo_p->c   = '#';  // accesso tramite puntatore semplificato
}

void loop() {}
6

Permettetemi un'ultima domanda :
nel listato di Alphabot.cpp che ho mostrato nel mio primo post,compare diverse volte:

this->

Ora,non c'e' nessun "this" nel file .H ne' nel file .INO,ne'in Arduino.h
Il tutto si compila benissimo e funziona.
Ho provato ad alterare un "this" scrivendo ad es "thiis",e il compilatore da' errore dicendo che non e' stato dichiarato.
Quindi si direbbe che "this" e' stato dichiarato,ma dove ?
Qualcuno sa spiegare questo piccolo mistero ?

7

In parole povere se vuoi accedere ad un membro di una struct, usi il punto tramite una variabile, mentre usi -> se lo fai attraverso un puntatore (come ha anche scritto sopra da @Salvorhardin)
struct x s; val=s.membro;
struct x *p=&s; val=p->membro; ovvero semplificazione di val= (*p).membro;

this è parola chiave del C++ e vuol dire indirizzo dell'oggetto stesso. E un oggetto è una classe e quindi una struct "speciale" che ha membri e funzioni. Puntatore ad oggetto quindi per accedere ad un suol elemento this->membro
Scusa ma sono cose da leggere in un libro del linguaggio C e del linguaggio C++.
Sono delle basi di quei linguaggi, ti consiglio di acquistare e leggere un buon testo sul C++.

8

Ti ringrazio,ma c'e' un piccolo dubbio :il linguaggio usato dall'Arduino coincide perfettamente con il C ed
il C++ ?

9

Il linguaggio è C++ (il compilatore gcc, ovvero gnu-c++) con dei comandi aggiunti specifici per l'ambiente Arduino (quello che viene chiamato core Arduino) tipo i comandi digitalRead() o analogWrite() che non esistono nel C++ ma sono estensioni (librerie interne) specifiche di Arduino

Imparare un linguaggio dagli esempi Arduino non è semplice, io ti consiglio un libro di C e POI un libro di C++, il c++ è il C con delle "aggiunte" (o dei siti in internet). Ti sconsiglio il libro per eccellenza del C di Kernighan/Ritchie perché è rivolto chi già conosce altri linguaggi (non per chi incomincia insomma).

10

nid69ita:
Il linguaggio è C++ (il compilatore gcc, ovvero gnu-c++) con dei comandi aggiunti specifici per l'ambiente Arduino (quello che viene chiamato core Arduino) tipo i comandi digitalRead() o analogWrite() che non esistono nel C++ ma sono estensioni (librerie interne) specifiche di Arduino ...

... per precisione, la programmazione Arduino avviene in C/C++ facendo spesso ricorso al framework "Wiring", ovvero una serie di funzioni, scritte da terzi e NON facenti parti del linguaggio C/C++, che semplificano la scrittura dei programmi nascondendo, dietro appunto semplici funzioni, come digitalWrite() o analogRead(), una serie di più complesse operazioni che occorre fare a basso livello e per le quali occorre conoscere bene il funzionamento della singola MCU.

Guglielmo

11

Per dirla con altre parole:
il "linguaggio" è esattamente lo stesso dei libri di testo: è C++ pressochè puro
ma non ci sono le varie librerie standard ne del 'C' ne del "C++"
non ci sono perchè le poche risorse HW di Arduino non permettono l'esistenza e quindi l'interazione con un sistema operativo
non esistono quindi alcune delle "librerie standard" ne del 'C' ne del "C++"
ma questo riguarda le librerie, pur se standard, non il linguaggio in se
tutti i costrutti: (for, while, if eccetera eccetera) sono esattamente quelli del linguaggio
anche i concetti di puntatore, puntato, oggetto, classe, metodo, array, struttura e via così sono esattamente gli stessi, pur se a causa della limitatezza dello HW non sempre si possono adoperare in pieno
al posto delle librerie standard del 'C' esistono alcune librerie che implementano metodi "alternativi" per interagire con l'esterno, senza passare per un sistema operativo
tipicamente non esistono le librerie e i metodi per interagire con console, terminali, file-system etc etc
ma ne esistono per leggere e scrivere su piedini
esistono librerie per gestire la seriale, che sono "simili" a quelle presenti in implementazioni standard del C, ma non sono "uguali uguali"
anche per leggere e scrivere su una scheda SD esistono funzioni, contenute in apposite librerie, che permettono di interagire con un file-system senza lo strato intermedio di un sistema operativo
ma se, come stai facendo tu, vai a vedere come sono "costruite" queste librerie, trovi esattamente il linguaggio "duro e puro"

ti posso consigliare di dare una lettura a questo?
AiutateCi ad AiutarVi

invece come testo io consiglio fortemente il K&R
sarà ostico, sarà difficile da capire (io non lo ho trovato così, ma ...)
però ha un grande vantaggio: K&R insegnano a programmare conciso
cosa che di recente è rara

12

Laverdure:
Ti ringrazio,ma c'e' un piccolo dubbio :il linguaggio usato dall'Arduino coincide perfettamente con il C ed
il C++ ?

No, per nulla

siccome C e C++ non coincidono tra di loro, nemmeno il linguaggio di Arduino può coincidere con essi

coincide esattamente con C++, e quindi C è quasi completamente utilizzabile

ma di questo non ti devi preoccupare, le differenze tra C e C++ che rendono un programma in C non funzionante in C++ esistono ma sono finezze tecniche che non avrai occasione di utilizzare per molto tempo ancora

non lo dico io, ma me lo ha detto il mio docente all'uni, mi sono limitato a citarlo

con parole mie: esistono rarissimi casi di incompatibilità tra C e C++, ma sono limitati a "usi astrusi", in Arduino non capitano

invece è completamente differente lo IDE

lo IDE di Arduino ti fa molto lavoro "nascosto" e ti fa disabituare a programmare bene:
-include automaticamente alcune librerie standard
-attacca tra di loro una serie di file sorgenti che altrimenti dovresti collegare in sede di link, evitandoti dichiarazioni Extern e robe simili, che invece sarebbero obbligatorie
-crea da solo i prototipi delle funzioni, evitandoti di doverli creare tu o di scrivere le funzioni "prima" di usarle
e poca altra roba, ma già questo ti fa "dimenticare" alcune delle cose più ostiche del linguaggio

13

Io sto iniziando con questo:
C++: Fondamenti di programmazione
Credo che sia il migliore per iniziare da zero.