Discussion :

[lupus5]

Bonjour,

Voici le code que j'ai écrit, pour pratiquer... mais en le regardant je me demande deux trois choses. Mais d'abord le code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
Fichier h
class Motor
{
	float	PWM_Freq;//Pulse Width Frequency 
	float	CalculatePWMFreq(const float &Value) const;//Calculate the pwm frequency versus voltage
public:
	Motor(const float &InitPWM_Freq);//constructeur
	bool SetPWM_Freq(const float &ValueVDOUT);
	float GetPWM_Freq() const;
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
fichier cpp
#include "stdafx.h"
#include "Fichier.h"
#include <iostream>
 
bool Motor::SetPWM_Freq(const float &Value)
{
	float result = CalculatePWMFreq(Value);
	return true
}
float Motor::GetPWM_Freq() const
{
	return PWM_Freq;
}
Motor::Motor(const float &Value)
{
	SetPWM_Freq(Value);
}
float Motor::CalculatePWMFreq(const float &VoutNeeded) const
{
	float result = (VoutNeeded * 0.5 * 1000);
	std::cout << result << std::endl;
	return result;//fake calculation
}

Voilà, est-ce que phylosophiquement c++ parlant ce code vous semble propre?

Parce qu'avec tout ces const on protége le code mais n'y en-a-t-il pas trop?



Merci par avance pour vos interventions.

[ternel]

En avant propos, j'ai l'usage de mettre le const à droite du type qu'il qualifie (comme c'est le cas normalement).
Ca a l'avantage de regrouper ensemble le const et la référence. Ce qui tombe bien car on parle (par abus, certes) de référence constante.

float const& n'est pas nécessaire, car le float est de la même taille qu'une référence, et le compilateur fait tout seule la substitution.
La fonction CalculatePWMFreq n'est pas liée à un moteur particulier, elle pourrait être statique. D'ailleurs, j'aurai tendance à la nommer voltage_to_PWF.

De cette façon, ton constructeur pourrait s'écrire ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Motor::Motor(float voltage): PWM_Freq(voltage_to_PWF(voltage)) {}

Tu devrais probablement nommer la fonction SetPWM_Freq, qui est son fonctionnement, mais use_voltage qui est son usage, son rôle.
D'un point de vue code, cette fonction est très mal écrite, puisqu'elle n'affecte pas PWM_Freq.

Sinon, du point de vue constance, c'est correctement construit.
Les fonctions de lecture sont marquées const, et les arguments sont en références constantes.

J'aurai ajouté des usings, afin de dénoter plus efficacement que les fonctions prennent ou retournent des voltages ou des fréquences.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public:
    using voltage_type = float;
    using pwf_type = float;//pulse width frequency

[Iradrille]

Pour rajouter à ce que dit @leternel.

Les const, yen a jamais assez.

Ta fonction CalculatePWMFreq va utiliser des valeurs qui devraient être extraites (tension de sortie au strict minimum, probablement une fréquence aussi). Et cette fonction n'a rien à voir avec un moteur : c'est une simple fonction utilitaire.

Aussi je stockerais les 3 valeurs (tension demandée / nombre de cycles à 0 / nombre de cycles à 1) dans ta classe Moteur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
float const FREQ = 1'000'000.f; // fréquence µC : 1MHz
float const PWM_FREQ = 1'000.f; // fréquence PWM : 1KHz
float const PWM_RATIO = FREQ / PWM_FREQ;
float const VOUT = 5.f; // tension de sortie : 5V
 
float clamp(float value, float vMin = 0.f, float vMax = 1.f) {
    return std::min(vMax, std::max(vMin, value));
}
 
float pwm(float value) {
    return clamp(value / VOUT) * PWM_RATIO;
}
 
// peut etre une classe PWM si plusieurs choses l'utilisent.
class Motor {
    float m_value; // tension demandée
    int m_at1; // nb de cycles à 1 - float éventuellement
    int m_at0; // nb de cycles à 0 - float éventuellement
 
public:
    float value() const { return m_value; }
    int at1() const { return m_at1; }
    int at0() const { return m_at0; }
 
    // le grand débat des opérations cachées dans un setter :D
    void value(float v) {
        m_value = v;
        auto p = pwm(v);
        m_at1 = int(p);
        m_at0 = int(PWM_RATIO - p);
    }
};

[lupus5]

Bonjour,
Merci pour vos réponses! J'ai beaucoup bossé ce matin pour comprendre ce que vous disiez.
Je précise que ceci n'est qu'un exemple pour me faire une idée et pas une vrai application, bien que je vais sans doute m'en inspirer pour une réalisation future.
Aussi je désirai aller un peu plus loin dans mon travail.
J'ai donc modifié le code pour pouvoir travailler avec une sortie analogique ''virtuel'' et pouvoir définir ce que je veux dessus. Par exemple un moteur ou créer un potentiomètre digital ou autre... ici j'ai choisi un moteur en résumé.
Ce moteur à des valeurs en dures de base, à savoir une tension max (et aussi une min comme ca on est dans les deux limites) et je voulais pouvoir définir mes limites de sorties analogiques avec ces valeurs de moteur.
J'ai donc coder le truc suivant, en essayant d'utiliser des pointeurs pour pointer sur l'objet sortie analogique. Voici:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
Fichier AnalogicVoltage.h
class Analogic_Voltage
{
	float		m_Max_Voltage;
	float		m_Min_Voltage;
 
	float	New_PWMRatio;//New needed PWM Frequency 
	float	Actual_PWMRatio;//Actual PWM Frequency
	float   Actual_Voltage;//Actual PWM Voltage
 
public:
	Analogic_Voltage(float const &InitPWM_Freq, float *MinVoltage, float *MaxVoltage);//constructeur
 
