/* -------------------------------------------------------
                      benchmark.c

     Einfacher Geschwindigkeitstest fuer Mikrocontroller

     MCU   :  ATmega328p
     Takt  :

     19.11.2025  R. Seelig
   ------------------------------------------------------ */

/* -------------------------------------------------------
     In tftdisplay.h wird angegeben, wie das Display
     angeschlossen werden muss..
     Aktuell ist dieses:

                     #define pindefs     2

     in tft_pindefs.h wird dieses ausgewertet.

   ------------------------------------------------------- */

#include <util/delay.h>
#include <avr/io.h>
#include <avr/pgmspace.h>
#include <avr/interrupt.h>
#include <inttypes.h>

#include "tftdisplay.h"
#include "my_printf.h"

#define printf           tiny_printf
#define delay            _delay_ms

volatile uint32_t millis = 0;

#define printf     my_printf            // "System-printf" durch eigenes ersetzen

/* --------------------------------------------------------
   my_putchar

   wird von my-printf / printf aufgerufen und hier muss
   eine Zeichenausgabefunktion angegeben sein, auf das
   printf dann schreibt !
   -------------------------------------------------------- */
void my_putchar(char ch)
{
  lcd_putchar(ch);
}

ISR (TIMER1_COMPA_vect)
{
  millis++;
}

void timer1_init(void)
{
  /* ---------------------------------------------
     CS10 / CS11 / CS12 sind Steuerbits
     des Taktvorteilers.

     CS 12 | CS11 | CS10
     ----------------------------------------------
       0      0      0   kein Takt, Timer gestoppt
       0      0      1   clk / 1 (kein Teiler)
       0      1      0   clk / 8
       0      1      1   clk / 64
       1      0      0   clk / 256
       1      0      1   clk / 1024
     ---------------------------------------------- */
  TCCR1B = 1 << WGM12 | 1 << CS10;
  OCR1A = F_CPU / 1000;                 // 1000 = Reloadwert fuer 16 MHz
  TCNT1 = 0;

  TIMSK1 = 1 << OCIE1A;
  sei();
}


#define loops_int8   100000
#define loops_int16  50000
#define loops_int32  20000
#define loops_float  8000

#define n_int8   16
#define n_int16  16
#define n_int32  16
#define n_float  16

// Benchmark-Funktionen
void benchmark_int8(uint8_t *array)
{
  uint32_t loop, i;
  uint8_t a, b, c, mix;

  for(loop = 0; loop < loops_int8; loop++)
  {
    for(i = 0; i < n_int8; i++)
    {
      a = array[i];
      b = (a * 17) + (i ^ 0x55);
      c = (b * 23) ^ a;
      mix = a ^ (b << 1) ^ (c >> 2);
      mix = (mix << 3) | (mix >> 5);
      array[i] = mix;
    }
  }
}

void benchmark_int16(uint16_t *array)
{
  uint32_t loop, i;
  uint16_t a, b, c, mix;

  for(loop = 0; loop < loops_int16; loop++)
  {
    for(i = 0; i < n_int16; i++)
    {
      a = array[i];
      b = (a * 123) + (i ^ 0xAAAA);
      c = (b * 97) ^ a;
      mix = a ^ (b << 1) ^ (c >> 2);
      mix = (mix << 3) | (mix >> 5);
      array[i] = mix;
    }
  }
}

void benchmark_int32(uint32_t *array)
{
  uint32_t loop, i;
  uint32_t a, b, c, mix;

  for(loop = 0; loop < loops_int32; loop++)
  {
    for(i = 0; i < n_int32; i++)
    {
      a = array[i];
      b = (a * 12345UL) + (i ^ 0xAAAA5555UL);
      c = (b * 98765UL) ^ a;
      mix = a ^ (b << 1) ^ (c >> 2);
      mix = (mix << 3) | (mix >> 5);
      array[i] = mix;
    }
  }
}

void benchmark_float(float *array)
{
  uint32_t loop, i;
  float a, b, c, mix;

  for(loop = 0; loop < loops_float; loop++)
  {
    for(i = 0; i < n_float; i++)
    {
      a = array[i];
      b = a * 1.2345f + (float)i;
      c = b * 0.9876f - a;
      mix = a + b - c;
      array[i] = mix;
    }
  }
}

void run_benchmark()
{
  uint8_t  array8[n_int8];
  uint16_t array16[n_int16];
  uint32_t array32[n_int32];
  float    arrayf[n_float];
  uint32_t i;

  // Arrays initialisieren
  for(i = 0; i < n_int8; i++)
    array8[i] = i * 3 + 1;

  for(i = 0; i < n_int16; i++)
    array16[i] = i * 7 + 11;

  for(i = 0; i < n_int32; i++)
    array32[i] = i * 123 + 456;

  for(i = 0; i < n_float; i++)
    arrayf[i] = (float)i * 0.5f + 1.0f;

  // Benchmarks durchfuehren
  printf("int_8 Benchmark\n\r");
  benchmark_int8(array8);
  printf("int_8 done: %d\n\r", array8[0]);

  printf("\n\rint_16 Benchmark\n\r");
  benchmark_int16(array16);
  printf("int_16 done: %k\n\r", array16[0]);

  printf("\n\rint_32 Benchmark\n\r");
  benchmark_int32(array32);

  // int32 nur untere 16 Bit ausgeben
  printf("int_32 done: %k\n\r", (uint16_t)array32[0]);

  printf("\n\rfloat Benchmark\n\r");
  benchmark_float(arrayf);

  // FLOAT ueber %k ausgeben, konvertiert
  for(i = 0; i < 1; i++)
  {
    printfkomma = 1;
    int16_t fval = (int16_t)(arrayf[i] * 10.0f);

    printf("float done: %k\n\r", fval);
  }
}

/* --------------------------------------------------------
                            main
   -------------------------------------------------------- */
int main(void)
{
  uint8_t  y,x;
  uint8_t  yofs;

  uint32_t prog_millis;
  uint16_t sek, hsek;

  lcd_init();
  lcd_enable();
  timer1_init();

  lcd_orientation(1);
  textcolor= rgbfromega(10);
  bkcolor= rgbfromega(1);
  clrscr();
  prog_millis= millis;

  gotoxy(0,0);
  run_benchmark();

  prog_millis= millis-prog_millis;
  sek= prog_millis / 1000;
  hsek= (prog_millis % 1000) / 100;
  textcolor= rgbfromega(15);

  gotoxy(0,15); printf("Zeit: %d.%d sek",prog_millis / 1000, (prog_millis / 100) % 10);

  while(1);
}