Busco consejo sobre que lenguaje conviene aprender

[Chaly29]

Hola a todos, pues mi pregunta es ¿Que lenguaje me recomiendan aprender?

Si, la cosa viene de esta manera. Ya programo en asembler micros de hasta 16F de una manera decente, pero mi interés es empezar a programar micros de una gama mayor hasta llegar a la linea 32, poseo una base de basic, pero siempre e leído que C es bastante superior, el tema es que el C e tratado de aprenderlo y como que no le agarro la onda, tal ves sea que nunca e iniciado de la manera correcta, no lo se...

Y por esto es mi pregunta. Hoy por hoy y ya sabiendo que el C es mejor compilador, ¿Vale la pena que queme neuronas tratando de aprender el C? ¿O bien desarrollo mi base de basic y esto me valdrá para toda la gama?

Desde ya estaré agradecido de las respuestas que puedan darme gente con experiencia es el temas.

Gracias.

Atte. CARLOS.

[Nocturno]

Sin duda creo que deberías intentarlo con C. No sólo por lo extendido y lo portable, sino porque es la puerta para entender lenguajes como Javascript, C++, Arduino y muchos otros que son derivados del C.

[KILLERJC]

Yo tambien odie salir del ASM, pero C tiene su encanto y los lenguajes de programacion me resultan faciles al menos son todos parecidos en algun punto (acostumbrado a php y javascript).

Por la extension diria que C es lo mejor, al menos donde miro por otros integrados la mayoria usa C en sus compiladores.

STM32, IAR, KEIL , CCS y e2studio (ambos en Eclipse), Energia, microchip con sus XC

¿Vale la pena que queme neuronas tratando de aprender el C? ¿O bien desarrollo mi base de basic y esto me valdrá para toda la gama?

Dedicarse a C seria lo mas sensato asi se aprende una sola ves y no tener que dedicarse a basic y luego a C, no vi compilador basic para un pic32 por ejemplo y quedan reservados para micros de no tan alta gama.

[RedPic]

Si, Chaly, yo también te aconsejo que te sumerjas profundamente en el C, el idioma C es el padre putativo de toda una familia de idiomas que entenderías mucho mejor si has trabajando antes con C, con cualquier versión de él.

Como dicen Manolo Nocturno y KillerJC, si has trabajado en C después el Java, el Javascript, el C# o el C++, incluso los distintos Pascales y Delphises los lees y comprendes muy bien, algunos de ellos incluso sin que haya diferencias importantes. Las estructuras son las mismas o similares y al final terminas mas bien buscando las diferencias entre ellos que las similitudes ya que éstas son tantas que tienes tres cuartos del camino recorrido para entenderlas.

Y sobre todo viniendo del ASM verás cómo de golpe el mundo es más fácil, cómo de momento puedes ponerte a pensar más o únicamente en qué quieres hacer que en cómo quieres hacerlo, C te facilita enormemente la labor de escribir programas, sus flujos de control y sus estructuras de datos te liberan, con respecto al ASM, de un montón de trabajo inútil que gastas en ASM para hacer cualquier nimiedad.

Eso si, lo pagas con programas compilados un poco mayores y un poco más lentos que los que acostumbrabas a hacer, pero si avanzas lo suficiente y terminas por entender qué hace tu compilador en concreto puedes llegar a hacerlos exactamente igual de eficientes que los que hacías en ASM, y afortunadamente "siempre nos quedará París", quiero decir que siempre tendrás la oportunidad de escribir #asm y #endasm y poner en medio tu trozo de código ASM para esa rutina que no acaba de convencerte en cómo la ha "traducido" tu compilador.

Y por último. Yo he hecho muchas rutinas o incluso programas completos para un 16F, lo he migrado para un 18F y éste otra vez migrado a un 24FJ sin más cambios que los settings iniciales del micro y la asignación de pines ya que utilizando el mismo compilador el 95% del código escrito en C era exactamente el mismo sin cambiarle ni una sola coma.

Y por si todo esto fuera poco una cosa importante: todo Micro tiene su C o varios de ellos. Y quien programa en uno los programa todos.  

[migsantiago]

Hola, yo también pienso que C te va a abrir las puertas para programar cualquier cosa. Desde un PIC12 para prender un relé, hasta recompilar el Kernel de Linux para modificar algo a tu gusto. Saludos. 

[PalitroqueZ]

hola carlos

me sumo a la lista de sugerencias sobre el lenguaje C

desde que me mudé al C, las cosas se simplificaron bastantes respecto al ensamblador. Tengo rutinas (o funciones) que uso una y otra vez en diferentes microcontroladores, incluso he realizado adaptaciones de codigos que fueron hechos para otros micros (no microchip) dejando casi intacto el código original.

recientemente estoy manejando arduino y la programación es casi identica a la que uso con compiladores de C para micros.

el basic también compite en el mundo de la programación para micros, pero no se, ya le agarré gusto al C 

[planeta9999]

El C es el lenguaje más universal y portable que existe.
Con respecto a otros lenguajes de alto nivel, solo tiene como particularidades los PUNTEROS y las CLASES (en C++), en el resto es comparable a cualquier otro lenguaje de alto nivel, practicamente te encuentras en todos el mismo tipo de instrucciones.

