Kikourou.net

SiRoB1 a écrit:

echoes a écrit:Savez vous comment arreter les "bips" de la montre en court d'excercices.
Il n'y a rien de plus saoulant qu'une montre qui sonne sans arret car on dépasse les zones cible qu'on avait programmées.

Oui en maintenant le bouton lap puis en sélectionnant un exercice qui n'utilise pas de limite.

Bonjour SiRoB1, merci pour ta réponse mais :
l'Ambit 2R n'est pas multisports, je ne peux donc pas zapper d'un exercice à l'autre...

juste par curiosité j'ai regardé le manuel.
Donc en appuyant 2s sur le bouton NEXT puis en sélectionnant ACTIVER, vous aurez l'option.

Manuel d'utilisateur Ambit2 R page 38 a écrit:Sélectionnez Limites FC off/Limites FC on pour activer ou
désactiver les limites de fréquence cardiaque. Vous pouvez
définir des valeurs limites de fréquence cardiaque dans
Movescount.

P.S.: n'utilisant pas de ceinture je ne voyais pas l'option.

non non non car les beeps sont générés par une appli et non pas les limites internes de la montre. J'ai bien lu la notice aussi
Sur mon ancienne Suunto Quest, il me suffisait juste d'appuier longement sur une touche pour désactiver tous les bips. Là visiblement ça n'existe pas sur nos Ambit ???

Ah c'est une application qui fait de la symphonie.
Oui la on a aucun moyen de la faire taire...
Une petite modification pour éviter de biper en permanence si hors limite durant un certain temps?

l'idée est excellente mais je ne sais pas trop coment programmer cela. Je vais aller à la peche aux info sur Mouvescount
Merci pour ton aide.

Ça fait deux jours que je ne parviens plus à accéder à l'app designer. Un message d'erreur apparaît sur le site lorsque j'essaie d'y accéder. Vous aussi ?

pas de soucis chez moi.
vide peut-être le cookie et l'historique de navigation de ton explorer pour voir si ça résoud le probleme.

Il suffisait d'en parler sur Kikourou. Ça marche de nouveau sans que je ne touche à quoi que ce soit de mon navigateur.

echoes a écrit:l'idée est excellente mais je ne sais pas trop coment programmer cela. Je vais aller à la peche aux info sur Mouvescount
Merci pour ton aide.

Il y a plein de solution suivant ce qu'on cherche à faire.
Sinon voici un petit exemple qui permet d'avoir des alarmes sur plusieurs zones ce qui me parait être la solution la plus souple:

Code: Tout sélectionner

/* %FC avec alarme au franchissement de zone definie
zone1 depuis plus de 7s: bipe 1 fois toutes les 7 secondes
zone2 depuis plus de 7s: bipe 2 fois toutes les 7 secondes
zone3 depuis plus de 7s: bipe 3 fois toutes les 7 secondes
zone4 depuis plus de 7s: bipe 4 fois toutes les 7 secondes
zone5 depuis plus de 7s: bipe 5 fois toutes les 7 secondes
si on reste hors zone 4 fois a la suite, on change de zone cible

variables a ajouter avec leur valeur:
zone       => 1
z2         => 60
z3         => 70
z4         => 80
z5         => 90
zFCmin     => 0
zFCmax     => 60
bips       => 0
horslimite => 0
alerte     => 0

*/

/* On affiche le pourcentage de la FC par rapport a la FCMAX definie au niveau des parametres corporels */
RESULT = Suunto.floor(100 * SUUNTO_HR / SUUNTO_USER_MAX_HR);

if (RESULT >= zFCmax) {
  /* on est au dessus ou a la limite max de la zone de FC actuelle */
  horslimite = horslimite + 1;
} else if (RESULT < zFCmin) {
  /* on est en dessous de la limite min de la zone de FC actuelle */
  horslimite = horslimite - 1;
} else {
  horslimite = 0;
  alerte = 0;
}

if (alerte >= 4) {
  /* si alerte 4 fois on change de zone cible */
  if (RESULT < z2) {
    zone = 1; postfix = "z1"; zFCmin =   0; zFCmax = z2;
  } else if (RESULT < z3) {
    zone = 2; postfix = "z2"; zFCmin =  z2; zFCmax = z3;
  } else if (RESULT < z4) {
    zone = 3; postfix = "z3"; zFCmin =  z3; zFCmax = z4;
  } else if (RESULT < z5) {
    zone = 4; postfix = "z4"; zFCmin =  z4; zFCmax = z5;
  } else if (RESULT <= 100) {
    zone = 5; postfix = "z5"; zFCmin =  z5; zFCmax = 100;
  } else {
    /* ne doit pas se produire en principe */
    zone = 6; postfix = "!!"; zFCmin = 100; zFCmax = 255;
  }
  alerte = 0;
} else if (Suunto.abs(horslimite) >= 7) {
  /* si hors limite 7 fois de suite */
  horslimite = 0;
  alerte = alerte + 1;
  if (RESULT < z2) {
    bips = 1;
  } else if (RESULT < z3) {
    bips = 2;
  } else if (RESULT < z4) {
    bips = 3;
  } else if (RESULT < z5) {
    bips = 4;
  } else if (RESULT <= 100) {
    bips = 5;
  } else {
    /* ne doit pas se produire en principe */
    bips = 6;
  }
}