	bool	Change_Voltage(float const&PWMRatio);
	bool	ChangeMINMAX(float const&MIN, float const&MAX);
 
	float	Get_Voltage() const;
	float	Get_PWMRatio() const;
};
static struct Motor
{//définitions spécifique pour un moteur
	float *pointeurMax;
	float *pointeurMin;
	float m_Max_Voltage;
	float m_Min_Voltage;
};

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
fichier AnalogicVoltage.cpp
#include "stdafx.h"
#include "AnalogicVoltage.h"
#include <iostream>
 
bool Analogic_Voltage::Change_Voltage(float const &NewPWMRatio)
{
	float VoltageCalc = (NewPWMRatio * 0.005);
	std::cout << "Voltage to set:" << std::endl;
	std::cout << VoltageCalc << std::endl;
	std::cout << "Voltage Min.:" << std::endl;
	std::cout << m_Min_Voltage << std::endl;
	std::cout << "Voltage Max.:" << std::endl;
	std::cout << m_Max_Voltage << std::endl;
 
	if (m_Min_Voltage < VoltageCalc && VoltageCalc < m_Max_Voltage)
	{		
		Actual_Voltage = VoltageCalc;
		Actual_PWMRatio = NewPWMRatio;
		Get_Voltage();
		Get_PWMRatio();
		return true;//fake calculation
	}
	else
	{
		std::cout << "Error in Voltage calculation" << std::endl;
		std::cout << "Result Voltage :" << std::endl;
		std::cout << VoltageCalc << std::endl;
		return false;
	}
}
bool Analogic_Voltage::ChangeMINMAX(float const &MIN, float const &MAX)
{
	m_Min_Voltage = MIN;
	m_Max_Voltage = MAX;
	std::cout << "Voltage Min.:" << std::endl;
	std::cout << m_Min_Voltage << std::endl;
	std::cout << "Voltage Max.:" << std::endl;
	std::cout << m_Max_Voltage << std::endl;
	return true;
}
Analogic_Voltage::Analogic_Voltage(float const &m_InitPWMRatio, float *m_MinVoltage, float *m_MaxVoltage)
{
	m_Min_Voltage = *m_MinVoltage;
	std::cout << m_Min_Voltage << std::endl;
	m_Max_Voltage = *m_MaxVoltage;
	std::cout << m_Max_Voltage << std::endl;
	Change_Voltage(m_InitPWMRatio);
}
float Analogic_Voltage::Get_Voltage() const
{
	std::cout << "Actual Voltage :" << std::endl;
	std::cout << Actual_Voltage << std::endl;
	return Actual_Voltage;
}
float Analogic_Voltage::Get_PWMRatio() const
{
	std::cout << "Actual PWM Ratio:" << std::endl;
	std::cout << Actual_PWMRatio << std::endl;
	return Actual_PWMRatio;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
Fichier Main
#include "stdafx.h"
#include "AnalogicVoltage.h"
#include <iostream>
 
void main()
{
	using namespace std;
	float value;
 
	Motor Moteur1;
	Moteur1.m_Max_Voltage = 12;	//on définit les valeurs
	Moteur1.m_Min_Voltage = 1;
	Moteur1.pointeurMin = &Moteur1.m_Min_Voltage;//on pointe sur les valeurs 
	Moteur1.pointeurMax = &Moteur1.m_Max_Voltage;
 
	Analogic_Voltage AN_Output1(200, Moteur1.pointeurMin, Moteur1.pointeurMax);//on passe les paramètres de la structure pour la sortie analogique 1
	//AN_Output1.ChangeMINMAX(0, 12);
	cout << "Entrez une valeur de frequence d'initialisation: [kHz]" << endl;
	std::cin >> value;
	AN_Output1.Change_Voltage(value);
	system("pause");
}

Pendant mes tests de ce matin j'ai aussi implémenté une fonction pour changer le minmax de tension dans la sortie analogique mais je l'utilise plus maintenant vu que j'ai une structure moteur pour ca.

J'ai aussi deux questions pour 'Iradrille'.
Dans le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
float clamp(float value, float vMin = 0.f, float vMax = 1.f) {
    return std::min(vMax, std::max(vMin, value));
}

Le compilateur me dit que max n'existe pas dans std....
Et aussi pourquoi cette remarque ? // le grand débat des opérations cachées dans un setter ?

Merci par avance, j'espère que j'abuse pas trop....

[Iradrille]

Les floats ça sert à rien de les passer par const ref. Les passer par copie est plus simple / rapide.
Ton cafouillage avec des pointeurs est inutile aussi : copie tes floats.

Si c'est pour une histoire de performance, copier tes float sera plus rapide; sinon la règle est simple :
- type primitif (ou objet de max 8 octets) -> copie.
- Le reste -> const ref.

Le compilateur me dit que max n'existe pas dans std....

Ils sont dans <algorithm>. Faut penser à l'inclure.

Et aussi pourquoi cette remarque ? // le grand débat des opérations cachées dans un setter ?

Quand on fait foo.setBar(); on s'attend à modifier l'attribut bar (et seulement celui là). Hors ici d'autres traitements sont fait.
Certains trouvent ça acceptable, d'autres non. C'est un débat qui revient de temps en temps ici.

[ternel]

D'ailleurs, je te recommande d'utiliser un site de référence du langage, tel que

• cplusplus.com
• cppreference.com

Le second est mon préféré, et les deux ne sont pas strictement équivalent dans leurs explications.
Par contre, ils sont d'accord (normalement)

Je t'invite notamment à apprendre ce qu'on peut trouver dans <algorithm>.
La syntaxe est un détail, j'y retourne souvent, mais ce sont de nombreuses fonctions utiles à connaitre.