Is there anything wrong with this code

Here are some random comments from looking at the code.

First issue, which is more about the example than the library itself: there is no Serial.printf() in the standard Arduino cores. Yes, it is provided by some alternate cores, and it is a shame it is not available in the Arduino ones, but that's how it is.

In the constructor, there is if(flowPin==254). Why this condition? flowPin is initialized to zero, so it would seem the condition should always be false.

As a matter of style, you can remove all the this-> from the methods. It is implicit anyway.

For the sake of naming consistency, I would rename retrieve_pin() as get_pin(), and all the assign_*() method as set_*().

It is not useful to detachInterrupt() right before attachInterrupt(), as the latter implies the former.

In calculate(), avoid calling millis() twice. You have no guarantee that both calls will return the same value and, if they do not, the timing calculations will be off. Also, this function will fail badly (division by zero) if called twice within the same millisecond.

It makes no sense to convert a flow rate to milliliters. Do you mean milliliters per minute? Per second? In any case, you here converting a rate to another unit, but it is still a flow rate.

The computation of totalMillilitres is wrong: it is incremented by a flow rate. It should instead be incremented by a product rate × time. Or better yet: compute it from the pulse count, without going through the rate. Otherwise you are computing a numerical derivative (to get the rate) only to integrate it later (to get a total volume). This extra computations serve no purpose other than accumulating rounding errors.

Edit: Thinking further about this program, I found a few more things that I think could be improved. A couple of minor points an one not so minor.

One of the minor points is that begin() would be a better name for start(), for consistency with most other Arduino libraries.

Another one is that there are a couple of methods that have no business being in the class: is_max() and percent(). They are trivial calculations that are in no way related to handling a flow meter. As a user of the library, I would rather write

if (flow.total_ml() >= threshold_volume) ...

than

if (flow.is_max(threshold_volume)) ...

as the former is way clearer and easy to understand.

The more serious point is about the handling of multiple flow meters. The first one is completely handled by the library, which is nice. However, for the second one, the user has to provide the lowest level bricks. The user of a library should not have to handle himself such low-level details. Thus, I think both the counter variable and the ISR function should be handled by the library, as members of the Flow class.

I am aware this creates some difficulties. In order to be attached to an interrupt, the ISR should be a static method of the class. In order for this method to access the counter, that counter should be a static member. In order for each flow meter to have its own counter, we must have a separate class for each one.

I found a solution that I think is elegant enough: have Flow be a class template, parametrized by the pin number. This creates a separate class for each flow meter. In order to avoid code duplication, these classes could be almost empty shells that delegate as much as possible to a handler which is a common, regular class.

Here is what that “handler” class could look like. It has everything but the ISR:

class FlowMeterHandler {
    // Everything here is private, only accessible to the Flow class.
    template<uint8_t pin> friend class Flow;
private:
    void begin(uint8_t pin, void (*isr)()) {
        attachInterrupt(digitalPinToInterrupt(pin), isr, FALLING);
    }
    float flow_rate() {
        uint32_t now = millis();
        if (now - last_millis >= 10) {
            uint32_t this_count;
            noInterrupts();
            this_count = count;
            interrupts();
            last_flow = calibration * (this_count - last_count)
                                    / (now - last_millis);
            last_millis = now;
            last_count = this_count;
        }
        return last_flow;
    }
    // + other methods...
    volatile uint32_t count = 0;
    uint32_t last_count = 0;
    uint32_t last_millis = 0;
    float last_flow = 0;
    float calibration = 1e3 / 4.5;
};

I've written the methods inline, but you could also put the implementations in a separate .cpp file.

And here is the template class. Save for the ISR, it forwards everything to the handler.

template<uint8_t pin> class Flow {
public:
    static void begin() { handler.begin(pin, isr); }
    static float flow_rate() { return handler.flow_rate(); }
    // other methods also forwarded to the handler...
private:
    static FlowMeterHandler handler;
    static void isr() { handler.count++; };
};

template<uint8_t pin> FlowMeterHandler Flow<pin>::handler;