if (SUUNTO_DURATION && bips && SUUNTO_SPEED) {
  /* l exercice a ete demarre et on doit faire sonner la montre et la vitesse est superieur a zero */
  bips = bips - 1;
  Suunto.alarmBeep();
} 

Sinon il y a des solutions qui utilise l'appuie sur le bouton LAP pour faire défiler des zones ou couper l'alarme.

ilgigrad a écrit:Il suffisait d'en parler sur Kikourou. Ça marche de nouveau sans que je ne touche à quoi que ce soit de mon navigateur.

Attention ce lundi 16 il y aura une maintenance.

echoes a écrit:l'idée est excellente mais je ne sais pas trop comment programmer cela. Je vais aller à la peche aux info sur Mouvescount
Merci pour ton aide.

Merci pour le coup de main SiroB1

Bon, j'ai du retrouver mon coté geek, et j'ai donc modifié mon programme pour que ça ne sonne plus une fois que j'ai bien tapé dedans au niveau de la FC

Code: Tout sélectionner

/*--------Travail de l'Endurance Fondamentale--------------

-Echauffement 10 minutes 

-Endurance Fondamentale 65-70% Karvonen
-Possibilite de se lacher si on depasse 75% (plus d'alarme)
-Application realisee initialement par Jfcalypso et modifiee pour ma convenance*/


/*-------ZONE ECHAUFFEMENT 10min-----*/

RESULT=((SUUNTO_HR_AVG[5]-SUUNTO_USER_REST_HR)/(SUUNTO_USER_MAX_HR-SUUNTO_USER_REST_HR))*100;

if(SUUNTO_DURATION>=0&&SUUNTO_DURATION<600){prefix = "ECH";postfix = "%HR";

if((SUUNTO_DURATION>=0&&SUUNTO_DURATION<600)&&(RESULT>68))
    /*Ralentissez votre vitesse - Slow down your speed - "SLO" */
    {Suunto.alarmBeep();prefix = "SLO";postfix = "%HR";}}

/*----------ZONE CIBLE-----------*/

if(SUUNTO_DURATION>=600)
    {if(Suunto.mod(SUUNTO_TIME,6)<3)
    {RESULT=SUUNTO_SPEED_AVG[5];postfix="Kmh";}

else{RESULT=((SUUNTO_HR_AVG[5]-SUUNTO_USER_REST_HR)/(SUUNTO_USER_MAX_HR-SUUNTO_USER_REST_HR))*100;
    
if(RESULT<65)
    /*Vous devez accelerer - "ACC" */
    {Suunto.alarmBeep();prefix = "ACC";postfix = "%HR";}
  
if (RESULT>=65&&RESULT<=70)
    /*Bonne vitesse, bien - "OK" */
    {prefix = "OK";postfix = "%HR";}
 
if(RESULT>70&&RESULT<=73)
    /*Ralentissez votre vitesse - Slow - "SLO" */
    {Suunto.alarmBeep();prefix = "SLO";postfix = "%HR";}
  
if(RESULT>73&&RESULT<=75)
    /*Arreter votre vitesse vous allez trop vite - "STOOP!!" */
    {Suunto.alarmBeep();prefix = "ST";RESULT=0;postfix = "P";}}}

if(RESULT>75)
    /*Lachez vous - "GO!!" */
    {prefix = "GO";postfix = "%HR";} 

Parfait c'est plus que du sur mesure.
Pour présenter le code d'une manière plus lisible dans les posts, il suffit de mettre code=php au lieu de code tout court dans les balises.

je viens de corriger avec code= php, c'est effectivement nettement plus lisible

Fin de la tempête sur movescount!
Attendons Dimanche soir avant de crier victoire.

Sinon à la demande d'un membre de watchuseek qui semble faire du windsurf, j'ai fait une autre application qui reprend globalement le code de l'application Vspd.
Mais cette fois, on s'intéresse à la vitesse moyenne sur une distance donnée que l'on vient de parcourir.
L'approximation se fait sur l'agrégation des échantillons où la différence de vitesse est la moins importante permettant de conserver au mieux le profile de la courbe de vitesse.
Si vous enregistrez les données de cette application, vous aurez la possibilité de visualiser l'emplacement des extremums.

• 500m avg SPD:calcule la vitesse moyenne sur les derniers 500m parcourus
• 1km avg SPD:calcule la vitesse moyenne sur les derniers 1000m parcourus

Bon move à tous.

Bonjour,

