Chirango » programacion http://www.chirango.com Cultura TV Tecnologí­a Software Mexico Fri, 31 Jul 2009 18:15:46 +0000 http://wordpress.org/?v=2.9.2 en hourly 1 Electroily http://www.chirango.com/electroily/ http://www.chirango.com/electroily/#comments Wed, 05 Nov 2008 03:29:10 +0000 escusado http://www.chirango.com/?p=601
Hola de nuevo herman-a/o-s míos jeje, de nuevo me tienen aquí poniéndolos al tanto de los pormenores en todas las cosas a las que me toca meterle mano … o_O …

[Choro personal que se pueden saltar xD]

Ok pues les platico y de paso los instruyo en una nueva manía que me ataca de manera inesperada. Resulta que dentro del marco de materias que comprende la maestría que actualmente me encuentro cursando se encuentra “Arquitectura de computadoras” lamentablemente el nombre no describe para nada lo que en esta ocasión estamos haciendo.

Como es normal en la Fundación los catedráticos tengan libertad de cátedra (lo que hace MUY especial a la escuela) y pues bueno, eso da la libertad de abarcar contenidos que quizás sean mejores que los sugeridos por el temario tradicional. Esta clase nos la imparte Jack (pa’ los cuates) y pues sugirió que estaría interesante tratar de adentrarnos un poco mas dentro de los fierros y alambres de las máquinas.

Poco a poco la bola de nieve fue creciendo y cambiando hasta quedar en una clase, (que me atreveré a llamar)de tipo “comprensión-didáctica-práctica-constructiva-colectiva” de “electrónica-asistida-por-computadoras”, digamos que con un enfoque MUY práctico abarcar los aspectos importantes y básicos de como hacer cosas interesantes y divertidas con alambres, leds, circuitos, etc.

Esto me cayó muy chido por que siempre había querido como hacer ese tipo de cosillas y la neta es que ps esta área en especial se me hacía como áspera y confusa ya que en mi carrera el enfoque se fué mucho sobre el software y metodologías de desarrollo, dejando la parte de Hardware simplemente en dispositivos sin tocar mucho la parte electrónica.

Y ok antes de continuar quiero externar mi granDECEPCIÓN de la mayoría los vendedores de electrónica del centro de la Ciudad de México. ¿Por que?, bueno, si han tenido la necesidad de adquirir suministros de este tipo en esta ciudad sabrán de lo que hablo. Resulta que la mayoría (NO TODOS), parece que no quieren vender O_O, así groseros, prepotentes, mamones, etc. (hasta parece trámite genérico burocrático) si no sabes EXACTAMENTE que pedir NO te atienden, no te sugieren mercancía similar, alternativas, 0 disposición a ayudarte. Me ha pasado que estoy viendo lo que quiero comprar en su aparador, y por la curiosidad de saber bien que es, pregunto si lo tienen y contestan tajantemente “NO”… ¿NO?, no ¿que?, ¿no hay?, ¿no los vendo?, ¿no mames? … etc. Pero afortunadamente también hay gente muy chida que es todo lo contrario, me refiero a casos como el de TC electrónica, atiende un carnal SUPER buen pedo que ps la neta me ayudo a saber que comprar.

Ok dicho lo anterior prosigo.

[Termina Choro personal que se pueden saltar xD]

En el AMPLIO campo del ahora popularmente llamado DIY la rama electrónica ha crecido un montón, mucha gente está haciendo cosas con micro controladores, motores, luces, etc. por su cuenta sin aventarse un solo curso de electrónica y eso me parece muy chido ya que ps demuestran que esto no es para solo nerds o la escuela, si no que puede ser divertido y práctico.

MAKEzine es un excelente lugar para empezar a ver el terreno, es un blog-revista-videopodcast dedicados al DIY en general pero se enfocan mucho en electrónicos, y se puede encontrar información MUY básica, proyectos con los cuales empezar y empezar a comprender de que se trata todo esto.

Bueno después de navegar durante muchos días viendo videos y leyendo blogs buscando datos, revisando artículos, empecé a notar una constante cuando se hablaba de electrónica para principiantes y esta era:

Arduino


Arduino es pa’ pronto un micro-controlador todo-en-uno que se programa y re-programa cuantas veces quieras vía USB mediante un lenguaje MUY parecido a C.

Con el se pueden hacer cosillas MUY chidas como esta, un proyecto simple de Arduino+Nunchuck:

Total que me animé a comprar uno para empezar a experimentar, y resulta que es BIEN chido jugar con el ya que puedes conectarle 1000 madres y no tiene ni un pedo, además de que la comunidad es muy grande y se encuentra información muy fácil. (mas videos de YT acá)

