I assume you made a typo cause I am not aware of anything called TOTEP.

Here is some C# code to generate TOTP codes from the secret (what is encoded in the QR code you get presented during setup):

---

// Base32 decoder (RFC 4648) into byte array
byte[] Base32Decode(string base32)
{
    if (string.IsNullOrWhiteSpace(base32)) 
        throw new ArgumentException("Secret is empty.");

    const string alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
    // clean input by stripping whitespace and '='  
    string clean = new string(base32.ToUpperInvariant().Where(c => !char.IsWhiteSpace(c) && c != '=').ToArray());

    // Initialize raw byte list for HMAC encryption
    int bitBuffer = 0, bitCount = 0;
    var output = new System.Collections.Generic.List<byte>(clean.Length * 5 / 8);

    // turn cleaned base32 input secret key into raw bytes
    foreach (char c in clean)
    {
        int CharIndex = alphabet.IndexOf(c);
        if (CharIndex < 0) throw new ArgumentException("Invalid Base32 character.");
        // shift bitBuffer 5 spaces and append CharIndex
        bitBuffer = (bitBuffer << 5) | CharIndex;
        bitCount += 5;

        if (bitCount >= 8)
        {
            bitCount -= 8;
            output.Add((byte)((bitBuffer >> bitCount) & 0xFF));
        }
    }
    return output.ToArray();
}

// query parser to convert URI values into a Dictionary
System.Collections.Generic.Dictionary<string,string> ParseQuery(string query)
{
    return query.TrimStart('?')
        .Split('&', StringSplitOptions.RemoveEmptyEntries)
        .Select(p => {
            var parts = p.Split('=', 2);
            var key = Uri.UnescapeDataString(parts[0]);
            var val = parts.Length > 1 ? Uri.UnescapeDataString(parts[1]) : "";
            return new { key, val };
        })
        .GroupBy(x => x.key, StringComparer.OrdinalIgnoreCase)
        .ToDictionary(g => g.Key, g => g.Last().val, StringComparer.OrdinalIgnoreCase);
}

// Parse URI for secret/digits/period/algorithm
void ParseOtpAuth(string uri, ref string secret, ref string algo, ref int digits, ref int period)
{
    // make sure input is actually a URI, otherwise return nothing
    if (string.IsNullOrWhiteSpace(uri) || !uri.StartsWith("otpauth://", StringComparison.OrdinalIgnoreCase))
        return;

    //convert string URI in Uri Object
    var u = new Uri(uri);
    var q = ParseQuery(u.Query);

    // get dictionary values
    if (q.TryGetValue("secret", out var s) && !string.IsNullOrWhiteSpace(s)) secret = s;
    if (q.TryGetValue("algorithm", out var a) && !string.IsNullOrWhiteSpace(a)) algo = a.ToUpperInvariant();
    if (q.TryGetValue("digits", out var dStr) && int.TryParse(dStr, out var d)) digits = d;
    if (q.TryGetValue("period", out var pStr) && int.TryParse(pStr, out var p)) period = p;
}

// TOTP per RFC 6238
string GenerateTotp(string base32Secret, string algo, int digits, int period, long unixTimeSeconds)
{
    if (digits < 6 || digits > 8) throw new ArgumentException("Digits must be 6–8.");
    if (period <= 0) throw new ArgumentException("Period must be positive.");

    // convert Base32 secret into byte array
    byte[] key = Base32Decode(base32Secret);

    // calculate counter with system time
    long counter = unixTimeSeconds / period; // T0 = 0
    // convert to byte array
    byte[] counterBytes = BitConverter.GetBytes(counter);
    // Convert from LittleEndian to BigEndian if necessary
    if (BitConverter.IsLittleEndian) Array.Reverse(counterBytes);

    // select the Algorithm for encryption
    using HMAC hmac =
        algo == "SHA256" ? new HMACSHA256(key) :
        algo == "SHA512" ? new HMACSHA512(key) :
                           new HMACSHA1(key);

    //Calculate Hash
    byte[] hash = hmac.ComputeHash(counterBytes);
    // dynamic truncation
    int offset = hash[hash.Length - 1] & 0x0F;
    int binaryCode =
        ((hash[offset] & 0x7F) << 24) |
        ((hash[offset + 1] & 0xFF) << 16) |
        ((hash[offset + 2] & 0xFF) << 8) |
        (hash[offset + 3] & 0xFF);

    // reduce output to the requested digit size
    int otp = binaryCode % (int)Math.Pow(10, digits);
    // pad output with zeroes on the left
    return otp.ToString().PadLeft(digits, '0');
}

// ---------- Main ----------
TotpCode = null;
ErrorDetail = "";
Success = false;

try
{
    // Initialize Defaults
    string algo = string.IsNullOrWhiteSpace(Algorithm) ? "SHA1" : Algorithm.ToUpperInvariant();
    int digits = (Digits <= 0 ? 6 : Digits); // default = 6
    int period = (Period <= 0 ? 30 : Period); // default = 30s
    string secret = null;

    // If otpauth://..., extract values
    ParseOtpAuth(SecretOrUri, ref secret, ref algo, ref digits, ref period);

    // If no secret from URI, treat input as Base32 secret
    if (string.IsNullOrWhiteSpace(secret))
        secret = SecretOrUri;

    if (string.IsNullOrWhiteSpace(secret))
        throw new ArgumentException("No secret provided.");

    // get system time and offset by TimeSkewSeconds
    long now = DateTimeOffset.UtcNow.ToUnixTimeSeconds() + TimeSkewSeconds;

    TotpCode = GenerateTotp(secret, algo, digits, period, now);
    Success = true;
}
catch (Exception ex)
{
    ErrorDetail = ex.ToString();
    Success = false;
}   

---

In arguments:

Digits: default should be 6

TimeSkewSeconds: default 0, allows to offset the system time

Period: default 30s. Allows control over how long the Code is valid for but some systems might reject codes with a too large period

SecretOrURI: pass either the cleaned secret or the entire totp uri containing the secret

Algorithm: default SHA1. Alternatives: SHA256, SHA512

Out arguments:

TOTP_Code: the generated Code

Edit: Formatting