je viens de craquer pour une ambit2….
EN regardant, j'ai vu qu'il y avait bcp d'apps pour calculer la vitesse verticale.
Quelle est a votre avis la plus fiable pour une utilisation en trail ?

Merci,

Edouard

salut,

Pour la vitesse verticale, je te conseille les applications de SiRoB1

Vspd (120s): basée sur les deux dernières minutes d'une montée ou descente
Vspd (60s) : basée sur les 60 dernières secondes

surement les 2 meilleures actuellement sur movescount

JMK

Merci JMK !

Bizarre de demander une appli pour la vitesse ascentionnelle, moi j'ai cette fonction directement dans l'Ambit 2R.
Est ce que c'est parce qu'elle n'est pas assez performante que vous en utilisez une autre ?

La vitesse ascensionnelle de base est très bruitée alors que les apps permettent de lisser sur des temps plus longs pour avoir des valeurs plus stables.
On le voit très bien en regardant des moves utilisant Vspd (120)

bonsoir,

je viens de me voir offrir une ambi 2 black HR par ma petite femme
un cadeau inespéré, j'en rêvé depuis dès mois car ma garmin 305 ne tient plus que 4h en sortie .

Cependant à une semaine du marathon j'aurais aimé installé l'apps ALLIONEV3 mais je m'y perds un peu
Quelqu'un pourrait il me guider ou me dire ou trouver un tutoriel afin d'installer l'apps.
J'arrive à l'enregistrer et à enregistrer les variables mais ne n'arrive pas à l'intégrer dans un mode sport…

Merci à vous

salut dans movescuont, choisie équipement sunnto ambit 2,personnalisation,choisie l activite,ajouter a l affichage,choisir ça ligne,mes apps.
sportivement

bonsoir

j'ai fait cela j'ai choisi ds mes apps allionev3 sur un seul affichage et j'enregistre puis transfert mais la montre me met wait puis bascule sur allionev3 et rebascule sur wait ??
j'ai du louper une étape

salut,

une info :

