trying ramp up a pwm signal

float a1 = 100; // percentage
float a2 = 100; //max percentage
float a3 = a2 * a1 / 100;  //percent of max percent
float b1 = 255 * a3 / 100; // percentage of pwm
float b2 = 255 * a2 / 100; // pwm as number
float c1 = 5000;  //time period to cascade up in milliseconds
float c2 = c1 / b1; // percent increments
float c3 = c1 / b2;//maxpercent increments
unsigned long currentMillis = 0;    // stores the value of millis() in each iteration of loop()
long acctime = 6000;
int LED = 11;
const int ledrly = 8;
const int ledfwd = 11;
const int ledrvs = 10;
int LEDbright = 12;
unsigned long precycle = 0;
unsigned long cycle = 6000;
unsigned long prerlyMillis = 00;
unsigned long rlyMillis = 2000;
unsigned long preontimeMillis = 0;   // will store last time the LED was updated
unsigned long ontimeMillis = 2000;
unsigned long preserialmillis = 0;
unsigned long serialmillis = 6000;
unsigned long incrementtime = c2;
unsigned long preincrementtime = 0;

void setup()
{
  digitalWrite(LEDbright, HIGH);
  Serial.begin(9600);
 pinMode(ledfwd, OUTPUT);
 pinMode(ledrvs, OUTPUT);
 pinMode(ledrly, OUTPUT);
 
  
}

void loop()
{currentMillis = millis();
  
/*  Serial.println("percent of percent");
  Serial.println(a1);
  Serial.println("max percent");
  Serial.println(a2);
  Serial.println("percent of percent actual");
  Serial.println(a3);
  Serial.println("pwm actual");
  Serial.println(b1);
  Serial.println("max pwm");
  Serial.println(b2);
  Serial.println("ramp up time");
  Serial.println(c1);
  Serial.println("ramp up interval for pwm");
  Serial.println(c2);
  Serial.println("max ramp up interval for pwm");
  Serial.println(c3);
  Serial.println("accumulated ontime");
  Serial.println(ontimeMillis);
  */
  waitfortimer();

}

void turnoncycle()
{
Serial.println("ramp up time");
   rampuplow();
}

void waitfortimer()
 {
  if (currentMillis - precycle >= cycle)
  {turnoncycle();
    precycle = currentMillis;}
  
  
 	 
}


void rampuplow() 
{int brightness = 1;
  analogWrite(LED, brightness);
 if (currentMillis - preincrementtime >= incrementtime)
 {brightness = brightness + 1;}
 preincrementtime = currentMillis;
   Serial.println(brightness);

  
}

so if you can read my silliness good luck.
the idea is simplistic but I am stuck on 1 part.... at the moment.
rampuplow is supposed to take the time period (C1) and divide it by a pwm value (b1) which is a percentage of a percentage(yes twice) of a pwm signal.
I want to automatically detect the values so put the maths up top there.
the issue is rather than using the values (so on this one its 100% of 100% of pwm, then take the time labelled c1, 5000 and divide it by the increments to end up with a value that will tell me when to step up 1 on pwm so that over 5 seconds it gets to full on rather than fast on.
the code seems to just go on at the 6 second mark with no build up. also the serial monitor is stating brightness is only 2.... so it DOES 1 increment but then no more.

You are calling "turnOnCycle" only every six seconds. That calls "rampupLow" every six seconds and "rampupLow" only increases the brightness by 1/256th. That will take 25.6 minutes to get to full brightness.

thanks for that, how do i stop it then?

Stop it from doing what? Stop it from ramping up? Stop it from being so slow?
If you want to make it faster, change the values of the appropriate timing variables.

You seem to want some pattern of brightness that starts every six seconds but you have not said what that pattern is. Your cascade of 'a', 'b', 'c' calculations hides the meaning of those values so it is hard to tell from the code what pattern you want. It seems to be about fading 'LED' up for 5 seconds and starting over every 6 seconds.

That would be something like this:

const byte LEDPin = 11;

unsigned long CycleStart = 0;
const unsigned long CycleInterval = 6000;

unsigned long FadeStart = 0;
const unsigned long FadeInterval = 5000 / 256;

byte Brightness = 0;

void setup()
{
  Serial.begin(115200);
  pinMode(LEDPin, OUTPUT);
}

void loop()
{
  unsigned long currentMillis = millis();
  if (currentMillis - CycleStart >= CycleInterval)
  {
    CycleStart += CycleInterval;
    Brightness = 0;  // Re-start the fade up
  }

  if (currentMillis - FadeStart >= FadeInterval)
  {
    FadeStart += FadeInterval;
    if (Brightness < 255)
      Brightness++;
  }

  analogWrite(LEDPin, Brightness);
}