Los punteros, no son dificiles de entender, el tema de las clases (en C++) ya es bastante más complejo, yo ahí me perdí un poco cuando me metí con Visual Studio, la verdad es que al final te produce una empanada mental tremenda, que si los containers, las herencias, el constructor, el destructor y todas esas gaitas, es un jaleo curioso.

Además si aprendes C, cuando tengas que tocar Java, te resultará muy familiar en muchos aspectos. Sin duda alguna ,el C es un lenguaje imprescindible, tanto para programar micros, como para desarrollos para PC.

[elgarbe]

Creo que no se puede agregar mas nada, vas a tener que ir por el C!!!!!

te pongo un ejemplo de lo que todos dicen de laportabilidad. En este post (http://www.todopic.com.ar/foros/index.php?topic=42254.msg353000#msg353000) estaba trabajando con un micro ARM y necesitaba una funcion para graficar puntos y lineas en un buffer de memoria y cito lo del post para resumir:

"Luefo para imprimir una línea uso exactemente la misma funcion de Ariel, creo que no toque nada, solo la definicion de variables... de hecho aún no estudie como funciona  Shocked:

Código: [Seleccionar]

//-----------------------------------------------------------------------
// Dibuja una linea desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void OSD_linea(unsigned short x1, unsigned short y1, unsigned short x2, unsigned short y2, char color)
{
   //Declaro variables-------------------
   signed short  x, y, incremento_x, incremento_y, distancia_x, distancia_y;
   signed short P;
   short i;

   //Calculo las diferencias entre las coordenadas de origen y destino
   distancia_x = fabs((signed short)(x2 - x1));
   distancia_y = fabs((signed short)(y2 - y1));

   //Inicializo x e y con las coordenadas de origen
   x = x1;
   y = y1;

   //Calculo el sentido de los incrementos (positivos o negativos)
   //en funcion de la posicion del origen y el destino
   if(x1 > x2) incremento_x = -1; else incremento_x = 1;
   if(y1 > y2) incremento_y = -1; else incremento_y = 1;

   //Si la distancia horizontal es mayor a la vertical...
   if(distancia_x >= distancia_y)
   { P = 2 * distancia_y - distancia_x;
      for(i=0; i<=distancia_x; ++i)
      {
      OSD_punto(x, y, color);

         if(P < 0)
         { P += 2 * distancia_y;
            x += incremento_x; }
         else
         { P += 2*distancia_y - 2*distancia_x;
            x += incremento_x;
            y += incremento_y;}
      }
   }

   //Si la distancia vertical es mayor a la horizontal...
   else
   { P = 2 * distancia_x - distancia_y;
      for(i=0; i<=distancia_y; ++i)
      { OSD_punto(x, y, color);
         if(P < 0)
         {  P += 2 * distancia_x;
            y += incremento_y; }
         else
         {  P += 2 * distancia_x - 2 * distancia_y;
            x += incremento_x;
            y += incremento_y; }
      }
   }
}
//-----------------------------------------------------------------------

Ese código, que aún sigo sin estudiar y ver como funciona, esta escrito para un micro de 8 bit de microchip, yo lo copié y pegue en el compilador del ARM y voila! anda de una sin tocar nada de nada incluso entre 2 tipos de uC totalmente distintos...

Saludos y buen año!

[migsantiago]

Hola ElGarbe, quisiera agregar un pequeño tip sobre tu comentario. La función que publicas puede no ser tan portable como parece. Los tipos de variables y su peso cambia entre compiladores. Es importante seguir de cerca los tamaños de las variables.

Eso se soluciona muy rápidamente definiendo tipos comunes como el uint8_t o el uint64_t. Se declaran como typedefs o defines en cada arquitectura o compilador. El código deberá usar sólo esos tipos, nunca hay que usar int, long, short, etc. ya que sus tamaños dependen del compilador. Ya ves que hay int de 8 bits (CCS), int de 16 bits (XC8) o int de 32 bits (XC32). Pero si se usa un uint32_t y su typedef está correctamente ligado al tamaño real del compilador destino, entonces tu código sí que será portable al 100%.

Saludos. 

[elgarbe]

Hola ElGarbe, quisiera agregar un pequeño tip sobre tu comentario. La función que publicas puede no ser tan portable como parece. Los tipos de variables y su peso cambia entre compiladores. Es importante seguir de cerca los tamaños de las variables.

Eso se soluciona muy rápidamente definiendo tipos comunes como el uint8_t o el uint64_t. Se declaran como typedefs o defines en cada arquitectura o compilador. El código deberá usar sólo esos tipos, nunca hay que usar int, long, short, etc. ya que sus tamaños dependen del compilador. Ya ves que hay int de 8 bits (CCS), int de 16 bits (XC8) o int de 32 bits (XC32). Pero si se usa un uint32_t y su typedef está correctamente ligado al tamaño real del compilador destino, entonces tu código sí que será portable al 100%.

Saludos. 

+1 no hace mucho que aprendi lo que comentas y aun me cuesta acostumbrarme.
No estaría mal un post con "buenas practicas de programacion", no?

Saludos!

[KILLERJC]

yo siempre utilize los uint32_t int32_t  como sea por que era lo unico que me quedaba claro a la hora de saber cuantos bits tenian... con eso de int que variaba en cada procesador era una locura saber para un micro de 8/16/32 bits cada uno de los valores. entonces utilize siempre esos.

[Chaly29]

Hola a todos y muchas gracias por su tan pronta respuesta, no me esperaba tantas respuesta en tan corto tiempo y menos de gente tan capaz como son todos ustedes, pues bueno, veo que el voto unánime es el C, y por ese lenguaje deberé ir....

Veo que tienen amplia experiencia en el tema y por supuesto, en algún momento han debido aprenderlo. Que consejos me dais para ver si puedo agarrarle la mano? Teniendo en cuenta que no se nada de nada, mis pocos intentos fueron en CCS y la parte de configuración la e entendido, pero pasando de esto, no logro comprender la/las funciones de cada instrucción, e leído ese pdf. que anda por la web sobre la definición de las instrucciones para CCS, pero parece para mí que estuviera escrito en chino...

Será que estoy muy acostumbrado al .asm que tal instrucción hace tal cosa, modifica tales registros y se tienen tales resultados? Todo bien simple y conciso.

Muchas gracias, un saludo a todos. Y FELICES FIESTAS!!! Que la pasen muy lindo con los suyos y de la mejor manera posible.

Atte. CARLOS.

[elgarbe]

Carlos, para mi, lo mejor es el xc8. El ccs lo deje por que me costaba entender las funciones enlatadas que trae. No digo que sea malo ni mucho menos, solo que a mi me resulto mucho mas fácil el xc8.
Creo que lo primero seria que definas el compilador, luego solo buscar algún tutoriales paso a paso, incluso algún videotutorial en youtube. Ahora estoy en el celu, pero después busco alguno y te pongo el link. Igual seguro que el resto debe tener alguna sugerencia mas

Lo que me gusta del xc8 es que trae como definición de datos los puertos y todos los registros con nombre igual al datasheet, entonces tenés un registro llamado portb de 8 bits y tenés PORTBbits.RB0 para modificar solo ese bit. Tmb renes, por ejemplo, INTCONbits.RBIF que coincide en definición con el bit Rbif del registro intcon, con nombre igual al que aparece en el datasheet.

Saludos y buen año!

[KILLERJC]

Si es para PIC yo tambien recomendaria XC, puede tener algunas desventajas con respecto a CCS ( por ejemplo veo que en CCS hacer una UART por soft te lleva una linea ), pero XC es de microchip, eso quiere decir que los micros vas a ser soportados por el compilador si o si ( o esperando un poco de tiempo ). La principal diferencia con ASM es que ahora en ves de tener una hoja con las instrucciones / registros a tu lado , tendrias una hoja con las funciones de las API que uses ( si es que usas - peripherical library ) por ahi incluso liberandote de saber que registros se deben modificar.

Consejos para agarrarle la mano? es empezar de a poco xD e ir agregando conocimientos
En si lo que voy a pasar es C, el tutorial esta hecho para PC, pero aplica exactamente a un micro. Incluso podes crear un archivo en modelo que trae el MPLAB asi el armado resulta un poco mas facil.

Primero conocer los operadores ( la diferencia entre un = y un == , entre otras )
http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B

Aprender sobre las funciones/prototipos ( empezando por algo simple que no retornen nigun valor, luego pasandole valores y que retornen un valor, luego despues que aprendas punteros podes pasarlo por ahi)
Variables locales/globales, diferencias.
http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Uso_de_funciones

Loops ( for, while, do-while(diferencia con while), switch-case, if-else )
http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Instrucciones_de_control

Eso es lo mas simple, luego agregas Vectores (n dimensiones,comenzas con 1, tambien aprender sobre los indices que el primer elemento es el 0):
http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Vectores
Con eso ya te podes meter a que son los "strings" o cadena de caracteres
http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Cadenas_de_caracteres

Luego podes empezar a ver el usar archivos cabeceras y otros archivos para poder hacer tus propios funciones y luego llamarlas desde tu programa principal.

Y recien ahi me meteria con punteros o estructuras. Punteros te va a resultar facil si entendes el uso de los registros FSR e INDF del micro (Acceso indirecto)
Creo que es el hilo por el cual iria para aprender C, no nombre variables por que en los post anteriores ya dijeron que mejor acostumbrarse usando uint8_t ( Unsigned y de 8 bit ) u otros (uint16_t e int16_t y tabmien para 32 bits). Es mas intuitivo que saber cuantos bits tiene un int.

Eso es C, realmente no recuerdo si me olvido algo, pero como todo cuando empezas todos sabemos que comenzamos prendiendo un led con un delay y luego vamos agregando.
Y entre eso y mirando otros codigos le vas a agarrar la mano rapidamente, una dirferencia con basic es que no comenzas con un IF y ENDIF sino que todo esta delimitado por llaves  if(condicion){ }

[RALF2]

Para iniciarte a mi me gusta el ccs ayuda muchiiisimo!