zufällige Dauer mit Gaußscher Normalverteilung

[Sternthaler]

Klasse Idee und Mathematik,
habe ich mal sofort etwas geändert und auch die Motoren mit in's Spiel genommen.

Ich bin ein Fan von blinkenden LED's  

/*****************************************************************************
*   zufall LED                                                               *
*****************************************************************************/

#include "asuro.h"


//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
//
// uint8_t zufall ()
//
// Liefert eine 8-Bit Pseudozufallszahl zurück,
// die Zahlenfolge wiederholt sich spätestens nach 65535 Aufrufen.
//
        unsigned  char    zufall ()
{
static  unsigned  int     startwert = 0x0AA;
        unsigned  int     temp;
        unsigned  char    n;

  for (n = 1; n < 8; n++)
  {
    temp       = startwert;
    startwert  = startwert << 1;
    temp      ^= startwert;
    if ((temp & 0x4000) == 0x4000)
      startwert |= 1;
  }

  return (startwert);
}


//----------------------------------------------------------------------------
//----------------------------------------------------------------------------
                  int     main (void)
{
                  int     i;          //Zähler
        unsigned  int     data [2];   //Odo
        unsigned  int     zuf;        //Zufall
        unsigned  char    dirlinks,   dirrechts;
        unsigned  char    speedlinks, speedrechts;

  Init ();

  StatusLED (OFF);

  /* Zufaellige Zeit fuer "Anfangs-Zufallszahl" */
  zuf = zufall ();
  OdometrieData (data);               // aktuelle Odometriewerte
  zuf ^= data [0];
  for (i = 1; i < zuf; i++)
    zufall ();

  while (1)
  {
    StatusLED (OFF);
    BackLED (OFF, OFF);

    /* Bereich StatusLED */
    zuf = zufall ();                  // Zufallszahlen zw. 0 und 255
    if (zuf < 25)
      StatusLED (OFF);                // ca. 10% aus
    else if (zuf < 75)
      StatusLED (YELLOW);             // ca. 20% gelb
    else if (zuf < 150)
      StatusLED (RED);                // ca. 30% rot
    else
      StatusLED (GREEN);              // ca. 40% grün

    /* Bereich BackLED */
    zuf = zufall ();                  // Zufallszahlen zw. 0 und 255
    if (zuf < 64)
      BackLED (OFF, OFF);             // 25% beide aus
    else if (zuf < 128)
      BackLED (ON, OFF);              // 25% links an  - rechts aus
    else if (zuf < 192)
      BackLED (OFF, ON);              // 25% links aus - rechts an
    else
      BackLED (ON, ON);               // 25% beide an

    /* Bereich FrontLED */
    zuf = zufall ();                  // Zufallszahlen zw. 0 und 255
    if (zuf < 204)
      FrontLED (OFF);                 // 80% aus
    else
      FrontLED (ON);                  // 20% an

    /* Richtung */
    zuf = zufall ();
    if (zuf < 216)
      dirlinks = FWD;                 // 85% vorwaerts
    else if (zuf < 230)
      dirlinks = BREAK;               // 5% stop
    else
      dirlinks = RWD;                 // 10% rueckwaerts

    zuf = zufall ();
    if (zuf < 216)
      dirrechts = FWD;                // 85% vorwaerts
    else if (zuf < 230)
      dirrechts = BREAK;              // 5% stop
    else
      dirrechts = RWD;                // 10% rueckwaerts
    MotorDir (dirlinks, dirrechts);

    /* Geschwindigkeit */
    zuf = zufall ();
    if (zuf < 128)
      speedlinks = 130;               // 50% langsam
    else if (zuf < 204)
      speedlinks = 170;               // 30% mittel
    else
      speedlinks = 200;               // 20% schnell

    zuf = zufall ();
    if (zuf < 128)
      speedrechts = 130;              // 50% langsam
    else if (zuf < 204)
      speedrechts = 170;              // 30% mittel
    else
      speedrechts = 200;              // 20% schnell
    MotorSpeed (speedlinks, speedrechts);

    /* "gauss" dauer zwischen 0 und 2 sec mit häufung um 1 sec */
    zuf = 0;
/*
    for (i = 1; i <= 10; i++)         // zahlen von 0 bis 2550
      zuf += zufall ();
    zuf *= 4;                         // zahlen von 0 bis 10200
    zuf /= 5;                         // zahlen von 0 bis 2040
*/
    /* "gauss" dauer zwischen 0 und 2 sec mit geringerer häufung um 1 sec */
    for (i = 1; i <= 4; i++)          // zahlen von 0 bis 1020
      zuf += zufall ();
    zuf *= 2;                         // zahlen von 0 bis 2040

    Msleep(zuf);
  }

  return 0;
}