fecha holoceno
This commit is contained in:
parent
6c3fcba6a0
commit
5ee0826789
|
|
@ -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 <avr/io.h>
|
||||
.org 0x0000
|
||||
|
||||
ldi r17, (1<<DDB0) ; configura al PB0 como salida
|
||||
sts DDRB, r17
|
||||
|
||||
ldi r16, (1<<PB0) ; enciende el bit correspondiente al PB0
|
||||
sts PORTB, r16 ; actualiza el puerto
|
||||
|
||||
sleep ; duerme por siempre (?)
|
||||
```
|
||||
|
||||
## blink.S
|
||||
|
||||
parpadea el pin PB0 usando el timer/counter0 — conecta un led
|
||||
|
||||
```
|
||||
; blink.S
|
||||
; parpadea el pin PB0 (OC0A)!
|
||||
; r16 y r17 se usan como registros auxiliares
|
||||
|
||||
; el programa usa el timer/counter 0 con:
|
||||
; * waveform generation mode (WGM0): 2, que es CTC (clear timer on compare match)
|
||||
; * compare match output A mode (COM0A): 1, que es toggle en compare match
|
||||
; * clock select (CS0): 5, que utiliza el reloj i/o dividido entre 1024
|
||||
|
||||
; notas sobre el reloj:
|
||||
; por default el attiny85 va a 8MHz, y el reloj i/o va a 1MHz
|
||||
; 1MHz/1024 ~= 967 Hz
|
||||
|
||||
#include <avr/io.h>
|
||||
; ***********************
|
||||
; vectores de interrupts:
|
||||
; ***********************
|
||||
; Reset
|
||||
.org 0x0000
|
||||
rjmp main
|
||||
|
||||
; ***********************
|
||||
; Main
|
||||
; ***********************
|
||||
.org 0x0010
|
||||
main:
|
||||
; pin PB0 (OC0A) como pin de salida
|
||||
ldi r16, (1<<DDB0) ; pin de salida
|
||||
sts DDRB, r16
|
||||
|
||||
; togglea OC0A en Compare match (1 en COM0A[1:0])
|
||||
; y usa modo Clear Timer on Compare Match (2 en WGM0[2:0])
|
||||
ldi r16, (0<<COM0A1) | (1<<COM0A0) | (1<<WGM01) | (0<<WGM00)
|
||||
sts TCCR0A, r16
|
||||
|
||||
; completa el modo WGM (waveform generaton mode, bit 2)
|
||||
; establece el tipo de reloj: 0b101 en CS0 es clk/1024
|
||||
ldi r16, (0<<WGM02) | (1<<CS02) | (0<<CS01) | (1<<CS00)
|
||||
sts TCCR0B, r16
|
||||
|
||||
; el TOP es el valor en OCR0A
|
||||
ldi r16, 0x80
|
||||
sts OCR0A, r16
|
||||
|
||||
loop:
|
||||
sleep
|
||||
rjmp loop
|
||||
```
|
||||
|
||||
## buzz.S
|
||||
|
||||
zumba el pin PB0 — conecta un buzzer
|
||||
|
||||
```
|
||||
; buzz.S
|
||||
; haz zumbar el pin PB0 (OC0A)!
|
||||
; el código es igual a blink.S, pero con diferentes frecuencias
|
||||
; r16 y r17 se usan como registros auxiliares
|
||||
|
||||
; el programa usa el timer/counter 0 con:
|
||||
; * waveform generation mode (WGM0): 2, que es CTC (clear timer on compare match)
|
||||
; * compare match output A mode (COM0A): 1, que es toggle en compare match
|
||||
; * clock select (CS0): 4, que utiliza el reloj i/o dividido entre 256
|
||||
|
||||
; notas sobre el reloj:
|
||||
; por default el attiny85 va a 8MHz, y el reloj i/o va a 1MHz
|
||||
; 1MHz/256 ~= 3906 Hz (/2 para el periodo completo ~=1953Hz)
|
||||
|
||||
#include <avr/io.h>
|
||||
; ***********************
|
||||
; vectores de interrupts:
|
||||
; ***********************
|
||||
; Reset
|
||||
.org 0x0000
|
||||
rjmp main
|
||||
|
||||
; ***********************
|
||||
; Main
|
||||
; ***********************
|
||||
.org 0x0010
|
||||
main:
|
||||
; pin PB0 (OC0A) como pin de salida
|
||||
ldi r16, (1<<DDB0) ; pin de salida
|
||||
sts DDRB, r16
|
||||
|
||||
; togglea OC0A en Compare match (1 en COM0A[1:0])
|
||||
; y usa modo Clear Timer on Compare Match (2 en WGM0[2:0])
|
||||
ldi r16, (0<<COM0A1) | (1<<COM0A0) | (1<<WGM01) | (0<<WGM00)
|
||||
sts TCCR0A, r16
|
||||
|
||||
; completa el modo WGM (waveform generaton mode, bit 2)
|
||||
; establece el tipo de reloj: 0b100 en CS0 es clk/256
|
||||
ldi r16, (0<<WGM02) | (1<<CS02) | (0<<CS01) | (0<<CS00)
|
||||
sts TCCR0B, r16
|
||||
|
||||
; el TOP es el valor en OCR0A
|
||||
ldi r16, 0x02
|
||||
sts OCR0A, r16
|
||||
|
||||
loop:
|
||||
sleep
|
||||
rjmp loop
|
||||
```
|
||||
|
||||
## alarm.S
|
||||
|
||||
zumbido intermitente en el pin PB0 — conecta un buzzer
|
||||
|
||||
```
|
||||
; alarm.S
|
||||
; zumbido intermitente en el pin PB0 (OC0A)!
|
||||
; r16 y r17 se usan como registros auxiliares
|
||||
; r20 tiene el valor de TCCR0A para apagar sonido
|
||||
; r21 tiene el valor de TCCR0A para encenderlo
|
||||
|
||||
; el programa usa el timer/counter 0 con:
|
||||
; * waveform generation mode (WGM0): 2, que es CTC (clear timer on compare match)
|
||||
; * compare match output A mode (COM0A): 1, que es toggle en compare match
|
||||
; * clock select (CS0): 3, que utiliza el reloj i/o dividido entre 64
|
||||
|
||||
; y el timer/counter 1 con:
|
||||
; * clock select (CS1): 0b1010, que es clk/512
|
||||
; * interrupciones de overflow y de compare match A:
|
||||
; - en compare match A el zumbido se apaga
|
||||
; - en overflow el zumbido inicia
|
||||
|
||||
; notas sobre el reloj:
|
||||
; por default el attiny85 va a 8MHz, y el reloj i/o va a 1MHz
|
||||
; 1MHz/256 ~= 3906 Hz (/2 para el periodo completo ~=1953Hz)
|
||||
|
||||
#include <avr/io.h>
|
||||
; ***********************
|
||||
; 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<<DDB0) ; pin de salida
|
||||
sts DDRB, r16
|
||||
|
||||
; valores de TCCR0A para encender o apagar sonido
|
||||
ldi r20, (0<<COM0A1) | (0<<COM0A0) | (1<<WGM01) | (0<<WGM00)
|
||||
ldi r21, (0<<COM0A1) | (1<<COM0A0) | (1<<WGM01) | (0<<WGM00)
|
||||
|
||||
;----------------------------------
|
||||
; configuración TIMER0 para buzzer
|
||||
;----------------------------------
|
||||
; togglea OC0A en Compare match (1 en COM0A[1:0])
|
||||
; y usa modo Clear Timer on Compare Match (2 en WGM0[2:0])
|
||||
sts TCCR0A, r21
|
||||
|
||||
; completa el modo WGM (waveform generaton mode, bit 2)
|
||||
; establece el tipo de reloj: 0b011 en CS0 es clk/64
|
||||
ldi r16, (0<<WGM02) | (0<<CS02) | (1<<CS01) | (1<<CS00)
|
||||
sts TCCR0B, r16
|
||||
|
||||
; el TOP es el valor en OCR0A
|
||||
; más pequeño es más agudo
|
||||
ldi r16, 0x06
|
||||
sts OCR0A, r16
|
||||
|
||||
;----------------------------------
|
||||
; configuración TIMER1 para alternar entre sonido on/off
|
||||
;----------------------------------
|
||||
; CS1 en 0b1010 es CK/512
|
||||
ldi r16, (1<<CS13) | (0<<CS12) | (1<<CS11) | (0<<CS10)
|
||||
sts TCCR1, r16
|
||||
|
||||
; establece el valor A al que cuenta el timer1 antes de apagar sonido
|
||||
; menor valor, menor tiempo de sonido (duty cycle)
|
||||
ldi r16, 0x30
|
||||
sts OCR1A, r16
|
||||
|
||||
; set Timer overflow interrupt enable 1
|
||||
; y timer output compare A interrupt enable 1
|
||||
ldi r16, (1<<TOIE1) | (1<<OCIE1A)
|
||||
sts TIMSK, r16
|
||||
|
||||
loop:
|
||||
sleep
|
||||
rjmp loop
|
||||
|
||||
timer1compareA_isr:
|
||||
; apaga la salida
|
||||
sts TCCR0A, r20
|
||||
reti
|
||||
|
||||
timer1overflow_isr:
|
||||
; enciende la salida
|
||||
sts TCCR0A, r21
|
||||
; regresa de la interrupción
|
||||
reti
|
||||
```
|
||||
|
||||
página actualizada en: sejmana-1660, día 1 (12021-05-20)
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
# coloring computers
|
||||
|
||||
non-electronic computers that work when you color them according to a simple set of rules.
|
||||
|
||||
an exploration of computation without electricity and semiconductors, an attempt to reinvent digital systems away from efficiency and productivity, and hopeful prototypes to expose the inner workings of computers.
|
||||
|
||||
# 4-bits to 7-segment display hexadecimal decoder (12020)
|
||||
|
||||
=> ./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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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 <output.mp4>
|
||||
```
|
||||
|
||||
# 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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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)
|
||||
|
|
@ -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" )
|
||||
}
|
||||
|
|
|
|||
|
|
@ -321,6 +321,7 @@ END{
|
|||
print "<p><a href='./index.html'>{" sitio "}</a></p>"
|
||||
print "<p>página actualizada en: "
|
||||
print "<time datetime='"fecha"'>" fechasjm "</time>"
|
||||
print " (1"fecha")"
|
||||
print "</p>"
|
||||
# fecha = system( "date -r " FILENAME " --rfc-3339=date" )
|
||||
# print "</p>"
|
||||
|
|
|
|||
Loading…
Reference in New Issue