Petit projet : de python à c++

1 pièce(s) jointe(s)

Bonjour tout le monde,
J'ai un petit projet de dernière année BTS et j'aurais besoin d'aide pour passer mon code qui es en python en c++ (ps : je suis novice en c++ :( ).
Je fonctionne à partir d'une carte raspberry de type b et d'un écran LCD de type HD44780, j'ai mon schéma électronique juste ici :
Pièce jointe 173280
alors voilà mon soucis c'est que j'ai fais un code en python pour afficher ce que je désire sauf que maintenant je dois le faire en c++ et je peine à le faire :/
Donc je recherche un bon programmeur en python/c++ qui puisse m'aider s'il vous plait :p.
Voici mon code en python :

Code:

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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
#!/usr/bin/python
 
############################
# Imports                  #
############################
import threading
import RPi.GPIO as GPIO
from time import sleep
import subprocess
 
############################
# Class de controle du LCD #
############################
class HD44780(threading.Thread):
	######################
	# Variable Shared    #
	######################
	_PULSE = 0.00005
	_DELAY = 0.00005
 
	######################
	# Constructeur       #
	######################
	def __init__(self, pin_rs=7, pin_e=8, pins_db=[25, 24, 23, 18], lcd_width=16):
		self.message = ""
		self.currentmessage = "azertyuiop"
		self.stop = False
		self.lcd_width = lcd_width
		self.pin_rs = pin_rs
		self.pin_e = pin_e
		self.pins_db = pins_db
		GPIO.setmode(GPIO.BCM) 				# Use BCM GPIO numbers
		GPIO.setup(self.pin_e, GPIO.OUT)
		GPIO.setup(self.pin_rs, GPIO.OUT)
		for pin in self.pins_db:
			GPIO.setup(pin, GPIO.OUT)
 
		self.Clear()
		threading.Thread.__init__(self)
 
	######################
	# Demarrage du Thread# 
	######################
	def run(self):
		while self.stop == False:
			if self.message != self.currentmessage:
				self.currentmessage = self.message
				self.LcdMessage()
			sleep(1)
 
	######################
	# Arret du Thread    # 
	######################	
	def Stop(self):
		self.stop = True
 
	######################
	# Initialisation LCD # 
	######################
	def Clear(self):
		""" Blank / Reset LCD """
		self.LcdByte(0x33, False) # $33 8-bit mode
		self.LcdByte(0x32, False) # $32 8-bit mode
		self.LcdByte(0x28, False) # $28 8-bit mode
		self.LcdByte(0x0C, False) # $0C 8-bit mode
		self.LcdByte(0x06, False) # $06 8-bit mode
		self.LcdByte(0x01, False) # $01 8-bit mode
 
	######################
	#Execution sur le LCD# 
	######################
	def LcdByte(self, bits, mode):
		""" Send byte to data pins """
		# bits = data
		# mode = True  for character
		#        False for command
 
		GPIO.output(self.pin_rs, mode) # RS
 
		# High bits
		for pin in self.pins_db:
			GPIO.output(pin, False)
		if bits&0x10==0x10:
			GPIO.output(self.pins_db[0], True)
		if bits&0x20==0x20:
			GPIO.output(self.pins_db[1], True)
		if bits&0x40==0x40:
			GPIO.output(self.pins_db[2], True)
		if bits&0x80==0x80:
			GPIO.output(self.pins_db[3], True)
 
		# Toggle 'Enable' pin
		sleep(HD44780._DELAY)    
		GPIO.output(self.pin_e, True)  
		sleep(HD44780._PULSE)
		GPIO.output(self.pin_e, False)  
		sleep(HD44780._DELAY)      
 
		# Low bits
		for pin in self.pins_db:
			GPIO.output(pin, False)
		if bits&0x01==0x01:
			GPIO.output(self.pins_db[0], True)
		if bits&0x02==0x02:
			GPIO.output(self.pins_db[1], True)
		if bits&0x04==0x04:
			GPIO.output(self.pins_db[2], True)
		if bits&0x08==0x08:
			GPIO.output(self.pins_db[3], True)
 
		# Toggle 'Enable' pin
		sleep(HD44780._DELAY)    
		GPIO.output(self.pin_e, True)  
		sleep(HD44780._PULSE)
		GPIO.output(self.pin_e, False)  
		sleep(HD44780._DELAY) 	
 
	######################
	#Affichage sur le LCD# 
	######################	
	def LcdMessage(self):
		""" Send string to LCD. Newline wraps to second line"""
		self.Clear()
		text = self.currentmessage
		self.LcdByte(0x80, False)
		for c in text:
			if c == '\n':
				self.LcdByte(0xC0, False) # next line
			else:
				self.LcdByte(ord(c),True)
 
	######################
	#Definir le message  # 
	######################
	def LcdSetMessage(self, text):
		self.message = text.ljust(self.lcd_width," ")
 
################################
# Class Informations Systeme   #
################################
class SysInfo(threading.Thread):
	######################
	# Constructeur       #
	######################
	def __init__(self):
		self.count = 0
		self.lcd = HD44780()
		self.stop = False
		threading.Thread.__init__(self)
 
	######################
	# Demarrage du Thread# 
	######################
	def run(self):
		self.lcd.start()
		while self.stop == False:
			if self.count == 0: 
				self.lcd.LcdSetMessage("premier\nmessage ")
			elif self.count == 1: 
				self.lcd.LcdSetMessage("second\nmessage ")
			elif self.count == 2: 
				self.lcd.LcdSetMessage("troisieme\nmessage ")
			elif self.count == 3:
				self.lcd.LcdSetMessage("quatrieme\nmessage ")
			elif self.count == 4: 
				self.lcd.LcdSetMessage("cinquieme\nmessage ")
			else:
				self.lcd.LcdSetMessage("sixieme\nmessage ")
			self.count += 1
			if self.count == 6:
				self.count = 0
			sleep(5)
	######################
	# Arret du Thread    # 
	######################
	def Stop(self):
		self.lcd.Stop()
		self.stop = True	
 
 
 
######################
# MAIN STARTER       # 
######################	
if __name__ == '__main__':
 
	si = SysInfo()
	si.start()
	q = str(raw_input('Press ENTER to quit program'))
	si.Stop()

merci d'avance :) :lol:

Le langage est une manière d'expliquer au compilateur comment écrire.
L'algorithme est l'idée qui est derrière, et tu dois avant tout le formuler en humain.

Prends le temps d'écrire ton algorithme en français (ou en anglais si tu préfères).
Il sera beaucoup plus facile d'exprimer l'algorithme en C++.

ok merci je pense commencer par faire un diagramme de classe ;)

C'est pas forcément le plus utile.

Réfléchis surtout en terme d'information.

Quelles informations existent? où et quand?
Comment sont-elles transformées?

Cela dit, une fois que tu auras posé tes réflexions sur papier, pose ta question dans le forum dédié à Raspberry-pi, tu auras plus de réponses

Y'a du threading etc, ça va pas être coton si tu connais pas...

Quel est l'objectif ? Pourquoi ne pas tout simplement compiler ton python ?
Pourquoi l'avoir fait en python si c'est incompatible ?
S'il te faut un code en C/C++, utilise Cython ?

C'est un projet de fin d'année et mes profs déteste python :'(, donc l'utilisation du c++ est obligatoire, si je l'ai fais en python c'était pour voir si c'était possible, je vais voir avec cython merci ! :)