Sur le RDV du marathon du Mont Blanc, Suunto organise une formation complète et gratuite autour de l' Ambit 2 à L ENSA.
Sujets : optimisation de l'utilisation de la montre / navigation / applications.
Date : vendredi apm (avant l'ensemble des épreuves)
Cette formation sera effectué par 2 experts Suunto.
Inscription à la tente suunto au salon exposant le jeudi sur la journée + vendredi avant 14H

JMK

Bonsoir,

Nouveau propriétaire d'une Ambit 2 en remplacement de ma garmin 305 sur laquelle plus aucune activité ne rentre, est-il possible de:

Dans un itinéraire, ajouter des POI aux points hauts et bas du profil,
définir des moyennes de vitesses pour chaque section entre les POI
Utiliser une app du type "Temps pour arriver au prochain POI" en tenant compte des prévisions et du réalisé?, un peu comme sur la garmin

L'idée est de programmer un itinéraire et de voir en live si on est dans bon dans les prév des temps de passage.

Merci.

Bonjour

Si vous utilisez les compteurs d'intervalles (elevés et faibles) qui sont natifs dans mouvescount, j'auri une petite (voire deux) questions
- de temps en temps des sons/mélodies se déclenchent en courant,mais je n'arrive pas comprendre à quel moment et sur quels critères
- est ce que ces mélodies seraient accessibles en mode programmation ? (ca permettrait de mettre un son différent quand on franchit une FC et quand on finit un intervalle par ex)

merci
deborah

@axon,

j'ai une app "Virtual Race Trail" qui fait ça à peu près.
Il faut definir des Waypoints en distance cumulées et le rythme moyen pour chacune des sections.
(11 sections / 10 WP).
L'app affiche successivement :
Ecart vs Plan
Distance au Next Way Point
Temps estimé d'arrivée au Next WayPoint (au rythme planifiée pour cette section)
ci-dessous c'est codé pour un plan ITT en 15h30 (temps max
sur movescount
ou ci-dessous :
(penser a definir les 20+ variables. Uniquement sur ambit2 (83%)

Code: Tout sélectionner

/* While in sport mode do this once per second                */
/* This App display every second , alternatively :            */
/* gap in min:ss vs plan                                      */
/* Distance to Next Waypoint                                  */
/* Time to Next Waypoint (at avg plan pace for that section   */
/* up to 11 section, 10 Waypoint                              */
/* Each Waypoint must be define in cumulative km ( D1 to D10) */
/* Each section must have average Ghost pace ( G1 to G11) */
if ( SUUNTO_DURATION == 0 )
{
    section         = 1;    /* current section # as per increment, total 10 sections */
    Comp           = 0;    /* remaining part in a section */
    NextWP           = 0;    /* distance to next WayPoint */
    WPpace          = 0;    /* planned pace to Next Waypoint */
    disp            = 0;    /* display : 0=gap vs plan, 1 = Distance to NextWP, 2=Duration to NextWP*/
    GHOST_DURATION  = 0;
    G1            = 591;  /* Ghost pace in seconds/km section 1*/
    G2            = 1027; /* Ghost pace in seconds/km section 2*/
    G3            = 1339; /* Ghost Pace In seconds/Km section 3*/
    G4            = 646;  /* Ghost Pace In seconds/Km section 4*/
    G5            = 828;  /* Ghost Pace In seconds/Km section 5*/
    G6            = 928;  /* Ghost Pace In seconds/Km section 6*/
    G7            = 1246; /* Ghost Pace In seconds/Km section 7*/
    G8            = 1332; /* Ghost Pace In seconds/Km section 8*/
    G9            = 679;  /* Ghost Pace In seconds/Km section 9*/
    G10           = 739;  /* Ghost pace in seconds/km section 10*/
    G11           = 500;  /* Ghost pace in seconds/km section 11*/

    D1              = 9.8;  /* Distance section 1*/
    D2              = 17.7; /* Distance section 2*/
    D3              = 19;   /* Distance section 3*/
    D4              = 26.1; /* Distance section 4*/
    D5              = 37.4; /* Distance section 5*/
    D6              = 41.6; /* Distance section 6*/
    D7              = 50.7; /* Distance section 7*/
    D8              = 52.1; /* Distance section 8*/
    D9              = 55.7; /* Distance section 9*/
    D10             = 64;   /* Distance section 10*/
}

/*----------------------------------------------------------------------
   Calculate Virtual Race GHOST_DURATION for Current SUUNTO_DISTANCE
-----------------------------------------------------------------------*/

section = SUUNTO_DISTANCE;
if ((section >= D10) )
{
    Comp = ( SUUNTO_DISTANCE - D10 );
    NextWP = 0;
    prefix = "WP11";
    WPpace = G11;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*(D8-D7))+(G9*(D9-D8))+(G10*(D10-D9))+( G11*Comp );
}
if ((section >= D9) && (section < D10) )
{
    Comp = ( SUUNTO_DISTANCE - D9 );
    NextWP = D10-SUUNTO_DISTANCE;
    prefix = "WP10";
    WPpace = G10;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*(D8-D7))+(G9*(D9-D8))+( G10*Comp );
}
if ((section >= D8) && (section < D9) )
{
    Comp = ( SUUNTO_DISTANCE - D8 );
    NextWP = D9-SUUNTO_DISTANCE;
    prefix = "WP9";
    WPpace = G9;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*(D8-D7))+(G9*Comp );
}
if ((section >= D7) && (section < D8) )
{
    Comp = ( SUUNTO_DISTANCE - D7 );
    NextWP = D8-SUUNTO_DISTANCE;
    prefix = "WP8";
    WPpace = G8;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*Comp );
}
if ((section >= D6) && (section < D7) )
{
    Comp = ( SUUNTO_DISTANCE - D6 );
    NextWP = D7-SUUNTO_DISTANCE;
    prefix = "WP7";
    WPpace = G7;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*Comp );
}
if ((section >= D5) && (section < D6) )
{
    Comp = ( SUUNTO_DISTANCE - D5 );
    NextWP = D6-SUUNTO_DISTANCE;
    prefix = "WP6";
    WPpace = G6;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*Comp );
}
if ((section >= D4) && (section < D5) )
{
    Comp = ( SUUNTO_DISTANCE - D4 );
    NextWP = D5-SUUNTO_DISTANCE;
    prefix = "WP5";
    WPpace = G5;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*Comp );
}
if ((section >= D3) && (section < D4) )
{
    Comp = ( SUUNTO_DISTANCE - D3 );
    NextWP = D4-SUUNTO_DISTANCE;
    prefix = "WP4";
    WPpace = G4;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*Comp );
}
if ((section >= D2) && (section < D3) )
{
    Comp = ( SUUNTO_DISTANCE - D2 );
    NextWP = D3-SUUNTO_DISTANCE;
    prefix = "WP3";
    WPpace = G3;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*Comp );
}
if ((section >= D1) && (section < D2) )
{
    Comp = ( SUUNTO_DISTANCE - D1 );
    NextWP = D2-SUUNTO_DISTANCE;
    prefix = "WP2";
    WPpace = G2;
    GHOST_DURATION = (G1*D1)+(G2*Comp );
}

if (section < D1)
{
    Comp = ( SUUNTO_DISTANCE  );
    NextWP = D1-SUUNTO_DISTANCE;
    prefix = "WP1";
    WPpace = G1;
    GHOST_DURATION = ( G1 * Comp);
}

if (disp==0) {
prefix ="Gap";
postfix="ms";
  RESULT = Suunto.mod((SUUNTO_DURATION-GHOST_DURATION),60);
  RESULT = (SUUNTO_DURATION-GHOST_DURATION)/60+RESULT/100;
disp=1;
}
else
{
if (disp==1) {
postfix="km";
  RESULT = NextWP;
disp=2;
}
else
{
if (disp==2) {
postfix="ms";
  RESULT = Suunto.mod((NextWP*WPpace),60);
  RESULT = (NextWP*WPpace)/60+RESULT/100;
disp=0;
}
}
}

