Programme avec différentes UT

Bonjour,

J'aimerais utiliser plusieurs ut dans un programme que je code sous prt, mais après recherches, je ne trouve pas de solutions.

Je développe, j'utilise l'ut M3 pour analyse d'une tendance, et je voudrait ouvrir un ordre (d'achat ou de vente) des que le cours passe sous un niveau, exemple 5000.
Or de ce que je comprend après avoir essayé plusieurs code, et dans les PDF ProOrder, l'ordre ne s'ouvre qu'à l'open de la Bougie suivante et non dans mon cas à 5000.

Dois-je créer 2 programmes ?:
-un qui repère s'il y a tendance (M3) -> renvoi 1 dans une variable si haussier
-un autre qui déclenche si variable=1 et si le cours = 5000 (1tick)

Une solution plus simple est d'utiliser un achat à cours limite ou à cours stop, selon ta configuration :
BUY AT 5000 LIMIT
ou
BUY AT 5000 STOP

Une des raisons pour lesquelles je ne code pas sous prt, tellement important de ne pas se concentrer sur une seule ut

Ahh une question qui m'intéresse également...

Epitaf, tu confirmes qu'il n'est pas possible d'utiliser plusieurs ut au sein du même code prt ?
Et pas d'astuce permettant d'utiliser dans "CODE2" une variable obtenue dans "CODE1" ?

Je ne pense pas que ce soit possible.
Après je ne me suis pas intéressé à proorder depuis un moment, je ne suis pas au courant des nouveautés.

Personnellement, je fais du "multi ut" sur mes indicateurs à partir d'une ut unique : le 1-tick. Je reconstruis les ut plus longues (1s, 20-tick et 5 min) à partir du 1-tick.
Avec la 10.3 et les nouveautés graphiques, on peut faire des trucs vraiment sympas.

Merci pour vos réponses, ce forum est une vrai mine d'or !

Je pense qu'il est réellement possible d'utiliser 2 codes avec une variable commune et la fonction call, mais ce genre de programmation n'est pas optimale d'après le guide pro order.

Jim, l'idée de créer un ut a partir du 1tick est interessante je pense que je vais creuser dans ce sens

En revanche, si j'utilise le "BUY AT 5000 LIMIT" en M5,M10 ou autre, l'ordre se déclenche à l'open de la prochaine Bougie, non ? (je n'ai pas l'occasion d'essayer ce soir)

Comme Jim j utilise une ut inférieure pour construire les ut supérieure , par contre c est un indic , je passe toujours les ordres a la mano

Apo,

Je déconseille formellement la fonction call. J'ai testé, les ventilos de mon PC s'en souviennent encore

Si tu veux reconstruire des ut supérieures, fais-toi la main sur des ut temporelles, plutôt que le 1-tick, parce que le 1-tick est "spécial". Il y a un petit bug assez pénible à gérer avec le 1-tick : le dernier tick de chaque seconde est attribué à la seconde suivante...

Avec ProOrder, quand ta Bougie est cloturée, elle est examinée dans les millisecondes suivant sa cloture, puis les ordres sont exécutés aussi rapidement que possible. Puis ProOrder attend que la Bougie en cours cloture, puis l'examine. Etc...

Ahhh oui c'est malin ça de partir d'une ut basse pour reconstruire des UTs >

J'ai maintenant des recherches à faire pour coder ça, je suis novice mais motivé

Je pense à deux options pour coder un ut M1 à partir d'un ut 1Sec :

-Incrémenter le nombre de bougies, mémoriser les HIGHEST et LOWEST dans des variables , et recommencer des que le compte est à 60.

-Ou utiliser la fonction TIME pour préciser l'open et la cluture de la barre et garder les HIGHEST et LOWEST pour les plus haut et plus bas.
( et dans cette deuxième option, on pourrait utiliser le 1Tick ou on a toujours le problème du dernier tick) ?