Bueno pues en clase conversando sobre que podríamos hacer, decidimos que una matriz de led’s controlada en un principio por el puerto paralelo y después por un micro sería un proyecto lo suficientemente complejo como para aprender lo básico y divertirnos un rato.

Así que pues nos pusimos manos a la obra, a la siguiente clase, llegamos todos con nuestros leds, hartas resistencias, cable de red, y ganas de darnos toques y armamos esto:


Un cable paralelo que va conectado a esta placa que mueve los leds que están ahí.

Resulta que, tuvimos que bootear desde un disco de 3 1/2 por que el XP protege los puertos y es como un pedo acceder a ellos.

Dado el caso y con eso en mente, me dispuse a hacer un cable para mayor comodidad a la hora de experimentar con el puerto y he aquí el resultado:

Cable de impresora viejo + Jumpers + soldadura + plastilina epóxica.

Simple y cómodo, pero después de usarlo no resultó tan cómodo xD así que me aventé la v2 del mismo:

Y con este me puse a jugar jeje.

Y bueno descubrí que en Linux es mas sencillo lo de puerto paralelo, pero eso se los cuento en otro post XD saludos hermanos y byebiiiiii.

]]> http://www.chirango.com/electroily/feed/ 2 Simulador URM http://www.chirango.com/simulador-urm/ http://www.chirango.com/simulador-urm/#comments Fri, 17 Oct 2008 03:26:18 +0000 escusado http://www.chirango.com/?p=598
Hace una semana me dejaron de tarea en la escuela, programar un ehm.. “simulador” de una maquina URM (Unlimited Register Machine) un modelo de computadora muy primitivo y básico, aunque es de los primeros modelos desarrollados, ha sido probado que puede resolver algoritmos de alta complejidad.

Esto les podrá servir un poco si necesitan hacer algo parecido, ya que en la internet, hay pocos ejemplos de este modelo, sumo uno mas con este.

El programa está escrito en C puro básicamente:

El programa lee instrucciones desde un txt en este formato:

Z(3)
Z(4)
Z(5)
S(4)
S(5)
J(1,5,8)
J(1,1,4)
Z(5)
S(3)
J(2,3,12)
J(1,1,4)

(Que en este caso es una multiplicación).
carga las instrucciones a un arreglo
y finalmente un switch lee y ejecuta las instrucciones.

Muy sencillo, se puede mejorar muchísimo con objetos, funciones, etc.