Rem,

Merci pour l'info

Si je veux transformer ton app pour 16 POI et donc 17 sections, je modifie le code comme suit:

Code: Tout sélectionner

/* While in sport mode do this once per second                */
/* This App display every second , alternatively :            */
/* gap in min:ss vs plan                                      */
/* Distance to Next Waypoint                                  */
/* Time to Next Waypoint (at avg plan pace for that section   */
/* up to 17 section, 16 Waypoint                              */
/* Each Waypoint must be define in cumulative km ( D1 to D16) */
/* Each section must have average Ghost pace ( G1 to G17) */
if ( SUUNTO_DURATION == 0 )
{
    section         = 1;    /* current section # as per increment, total 10 sections */
    Comp           = 0;    /* remaining part in a section */
    NextWP           = 0;    /* distance to next WayPoint */
    WPpace          = 0;    /* planned pace to Next Waypoint */
    disp            = 0;    /* display : 0=gap vs plan, 1 = Distance to NextWP, 2=Duration to NextWP*/
    GHOST_DURATION  = 0;
    G1            = 591;  /* Ghost pace in seconds/km section 1*/
    G2            = 1027; /* Ghost pace in seconds/km section 2*/
    G3            = 1339; /* Ghost Pace In seconds/Km section 3*/
    G4            = 646;  /* Ghost Pace In seconds/Km section 4*/
    G5            = 828;  /* Ghost Pace In seconds/Km section 5*/
    G6            = 928;  /* Ghost Pace In seconds/Km section 6*/
    G7            = 1246; /* Ghost Pace In seconds/Km section 7*/
    G8            = 1332; /* Ghost Pace In seconds/Km section 8*/
    G9            = 679;  /* Ghost Pace In seconds/Km section 9*/
    G10           = 739;  /* Ghost pace in seconds/km section 10*/
    G11           = 500;  /* Ghost pace in seconds/km section 11*/
    G12           = 500;  /* Ghost pace in seconds/km section 12*/
    G13           = 500;  /* Ghost pace in seconds/km section 13*/
    G14           = 500;  /* Ghost pace in seconds/km section 14*/
    G15           = 500;  /* Ghost pace in seconds/km section 15*/
    G16           = 500;  /* Ghost pace in seconds/km section 16*/
    G17           = 500;  /* Ghost pace in seconds/km section 17*/


    D1              = 9.8;  /* Distance section 1*/
    D2              = 17.7; /* Distance section 2*/
    D3              = 19;   /* Distance section 3*/
    D4              = 26.1; /* Distance section 4*/
    D5              = 37.4; /* Distance section 5*/
    D6              = 41.6; /* Distance section 6*/
    D7              = 50.7; /* Distance section 7*/
    D8              = 52.1; /* Distance section 8*/
    D9              = 55.7; /* Distance section 9*/
    D10             = 64;   /* Distance section 10*/
    D11             = 64;   /* Distance section 11*/
    D12             = 64;   /* Distance section 12*/
    D13             = 64;   /* Distance section 13*/
    D14             = 64;   /* Distance section 14*/
    D15             = 64;   /* Distance section 15*/
    D16             = 64;   /* Distance section 16*/
}

/*----------------------------------------------------------------------
   Calculate Virtual Race GHOST_DURATION for Current SUUNTO_DISTANCE
-----------------------------------------------------------------------*/

section = SUUNTO_DISTANCE;
if ((section >= D16) )
{
    Comp = ( SUUNTO_DISTANCE - D16 );
    NextWP = 0;
    prefix = "WP17";
    WPpace = G17;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-D5))+(G7*(D7-D6))+(G8*(D8-D7))+(G9*(D9-D8))+(G10*(D10-D9))+(G11*(D11-D10))+(G12*(D12-D11))+(G13*(D13-D12))+(G14*(D14-D13))+(G15*(D15-D14))+(G16*(D16-D15))+( G17*Comp);
}
if ((section >= D15) && (section < D16) )
{
    Comp = ( SUUNTO_DISTANCE – D15 );
    NextWP = D16-SUUNTO_DISTANCE;
    prefix = "WP16";
    WPpace = G16;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*(D8-D7))+(G9*(D9-D8)) +(G10*(D10-D9)) +(G11*(D11-D10)) +(G12*(D12-D11)) +(G13*(D13-D12)) +(G14*(D14-D13)) +(G15*(D15-D14))+( G16*Comp );
}

if ((section >= D14) && (section < D15) )
{
    Comp = ( SUUNTO_DISTANCE – D14 );
    NextWP = D15-SUUNTO_DISTANCE;
    prefix = "WP15";
    WPpace = G15;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*(D8-D7))+(G9*(D9-D8)) +(G10*(D10-D9)) +(G11*(D11-D10)) +(G12*(D12-D11)) +(G13*(D13-D12)) +(G14*(D14-D13))+( G15*Comp );
}


