From 5ee0826789dfc0beb432b29104a16b0480884b99 Mon Sep 17 00:00:00 2001 From: sejo Date: Thu, 20 May 2021 17:57:40 -0500 Subject: fecha holoceno --- gem/avr-asm.gmi | 323 ++++++++++++++++++++++ gem/coloring_computers.gmi | 51 ++++ gem/compudanzas.gmi | 116 ++++++++ gem/danzasistemas-tag.gmi | 80 ++++++ gem/darena.gmi | 652 +++++++++++++++++++++++++++++++++++++++++++++ gem/ffmpeg.gmi | 114 ++++++++ gem/imagemagick.gmi | 118 ++++++++ gem/index.gmi | 14 + gem/indice.gmi | 14 + gem/logiteca.gmi | 290 ++++++++++++++++++++ gem/recetas.gmi | 194 ++++++++++++++ gem/s-camino.gmi | 33 +++ gem2gem.awk | 2 +- gemtext2html.awk | 1 + 14 files changed, 2001 insertions(+), 1 deletion(-) create mode 100644 gem/avr-asm.gmi create mode 100644 gem/coloring_computers.gmi create mode 100644 gem/compudanzas.gmi create mode 100644 gem/danzasistemas-tag.gmi create mode 100644 gem/darena.gmi create mode 100644 gem/ffmpeg.gmi create mode 100644 gem/imagemagick.gmi create mode 100644 gem/index.gmi create mode 100644 gem/indice.gmi create mode 100644 gem/logiteca.gmi create mode 100644 gem/recetas.gmi create mode 100644 gem/s-camino.gmi diff --git a/gem/avr-asm.gmi b/gem/avr-asm.gmi new file mode 100644 index 0000000..61f8d7c --- /dev/null +++ b/gem/avr-asm.gmi @@ -0,0 +1,323 @@ +# avr-asm + +explorando programación de microcontroladores avr a través de asm, en attiny85. {s-camino} + +=> ./s-camino.gmi {s-camino} + +# attiny85 + +## diagrama de pines + +```diagrama de pines + ┌──────┐ +PB5 │1 8│ VCC +PB3 │2 7│ PB2 +PB4 │3 6│ PB1 +GND │4 5│ PB0 + └──────┘ +``` + +además, cada pin es: + +* 1: PB5 / PCINT5 / ~RESET / ADC0 / dW +* 2: PB3 / PCINT3 / XTAL1 / CLKI / ~OC1B / ADC3 +* 3: PB4 / PCINT4 / XTAL2 / CLKO / OC1B / ADC2 +* 5: PB0 / MOSI / DI / SDA / AIN0 / OC0A / ~OC1A / AREF / PCINT0 +* 6: PB1 / MISO / DO / AIN1 / OC0B / OC1A / PCINT1 +* 7: PB2 / SCK / USCK / SCL / ADC1 / T0 / INT0 / PCINT2 + +para flashear nos interesan los pines desde el punto de vista de SPI: + +```pines spi + ┌──────┐ +~RESET │1 8│ VCC + │2 7│ SCK + │3 6│ MISO +GND │4 5│ MOSI + └──────┘ +``` + +## programador + +=> https://www.fischl.de/usbasp/ USBasp - USB programmer for Atmel AVR controllers (web) + +## makefile + +para ensamblar y flashear + +```makefile +# Makefile +# nombre del programa sin .S : +PROG = test +# config hardware +BOARD = attiny85 +PROGRAMMER = usbasp + +# ensambla programa a .hex +hex: + avr-gcc -Os -DF_CPU=8000000 -mmcu=$(BOARD) -c $(PROG).S + avr-ld -o $(PROG).elf $(PROG).o + avr-objcopy $(PROG).elf -O ihex $(PROG).hex + rm $(PROG).o $(PROG).elf + +# flashea +flash: + avrdude -c $(PROGRAMMER) -p $(BOARD) -U flash:w:$(PROG).hex:i + +# lee la memoria flash a read.hex +read: + avrdude -c $(PROGRAMMER) -p $(BOARD) -U flash:r:read.hex:i + +# prueba conexión con programador y micro +test: + avrdude -c $(PROGRAMMER) -p $(BOARD) +``` + + + +# programas + +software experimental, compartido como referencia y sin garantía de ningún tipo :) + + +## test.S + +enciende un el pin PB0 — conecta un led + +``` +; test.S +; enciende un pin +#include +.org 0x0000 + + ldi r17, (1< +; *********************** +; vectores de interrupts: +; *********************** +; Reset +.org 0x0000 + rjmp main + +; *********************** +; Main +; *********************** +.org 0x0010 +main: + ; pin PB0 (OC0A) como pin de salida + ldi r16, (1< +; *********************** +; vectores de interrupts: +; *********************** +; Reset +.org 0x0000 + rjmp main + +; *********************** +; Main +; *********************** +.org 0x0010 +main: + ; pin PB0 (OC0A) como pin de salida + ldi r16, (1< +; *********************** +; vectores de interrupts: +; *********************** +; Reset +.org 0x0000 + rjmp main + +; dirección 0x0003 * 2 +.org 0x0006 + rjmp timer1compareA_isr + +; dirección 0x0004 * 2 +.org 0x0008 + rjmp timer1overflow_isr + +; *********************** +; Main +; *********************** +.org 0x001E +main: + ;---------------------------------- + ; configuración general + ;---------------------------------- + + ; habilita interrupciones + sei + + ; pin PB0 (OC0A) como pin de salida + ldi r16, (1< ./img/foto_20201130_hex7segdecoder_01.png the coloring computer/decoder, waiting to be activated +=> ./img/foto_20201130_hex7segdecoder_02.png a human coloring the wires according to the logic rules +=> ./img/foto_20201130_hex7segdecoder_03.png the coloring computer/decoder, with an input of 0011, and an output that can be read as 3 + +a coloring decoder built with NOT (triangle), AND (semicircle), and OR (the other shape (?)) gates, based on a manual design. + +=> ./img/dibujo_20201207_hex7segdecoder_small.png the complete decoder + +=> https://opguides.info/engineering/digitallogic/ colored and animated version by Vega +=> https://ipfs.io/ipfs/QmZv53hr7QEzxrPaRNpiyU9VUNHw9UgyaTUqYD9x9iFpNA/dibujo_20201207_hex7segdecoder.png download the decoder in full size 1487x3057 (png, ~446KB) + +# computadora no(r)pal (12019) + +=> ./img/dibujo_20190715-norpalera-fulladder_blanco_small.png logic circuit in the shape of nopal + +a full-adder built with nor gates (see {logiteca}) in the shape of no(r)pales + +=> ./logiteca.gmi {logiteca} + +=> https://ipfs.io/ipfs/QmPz2D3bZRYFi1HnfiNJB8o9TZZvH8atuYpFixMKccYCYP/dibujo_20190715-norpalera-fulladder_blanco.png download computadora no(r)pal in full size 1200x1600 (png, ~429KB) + +# coloring computers (12018) + +the original ones + +=> ./img/foto_coloring-computers_cover-lee.png photo of the cover of the zine, colored +=> ./img/foto_coloring-computers_7seg-lee.png photo of a pair of colored pages of the zine, with a 7 segment display showing the digits 2 and 3 +=> ./img/foto_coloring-computers_pcd2019.png photo of a pair of colored pages of the zine, showing a digital circuit answering if two colors are the same + +the booklet contains three series of computers: computers that compare, computers that count, and computers that play. they are all NOR-based logic circuits designed by using truth tables, karnaugh maps, and maxterm expansions. + +=> https://ipfs.io/ipfs/QmYz7DPRWypGQcbAHr7Mi8EKB6ntSPsEnUsCXbAhBiHQZP/ original site and resources +=> https://ipfs.io/ipfs/QmYz7DPRWypGQcbAHr7Mi8EKB6ntSPsEnUsCXbAhBiHQZP/coloringcomputers_pages.pdf download the page-by-page zine (pdf, ~1.5MB) +=> https://ipfs.io/ipfs/QmYz7DPRWypGQcbAHr7Mi8EKB6ntSPsEnUsCXbAhBiHQZP/coloringcomputers.pdf download the ready-to-print-and-cut zine (pdf, ~1.4MB) + +CC-BY-SA 4.0 + +for the print and cut zine: print double-sided, cut in half, fold the pages and assemble + +presented as a workshop in the +=> https://processing.nyc/2019/#workshops processing community day nyc 2019 + +página actualizada en: sejmana-1660, día 1 (12021-05-20) diff --git a/gem/compudanzas.gmi b/gem/compudanzas.gmi new file mode 100644 index 0000000..59331c6 --- /dev/null +++ b/gem/compudanzas.gmi @@ -0,0 +1,116 @@ +# compudanzas + +materializando ciencias computacionales en cuerpxs humanxs y coreografía + +# el taller + +## abstract + +el taller de compudanzas materializa ciencias computacionales en cuerpxs humanxs y coreografía. + +¿qué es una computadora? ¿cómo es tan poderosa y hace lo que hace, si “solo” consiste en minerales super ordenados a través de procesos complejos? + +¿qué pasa si la alentamos? ¿y si incrementamos su tamaño? ¿y si le quitamos todo rastro de eficiencia para que la podamos bailar? + +en este taller nos insertaremos entre el mundo abstracto de las ciencias computacionales y el mundo de su materialización industrial, para darle cuerpo humano, social, coreográfico, a algunos de sus conceptos fundamentales: máquinas de turing, compuertas lógicas, autómatas celulares, arquitectura von neumann, y más. + +lo que queremos es construir y programar computadoras relativamente lentas, grandes e ineficientes, a partir de personas en movimiento siguiendo/jugando instrucciones. así, nos podremos reapropiar de las maneras computacionales de entender el mundo, para usarlas a nuestro gusto con el fin de proponer otras posibles computadoras, danzas, y/o vidas. + +## justificación + + la miniaturización y aceleración de los circuitos de semiconductores, además de tener un gran costo ambiental, social y económico, dificulta el conocer y entender qué pasa en su interior, y cómo es que logran hacer emerger todas las capacidades que entendemos inherentes al cómputo. + +por otro lado, la configuración social actual genera e incrementa una brecha de conocimientos y posibilidades entre unos cuantos que tienen el poder de desarrollar las tecnologías digitales, y el resto de la población al que se le asigna únicamente un rol de consumidor y de fuente de datos a extraer. + +por si fuera poco, lo abstracto y ofuscado de las ciencias computacionales y de la forma en que suelen ser compartidas, se oponen a sanar esta brecha de acceso. + +es por esto que el taller busca experimentar con otros acercamientos y estrategias para abordar estos temas, tratando no de hablarlos y racionalizarlos sino de bailarlos, sentirlos y recontextualizarlos. + +partimos de que todo el cuerpo de conocimientos sobre la computación fue desarrollado por personas con pasiones así como cualquier otra, por lo que las nociones de lo "frío" y "cuadrado" de lo "maquínico" y digital pueden ser entendidas desde una perspectiva que las acerca a lo orgánico, lo fluido, y a nosotras como personas vivas. + +dadas las crisis climáticas, ecológicas y sociales actuales, consideramos que el taller es un importante ejercicio de imaginación donde nos preguntamos: ¿qué pasaría si las computadoras fueran bailes y no cajas de metal y semiconductor? + + +## objetivos + +* introducir y difundir conceptos fundamentales de la computación a través de estrategias pedagógicas inspiradas en la danza. +* visibilizar procesos e ideas que rigen las realidades digitales actuales pero que suelen ser accesibles solo para un grupo reducido de personas. +* instigar la reapropriación de dichos conceptos con el objetivo de imaginar y realizar mundos donde sirven a intereses alternos, como los de la danza, la vida y la liberación. +* promover el pensar y sentir con el cuerpo, con énfasis en lo computacional por ser algo considerado abstracto y cerebral a pesar de sus múltiples impactos materiales. + + +## temario + +los siguientes temas son puntos de partida para los bailes y actividades corporales propuestos, así como para los proyectos creativos de les participantes. + +se abordarán los principios teóricos, pero sin ahondar en discusiones abstractas que se alejen mucho del cuerpo + +* ciencias computacionales, coreografía, ¿cyborgs? +* el universo discreto: estados finitos y tiempos discontinuos +* operaciones lógicas / digitales +* memoria básica con registro de corrimiento +* mundo binario: operaciones y compuertas lógicas +* autómatas celulares y complejidad emergente +* computación formal +* sistemas de "tag" +* máquinas de turing +* máquina universal de turing +* organización computacional +* arquitectura de von neumann +* código máquina y programación + +## agenda + +el taller consiste en 6 sesiones de 2 horas de duración cada una + +* danzas compuertas +* autómatas celulares +* computación formal +* máquina universal de turing +* organización computacional +* integración + +# las danzas + +sección en construcción + +## ciclo de memoria + +en la que nos volvemos un registro de corrimiento (shift register) síncrono para almacenar de manera activa una secuencia de símbolos. + +## danzas compuertas + +en la que nos convertimos en red de compuertas lógicas para resolver en conjunto operaciones aritméticas o lógicas. + +comportamiento asíncrono, que podemos sincronizar para procesos más complejos. + +=> ./logiteca.gmi {logiteca} + +## reglas de wolfram + +danzas en las que nuestro nuevo estado individual depende de nuestro estado propio y del de dos personas más. + +## danzasistemas-tag + +“batallas” en las que respondemos procesando elementos de la secuencia anterior. + +=> ./danzasistemas-tag.gmi {danzasistemas-tag} + +## d. turing + +en donde bailamos con y a partir de una fila / tira / cinta de objetos / símbolos y una tabla específica de estados. + +## máquina universal bailable + +en donde bailamos con y a partir de una fila / tira / cinta de objetos y una tabla específica de estados, en un acomodo tal que nos permite simularnos bailando con y a partir de una fila / tira / cinta de objetos y cualquier tabla específica de estados + +## pequeña persona computadora + +en donde nuestras acciones toman la forma de las operaciones de una computadora organizada casi como las que conocemos. + +enlazan aquí: +=> ./danzasistemas-tag.gmi {danzasistemas-tag} +=> ./logiteca.gmi {logiteca} + + +página actualizada en: sejmana-1660, día 1 (12021-05-20) diff --git a/gem/danzasistemas-tag.gmi b/gem/danzasistemas-tag.gmi new file mode 100644 index 0000000..4f57ca5 --- /dev/null +++ b/gem/danzasistemas-tag.gmi @@ -0,0 +1,80 @@ +# danzasistemas-tag + +una compudanza basada en máquina abstracta (tag systems, o bien, máquina de post) + +=> ./compudanzas.gmi {compudanzas} + +# descripción + +las danzasistemas-tag consisten en "batallas" de baile en las que alternamos recibiendo y respondiendo secuencias de movimiento. + +las secuencias que respondemos son producto de procesar elementos de la secuencia que recibimos. + +# indicaciones + +necesitamos los siguientes elementos: + +* A: alfabeto finito de símbolos/movimientos identificables y replicables +* P: las reglas de producción: qué símbolos/movimientos hay que agregar al final de la nueva secuencia, de acuerdo al primer símbolo/movimiento de la secuencia recibida. +* m: número de eliminación: cuántos símbolos/movimientos hay que eliminar del inicio de la secuencia recibida. + +al recibir una secuencia de movimiento, hemos de poner atención y realizar lo siguiente para construir nuestra respuesta: + +* notar el primer símbolo/movimiento, que nos indica qué regla de producción seguir al final de la secuencia. +* descartar la cantidad de símbolos/movimientos del inicio de la secuencia de acuerdo al número de eliminación. (esto incluye al primer símbolo/movimiento). +* memorizar y replicar la secuencia recibida a partir de ese punto, en orden y hasta el final. +* agregar el o los símbolos/movimientos al final de la secuencia, de acuerdo a la regla de producción. + +según la danzasistema-tag, la dinámica de respuestas continúa hasta llegar al símbolo/movimiento que indique detenerse, o hasta que la secuencia de movimiento quede vacía. + +# ejemplo + +cómputo de secuencias de collatz, tomado de wikipedia + +=> https://en.wikipedia.org/wiki/Tag_system#Example:_Computation_of_Collatz_sequences Tag system - Example: Computation of Collatz sequences (web) + +los elementos de nuestra danzasistema-tag serían los siguientes: + +## A: alfabeto finito de símbolos/movimientos + +tres símbolos/movimientos: a, b, c + +## P: reglas de producción + +si primer símbolo/movimiento es 'a', agrega 'bc' al final. + +si primer símbolo/movimiento es 'b', agrega 'a' al final. + +si primer símbolo/movimiento es 'c', agrega 'aaa' al final. + +nota cómo cada regla de producción agrega una cantidad distinta de símbolos/movimientos al final. + +## m: número de eliminación + +en este caso, siempre descartaremos 2 símbolos/movimientos del inicio de la secuencia. + +## desarrollo + +partiendo de una secuencia inicial 'aaa'... + +``` +inicio: aaa +respuesta: abc +respuesta: cbc +respuesta: caaa +respuesta: aaaaa +respuesta: aaabc +respuesta: abcbc +respuesta: cbcbc +etc... +``` + +siempre se descartan los 2 símbolos/movimientos del inicio, pero la cantidad de símbolos/movimientos que se agregan al final cambian de acuerdo a la regla de producción. + +esta dinámica de respuestas a partir de esa secuencia inicial, eventualmente termina descartando a la secuencia completa. + +enlaza aquí {compudanzas} + +=> ./compudanzas.gmi {compudanzas} + +página actualizada en: sejmana-1660, día 1 (12021-05-20) diff --git a/gem/darena.gmi b/gem/darena.gmi new file mode 100644 index 0000000..3bf8162 --- /dev/null +++ b/gem/darena.gmi @@ -0,0 +1,652 @@ +# darena + +an open-ended game of rocks and sand + +the sandy space contains a bunch of rocks in either one of two possible colors, and yourself. + +push and arrange the rocks to prototype and build your own computer, cellular automata, 1-bit art, etc. + +=> ./img/screenshot_darena.png screenshot of the game. it shows a square clear space inside a textured world. inside the square there are several round rocks of two possible colors. there is a small platform, and a person. + +what will you do with the sand? + +# about + +darena was developed as an exercise to learn about the + +=> https://wiki.xxiivv.com/site/uxn.html uxn virtual machine and assembly language + +as part of the {s-camino} practice. + +=> ./s-camino.gmi {s-camino} + +# features + +* a character that moves in all four cardinal directions +* rocks that can be pushed around, unless they are colliding with other rocks or the borders of the "arena" +* a toggling station where rocks can be switched to the other color +* realistic animation: the character slows down when pushing rocks, recovering their original speed when walking + +# controls + +use the arrow keys for cartesian movement within the space + +# possible "improvements" + +* add an "official" pulling option (you can pull rocks right now, but in a hacky way) +* save rocks state (position and color) to file +* optimize the use of memory for rock colors, using one bit per rock instead of one byte + +# the code + +this iteration has 31 rocks and a single toggling station where one can switch their color/state. + +last updated: sjm-1659d3 (changed JNZ to JCN) + +you can also find the code in the +=> https://git.sr.ht/~rabbits/uxn/log/master/item/projects/demos/darena.usm uxn repo + + + +```darena.usm +( darena.usm ) +( an open-ended game of rocks and sand ) +( cc0 sejo 12021 ) + +%DEBUG { .Console/byte DEO #0a .Console/char DEO } + +=> ./ .Console/byte DEO #0a .Console/char DEO .gmi { .Console/byte DEO #0a .Console/char DEO } +%DEBUG2 { .Console/short DEO2 #0a .Console/char DEO } + +=> ./ .Console/short DEO2 #0a .Console/char DEO .gmi { .Console/short DEO2 #0a .Console/char DEO } + +( parameters ) +%nrocks { #1f } + +=> ./ #1f .gmi { #1f } +%nrocks-1 { #1e } + +=> ./ #1e .gmi { #1e } +%nrocks_mask { #1f } + +=> ./ #1f .gmi { #1f } +%minposx { #0f } + +=> ./ #0f .gmi { #0f } +%minposy { #0f } + +=> ./ #0f .gmi { #0f } +%maxposx { #f1 } + +=> ./ #f1 .gmi { #f1 } +%maxposy { #f1 } + +=> ./ #f1 .gmi { #f1 } +%anispeedmask_normal { #03 } + +=> ./ #03 .gmi { #03 } +%anispeedmask_slow { #07 } + +=> ./ #07 .gmi { #07 } + +%c_color_normal { #33 } + +=> ./ #33 .gmi { #33 } +%c_color_flipx { #73 } + +=> ./ #73 .gmi { #73 } +%index_norock { #ff } + +=> ./ #ff .gmi { #ff } + +( output macros ) +%out_screen_x { LDA #00 SWP .Screen/x DEO2 } ( ;addr ) + +=> ./ LDA #00 SWP .Screen/x DEO2 .gmi { LDA #00 SWP .Screen/x DEO2 } +%out_screen_y { LDA #00 SWP .Screen/y DEO2 } ( ;addr ) + +=> ./ LDA #00 SWP .Screen/y DEO2 .gmi { LDA #00 SWP .Screen/y DEO2 } + +( helper macros ) +%get_bit_n { SFT #01 AND } + +=> ./ SFT #01 AND .gmi { SFT #01 AND } +%get_nibble_h { #04 SFT #0f AND } + +=> ./ #04 SFT #0f AND .gmi { #04 SFT #0f AND } +%get_nibble_l { #0f AND } + +=> ./ #0f AND .gmi { #0f AND } + +%is_bit_n_set { get_bit_n #01 EQU } + +=> ./ get_bit_n #01 EQU .gmi { get_bit_n #01 EQU } + +%set_animate { #01 ;c_state LDA ORA ;c_state STA } + +=> ./ #01 ;c_state LDA ORA ;c_state STA .gmi { #01 ;c_state LDA ORA ;c_state STA } +%rst_animate { #00 ;c_state STA } + +=> ./ #00 ;c_state STA .gmi { #00 ;c_state STA } + +( devices ) + +|00 @System [ &vector $2 &wst $1 &rst $1 &pad $4 &r $2 &g $2 &b $2 ] +|10 @Console [ &pad $8 &char $1 &byte $1 &short $2 &string $2 ] +|20 @Screen [ &vector $2 &width $2 &height $2 &pad $2 &x $2 &y $2 &addr $2 &color $1 ] +|80 @Controller [ &vector $2 &button $1 &key $1 ] + +( variables ) + +|0000 + +@c_pos [ &x $1 &y $1 ] ( character position ) +@c_speed [ &x $1 &y $1 ] ( character speed ) +@c_color [ $1 ] ( character color ) +@c_sprite [ $2 ] ( character sprite addr ) +@c_state [ $1 ] ( high_nibble: animation pointer, bit0: is_animated ) + +@f_count [ $1 ] ( frame counter ) +@ani_speedmask [ $1 ] ( animation speed mask ) + +@r_speed_x [ $f ] +@r_speed_y [ $f ] + +@tog [ &x $1 &y $1 &state $1 ] ( toggle station state ) + +( program ) + +|0100 @reset ( -> ) + #f396 .System/r DEO2 + #e263 .System/g DEO2 + #9030 .System/b DEO2 + + ;on_frame .Screen/vector DEO2 + + ( init character ) + #50 ;c_pos/x STA + #10 ;c_pos/y STA + #00 ;c_speed/x STA + #00 ;c_speed/y STA + c_color_normal ;c_color STA + ;s_monitx_stepfront0 ;c_sprite STA2 + rst_animate + + anispeedmask_normal ;ani_speedmask STA + + ( init toggler ) + #27 ;tog/x STA + #27 ;tog/y STA + #00 ;tog/state STA + + + ( init background ) + ;init_bg JSR2 +BRK + + +@on_frame ( -> ) + ;f_count LDA #01 ADD DUP ;f_count STA ( increase frame counter ) + ;ani_speedmask LDA ( mask with animation speed mask ) + AND #00 EQU ,update_frame JCN ( jump to update if it's time ) +BRK + +@update_frame + ( check keyboard ) + ;check_keys JSR2 + + ( animate character sprite ) + ;animate_c JSR2 + + ( clear sprites ) + ;clear JSR2 + + ( update character vars ) + ;update_c/run JSR2 + + ( update rocks + stand ) + ;update_r/run JSR2 + + ( draw ) + ;draw JSR2 + +BRK + +@clear + ( clear rocks ) + ;s_clear .Screen/addr DEO2 + + nrocks #00 + &rocks_loop + DUP ( get rocks_x[i] ) + ;rocks_x ROT #00 SWP ADD2 out_screen_x + + DUP ( get rocks_y[i] ) + ;rocks_y ROT #00 SWP ADD2 out_screen_y + + #30 .Screen/color DEO + + #01 ADD + DUP2 + NEQ ,&rocks_loop JCN + POP2 + + ( clear character ) + ;clear_c JSR2 +JMP2r + +@draw + ( draw toggler ) + + ;tog/x out_screen_x + ;tog/x out_screen_y + ;s_stand .Screen/addr DEO2 + #23 .Screen/color DEO + + ( draw rocks ) + ;s_bola .Screen/addr DEO2 + + nrocks #00 + + &rocks_loop + DUP ( get rocks_x[i] ) + ;rocks_x ROT #00 SWP ADD2 out_screen_x + + DUP ( get rocks_y[i] ) + ;rocks_y ROT #00 SWP ADD2 out_screen_y + + ( DUP ( get color bitwise ) ) + ( ;r_color LDA SWP get_bit_n #31 ADD .Screen/color DEO ) + + DUP + ;r_color ROT #00 SWP ADD2 LDA #31 ADD .Screen/color DEO + + #01 ADD + + DUP2 + NEQ ,&rocks_loop JCN + POP2 + + ( draw character ) + ;draw_c JSR2 +JMP2r + +@check_keys + #00 ;c_speed/x STA + #00 ;c_speed/y STA + + .Controller/button DEI #07 is_bit_n_set ,&der JCN + .Controller/button DEI #06 is_bit_n_set ,&izq JCN + .Controller/button DEI #05 is_bit_n_set ,&aba JCN + .Controller/button DEI #04 is_bit_n_set ,&arr JCN + + rst_animate + + JMP2r + + &der + #01 ;c_speed/x STA + set_animate + c_color_normal ;c_color STA + ;s_monitx_stepside0 ;c_sprite STA2 + JMP2r + + &izq + #ff ;c_speed/x STA + set_animate + c_color_flipx ;c_color STA + ;s_monitx_stepside0 ;c_sprite STA2 + JMP2r + + &aba + #01 ;c_speed/y STA + set_animate + c_color_normal ;c_color STA + ;s_monitx_stepfront0 ;c_sprite STA2 + JMP2r + + &arr + #ff ;c_speed/y STA + set_animate + c_color_normal ;c_color STA + ;s_monitx_stepback0 ;c_sprite STA2 + JMP2r + + &end +JMP2r + +( sub-routines ) + +( in: sourcex, source y, index, rangex, rangey ) +( puts in the stack the index of rock collisioned with ) +@collision_rocks + &range_y $1 + &range_x $1 + &src_i $1 + &src_x $1 + &src_y $1 + + &rock_x $1 + &rock_y $1 + + &run + ,&range_y STR + ,&range_x STR + ,&src_i STR + ,&src_y STR + ,&src_x STR + + ( check collision with rocks ) + ( nrocks #00 ) + ,&src_i LDR nrocks_mask AND DUP #01 ADD nrocks_mask AND + + &rocks_loop + DUP ( get rocks_x[i] ) + ;rocks_x ROT #00 SWP ADD2 LDA ,&rock_x STR + + DUP ( get rocks_y[i] ) + ;rocks_y ROT #00 SWP ADD2 LDA ,&rock_y STR + + ,&src_x LDR ,&rock_x LDR ,&range_x LDR SUB GTH ( if sx > rx - 8 ) + ,&src_x LDR ,&rock_x LDR ,&range_x LDR ADD LTH ( if sx < rx + 8 ) + ,&src_y LDR ,&rock_y LDR ,&range_y LDR SUB GTH ( if sy > ry - 8 ) + ,&src_y LDR ,&rock_y LDR ,&range_y LDR ADD LTH ( if sy < ry + 8 ) + ADD ADD ADD #04 EQU ,&found JCN + + #01 ADD nrocks_mask AND + DUP2 + NEQ ,&rocks_loop JCN + POP2 + #ff + JMP2r + &found + SWP POP ( remove loop limit ) + DUP ;&src_i LDA NEQ ,&end JCN ( check if result is the same as index ) + POP #ff + JMP2r + + &end + +JMP2r + +@update_c ( update character position ) + &new_x $1 + &new_y $1 + + &rock_i $1 + &rock_x $1 + &rock_y $1 + + + &run + ;c_speed/x LDA ;c_pos/x LDA ADD + ,&new_x STR + ;c_speed/y LDA ;c_pos/y LDA ADD + ,&new_y STR + + anispeedmask_normal ;ani_speedmask STA + + &check_x + ( check collision with borders ) + ,&new_x LDR minposx EQU ;&noup_x JCN2 + ,&new_x LDR maxposx EQU ;&noup_x JCN2 + + + ( check collision with rocks ) + ,&new_x LDR ,&new_y LDR index_norock #09 #06 + ;collision_rocks/run JSR2 + + ( if it is colliding with rock, check further ) + DUP #ff NEQ ,&check_x_collision JCN + POP + ,&update_x JMP + + &check_x_collision + ( DUP DEBUG ) + ( slow down and save rock index ) + anispeedmask_slow ;ani_speedmask STA + ,&rock_i STR + + ( check if rock collides with others ) + ;rocks_x #00 ,&rock_i LDR ADD2 LDA ,&rock_x STR + ;rocks_y #00 ,&rock_i LDR ADD2 LDA ,&rock_y STR + + ,&rock_x LDR ,&rock_y LDR ,&rock_i LDR #09 #06 + ;collision_rocks/run JSR2 + + ( DUP DEBUG ) + + ( if it is colliding, then skip adding x ) + DUP #ff NEQ ,&check_y JCN + POP + + + ( if not, check for borders ) + ;&rock_x LDA minposx EQU ;&noup_x JCN2 + ;&rock_x LDA maxposx EQU ;&noup_x JCN2 + + ( move rock with same speed as c ) + ;&rock_x LDA ;c_speed/x LDA ADD + ;rocks_x #00 ;&rock_i LDA ADD2 + STA + + + &update_x + ;&new_x LDA ;c_pos/x STA + + ,&check_y JMP + + &noup_x + + &check_y + ( check collision with borders ) + ;&new_y LDA minposy EQU ;&noup_y JCN2 + ;&new_y LDA maxposy EQU ;&noup_y JCN2 + + ( check collision with rocks ) + ;&new_x LDA ;&new_y LDA index_norock #06 #09 + ;collision_rocks/run JSR2 + + ( if it is colliding with rock, check further ) + DUP #ff NEQ ,&check_y_collision JCN + POP + ,&update_y JMP + + &check_y_collision + ( DUP DEBUG ) + anispeedmask_slow ;ani_speedmask STA + ;&rock_i STA + + ( check if rock collides with others ) + ;rocks_x #00 ;&rock_i LDA ADD2 LDA ;&rock_x STA + ;rocks_y #00 ;&rock_i LDA ADD2 LDA ;&rock_y STA + + ;&rock_x LDA ;&rock_y LDA ;&rock_i LDA #06 #09 + ;collision_rocks/run JSR2 + + ( DUP DEBUG ) + + ( if it is colliding, then skip adding y ) + DUP #ff NEQ ,&noup_y JCN + POP + + ( if not, check for borders ) + ;&rock_y LDA minposx EQU ;&noup_y JCN2 + ;&rock_y LDA maxposx EQU ;&noup_y JCN2 + + ( if not colliding, then move rock with same speed as c ) + ;&rock_y LDA ;c_speed/y LDA ADD + ;rocks_y #00 ;&rock_i LDA ADD2 + STA + + + &update_y + ;&new_y LDA ;c_pos/y STA + JMP2r + + &noup_y +JMP2r + +@update_r + &rock_i $1 + + &run + + ( check collision with rocks ) + ;tog/x LDA ;tog/y LDA index_norock #02 #02 + ;collision_rocks/run JSR2 + + ( if it is colliding with rock, check if it needs to change state ) + DUP #ff NEQ ,&change_state JCN + + ( DUP DEBUG ) + + ( if there's no collision, reset toggler ) + POP + #00 ;tog/state STA + JMP2r + + &change_state + ( DUP DEBUG ) + ,&rock_i STR + ;tog/state LDA ,&done JCN ( don't toggle if state is active ) + + ;r_color #00 ,&rock_i LDR ADD2 DUP2 STH2 + LDA #01 EOR STH2r STA + #01 ;tog/state STA + &done + +JMP2r + +@animate_c + ( is bit0 -animate- on? ) + ;c_state LDA DUP #00 get_bit_n #01 NEQ ,&s_no_animate JCN + + ( increment and save animation pointer ) + &s_animate + DUP + get_nibble_h #01 ADD #03 AND #40 SFT + SWP get_nibble_l ORA + ;c_state STA + JMP2r + + &s_no_animate + get_nibble_h #0f AND ;c_state STA +JMP2r + +@draw_c ( draw character ) + #00 ;c_state LDA get_nibble_h #08 MUL + ;c_sprite LDA2 ADD2 .Screen/addr DEO2 + ;c_pos/x out_screen_x + ;c_pos/y out_screen_y + ;c_color LDA .Screen/color DEO +JMP2r + +@clear_c ( clear character ) + ;s_clear .Screen/addr DEO2 + ;c_pos/x out_screen_x + ;c_pos/y out_screen_y + #30 .Screen/color DEO +JMP2r + +@init_bg + ( init bg ) + ;s_border .Screen/addr DEO2 + + .Screen/height DEI2 #0000 STH2 + &vertical0loop + DUP2 + STH2r + DUP2 .Screen/y DEO2 + + + .Screen/width DEI2 #0000 STH2 + &horizontal0loop + DUP2 + STH2r + DUP2 .Screen/x DEO2 + + #23 .Screen/color DEO + + #0008 ADD2 DUP2 STH2 + GTH2 ,&horizontal0loop JCN + + STH2r POP2 POP2 + + + #0008 ADD2 DUP2 STH2 + GTH2 ,&vertical0loop JCN + STH2r + POP2 POP2 + + ( arena ) + + ;s_clear .Screen/addr DEO2 + + #00 maxposy #00 minposy STH2 + &vertical0loop_clear + DUP2 + STH2r + DUP2 .Screen/y DEO2 + + + #00 maxposx #00 minposx STH2 + &horizontal0loop_clear + DUP2 + STH2r + DUP2 .Screen/x DEO2 + + #20 .Screen/color DEO + + #0008 ADD2 DUP2 STH2 + GTH2 ,&horizontal0loop_clear JCN + + STH2r POP2 POP2 + + #0008 ADD2 DUP2 STH2 GTH2 ,&vertical0loop_clear JCN + STH2r + POP2 POP2 + +JMP2r + +( rocks ) +@rocks_x [ 25 30 42 50 67 90 98 e8 20 43 43 57 5a 7f bc a5 + e5 dd a2 20 b7 9b 38 e8 33 43 63 b7 aa cf bc ] +@rocks_y [ 60 48 34 56 23 65 65 65 ba e9 24 22 72 91 22 c5 + 25 30 42 50 67 90 98 e8 20 43 43 57 5a 7f bc ] +@r_color [ 00 01 01 00 00 00 01 01 01 01 00 00 01 01 00 00 + 01 00 01 00 00 01 00 01 01 01 01 01 00 00 00 ] + + +( sprites ) + +@s_clear [ 0000 0000 0000 0000 ] +@s_border [ 3288 7e83 780d e013 ] +@s_bola [ 3c4e 9ffd f962 3c00 ] +@s_stand [ 0000 0000 0024 7eff ] +@s_stand_original [ 0000 0000 0000 3c7e ] + +@s_monitx [ 3c7e 5a7f 1b3c 5a18 ] +@s_monitx_back [ 3c7e 7efe d83c 5a18 ] + +@s_monitx_stepfront0 [ 3c7e 5a7f 1b3c 5a18 ] +@s_monitx_stepfront1 [ 3c7e 5a7f 1b3c 5a10 ] +@s_monitx_stepfront2 [ 3c7e 5a7f 1b3c 5a18 ] +@s_monitx_stepfront3 [ 3c7e 5a7f 1b3c 5a08 ] + +@s_monitx_stepback0 [ 3c7e 7efe d83c 5a18 ] +@s_monitx_stepback1 [ 3c7e 7efe d83c 5a10 ] +@s_monitx_stepback2 [ 3c7e 7efe d83c 5a18 ] +@s_monitx_stepback3 [ 3c7e 7efe d83c 5a08 ] + +@s_monitx_stepside0 [ 1c3c 7afc d81c 1818 ] +@s_monitx_stepside1 [ 1c3c 7afc d81c 1828 ] +@s_monitx_stepside2 [ 1c3c 7afc d81c 3810 ] +@s_monitx_stepside3 [ 1c3c 7afc d81c 1814 ] +``` + +enlaza aquí {s-camino} + +=> ./s-camino.gmi {s-camino} + +página actualizada en: sejmana-1660, día 1 (12021-05-20) diff --git a/gem/ffmpeg.gmi b/gem/ffmpeg.gmi new file mode 100644 index 0000000..cb83374 --- /dev/null +++ b/gem/ffmpeg.gmi @@ -0,0 +1,114 @@ +# apuntes de ffmpeg + +notas de usos comunes que le doy a ffmpeg + +# "trim" / cortar + +``` +ffmpeg -i input.video -ss 5 -t 20 output.video +``` + +donde: +-ss es el tiempo inicial +-t es la duracion total del nuevo video + + +# escalar + +``` +ffmpeg -i input.video -vf scale=640:480 output.video +``` + +y para reducir el tamaño del archivo, suele ser útil recomprimir con crf (constant rate factor) + +``` +ffmpeg -i input.video -crf 24 output.video +``` + +en teoría 24 es una compresión difícil de percibir. números mayores comprimen más. + +# cambio de framerate + +``` +ffmpeg -i input.video -r 30 output.video +``` + +o + +``` +ffmpeg -i input.video -filter:v fps=fps=30 output.video +``` + +# cambio de "velocidad" + +obtiene un video a 2x de velocidad: + +``` +ffmpeg -i input.video -filter:v "setpts=0.5*PTS" output.video +``` + +para hacer 60x (por ejemplo, convertir minutos a segundos): + +``` +ffmpeg -i input.video -filter:v "setpts=0.016*PTS" output.video +``` + +# concatenar + +hacer lista de videos con el formato: + +``` +file 'archivo1' +file 'archivo2' +file 'archivo3' +``` +y luego: + +``` +ffmpeg -f concat -i lista.txt -c copy output.video +``` + + +# generar video desde serie de img + +``` +ffmpeg -framerate 30 -i frame-%04d.tif -pix_fmt yuv420p -c:v libx264 +``` + +# crop (y exportar desde recordmydesktop) + +``` +ffmpeg -i out.ogv -filter:v "crop=1280:720:0:0" -codec:v libx264 -codec:a libmp3lame output.mp4 +``` + + +# video a partir de una imagen + +``` +# video de una imagen, +# 10 segundos, 30 frames por segundo +ffmpeg -loop 1 \ + -i imagen_verde.png \ + -t 00:00:10 -r 30 \ + video_verde.ogv +``` + +# video a partir de serie de imágenes + +``` +# cambia entre imágenes a 2fps, +# video final a 30fps +ffmpeg -framerate 2 \ + -i "%02d.png" \ + -pix_fmt yuv420p \ + -c:v libx264 \ + -r 30 salida.mp4 +``` + +# overlay de imagen sobre video + +``` +ffmpeg -i input.mp4 -i imagen.png -filter_complex "overlay=(main_w-overlay_w)/2:(main_h-overlay_h)/2" output.mp4 +``` + +página actualizada en: sejmana-1660, día 1 (12021-05-20) diff --git a/gem/imagemagick.gmi b/gem/imagemagick.gmi new file mode 100644 index 0000000..50e69c6 --- /dev/null +++ b/gem/imagemagick.gmi @@ -0,0 +1,118 @@ +# apuntes de imagemagick + +# redimensiona imagen + +``` +convert imagen.png -resize 100x100 imagen100.png +``` + +o con -scale, para no interpolar y mantener la apariencia de pixeles + +``` +convert imagen.png -scale 200% imagenx2.png +``` + +# reemplaza color por otro + +reemplaza azul por blanco: + +``` +convert imagen.png -fill white -opaque blue salida.png +``` + +se puede agregar fuzz factor: + +``` +convert imagen.png -fuzz 45% -fill white -opaque blue salida.png +``` + +y para convertir a transparente: + +``` +convert imagen.png -fuzz 45% -transparent blue salida.png +``` + +# elimina metadatos exif + +para imágenes jpg + +``` +convert foto.jpg -strip fotolimpia.jpg +``` + +esto re-comprime la imagen, pero puede usarse al mismo tiempo que se redimensiona + +``` +convert foto.jpg -strip -resize 640x480 fotolimpia_480p.jpg +``` + +# convierte pdf + +por default la conversión sucede en baja calidad, esto la mejora: + +``` +convert imagen.png -quality 100 -units PixelsPerInch -density 300x300 imagen.pdf +``` + +y para el caso opuesto: + +``` +convert -quality 100 -units PixelsPerInch -density 300x300 imagen.pdf imagen.png +``` + +# reduce la cantidad de colores + +deja que imagemagick elija qué colores utilizar: + +``` +convert imagen.png -colors 8 imagen_8.png +``` + +o con dithering: + +``` +convert imagen.png -dither FloydSteinberg -colors 8 imagen_8.png +``` + +en -dither se puede usar None, Riemersma, o FloydSteinberg + + +# genera mapas de bits + +con color plano: + +``` +convert -size 100x100 xc:'rgb(0,255,0)' imagen_verde.png +``` + +con ruido: + +``` +convert -size 100x100 xc: +noise Random imagen_ruido.png +``` + +# compone/encima imágenes + +para componer una imagen con fondo transparente sobre otra que se convertirá en su fondo + +``` +composite -gravity center imagen_con_alpha.png fondo.png resultado.png +``` + +# corta + +para cortar una imagen a ciertas dimensiones (wxh) y cierto offset en x,y + +``` +convert imagen.png -crop 300x300+100+50 +repage recorte.png +``` + + +para quitarte el borde de color constante a una imagen + +``` +convert imagen.png -trim +repage sinborde.png +``` + + +página actualizada en: sejmana-1660, día 1 (12021-05-20) diff --git a/gem/index.gmi b/gem/index.gmi new file mode 100644 index 0000000..b2a2d2f --- /dev/null +++ b/gem/index.gmi @@ -0,0 +1,14 @@ +# ¿queso de mango? + +cuaderno en proceso de almacenar y compartir notas variadas, con miras a que tengan (más) vida al vibrar en la red… + +notebook in progress, saving and sharing various materials, trying to give them (networked) life. + +=> ./compudanzas.gmi {compudanzas} +=> ./coloring_computers.gmi {coloring computers} +=> ./s-camino.gmi {s-camino} +=> ./darena.gmi {darena} +=> ./recetas.gmi {recetas} +=> ./indice.gmi {índice} + +página actualizada en: sejmana-1660, día 1 (12021-05-20) diff --git a/gem/indice.gmi b/gem/indice.gmi new file mode 100644 index 0000000..c88bd02 --- /dev/null +++ b/gem/indice.gmi @@ -0,0 +1,14 @@ +# índice de páginas + +=> ./avr-asm.gmi {avr-asm} +=> ./coloring_computers.gmi {coloring computers} +=> ./compudanzas.gmi {compudanzas} +=> ./danzasistemas-tag.gmi {danzasistemas-tag} +=> ./darena.gmi {darena} +=> ./ffmpeg.gmi {ffmpeg} +=> ./imagemagick.gmi {imagemagick} +=> ./logiteca.gmi {logiteca} +=> ./recetas.gmi {recetas} +=> ./s-camino.gmi {s-camino} + +página actualizada en: sejmana-1660, día 1 (12021-05-20) diff --git a/gem/logiteca.gmi b/gem/logiteca.gmi new file mode 100644 index 0000000..891aa7d --- /dev/null +++ b/gem/logiteca.gmi @@ -0,0 +1,290 @@ +# logiteca + +compendio de circuitos lógicos que pueden implementarse en las "danzas compuertas". + +material de referencia para las {compudanzas} + +=> ./compudanzas.gmi {compudanzas} + +# acerca de + +este es un compendio de circuitos lógicos que pueden implementarse en las "danzas compuertas". + +están descritos en *verilog*, un lenguaje descriptor de hardware. esto con la idea de estandarizarlos, de facilitar simularlos e implementarlos en otros materiales, y de indicar su cualidad de *red abstracta*. + +utilizamos el lenguaje a nivel de compuertas lógicas solamente: cada compuerta se expresa como una función (`and()`, `not()`, `or()`, `nor()`, `nand()`, etc) donde el primer argumento es el nombre de la *salida* de la compuerta, y el o los otros argumentos son los nombres de las *entradas*. + +el número de participantes asignado por circuito está contado como el *número de entradas* más el *número de compuertas*, donde alguna(s) de ella(s) incluyen las compuertas cuyas salidas son también la(s) del circuito. si se tienen más participantes, se pueden agregar el *número de salidas*: persona(s) que copien el resultado de la compuerta correspondiente. + +# multiplicador de 1 bit + +circuito que multiplica a dos números de 1 bit y da el resultado en 1 bit. + +## multiplicador de 1 bit con compuertas habituales (3 o 4 participantes) + +``` +// multiplicador construido con compuertas habituales +// entradas (2): a,b +// salidas (1): r (resultado) +// compuertas (1): 1 de 2 entradas + +module multiplicador( a, b, r); + +input wire a, b; +output wire r; + +and C1(r, a, b); + +endmodule +``` + +## multiplicador de 1 bit con nor (5 o 6 participantes) + +``` +// multiplicador construido con nor's +// entradas (2): a,b +// salidas (1): r (resultado) +// compuertas (3): 2 de 1 y 1 de 2 entradas + +module multiplicador( a, b, r); + +input wire a, b; +output wire r; +wire p1,p2; + +// negadas +nor C1(p1, a); +nor C2(p2, b); + +// resultado +nor C3(r, p1, p2); + +endmodule +``` + +# contadores + +circuitos que incrementan 1 al número binario colocado en la entrada, con el mismo número de bits a la entrada que a la salida. + +si la salida se "conecta" a la entrada, entonces con cada paso se obtiene el +número siguiente en la secuencia, es decir se "cuenta". + +al llegar al último número, se regresa a 0. + +## contador de 2 bits con compuertas habituales (4 o 6 participantes) + +``` +// contador de 2 bits con compuertas habituales +// entradas (2): a, b +// salidas (2): x, y +// compuertas (2): 1 de 1 y 1 de 2 entradas + +module contador(a, b, x, y); + +input wire a,b; +output wire x,y; + +not C1(y, b); +xor C2(x, a,b); + +endmodule +``` + +## contador de 2 bits con nor (7 o 9 participantes) + +``` +// contador de 2 bits con nor +// entradas (2): a, b +// salidas (2): x, y +// compuertas (5): 2 de 1 y 3 de 2 entradas + +module contador(a, b, x, y); + +input wire a,b; +output wire x,y; +wire p1, p2, p3; + +// negaciones +nor C1(y, b); +nor C2(p1, a); + +// para x +nor C3(p2, a,b); +nor C4(p3, y,p1); +nor C5(x, p2,p3); + +endmodule +``` + + +## contador de 3 bits con nor (13 o 16 participantes) + +``` +// contador de 3 bits con compuertas habituales +// entradas (3): a, b, c +// salidas (3): x, y, z +// compuertas (10): 3 de 1, 4 de 2, 3 de 3 entradas + +module contador(a, b, c, x, y, z); + +input wire a,b,c; +output wire x,y,z; +wire p1, p2, p3, p4, p5, p6, p7; + +// negaciones +nor C1(p1, a); +nor C2(p2, b); +nor C3(z, c); + +// para y +nor C4(p3, b,c); +nor C5(p4, p2,z); +nor C6(y, p3,p4); + +// para x +nor C7(p5, a,b); +nor C8(p6, p1, p2, z); +nor C9(p7, a, p2, c); +nor C10(x, p5, p6, p7); + +endmodule +``` + + +# half adder + +circuito que suma dos bits y da el resultado en dos bits (resultado y *carry*) + +## half adder con compuertas habituales (4 o 6 participantes) + +``` +// half adder construido con compuertas habituales +// entradas (2): a,b +// salidas (2): r, c (resultado, carry) +// compuertas (2): 2 de 2 entradas + +module halfadder( a, b, r, c); + +input wire a, b; +output wire r,c; + +// carry +and C1(c, a, b); + +// resultado +xor C2(r, a, b); + +endmodule +``` + +## half adder usando nor (7 o 9 participantes) + +``` +// half adder construido usando nor's +// entradas (2): a,b +// salidas (2): r, c (resultado, carry) +// compuertas (5): 2 de 1 y 3 de 2 entradas + +module halfadder( a, b, r, c); + +input wire a, b; +output wire r,c; +wire p1,p2,p3; + +// negadas +nor C1(p1, a); +nor C2(p2, b); + +// carry +nor C3(c, p1, p2); + +// resultado +nor C4(p3, a, b); +nor C5(r, c, p3); + +endmodule +``` + + +# full adder + +circuito que suma tres bits y da el resultado en dos bits (resultado y *carry*). + +## full adder con compuertas habituales (14 o 16 participantes) + +``` +// full adder construido con compuertas habituales +// entradas (3): a, b, c +// salidas (2): carry, r (resultado) +// compuertas (11): 2 de 1 y 9 de 2 entradas + +module fulladder( a, b, c, r, carry); + +input wire a, b, c; +output wire r, carry; +wire p1, p2, p3, p4, p5, p6, p7, p8, p9; + +// negadas +not C1(p1, a); +not C2(p3, p2); + +// diferencias b,c +xor C3(p2, b, c); +or C4(p4, b, c); +and C5(p5, b, c); + +// armado de resultado +and C6(p6, p1, p2); +and C7(p7, a, p3); +or C8(r, p6, p7); + +// armado de carry +and C9(p8, p1, p5); +and C10(p9, a, p4); +or C11(carry, p8, p9); + +endmodule +``` + +## full adder usando nor (15 o 17 participantes) + +``` +// full adder construido usando nor's +// entradas (3): a, b, c +// salidas (2): carry, r (resultado) +// compuertas (12): 3 de 1, 3 de 2, 4 de 3 y 1 de 4 entradas + +module fulladder( a, b, c, r, carry); + +input wire a, b, c; +output wire r, carry; +wire p1, p2, p3, p4, p5, p6, p7, p8, p9, p10; + +// negadas +nor C1(p1, a); +nor C2(p2, b); +nor C3(p3, c); + +// pa'l carry +nor C4(p4, a, b); +nor C5(p5, a, c); +nor C6(p6, b, c); + +// pa resultado +nor C7(p7, a, b , c); +nor C8(p8, p1, b, p3); +nor C9(p9, a, p2, p3); +nor C10(p10, p1, p2, c); + +// salidas +nor C11(carry, p4, p5, p6); +nor C12(r, p7, p8, p9, p10); + +endmodule +``` + +enlaza aquí {compudanzas} + +=> ./compudanzas.gmi {compudanzas} + +página actualizada en: sejmana-1660, día 1 (12021-05-20) diff --git a/gem/recetas.gmi b/gem/recetas.gmi new file mode 100644 index 0000000..9318b41 --- /dev/null +++ b/gem/recetas.gmi @@ -0,0 +1,194 @@ +# recetas veganas + +# hotcakes de chocolate + +~35 min +~10-12 piezas + +(remix de sejo y mel* de la receta en pag 46 del libro "cocinar vegano vol.1" de francesca carpinelli cocinavegano.com) + +## ingredientes + +* 2 tazas avena (hojuela de grano entero, "old-fashioned") +* 1.5 tazas leche de soya +* 1 cdita polvo para hornear +* 1 cdita bicarbonato de sodio +* 1 cdita canela en polvo +* 1/2 cdita sal de mar +* 3 cdas azucar mascabado +* 2 cdas cocoa en polvo +* 1 cda extracto de vainilla +* 1 cdita aceite de coco (u otro) +* 1/2 taza chocolate amargo en trozos (opcional) + +## instrucciones + +* muele la avena hasta hacerla harina +* agrega el polvo para hornear, bicarbonato de sodio, sal, canela, cocoa y azucar +* mezcla bien +* poco a poco agrega leche de soya y bate hasta incorporar los ingredientes +* agrega el extracto de vainilla y bate de nuevo +* coloca sarten a fuego medio +* cuando se caliente, aceita y sirve la mezcla en partes iguales +* cuando se hagan burbujas en la superficie, agrega trozos de chocolate y voltea +* retira cuando tengan la consistencia que te agrade + +(recuerda que no hay ingredientes crudos en la receta por lo que no hay riesgos por si parece que algo falta de cocerse) + +## sugerencia + +sirve con frutos rojos, moras, platano, mermeladas, mantequilla de cacahuate y/o de almendra. + + +# "leche" y "queso" de soya + +preparar "leche" de soya resulta en restos llamados "okara", que puede usarse entre otras cosas para preparar un "queso" + +~60 min +~1 lt de leche y +un queso de ~120 gr + +## ingredientes + +solo para la "leche": + +* 1/2 taza frijol de soya seco +* 4 tazas agua + +para el queso: + +* 2 cditas levadura nutricional +* 1/2 cdita sal +* 1/2 limón +* 1 chorrito aceite de oliva +* 3 tazas agua + +necesitas alguna herramienta para licuar/moler, y otra para colar finamente (e.g. manta de cielo) + +dos ollas y algunos recipientes, y un colador ayuda + +## instrucciones + +### previo: + +* deja remojando el frijol de soya por unas 8 horas + +### durante: + +para el queso: +* empieza a hervir 3 tazas de agua + +para la leche: +* escurre el frijol de soya - al remojarse crece como hasta 1.5 tazas +* muele en la licuadora el frijol con 3 tazas de agua +* usa la manta de cielo para filtrar y exprimir el resultado dentro de una olla + (el liquido se vuelve la leche, y lo solido es la okara) +* pon la olla de la leche a hervir, cuidando de quitarle la espuma y nata +* cuando hierva, cambia a fuego medio y espera ~20 minutos, quitando espuma y + revolviendo en ocasiones +* deja enfriar y bebe! + +para el queso: +* tan pronto el agua hierva, y ya tengas la okara, ponla en esa olla +* deja cocer a fuego medio durante 15-20 minutos +* usa el colador y la manta de cielo para filtrar el resultado (el liquido ya no + lo usaremos, y el solido es la okara cocida) +* deja enfriar un rato +* cuando te sea posible, exprime para quitar todo el liquido que puedas +* coloca la okara cocida y "seca" en un recipiente +* sirve encima la levadura nutricional, sal, limon y aceite de oliva +* mezcla muy bien con tus manos +* compacta la mezcla para que sea "queso" +* aparentemente conviene refrigerar un rato antes de comerlo + + +## referencias + +remix de estas recetas: +=> https://simpleveganblog.com/homemade-soy-milk/ leche de soya +=> https://youtube.com/watch?v=BU2LEYHb_qk tofu casero (youtube) + + + +# pastel de garbanzo + +remix de "falafel al horno" + +(receta en proceso de afinarse porque la hago de manera intuitiva (?)) + +~60 min +~2 "pasteles" + +## ingredientes + +### para la masa + +* 1 taza garbanzo seco +* 2 jitomates medianos +* 1/2 cebolla +* 2 dientes ajo +* 1 cucharada sal +* 1 cucharadita pimienta +* 1 cucharada comino +* 1.5 tazas agua +* 1 cucharadita aceite +* al gusto cilantro +* al gusto chiles serranos + +### extras: + +* 1 cucharadita ajonjoli +* 1 pimiento +* 1/2 taza setas +* 1/2 taza espinaca + +necesitas horno y alguna herramienta para moler/licuar + +## instrucciones + +### previo: + +* deja remojando los garbanzos entre 8 y 12 horas (crecen como a 2.25 tazas) + +### durante: + +* escurre y enjuaga los garbanzos +* muele en la licuadora los garbanzos con el agua, cebolla, jitomates, ajo, sal, + pimienta, comino, cilantro y chile(s) +* aceita un par de moldes para pan y sirve la mezcla en ellos +* opcional: deja reposar en el refrigerador por ~30 minutos +* parte los pimientos y setas en rebanaditas, coloca junto con la espinaca y + ajonjoli en la superficie de la masa +* coloca los moldes en el horno, enciende a ~300 grados C +* espera unos 40-50 minutos, o hasta que adquieran la consistencia que desees +* apaga el horno y aprovecha el calor para seguir cociendo +* deja enfriar y sirve! + +queda bien junto con limon, aguacate, y alguna salsa (en proceso de definirla) + + +# kombucha + +(notas que uso para cada ronda) + +~1 lt de kombucha + +## ingredientes + +* 1/2 taza liquido iniciador + scoby +* 1 taza agua caliente +* 1 cucharadita te negro (o 2 sobres) +* 1/4 taza azucar mascabado (4 cucharadas) +* 3 tazas agua fria + +## instrucciones + +* prepara el te con el agua caliente +* cuela las hojas del te +* disuelve la azucar en el te +* diluye el te con el agua fria +* agrega la mezcla al liquido iniciador + scoby +* tapa con tela / filtros de cafe, y espera al menos un par de semanas + + +página actualizada en: sejmana-1660, día 1 (12021-05-20) diff --git a/gem/s-camino.gmi b/gem/s-camino.gmi new file mode 100644 index 0000000..bb5ab21 --- /dev/null +++ b/gem/s-camino.gmi @@ -0,0 +1,33 @@ +# s-camino... el camino del ensamblador (?) + +veo razones varias, múltiples, para el estudio poético y contemplativo de la computación a bajo nivel. + +específicamente aquí me refiero al programar en el llamado lenguaje ensamblador (¿o idioma ensamblador?) + +en otros contextos se puede hablar de que conviene hacerlo buscando eficiencia, velocidad, haciendo el sacrificio de descender por las escaleras para mover los fierros; ensuciarse las manos mientras se observa la complejidad del dispositivo... pero todo sea por la productividad y el resultado óptimo que se encontrará a final del tunel. + +aquí no estamos en ese contexto, claramente. pero justo esa impracticidad, esa mugre, esa manualidad o artesanalidad, la imagen de que a fin de cuentas (solo) estamos moviendo bits de aquí para allá (conectados de tal manera que algo más sucede) es la que llama la atención. + +¿qué tal si acompañamos a la máquina en un nivel cercano al que será su propósito (¿o condena?) de vida? + +tomamos conciencia de cada uno de los pasos por la que la haremos pasar sin otra opción más que seguir, seguir, seguir… + +y sí, al escribir y programar en ensamblador vamos con lentitud, porque las convenciones son extrañas (todo un dialecto que tal vez busca alejar a quien no tiene cierto perfil), porque es un mundo que contrasta con la costumbre de la eficiencia, de los resultados inmediatos. + +además, ¿cuál es la prisa, por qué querer hacer tanto? + +hacer un programa se puede convertir en un ritual; la invocación del libro de instrucciones y conexiones, la planeación y reflexión antes de escribir la primera letra; tardarse horas en algo que aquellas estructuras de facilidad, practicidad, te permiten hacer en minutos, segundos (¿pero te quitan toda la magia, todo el asombro y confrontación con lo que realmente está pasando?) + +la no portabilidad del código está a nuestro favor, porque implica rehacerlo cada vez (o cuando sea necesario), re-contemplar, ir lento. de nuevo, ¿cuál es la prisa? + +estoy de acuerdo, es un mundo inaccesible (¿similar a cualquier otro tipo de hechicería?), pero parte de la labor que me autoasigno es hacerle puertas (o grietas, hoyos, y adentro madrigueras) para poderlo compartir. + +no cualquiera tiene el tiempo... igual aquí andaremos, con paciencia, y un paso a la vez. + +(escrito el 12019-07-05) + +enlazan aquí: +=> ./avr-asm.gmi {avr-asm} +=> ./darena.gmi {darena} + +página actualizada en: sejmana-1660, día 1 (12021-05-20) diff --git a/gem2gem.awk b/gem2gem.awk index e854d7e..eea63f6 100644 --- a/gem2gem.awk +++ b/gem2gem.awk @@ -32,6 +32,6 @@ END{ print "" - print "página actualizada en: " fechasjm + print "página actualizada en: " fechasjm " (1" fecha ")" # fecha = system( "date -r " FILENAME " --rfc-3339=date" ) } diff --git a/gemtext2html.awk b/gemtext2html.awk index ab4d44e..c1b44a7 100644 --- a/gemtext2html.awk +++ b/gemtext2html.awk @@ -321,6 +321,7 @@ END{ print "

{" sitio "}

" print "

página actualizada en: " print "" + print " (1"fecha")" print "

" # fecha = system( "date -r " FILENAME " --rfc-3339=date" ) # print "

" -- cgit v1.2.3