Comment créer de la valeur pulsant de 0..1..0..1..0 etc pour une durée donnée?

Question

Je travaille sur un code où j'ai un objet Time avec un time membre. Time.time donne moi le temps écoulé depuis mon application a commencé en secondes (valeur flottante). Maintenant, je veux créer une valeur pulsatoire entre 0 et 1, puis de 1 à 0 à nouveau, qui continue de faire amincit jusqu'à ce que le arrête l'application.

Je pensais à utiliser le péché () mais je ne sais pas quoi lui passer comme paramters pour créer cette valeur pulsant.

Comment puis-je créer cette valeur pulsant?

Cordialement, Pollux

Answer 1

Vous mentionnez en utilisant le péché (), donc je suppose que vous voulez qu'il continue d'impulsion entre 0 et 1.

Quelque chose comme cela va faire:

float pulse(float time) {
    const float pi = 3.14;
    const float frequency = 10; // Frequency in Hz
    return 0.5*(1+sin(2 * pi * frequency * time));
}

1/frequency = 0.1 second est la période, qui est le temps entre des 1.

Answer 2

Qu'en est-x = 1 - x? Ou si vous voulez qu'il soit utilisé en fonction du temps du temporisateur% 2

Oh, vous vouliez les valeurs comprises entre 0 et 1 ainsi. Que diriez-vous Math.abs (100 - (temporisateur% 200)) / 100 Où minuterie est quelque chose comme DateTime.Now.TimeOfDay.TotalMilliseconds

Edit: Mes tests indiquent que cela est plus de deux fois plus vite que la méthode Sin. Pour 1 million d'itérations, la méthode du péché prend .048 secondes alors que la méthode Abs prend environ .023 secondes. En outre, vous obtenez différentes formes d'onde sur les deux, bien sûr. Sin produit une onde sinusoïdale, tandis que Abs produit une onde triangulaire.

static void Main(string[] args)
{
   System.Diagnostics.Stopwatch sw = new System.Diagnostics.Stopwatch();
   sw.Start();
   const int count = 1000000;
   float[] results = new float[count];
   for (int i = 0; i < count; i++)
   {
      results[i] = AbsPulse(i/1000000F);
      //results[i] = SinPulse(i / 1000000F);
   }
   sw.Stop();
   Console.WriteLine("Time Elapsed: {0} seconds", sw.Elapsed.TotalSeconds);
   char[,] graph = new char[80, 20];
   for (int y = 0; y <= graph.GetUpperBound(1); y++)
      for (int x = 0; x <= graph.GetUpperBound(0); x++)
         graph[x, y] = ' ';
   for (int x = 0; x < count; x++)
   {
      int col = x * 80 / count;
      graph[col, (int)(results[x] * graph.GetUpperBound(1))] = 'o';
   }
   for (int y = 0; y <= graph.GetUpperBound(1); y++)
   {
      for (int x = 0; x < graph.GetUpperBound(0); x++)
         Console.Write(graph[x, y]);
      Console.WriteLine();
   }
}

static float AbsPulse(float time)
{
   const int frequency = 10; // Frequency in Hz
   const int resolution = 1000; // How many steps are there between 0 and 1
   return Math.Abs(resolution - ((int)(time * frequency * 2 * resolution) % (resolution * 2))) / (float)resolution;
}

static float SinPulse(float time)
{
   const float pi = 3.14F;
   const float frequency = 10; // Frequency in Hz
   return 0.5F * (1 + (float)Math.Sin(2 * pi * frequency * time));
}

Answer 3

Une fonction sinus serait idéal je pense, mais vous devez ajuster la période et l'échelle.

La fonction sinus produit des résultats entre -1 et 1, mais vous voulez aller entre 0 et 1. Pour l'échelle correctement vous voulez (sin(x)+1)/2.

la fonction sinus commence à zéro, passe à 1 à pi / 2, à zéro à nouveau à pi -1 à 3 * pi / 2, et de retour à zéro à 2 * pi. Scaled, le premier zéro se produira à 3 * pi / 2 et le premier maximum après sera à 5/2 * pi. Donc x dans la formule précédente est (2*time + 3) * pi/2.

Mettre tous ensemble: (sin((2*time.time + 3) * pi/2) + 1) / 2

Answer 4

À quelle fréquence voulez-vous à impulsion?

Le mot Let vous voulez aller de 0 à 1 plus de 10 secondes.

float pulseValueForTime(int sec) {
    int pulsePoint = sec % 10;
    float pulsePercent = (float)pulsePoint / (float)10;
    float pulseInTermsOfPI = (pulsePercent * 2 * PI) - PI;
    float sinVal = MagicalSinFunction(pulseInTermsOfPI); // what framework you use to compute sin is up to you... I'm sure you can google that!
    return (sinVal + 1) / 2; // sin is between 1 and -1, translate to between 0 and 1
}

Answer 5

Regardez dans les fonctions de facilité. Ils font ce genre de chose dans toutes sortes de manières -. Linéaires, poly, exp, sin, etc