if ((section >= D13) && (section < D14) )
{
    Comp = ( SUUNTO_DISTANCE – D13 );
    NextWP = D14-SUUNTO_DISTANCE;
    prefix = "WP14";
    WPpace = G14;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*(D8-D7))+(G9*(D9-D8)) +(G10*(D10-D9)) +(G11*(D11-D10)) +(G12*(D12-D11)) +(G13*(D13-D12))+( G14*Comp );
}


if ((section >= D12) && (section < D13) )
{
    Comp = ( SUUNTO_DISTANCE – D12 );
    NextWP = D13-SUUNTO_DISTANCE;
    prefix = "WP13";
    WPpace = G13;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*(D8-D7))+(G9*(D9-D8)) +(G10*(D10-D9)) +(G11*(D11-D10)) +(G12*(D12-D11))+( G13*Comp );
}

if ((section >= D11) && (section < D12) )
{
    Comp = ( SUUNTO_DISTANCE – D11 );
    NextWP = D12-SUUNTO_DISTANCE;
    prefix = "WP12";
    WPpace = G12;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*(D8-D7))+(G9*(D9-D8)) +(G10*(D10-D9)) +(G11*(D11-D10))+( G12*Comp );
}
if ((section >= D10) && (section < D11) )
{
    Comp = ( SUUNTO_DISTANCE – D10 );
    NextWP = D11-SUUNTO_DISTANCE;
    prefix = "WP11";
    WPpace = G11;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*(D8-D7))+(G9*(D9-D8)) +(G10*(D10-D9))+( G11*Comp );
}

if ((section >= D9) && (section < D10) )
{
    Comp = ( SUUNTO_DISTANCE - D9 );
    NextWP = D10-SUUNTO_DISTANCE;
    prefix = "WP10";
    WPpace = G10;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*(D8-D7))+(G9*(D9-D8))+( G10*Comp );
}
if ((section >= D8) && (section < D9) )
{
    Comp = ( SUUNTO_DISTANCE - D8 );
    NextWP = D9-SUUNTO_DISTANCE;
    prefix = "WP9";
    WPpace = G9;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*(D8-D7))+(G9*Comp );
}
if ((section >= D7) && (section < D8) )
{
    Comp = ( SUUNTO_DISTANCE - D7 );
    NextWP = D8-SUUNTO_DISTANCE;
    prefix = "WP8";
    WPpace = G8;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*(D7-D6))+(G8*Comp );
}
if ((section >= D6) && (section < D7) )
{
    Comp = ( SUUNTO_DISTANCE - D6 );
    NextWP = D7-SUUNTO_DISTANCE;
    prefix = "WP7";
    WPpace = G7;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*(D6-

D5))+(G7*Comp );
}
if ((section >= D5) && (section < D6) )
{
    Comp = ( SUUNTO_DISTANCE - D5 );
    NextWP = D6-SUUNTO_DISTANCE;
    prefix = "WP6";
    WPpace = G6;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*(D5-D4))+(G6*Comp );
}
if ((section >= D4) && (section < D5) )
{
    Comp = ( SUUNTO_DISTANCE - D4 );
    NextWP = D5-SUUNTO_DISTANCE;
    prefix = "WP5";
    WPpace = G5;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*(D4-D3))+(G5*Comp );
}
if ((section >= D3) && (section < D4) )
{
    Comp = ( SUUNTO_DISTANCE - D3 );
    NextWP = D4-SUUNTO_DISTANCE;
    prefix = "WP4";
    WPpace = G4;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*(D3-D2))+(G4*Comp );
}
if ((section >= D2) && (section < D3) )
{
    Comp = ( SUUNTO_DISTANCE - D2 );
    NextWP = D3-SUUNTO_DISTANCE;
    prefix = "WP3";
    WPpace = G3;
    GHOST_DURATION = (G1*D1)+(G2*(D2-D1))+(G3*Comp );
}
if ((section >= D1) && (section < D2) )
{
    Comp = ( SUUNTO_DISTANCE - D1 );
    NextWP = D2-SUUNTO_DISTANCE;
    prefix = "WP2";
    WPpace = G2;
    GHOST_DURATION = (G1*D1)+(G2*Comp );
}

if (section < D1)
{
    Comp = ( SUUNTO_DISTANCE  );
    NextWP = D1-SUUNTO_DISTANCE;
    prefix = "WP1";
    WPpace = G1;
    GHOST_DURATION = ( G1 * Comp);
}