acá el code ->

  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5.  
  6. /*www.chirango.com
  7. Programado por Toily el 16 de Octubre 2008 para la Fundación Arturo Rosenblueth
  8. rosenblueth.mx
  9. Objetivo didáctico*/
  10.  
  11. int main() {
  12.         int tamano = 0; //inicializacoón de la variable que determina el tamaño del arreglo
  13.         int lin,col; //navega arreglo para imprimirlo
  14.         int i =0; //navega arreglo para llenarlo
  15.         int j =0; //navega arreglo para llenarlo
  16.         char c;     //char para capturar caracter del archivo
  17.         char valor[1024]; //auxiliar para baajar los valores que se leen en formato char a int en el arreglo de instrucciones
  18.         valor[0] = ‘\0′; //inicializar valor como cadena vacia
  19.  
  20.        
  21.         //Necesario para abrir el archivo
  22.         FILE *file;
  23.         file = fopen("suma.txt", "r");  //nombre de archivo
  24.        
  25.         /* abrir archivo */
  26.         if(file==NULL) {
  27.                 printf("No existe el archivo.\n");
  28.                 return 1;
  29.         }
  30.         else {
  31.                 printf("Leyendo archivo y cargando programa…\n");
  32.                 //Archivo abierto
  33.                 //Leer archivo
  34.                 /*calcular el tamaño del programa basado en el numero de) encontrados*/
  35.                 while(1) {
  36.                         c = fgetc(file);
  37.                         if(c!=EOF) {
  38.                                 if(c==’)'){ //calcular el tamaño del programa para crear el arreglo…
  39.                                         tamano++;
  40.                                 }
  41.                         }
  42.                         else {
  43.                                 printf("El programa tiene %i lineas\nCargando programa al arreglo de instrucciones…\n",tamano);
  44.                 fclose(file);
  45.                                 break; //fin del archivo
  46.                         }
  47.                 }
  48.                 file = fopen("suma.txt", "r");
  49.                 int instrucciones [tamano][4]; //crear arreglo basado en el tamaño del programa o el numero de ) que haya encontrado
  50.  
  51.                 lin=0;
  52.                 col=0;
  53.                 while(1) {
  54.                         c = fgetc(file);
  55.                         if(c!=EOF) {
  56.                                
  57.                         if(c==’\n’) c=’\0′; //hack para corregir el salto de linea en la cadena y que no pase al arreglo de instrucciones
  58.                                
  59.                                 /*Cargado de programa al arreglo
  60.                                  instrucciones [lin] [col]
  61.                                  por ser un arreglo de enteros, las instrucciones corresponden así:
  62.                                  Z = 0
  63.                                  S = 1
  64.                                  J = 2
  65.                                  C = 3
  66.                                  */     
  67.                         switch (c) {
  68.                                 case ‘Z’:
  69.                                         c=’0′;
  70.                                         break;
  71.                                 case ‘S’:
  72.                                         c=’1′;
  73.                                         break;
  74.                                 case ‘J’:
  75.                                         c=’2′;
  76.                                         break;
  77.                                 case ‘C’:
  78.                                         c=’3′;
  79.                                         break;
  80.                                 default:
  81.                                         break;
  82.                         }       
  83.                                
  84.                                 if( c==’(‘ || c==’,’ || c==’)’ ) {
  85.                                 //      Navegacion dentro del arreglo para acomodar los numeros en sus lugares y,0 para instrucciones);
  86.                                         if(c==’(‘ || c==’,'){
  87.                                                 col++;
  88.                                         }
  89.  
  90.                                         if(c==’)'){
  91.                                                 lin++;
  92.                                                 col=0;
  93.                                         }       
  94.                                        
  95.                                         memset(valor, 0, 1024); //resetea la variable valor para poder ser usada de nuevo
  96.                                 }else{ 
  97.                                         valor[strlen(valor)] = c;
  98.                                         valor[strlen(valor)] = ‘\0′;
  99.                                 }
  100.                                 instrucciones[lin][col] = atoi(valor); //atoi convierte de cadena a entero para bajarlo al arreglo int
  101.                         }
  102.                         else {
  103.                                 printf("———–\nPrograma cargado con éxito:\n\n");
  104.                                 break; //fin del archivo
  105.                         }
  106.                 }
  107.                 for (i = 0; i < lin; i++){//muestra el contenido del programa
  108.                         for (j = 0; j < 4; j++){
  109.                                 printf(" %i ",instrucciones[i] [j]);
  110.                         }
  111.                         printf("\n");
  112.                 }
  113.                 printf("\nCerrando archivo…\n");
  114.                 fclose(file);
  115. /*****************************************  TERMINA LECTURA DE ARCHIVO y no mames falta lo demás xD  ************************/        
  116.                  int registros[256]; //tira de registros manipulables;
  117.                 //int registros[6] = { 2, 2, 3, 0, 5, 6 };
  118.  
  119.                
  120.                 int cabezal=0; //variable para recorrer el arreglo de instrucciones
  121.                 //int largo=0;//conocer el tamaño de la tira de registros
  122.                 int k=0;//auxiliar para contar
  123.                
  124.                
  125.                 printf("\nIndique los valores de los registros (-1 para terminar)\n");
  126.                 while(1){//llenado de la tira de registros
  127.                         printf("\n%i: ",k+1);
  128.                         scanf( "%d", &registros[k]);
  129.                         //if(k>0 && registros[k]>registros[k-1]) largo = registros[k] //conocer el valor mas alto para crear la tabla de registros
  130.                         if(registros[k]<0)break;
  131.                         k++;
  132.                 }
  133.                
  134.                  
  135.                 /*
  136.                 Z = 0
  137.                 S = 1
  138.                 J = 2
  139.                 C = 3
  140.                 */
  141.  
  142.                 while(1){
  143.                         switch (instrucciones[cabezal][0]) {
  144.                                 case 0: //Z crea un 0 en el registro X
  145.                                         registros[ (instrucciones[cabezal][1])-1 ]=0; //-1 para la correccion del espacio ya que el array empiezxa en 0
  146.                                         cabezal++;
  147.                                         break;
  148.                                 case 1:
  149.                                         registros[ (instrucciones[cabezal][1])-1 ]++;
  150.                                         cabezal++;
  151.                                         break;
  152.                                 case 2:
  153.                                         if( registros[ (instrucciones[cabezal][1])-1 ] == registros[ (instrucciones[cabezal][2])-1 ]){
  154.                                                 cabezal= instrucciones[cabezal][3]-1;
  155.                                         }else{
  156.                                                 cabezal++;
  157.                                         }
  158.                                         break;
  159.                                 case 3:
  160.                                         registros[ (instrucciones[cabezal][2])-1 ]=registros[ (instrucciones[cabezal][1])-1 ];
  161.                                         cabezal++;
  162.                                         break;
  163.                                 default:
  164.                                         break;
  165.                         }
  166.                        
  167.                         if(cabezal==lin) break;
  168.                 }
  169.                
  170.                 for (j = 0; j < 10; j++){
  171.                         printf("%i: %i \n",j+1,registros[j]);
  172.                 }
  173.                
  174.                 return 0;
  175.         }
  176. }
  177.  
  178.  