Qu'en pensez vous ?

Après avoir mis de côté le code, j'y reviens, j’incrémente donc jusqu’à 30 secondes (un exemple).

Maintenant, comment faire pour mémoriser les high,low,open et close des dernières bougies sur mon ut 30s ( je dois créer des variables pour les X bougies que je veux garder en mémoire ?)

Une fois le code terminé je le publierais pour que tout le monde puisse en profiter, mais il me manque encore quelques détails

Par exemple, pour le plus haut de tes 10 dernières bougies : Highest[9](high)

Pour des situations plus tordues il faudra utiliser BarIndex

Je pars d'un ut 1s pour créer un ut 30s.

Lorsque je demande de regarder les bougies précédentes, avec [1,2,3 ou X] derrière une fonction, comme ton exemple Highest[9](high), cela regarde les 9 dernières secondes, et non les 9 dernières périodes de 30s.

Quel est le moyen pour sauvegarder temporairement ces données ?

A part créer une très grande quantité de variable :

highPeriodeMoinsUn
HighPeriodeMoinsDeux
HighPeriodeMoinsTrois ...

Et on multiplie pour sauvegarder les open,close, et low.
Donc cela fait 12 variables pour sauvegarder seulement les 3 dernières périodes de 30s. ça parait lourd, avec vous un moyen plus "ligh"

Ca dépend de ce que tu veux faire.

Je te mets ci-dessous un code maison pour calculer une Kijin(26) en UT 5min à partir d'une UT 1-tick.
Le code est lourdingue, mais beaucoup plus rapide que des codes plus élégants.
J'espère que ça pourra t'inspirer :

Code : #

ONCE i = 1 // compteur de chandeliers de 5 min, de 1 à 25

TestMOD5 = minute MOD 5 = 0

IF trigger AND TestMOD5 THEN // cette condition n'est vraie que pour le premier tick du nouveau chandelier de 5min
trigger = 0 // on désarme le trigger dans le premier tick du nouveau chandelier de 5min