if (disp==0) {
prefix ="Gap";
postfix="ms";
  RESULT = Suunto.mod((SUUNTO_DURATION-GHOST_DURATION),60);
  RESULT = (SUUNTO_DURATION-GHOST_DURATION)/60+RESULT/100;
disp=1;
}
else
{
if (disp==1) {
postfix="km";
  RESULT = NextWP;
disp=2;
}
else
{
if (disp==2) {
postfix="ms";
  RESULT = Suunto.mod((NextWP*WPpace),60);
  RESULT = (NextWP*WPpace)/60+RESULT/100;
disp=0;
}
}
}


Mais Movescount desgin me signale une erreur: "Le code contient des caractères non pris en charge."

axon a écrit:

Code: Tout sélectionner

    Comp = ( SUUNTO_DISTANCE - D16 ); 
...
    Comp = ( SUUNTO_DISTANCE – D15 ); 
...
    Comp = ( SUUNTO_DISTANCE – D14 ); 
...
    Comp = ( SUUNTO_DISTANCE – D13 ); 
...
    Comp = ( SUUNTO_DISTANCE – D12 ); 
...
    Comp = ( SUUNTO_DISTANCE – D11 ); 
...
    Comp = ( SUUNTO_DISTANCE – D10 ); 
...
    Comp = ( SUUNTO_DISTANCE - D9 ); 
 

Mais Movescount desgin me signale une erreur: "Le code contient des caractères non pris en charge."

Les caractères qui devraient être des moins sont en fait des tirets numérique.
Ils apparaissent en orangé au niveau de l'app desinger et en bleu dans la citation.
La dernière ligne avec D9 est correcte et le signe moins apparait bien en vert ici.

je crois que le pb a plus a voir avec la limite de la montre.
A 11 sections on est a 83%
si je devais le faire, je reprendrais l'app a 11 sections et aujouterais progressivement des sections et variables supplémentaires.

je pense que la limite doit être autour de 13.

il va falloir re-investir dans une "Ambit3 Peak" , puisque c'est son nom

Effectivement le code est bien trop grand, du coup j'ai modifié mon itinéraire à 10 POI.
Je découvre les app, il y a peut-être un moyen de mettre des boucles et de paramétrer ce code pour le rendre moins long. A voir aussi pour le nombre de variable qui va coincer.

axon a écrit:Effectivement le code est bien trop grand, du coup j'ai modifié mon itinéraire à 10 POI.

Oui, mais l'erreur rapporté par App Designer était bien dû à un caractère Unicode.

axon a écrit:Je découvre les app, il y a peut-être un moyen de mettre des boucles et de paramétrer ce code pour le rendre moins long. A voir aussi pour le nombre de variable qui va coincer.

J'ai envoyé une version condensé à Rem de son code, on peut l'utiliser dans l'Ambit1 avec 13 sections et l'Ambit2 avec plus de 50 sections voir encore plus si on réduit le nom des points de passage.
Une fois testé, je pense qu'il nous en fera part.

Je posterai un code différent qui utilise des positions GPS pour identifier des sections un peu à la manière de STRAVA. Mes premiers testes sont encourageant même sur des temps courts.