Note that the class has no instance data: everything in it is static.

Here is how this would be used:

Flow<3> f1;
Flow<4> f2;

void setup()
{
    f1.begin();
    f2.begin();
}

void loop()
{
    Serial.print(F("flow rate on 3 = "));
    Serial.println(f1.flow_rate());
    Serial.print(F("flow rate on 4 = "));
    Serial.println(f2.flow_rate());
    delay(1000);
}

Ok so if anyone is interested here is what I ended up with

/*
  this is yet to be varified but comes from the following links
  * 
  https://www.bc-robotics.com/tutorials/using-a-flow-sensor-with-arduino/ 
  
  "These are not able to monitor a flow of less than 1 liter per minute or in excess of 30 liters per minute.
  The sensor is rated to a Maximum of 2.0MPa (290 PSI) "
  and   
  every rotation means 2.25mL of fluid has passed the sensor

  another is 

  https://diyhacking.com/projects/FlowMeterDIY.ino
  "// The hall-effect flow sensor outputs approximately 4.5 pulses per second per
   // litre/minute of flow.
  "
  
  then finally 
  
  https://arduino.stackexchange.com/questions/84578/is-there-anything-wrong-with-this-code
  
  I make no personal claim to any of this code. It is simply my version of Edgar's version. 
  Thanks Edgar
  * 
  * 
  * 
  * I have used start and stop as they signify the start and stop of the process 
  * the class begins when it starts and has no end the isr stays linked to the class for the duration 
  * and start simply attaches the interrupt to the isr 
  * stop simply calculates the total volume and detaches the interrupt.
  * 
  * as flow rate related to time 
  * just set your own start time 
  * read the total_ml
  * then after your own predefined time
  * read the total_ml again 
  * and work out the flow rate from that.
  */


class FlowMeterHandler {
  // Everything here is private, only accessible to the Flow class.
  template<uint8_t pin> friend class Flow;
private:
  
  void start(uint8_t pin, void (*isr)()) 
  {
    noInterrupts();
    count = 0;
    interrupts();
    attachInterrupt(digitalPinToInterrupt(pin), isr, FALLING);
  }
  
  void stop(uint8_t pin)
  {
    detachInterrupt(digitalPinToInterrupt(pin));
  }
  
  unsigned int count_is()
  {
    unsigned int this_count;
    noInterrupts();
    this_count = count;
    interrupts();
    return this_count;
  }
  
  volatile unsigned int count = 0;
  unsigned int ul_per_tick = 2250;
  
};


template<uint8_t pin> class Flow {
public:
    static void start() { handler.start(pin, isr); }
    static void stop() { handler.stop(pin); }
    static unsigned int total_ul() { return handler.count_is() * handler.ul_per_tick; }
    static unsigned int total_ml() { return ( handler.count_is() * handler.ul_per_tick ) / 1000 ; }
    static void set_ul_per_rotation( unsigned int ul) { handler.ul_per_tick = ul; }
private:
    static FlowMeterHandler handler;
    static void isr() { handler.count++; };
};

template<uint8_t pin> FlowMeterHandler Flow<pin>::handler;

the example ino looks like this

#include "flow.h"
Flow<3> f1;
Flow<4> f2;

void setup()
{
    f1.start();
    f2.start();
}

void loop()
{
    Serial.print(F("So far volume on 3 = "));
    Serial.println(f1.total_ml());
    Serial.print(F("and the volume on 4 = "));
    Serial.println(f2.total_ml());
    delay(1000);
}

Compiles cleanly on all my boards. Runs ??? Any other suggestions will be gratefully received.

Thanks. Greg

It's hard to answer without any description of the actual problem.

On the top of my head, with that much code i'd consider starting off by creating a separate class declaration, and write your member definitions outside. It will make the code way more manageable, and easier to troubleshoot.

https://www.learncpp.com/cpp-tutorial/class-code-and-header-files/

Also, you have several include statements in at least two different places. They usually go first in a file, along with include guards. If your code consists of separate files, please make that clear to readers.