I can't tell what you are doing wrong, but I suspect that it has something to do with using 2d input, which I distrust. It seems to be ignoring some of your commands as if they were commented out.

Using 1d input, and doing essentially the same thing as you (I added variable initial conditions):

restart:
eq1:= diff(V(t),t) = alpha-beta:
Q:= t-> V(t)*C(t):
eq2:= diff(Q(t),t) = G - K*C(t):
Sol:= dsolve({eq1, eq2, V(0)= V0, C(0)= C0});

Maple will not return an answer for a numeric integral unless it has some confidence that the error is less than what is specified by Digits (by default, it is 10 significant digits). Set the Digits environment variable higher and set the digits option to Int lower.

restart:
Digits:= 30:
#I distributed the sqrt(x) in the inner integral.
Inner:= Int(
     0.579160e-1*Ei(1., 0.500000e-4*x)+(1072.23*(.999950-1.*exp(-0.500000e-4*x)))/x,
     x = 1. .. eta,
     digits= 15
):
Int(exp(18.1818*Inner-9.10000*eta)/eta, eta = 1. .. 100., digits= 5):
evalf(%);

     0.00046645

I see that you have six digits of precision in your constants. I didn't have the patience to ge the answer to six digits, but I think it will finish. I would take it out further than six digits to be confident of the digits.

I found a closed-form formula for phi[j](x,y).

Download Induction.mw

Here's another way: We make a single recursive procedure that reads its own index (whatever's in the square brackets after the procedure name). No loop is needed.

phi:= proc(x,y)
local s, j:= op(1,procname);
     `if`(j=1, exp(x-y), int(exp(x-s)*thisproc[jj-1](s,y), s= y..x))
end proc:

phi[1](x,y);

phi[2](x,y);

phi[3](x,y);

Use plots:-odeplot. For example, assuming your independent variable is t:

plots:-odeplot(dsn, [t, Y[1](t)], t= 0..10);

You have three syntax errors. I'm surprised that you did not get an error message.

The first two errors are that you used both proc(x) ... and x-> ... to define procedures. Every procedure must begin with one of these, but never both.

The third error is that you didn't declare the variable of integration. Given a procedure f, its integral can be expressed these two ways: int(f, a..b) or int(f(x), x= a..b). (There a few other syntaxes also.)

So here's your code, corrected. I pulled the procedure definitions out of the loop and simplified a complicated logical expression by using xor. And I removed needless repetition from the sum of integrals expression.

PMmmf_func:= x->
     `if`(x >= rotorshift xor trunc((x-rotorshift)/tau[p])::odd, 1, -1)*H[c]*l[m]:

B[g]:= x-> 1000*mu[0]*(PMmmf_func(x)+MMF_func(x))/d[eff, stator](x):

for i from 0 to 42 do
     rotorshift:= evalf[6](2*(1/180* i *Pi*(1/2*OO[gap]))/N[m]-1/2*(tau[p]-tau[s]));
     Flux(i+1):=
          add(Int(B[g](x), x= map(`*`, R, tau[s])), R= [0..1, 3..4, 6..7, 9..10])*1e-3*L[ro]    
end do:

This will return the integrals in unevaluated Int form. If you want numeric results, apply evalf to these.

You were correct that the presence of Pi was causing your problem. You can convert it to a number by replacing Pi with evalf(Pi).

Since there are only 11 variables there are only 2^11 = 2048 possible variable assignments. It would be trivial to loop through all possibilities and select the ones that satisfy the equations. I'll work on some code for it later today, if you haven't finished it already. I expect it'll be only 10-20 lines.

How about this?

Y:= expand(add(a_||k*x^k, k= 0..3)*f(y) + add(b_||k*x^k, k= 0..3)*g(y));

alias(P_1= coeff(Y, f(y)), P_2= coeff(Y, g(y))):
collect(Y, [f(y),g(y)]);

Maintaining sets of Vectors or Matrices in Maple is a big problem because Maple considers each copy of a Vector or Matrix  to be a unique entity even if they are identical mathematically. One way to get around this is by converting a Vector to list form or converting a Matrix to listlist form before adding it to the set. Thus,

St1:= St1 union {convert(Mt1.Ms, list)};

Be careful about building sets or lists one element at a time. It is inefficient when done large scale. There are better ways that require a tiny bit more programming.

Eqs:= [sqrt((x-1)^2+(y-5)^2)+(1/2)*abs(x+y) = 3*sqrt(2), sqrt(abs(x+2)) = (2-y)]:
Y:= solve(Eqs[2], y);

X:= solve(eval(Eqs[1], y= Y));

[x,y] =~ eval([x,Y], x= X);

1. To convert an integer n to base b, use convert(n, base, b). To convert a float to another base (other than base 2) will require a custom procedure I think. I might work on it.

2. To do custom logical operations on strings of bits, use the Bits package. There are only 16 possible binary operations on two variable. Every one of them can be built from the operators given in the package. The example you gave is simply Not(2nd op); it doesn't depend on the first operand.

So,

Bits:-Not(235, bits= 8);

                        20

You almost had the answer. You apparently don't know about the value command, which converts inert integrals (those composed with Int) to active form (as if composed with int). You attempted to do this with eval. You also forgot the v= in the limits of integration. Also, those complicated (and not mathematically robust) applyrules are unnecessary; it can be done with convert and simplify.

Int(ln(1+x)/(1+x^2), x= 0..1):
IntegrationTools:-Change(%, x= tan(v/2));

convert(%, sincos);

simplify(%);

value(%);

I don't know how to make pdsolve solve this easy PDE. Here's a solution with Laplace transforms and dsolve.

restart:
pde:= diff(u(x,t),t$2) + 2*diff(u(x,t),t) - diff(u(x,t),x$2) = 18*sin(3*Pi*x/L):
ic:= u(0,t)=0, u(L,t)=0, u(x,0)=0, D[2](u)(x,0)=0:
inttrans[laplace](pde, t, s);

#Convert to an ODE:
eval(%, [ic, laplace(u(x,t), t, s)= U(x)]);

dsolve({%, U(0)=0, U(L)=0}, U(x));

#Final solution:
Sol:= inttrans[invlaplace](rhs(%), s, t);

"Length of out exceeds limit of ...." is not an error. The computation was carried out fully. Maple's (Standard) GUI simply chose not to display the output. This output can still be assigned to a variable for continued analysis and manipulation.

You can set the maximum length of an expression that will be displayed using the Tools menu. Select Options, then the Precision tab. The last item is "Limit expression length to ...." But, I warn you, having a long expression displayed can make the GUI unbearably slow. And, really, what's the point of looking at an expression that's hundreds of screens long?