Merci SiRoB1 ,
Je n'avais pas vu ton msg
très beau code bien condensé !
bien vu l'utilisation d'une seule variable pour les distances et Ghost pace ,D et G.
Et , de reprendre les valeurs de la précédente boucle.
je venais d'y penser (la boucle) et tu l'a fait en 10x mieux
(faut que je revois ton code j'ai pas encore tout saisi)
je vais le tester sans tarder

merci encore !

deborah a écrit:- est ce que ces mélodies seraient accessibles en mode programmation ? (ca permettrait de mettre un son différent quand on franchit une FC et quand on finit un intervalle par ex)

Au sujet des intervalles, je ne pourrai pas aider.
Sinon pour la programmation, on a pas la possibilité d'utiliser autre chose qu'un bip standard.

Merci SiRoB1
mais quel est la fonction qui permet d'avoir autre chose que les bips standards ?

deborah a écrit:Merci SiRoB1
mais quel est la fonction qui permet d'avoir autre chose que les bips standards ?

- Contrôle de la FC produit des sons mais je ne pourrai dire de quel type car je n'utilise pas de ceinture de FC.
- Alarme de tempête produit bien une mélodie, elle pourrait se déclencher si vous n'avez pas correctement spécifié le mode de l'altimètre barométrique.
- Les intervalles je viens de tester des intervalles de temps à chaque mélodie on change d'état (haut/bas)
- Auto-Pause Auto-Lap on peut aussi les considérer comme des mélodies au sens ou les sons produits sont différents du bips standard de la programmation.

Je ne vois pas d'autres fonctions qui pourraient produire des mélodies.

Hello ,
ci dessous, la version optimisée de SiRoB1 de l'app Virtual Race Trail .
ici, version 10WP, 11 sections mais peut en avoir bcp plus (cf comment de SiRoB1 plus haut).
testé et approuvé

je pense changer le mode de calcul du temps pour atteindre NextWP , actuellement sur la base du rythme prévu, remplacé par le rythme moyen depuis le précédent WP, plus significatif.

Code: Tout sélectionner

/* This App display every second , alternatively :           */
/* gap in min:ss vs plan                                     */
/* Distance to Next Waypoint                                 */
/* Time to Next Waypoint at avg plan pace for that section   */
/* up to 13 section, 12 Waypoint for Ambit1                  */
/* Each Waypoint must be defined in km ( D )                 */
/* Each section must have average Ghost pace ( G )           */
if ( startDuration == 0 || SUUNTO_DURATION == 0) {
  section         = 1;    /* current section # as per increment, total 10 sections */
  Comp            = 0;    /* remaining part in a section */
  NextWP          = 0;    /* distance to next WayPoint */
  WPpace          = 0;    /* planned pace to Next Waypoint */
  D               = 0;    /* distance of current section */
  GHOST_DURATION  = 0;
  
  lastDistance    = SUUNTO_DISTANCE; /* Address multisport usage */
  startDuration   = SUUNTO_DURATION; /* Address multisport usage */
}

if ((section < 10) && (SUUNTO_DISTANCE > lastDistance + D)) {
  GHOST_DURATION = GHOST_DURATION + WPpace * D;
  lastDistance = lastDistance + D;
  section = section + 1;
}

/*    Section #      Ghost pace (s/km)   Distance (km)       Info        */
if (section ==  1) {  WPpace =  591;       D =  9.8;     prefix = "WP1 "; }
if (section ==  2) {  WPpace = 1027;       D =  7.9;     prefix = "WP2 "; }
if (section ==  3) {  WPpace = 1339;       D =  1.3;     prefix = "WP3 "; }
if (section ==  4) {  WPpace =  646;       D =  7.1;     prefix = "WP4 "; }
if (section ==  5) {  WPpace =  828;       D = 11.3;     prefix = "WP5 "; }
if (section ==  6) {  WPpace =  928;       D =  4.2;     prefix = "WP6 "; }
if (section ==  7) {  WPpace = 1246;       D =  9.1;     prefix = "WP7 "; }
if (section ==  8) {  WPpace = 1332;       D =  1.4;     prefix = "WP8 "; }
if (section ==  9) {  WPpace =  679;       D =  3.6;     prefix = "WP9 "; }
if (section == 10) {  WPpace =  739;       D =  8.3;     prefix = "WP10"; }

Comp = (SUUNTO_DISTANCE - lastDistance);
NextWP = D - Comp;

disp = disp + 1;
if ((NextWP < 0) || (disp > 2)) { disp = 0; }
if (disp==1) {
  postfix="km";
  RESULT = NextWP;
} else {
  if (disp==2) {
    RESULT = NextWP*WPpace;
  } else if (disp==0) {
    prefix ="Gap ";
    RESULT = SUUNTO_DURATION-startDuration-GHOST_DURATION-WPpace*Comp;
  }
  postfix="ms";
  if (RESULT < 0) {
    RESULT = -RESULT;
    Comp = -1;
  }
    RESULT = Suunto.floor(RESULT/60)+Suunto.mod(Suunto.floor(RESULT),60)/100;
  if (Comp==-1) {
    RESULT = -RESULT;
  }
} 
 

Bonjour a toutes et tous

y a t'il la possibilité sur une Ambit 2



1°) Qu'elle bip tous les km
2°) Qu'elle affiche le temps de passage de ce km pendant 15-20 secondes
3°) Qu'elle affiche le résultat sur 10 km pendant ces même 15 - 20 secondes

MERCI

Rem a écrit:Hello ,
ci dessous, la version optimisée de SiRoB1 de l'app Virtual Race Trail .
ici, version 10WP, 11 sections mais peut en avoir bcp plus (cf comment de SiRoB1 plus haut).
testé et approuvé

je pense changer le mode de calcul du temps pour atteindre NextWP , actuellement sur la base du rythme prévu, remplacé par le rythme moyen depuis le précédent WP, plus significatif.

Bon moi je suis un peu nul la dedans mais si tu prends le rythme moyen depuis le précédent wp pour estimer le temps pour atteindre le prochain wp, ça ne risque pas de donner un truc complètement aléatoire si tu viens de faire 10km faux plats descendant et que tu attaques un D+ de 1400m ?

Renvoi de la suunto au service sav apres qu elle se soit éteinte au bout de 13h sur la MH....grrr

jack

jack91290 a écrit:Renvoi de la suunto au service sav apres qu elle se soit éteinte au bout de 13h sur la MH....grrr

jack

Tu avais mis quoi comme paramètres?
Je ne pense pas qu'elle tienne plus longtemps que ça avec tout au max et des appli qui tournent.

Jack
a titre d'exemple mon Ambit 2 sur la maxi sans cardio enregistrement a la seconde,apres 9h de course il me rester que 25%,e lui es remis un coup de charge en cour de route avec une batterie de secour pour qu'elle tienne tout le long