| PIC: | Worst case RAM: | ROM: | Worst case Stack levels: |
| 18F4550 | 17%(348 bytes) | 63%(20640 bytes) | 5(of 31 avaiable) |
| 18F6722 | 13%(434 bytes) | 16%(20718 bytes) | 5(of 31 avaiable) |
| Ecuación: | Gráfica: |
| (x/4)^2-(y/4)^2 | (http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=28680.0;attach=10656) |
| x^2+y^2 | (http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=28680.0;attach=10658) |
| sqrt(20-x^2-y^2) | (http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=28680.0;attach=10660) |
| sin(x)cos(y) | (http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=28680.0;attach=10662) |
| Sin3xCos3x | (http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=28680.0;attach=17245) |
| sqrt(5-x^2)-sqrt(9-y^2) | (http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=28680.0;attach=17247) |
| x^2+y^2-2 | (http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=28680.0;attach=17249) |
| x+y | (http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=28680.0;attach=17251) |
| x^2+y^2-2 | (http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=28680.0;attach=17261) |
| (sqrt(5-x^2)-sqrt(9-y^2)) | (http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=28680.0;attach=17263) |
| página del proyecto original: | en foro uControl (http://www.ucontrol.com.ar/forosmf/proyectos-con-pic/calculadora-cientifica-grafica-con-pic/) |
| Repositorio del parseador y evaluador: | http://github.com/brunof/PicParser |
| Repositorio del software de la calculadora/graficadora: | http://github.com/brunof/PicCalcGraph |
| Proyecto con pantalla color(Autor: Suky) | Aquí (http://www.todopic.com.ar/foros/index.php?action=dlattach;topic=28680.0;attach=17265/) |
Hola BrunoF!
Me gustaría aportar un pequeño código a la calculadora que creo que es muy útil. Se trata de la función nsolve que encuentra valores de una variable que hacen cumplir una ecuación
nsolve( 3 * x + 5 = 7 , x ) devuelve un 0.666
nsolve( #e^(x) + x = 10, x ) devuelve 2.070579901
Mi calculadora casio de 20 € la incorpora y te ahorra mucho tiempo ya que no tienes que estar despejando ecuaciones para resolverlas.
El método que utiliza para resolver se llama el Metodo de Newton ( http://es.wikipedia.org/wiki/M%C3%A9todo_de_Newton (http://es.wikipedia.org/wiki/M%C3%A9todo_de_Newton) )
y este necesita de derivadas numéricas que se pueden obtener mediante la definición diff(f(x),x) = lim((f(x+h)-f(x-h))/(2*h),h,0) .
También voy a mirar el parser y el evaluador para ver si se podría añadir operaciones con matrices.
Espectacular! Faltaba poquito nomas! :mrgreen: Esta realizado en un PIC24FJ256GB110 ?Si es así, lo complicado va a ser armar el hardware :(
Felicitaciones por el logro :-/
Saludos!
| PIC: | Worst case RAM: | ROM: | Worst case Stack levels: |
| 18F4550 | 17%(348 bytes) | 63%(20640 bytes) | 5(of 31 avaiable) |
| 18F6722 | 21%(434 bytes) | 16%(20718 bytes) | 5(of 31 avaiable) |
Es como un mini matlab pero con pic jeje... llamémoslo piclab :D
Felicidades Bruno.
Oye Bruno, veo el 18f6722 y corre hasta 40MHz, ¿no te convendría el 4550 que corre hasta 48MHz? :mrgreen:
Wouu :o excelente trabajo ers un genio. Solo no encontre el comando que hace rotar las graficas entorno al eje z :lol:
Terrible pedazo de soft.
Aplausos para vos!!! :mrgreen: :mrgreen: :mrgreen: :mrgreen: :mrgreen:
Seria buenisimo poder hacer el hard. La idea original quedo muy por detrás del soft.
Felicitaciones otra vez. :)
el hardware fisico no existe, sólo en el simulador pude utilizarlo.
el hardware fisico no existe, sólo en el simulador pude utilizarlo.
Que simulador? y como puedo probarlo
Un link de un emulador de la calculadora CASIO PB1000/2000C
http://www.pisi.com.pl/piotr433/pb1000ee.htm
te pasaste Bruno :shock:, Gran Proyecto!! Felicidades:mrgreen:
No, esta realizado con un 18F6722 que es un 18F con 128K de memoria ROM, que es lo que el aparato devora. El código también entra en un 18F4550. Hay una gran parte de la ROM que está siendo consumida por "printf()" innecesarios, que actualmente uso para guiar al usuario durante el proceso de ingresado de los datos...:oops: No había visto el *.rar para descargar, pensé que eran las imágenes :mrgreen: Estuve probando y es excelente. Falta menos, implementar teclado y las operaciones, que ya es lo de menos, pero.. entrará en 4550? capaz un 4620 que tiene 64k. ;-)
El circuito electrónico es hiper sencillo. Actualmente sólo consta de la conexión al LCD y 2 pines para la terminar virtual.
Comento lo que ocupa(parser+evaluador+main) en los peores casos:
PIC: Worst case RAM: ROM: Worst case Stack levels: 18F4550 17%(348 bytes) 63%(20640 bytes) 5(of 31 avaiable) 18F6722 21%(434 bytes) 16%(20718 bytes) 5(of 31 avaiable)
Obviamente el 18F6722 tiene muchísima más ROM que el 18F4450. 128KBytes contra 32KBytes(lo cuadriplica en tamaño) y por eso la diferencia.
En la circuito de Proteus aparecen ambos, pero no se asusten que sólo funciona el de abajo en la simulación... :D
No, esta realizado con un 18F6722 que es un 18F con 128K de memoria ROM, que es lo que el aparato devora. El código también entra en un 18F4550. Hay una gran parte de la ROM que está siendo consumida por "printf()" innecesarios, que actualmente uso para guiar al usuario durante el proceso de ingresado de los datos...:oops: No había visto el *.rar para descargar, pensé que eran las imágenes :mrgreen: Estuve probando y es excelente. Falta menos, implementar teclado y las operaciones, que ya es lo de menos, pero.. entrará en 4550? capaz un 4620 que tiene 64k. ;-)
El circuito electrónico es hiper sencillo. Actualmente sólo consta de la conexión al LCD y 2 pines para la terminar virtual.
Comento lo que ocupa(parser+evaluador+main) en los peores casos:
PIC: Worst case RAM: ROM: Worst case Stack levels: 18F4550 17%(348 bytes) 63%(20640 bytes) 5(of 31 avaiable) 18F6722 21%(434 bytes) 16%(20718 bytes) 5(of 31 avaiable)
Obviamente el 18F6722 tiene muchísima más ROM que el 18F4450. 128KBytes contra 32KBytes(lo cuadriplica en tamaño) y por eso la diferencia.
En la circuito de Proteus aparecen ambos, pero no se asusten que sólo funciona el de abajo en la simulación... :D
Saludos!
Dicho y hecho, ya todos quieren agregar librerías al pobre pic convirtiéndolo en mini matlab :D :D
Dicho y hecho, ya todos quieren agregar librerías al pobre pic convirtiéndolo en mini matlab :D :D
Son muy avanzados los cálculos? Yo creo que seguro entra...
Mirá que hay bastante memoria disponible por ahora...:)
/// <summary>
/// Gets the cumulative normal distribution function.
/// </summary>
public double ValueOf(double x)
{
x = (x - mean) / (Math.Sqrt(2) * sigma);
double erf = 0.0;
if(x != 0.0)
{
if(double.IsPositiveInfinity(x))
{
erf = 1.0;
}
else if(double.IsNegativeInfinity(x))
{
erf = -1.0;
}
else
{
if(x >= 0.0)
{
erf = IncompleteGamma(0.5, x*x);
}
else
{
erf = - IncompleteGamma(0.5, x*x);
}
}
}
return (erf + 1.0) / 2.0;
}
// Incomplete Gamma Function P(a,x) = integral from zero to x of (exp(-t)t^(a-1))dt
private static double IncompleteGamma(double a, double x)
{
Debug.Assert(a >= 0.0 && x >= 0.0);
double igf = 0.0;
if(x < a + 1.0)
{
// Series representation
igf = IncompleteGammaSer(a, x);
}
else
{
// Continued fraction representation
igf = IncompleteGammaFract(a, x);
}
return igf;
}
// Incomplete Gamma Function P(a,x) = integral from zero to x of (exp(-t)t^(a-1))dt
// Series representation of the function - valid for x < a + 1
private static double IncompleteGammaSer(double a, double x)
{
Debug.Assert(a >= 0.0 && x >= 0.0);
Debug.Assert(x < a + 1.0, "#E00 Continued Fraction Representation.");
int i = 0;
double igf = 0.0D;
bool check = true;
double acopy = a;
double sum = 1.0 / a;
double incr = sum;
double loggamma = LogGamma(a);
while(check)
{
++i;
++a;
incr *= x/a;
sum += incr;
if(Math.Abs(incr) < Math.Abs(sum) * igfeps)
{
igf = sum * Math.Exp(-x + acopy * Math.Log(x)- loggamma);
check = false;
}
if(i >= igfiter)
{
check = false;
igf = sum * Math.Exp(-x + acopy * Math.Log(x)- loggamma);
}
}
return igf;
}
Estuve pensando en poder graficar superficies en f(x,y,z).Claro, lo malo que con la pantalla no se va a entender nada o casi nada :(
Creo que puede hacerse. El parseador y el evaluador actualmente lo soportan. El que no soporta mostrar este tipo de superficies, es el graficador. Obviamente se puede modificar. Sería para poder acceder a graficar casi todas las figuras así(pero no tan lindas como ahí porque no nos da la pantalla :() http://www1-c703.uibk.ac.at/mathematik/project/bildergalerie/gallery.html
Saludos
Algunos son complicados, otros para nada, de la biblioteca Math (de C# en este caso), uso solo estas funciones
Log, Abs, Exp, Sqrt, Floor, Pow, Sin, Cos y PI.
Mirá los códigos un ratito y vas a ver que son cálculos muy sencillos y que sirven para resuelver problemas estadísticos complejos.
Estuve pensando en poder graficar superficies en f(x,y,z).Claro, lo malo que con la pantalla no se va a entender nada o casi nada :(
Creo que puede hacerse. El parseador y el evaluador actualmente lo soportan. El que no soporta mostrar este tipo de superficies, es el graficador. Obviamente se puede modificar. Sería para poder acceder a graficar casi todas las figuras así(pero no tan lindas como ahí porque no nos da la pantalla :() http://www1-c703.uibk.ac.at/mathematik/project/bildergalerie/gallery.html
Saludos
Hola Brunof!
Yo creo que esto amerita laburar para hacer el hard. Hasta me animaria a decirte que si tanteas un poco el terreno, entre los dos foros se pueden juntar.....30 o 40 personas interesadas en construirla, como para hacer los PCB con un costo razonable. Calculo que un PCB en esas cantidades no seria demasiado caro.....y te queda una super calculadora "made in uno mismo" :)
P.D: Vengo siguiendo el Ordenador basado en un PIC de 40 pines (http://www.ucontrol.com.ar/forosmf/proyectos-con-pic/ordenador-basado-en-un-pic-de-40-pines/msg19193/#msg19193) desde el incio, pero vengo intentando resistirme a participar, porque tengo miedo ya de meterme con otra cosa a la vez...ja ja! Juro que me resulto difícil no meterme más de 10 veces. Igual si necesitás la mano, especialmente si es para programarle algo en assembler o arquitectura(que creo ya está bastante definida), pedimela que ahí voy a estar...;)
Tengo una idea para utilizar un pic algo más accesible, ¿se puede utilizar una eeprom externa para gran parte del programa?
Quizás sea muy descabellado, pero creo que en algunos se pueden trabajar con direcciones externas.
/* test.ffc - test file for ffcalc.syn grammar */
(156.7-8.2+1.5)/3 - 7*7
F=32
C = (5/9)*(F-32)
a=3
a= 10*(10*(10*(a+7)))
m=3
b=9
x=7
y = m*x + b
{/* FOUR FUNCTION CALCULATOR: FFCALC.SYN */}
// -- CONFIGURATION SECTION ----------------------------
[
default token type = double
disregard white space
lexeme { real}
]
// -- FOUR FUNCTION CALCULATOR -------------------------
(void) calculator $
-> [calculation?, '\n']..., eof
(void) calculation
-> expression:x =printf("%g\n",x);
-> name:n, '=', expression:x ={
printf("%c = %g\n",n+'A',value[n]=x);}
-> error
expression
-> term
-> expression:x, '+', term:t = x+t;
-> expression:x, '-', term:t = x-t;
term
-> factor
-> term:t, '*', factor:f = t*f;
-> term:t, '/', factor:f = t/f;
factor
-> name:n = value[n];
-> real
-> '(', expression:x, ')' = x;
-> '-', factor:f = -f;
// -- LEXICAL UNITS ------------------------------------
digit = '0-9'
eof = -1
(void) white space
-> ' ' + '\t' + '\r' + '\f' + '\v'
-> "/*", ~eof?..., "*/"
(int) name
-> 'a-z' + 'A-Z':c = c-'A';
real
-> integer part:i, '.', fraction part:f = i+f;
-> integer part, '.'?
-> '.', fraction part:f = f;
integer part
-> digit:d = d-'0';
-> integer part:x, digit:d = 10*x + d-'0';
fraction part
-> digit:d =(d-'0')/10.;
-> digit:d, fraction part:f =(d-'0' + f)/10.;
{ /* -- EMBEDDED C ---------------------------------- */
double value[64]; /* registers */
int main(void) {
ffcalc();
return 0;
}
} /* -- END OF EMBEDDED C ----------------------------*/
Algo asi es lo que estoy tratando de poner a punto en el proyecto del ordenador basado en un PIC. Pero lo que yo estoy haciendo es almacenar en la memoria externa un programa en ASM del 6502, y el PIC las "interpreta" (o lo hará en algun momento, para ser mas exactos :) ). Quizas un enfoque parecido sirva para lo que queres hacer....no?
P.D. Si te parece bien puedo agregar esas gráficas al 1er post del hilo y si tienes algún lugar donde colgarás el proyecto puedo linkearlo allí también.
Imagino que en un PIC32 la velocidad de dibujado es alta, no?