Lamentablemente ( y lo acepto xD jaja) estoy OXIDADISMO en C así que el programa esta bastante sucio, estructuradisimo, y mal muy mal hecho, PERO lo interesante es que explica el algoritmo de manera MUY simple.
Saludos banda geeky

]]> http://www.chirango.com/simulador-urm/feed/ 1 Flex 3 XML reader en dataGrid http://www.chirango.com/flex-3-xml-reader-en-datagrid/ http://www.chirango.com/flex-3-xml-reader-en-datagrid/#comments Fri, 04 Apr 2008 23:16:58 +0000 escusado http://www.chirango.com/?p=464 flextoto.jpg
Hace unos dí­as me puse a trabajar un poco con Flex 3 para mis actuales actividades laborales, debo decir que es una aplicación BASTANTE poderosa pero al ser tan nueva falta MUCHA documentación práctica al respecto, pero bueno el chiste es que poco a poco uno le va agarrando la onda a las cosas nuevas, como me paso con CSS, WordPress, PhotoShop etc.

Pero hoy les traigo para ustedes pequeños niño/as que llegan a un blog en busca de sabidurí­a como yo lo hago siempre xD jeje, les pongo un Source Code MUY simple para, desde FLEX leer un archivo XML n___n.

Nuestro XML se debe ver algo así­ (SI SI SIIII es un ejemplo con equipos de Fucho y que, naco pero da de comer ni pedo xD)

  1. <teams type="array">
  2.  
  3. <team>
  4. <fullname>Club Deportivo Tiburones Rojos de Veracruz</fullname>
  5. </team>
  6.  
  7. <team>
  8. <fullname>Universidad Nacional</fullname>
  9. </team>
  10.  
  11. <team>
  12. <fullname>ETC….</fullname>
  13. </team>
  14.  
  15. </teams>

Y pues la opción mas simple es meter estos datos en un dataGrid en Flex este es el source para flex

  1. <?xml version="1.0" encoding="utf-8"?>
  2.  
  3. <!–Esto es para que pida los datos al terminar de cargar la aplicación llama la función HTTPService de abajo pedirDatos–>
  4. <mx:Application xmlns:mx="http://www.adobe.com/2006/mxml" layout="absolute" backgroundGradientAlphas="[1.0, 1.0]" backgroundGradientColors="[#5E5E5E, #000000]" borderStyle="inset" borderColor="#A3A3A3" cornerRadius="10"
  5.  
  6.  
  7. creationComplete="pedirDatos.send()"
  8. >
  9.  
  10. <!–El HTTPService hace la petición de XML ví­a la URL y los asigna a la variable pedirDatos–>
  11. <mx:HTTPService
  12. id="pedirDatos"
  13. url="http://ip.de.tu.xml"
  14. showBusyCursor="true"
  15. />
  16.  
  17. <!–El Datagrid usa como proveedor de datos "pedirDatos" y navega en la última petición (lastResult) el XML teams.team–>
  18. <mx:DataGrid
  19. id="lista"
  20. dataProvider="{pedirDatos.lastResult.teams.team}"
  21. x="53"
  22. y="34"
  23. width="532"
  24. height="276"
  25. >
  26.  
  27. <!–Aquí­ se declaran TODAS las colunas del dataGrid–>
  28. <mx:columns>
  29. <!–Aquí­ se declara solo UNA columna de titulo Nombre y a cada fila le pone el valor del XML assignedto–>
  30. <mx:DataGridColumn headerText="Column 1" dataField="fullname"/>
  31. </mx:columns>
  32.  
  33. </mx:DataGrid>
  34.  
  35. </mx:Application>

Con esto tendrán una pequeña aplicación en Flex que leerá una pequeña forma en XML pueden probar con el feed de este blog o cualquier otro y hacer sus pruebas.

Saludos a todos y espero a alguien en el mundo le sirva eso xD

]]> http://www.chirango.com/flex-3-xml-reader-en-datagrid/feed/ 2