IF i = 1 THEN
PlusHaut = Highest[barindex-barindex1-1](close)
PlusBas = Lowest[barindex-barindex1-1](close)
barindex1 = barindex
ELSIF i = 2 THEN
PlusHaut = Highest[barindex-barindex2-1](close)
PlusBas = Lowest[barindex-barindex2-1](close)
barindex2 = barindex
ELSIF i = 3 THEN
PlusHaut = Highest[barindex-barindex3-1](close)
PlusBas = Lowest[barindex-barindex3-1](close)
barindex3 = barindex
ELSIF i = 4 THEN
PlusHaut = Highest[barindex-barindex4-1](close)
PlusBas = Lowest[barindex-barindex4-1](close)
barindex4 = barindex
ELSIF i = 5 THEN
PlusHaut = Highest[barindex-barindex5-1](close)
PlusBas = Lowest[barindex-barindex5-1](close)
barindex5 = barindex
ELSIF i = 6 THEN
PlusHaut = Highest[barindex-barindex6-1](close)
PlusBas = Lowest[barindex-barindex6-1](close)
barindex6 = barindex
ELSIF i = 7 THEN
PlusHaut = Highest[barindex-barindex7-1](close)
PlusBas = Lowest[barindex-barindex7-1](close)
barindex7 = barindex
ELSIF i = 8 THEN
PlusHaut = Highest[barindex-barindex8-1](close)
PlusBas = Lowest[barindex-barindex8-1](close)
barindex8 = barindex
ELSIF i = 9 THEN
PlusHaut = Highest[barindex-barindex9-1](close)
PlusBas = Lowest[barindex-barindex9-1](close)
barindex9 = barindex
ELSIF i = 10 THEN
PlusHaut = Highest[barindex-barindex10-1](close)
PlusBas = Lowest[barindex-barindex10-1](close)
barindex10 = barindex
ELSIF i = 11 THEN
PlusHaut = Highest[barindex-barindex11-1](close)
PlusBas = Lowest[barindex-barindex11-1](close)
barindex11 = barindex
ELSIF i = 12 THEN
PlusHaut = Highest[barindex-barindex12-1](close)
PlusBas = Lowest[barindex-barindex12-1](close)
barindex12 = barindex
ELSIF i = 13 THEN
PlusHaut = Highest[barindex-barindex13-1](close)
PlusBas = Lowest[barindex-barindex13-1](close)
barindex13 = barindex
ELSIF i = 14 THEN
PlusHaut = Highest[barindex-barindex14-1](close)
PlusBas = Lowest[barindex-barindex14-1](close)
barindex14 = barindex
ELSIF i = 15 THEN
PlusHaut = Highest[barindex-barindex15-1](close)
PlusBas = Lowest[barindex-barindex15-1](close)
barindex15 = barindex
ELSIF i = 16 THEN
PlusHaut = Highest[barindex-barindex16-1](close)
PlusBas = Lowest[barindex-barindex16-1](close)
barindex16 = barindex
ELSIF i = 17 THEN
PlusHaut = Highest[barindex-barindex17-1](close)
PlusBas = Lowest[barindex-barindex17-1](close)
barindex17 = barindex
ELSIF i = 18 THEN
PlusHaut = Highest[barindex-barindex18-1](close)
PlusBas = Lowest[barindex-barindex18-1](close)
barindex18 = barindex
ELSIF i = 19 THEN
PlusHaut = Highest[barindex-barindex19-1](close)
PlusBas = Lowest[barindex-barindex19-1](close)
barindex19 = barindex
ELSIF i = 20 THEN
PlusHaut = Highest[barindex-barindex20-1](close)
PlusBas = Lowest[barindex-barindex20-1](close)
barindex20 = barindex
ELSIF i = 21 THEN
PlusHaut = Highest[barindex-barindex21-1](close)
PlusBas = Lowest[barindex-barindex21-1](close)
barindex21 = barindex
ELSIF i = 22 THEN
PlusHaut = Highest[barindex-barindex22-1](close)
PlusBas = Lowest[barindex-barindex22-1](close)
barindex22 = barindex
ELSIF i = 23 THEN
PlusHaut = Highest[barindex-barindex23-1](close)
PlusBas = Lowest[barindex-barindex23-1](close)
barindex23 = barindex
ELSIF i = 24 THEN
PlusHaut = Highest[barindex-barindex24-1](close)
PlusBas = Lowest[barindex-barindex24-1](close)
barindex24 = barindex
ELSIF i = 25 THEN
PlusHaut = Highest[barindex-barindex25-1](close)
PlusBas = Lowest[barindex-barindex25-1](close)
barindex25 = barindex
//ELSIF i = 26 THEN
//PlusHaut = Highest[barindex-barindex26-1](close)
//PlusBas = Lowest[barindex-barindex26-1](close)
//barindex26 = barindex
i=0 // i=0 en prévision de la future incrémentation
ENDIF

i=i+1 // on incrémente i pour le prochain chandelier

IF time > 100400 AND time < 215400 THEN  // la kijun est pertinente seulement à partir de 10h05 sur Future (25 périodes de 5min = 2h05)
Kijun = (PlusHaut+PlusBas)/2
ELSE
Kijun = 0
ENDIF



ELSIF NOT TestMOD5 THEN // armement du trigger lorsqu'on n'est plus dans la première minute du chandelier de 5min
trigger = 1
ENDIF

RETURN Kijun coloured (255,153,51) STYLE(line,2) as "Kijun 5min"

Bonjour,
J'ai posé la question à ig lors du dernier salon AT de Paris et l'utilisation de différentes ut dans les systèmes automatiques est dans la roadmap.
La fonction devrait être disponible dans quelques semaines m'ont ils dit.
J'ai hâte !