The Kills

Compuesta por Alison Mosshart (Americana) y Jamie Hince (Británico) es un dúo de indie rock / garage rock que hace un poco de trampa porque tiene un tercer miembro: una caja de ritmos, pero lejos de ser una desventaja, ésto les da un toque de repetitividad y simplicidad muy especial a sus canciones. La verdad durante las últimas semanas únicamente los he estado escuchando a ellos, porque simplemente después de escuchar a The Kills las demás bandas parecen malísimas, lo que no es para nada cierto, pero es el efecto que provoca The Kills.  Mi rola recomendada es: ¡TODAS! jaja, bueno esta: Sour Cherry.

Blood Red Shoes

Este si es un dúo sin trampas :) formado por Steven Ansell y Laura-Mary Carter, ambos de Inglaterra y tocan algo como indie rock / alternative rock. Es increíble como sólo dos personas pueden llegar a hacer tan buena música con sólo batería y guitarra. Mi rola recomendada es: HeartSink.

Yo la verdad nunca pensé que una banda pudiera llegar a sonar bien sin bajo, sin embargo ya tengo dos pruebas bastante buenas de que eso no es cierto.

En este juego tú eres un simple pixel que se desplaza únicamente lateralmente y que puede disparar. El objetivo es evitar que ‘el enemigo’ llegue hasta donde estás tú. Cada vez que matas al enemigo éste reaparece más enojado y con mayor velocidad, así que en realidad no puedes ganar, sólo se trata de sobrevivir por el mayor tiempo posible.

Lo que se necesita

• Arduino
• LCD 16×2 Hitachi HD44780 compatible (es decir, la más común)
• 2 Potenciómetros (cualquier tamaño está bien)
• 1 Pushbutton
• 1 Resistencia de 10 Kohms
• 1 Resistencia de 100 ohms

El diagrama

En la foto hay dos pushbuttons por otro programa que estaba haciendo antes, sólo es necesario uno. El segundo potenciómetro (el de abajo) es el que ajusta el contraste del LCD.

El código

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167

/*
  __DOTSHIP__
  "The adventure of a dot-shaped ship versus the thing-shaped 
  immortal enemy"
 
  A simple Arduino game that uses a common 16x2 LCD (Hitachi 
  HD44780 compatible) and a potentiometer and a pushbutton as 
  a controller.
 
  You can find the LCD wiring here: 
  http://arduino.cc/en/Tutorial/LiquidCrystal
    - RS to 12
    - Enable to 11
    - Data pins to 5, 4, 3, 2
    - R/W to GND
 
  also you will need a:
  * Potentiometer: 
    - end pins to +5v and GND
    - middle pin to A0 pin
  * Pushbutton:
    - attached to pin 8 from +5V
    - 10K resistor attached to pin 8 from ground
 
  More details: http://thebatzuk.org/2011/09/dotship-juego-en-
  arduino-lcd-pot-pushbutton.html
 
  11 Sep 2011
  by Raúl Rivas (thebatzuk)   <--------\
                                        \  
  You can use, copy and modify           \
  this code but do not remove this  line -\
*/
 
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
 
unsigned long time = 0;
boolean game = true;
unsigned int score = 0;
 
// potentiometer and button pins
int pot_pin = 0;
int bttn_pin = 8;
int bttn_val = 0;
int bttn_last = 0;
 
// ship variables 
int ship_px = 0;
int ship_y = 0;
 
// shoots variables
boolean shot = false;
int shoot_time = 0;
byte shot_pos[5] = {B00001, B00010, B00100, B01000, B10000};
int shoot_x = 14;
int shoot_y = 0;
int shoot_px = 0;
int mi = 0;
 
// enemies variables
byte enemies[8] = {B00000, B00110, B00001, B01111, B01111, 
                   B00001, B00110, B00000};
int enemy_y = 0;
int enemy_x = 0;
int enemy_vel = 100;
int vel_increment = 20;
 
void setup() 
{
  lcd.begin(16, 2);
  lcd.createChar(2, enemies);
  randomSeed(analogRead(1));
}
 
void loop() 
{
  if(game)
  {
    time++;
    // ship stuff
    byte ship[8] = {B00000, B00000, B00000, B00000, B00000, 
                    B00000, B00000, B00000};
    ship_px = map(analogRead(pot_pin), 0, 1023, 0, 16);
    if(ship_px >= 0 && ship_px <= 7)
      ship_y = 0;
    else if(ship_px >= 8 && ship_px <= 15)
      ship_y = 1; 
    ship[ship_px - ship_y * 8] = B10000;
    lcd.createChar(0, ship);
    lcd.setCursor(15, ship_y);
    lcd.write(0);
 
    // shoots stuff
    byte shoot[8] = {B00000, B00000, B00000, B00000, B00000, 
                     B00000, B00000, B00000};
    bttn_val = digitalRead(bttn_pin);
    if(bttn_val != bttn_last && bttn_val == HIGH && !shot)
    {
      shot = true;
      shoot_time = 0;
      mi = 0;
      shoot_px = ship_px - ship_y * 8;
      shoot_y = ship_y;
    }
    if(shot)
    {
      for(int i = 0; i < 15; i++)
      {
        if(shoot_time >= mi && shoot_time <= mi+4)
        {
          shoot_x = 14 - (mi / 5);
          mi += 5;
          if(shoot_x == 0)
            shot = false;
          break;
        }
      }
      shoot[shoot_px] = shot_pos[shoot_time - (14 - shoot_x) * 5];
      lcd.createChar(1, shoot);
      lcd.setCursor(shoot_x, shoot_y);
      lcd.write(1);
      shoot_time++;
    }
 
    // enemies stuff
    if(time % enemy_vel == 0)
    {
      enemy_x++;
      enemy_y = random(0, 2);
    }
    lcd.setCursor(enemy_x, enemy_y);
    lcd.write(2);
    // enemy got shot:
    if(shoot_y == enemy_y && shoot_x == enemy_x && 
       shoot_px > 0 && shoot_px < 7)
    {
      score += 10 * enemy_x;
      enemy_x = 0;
      enemy_vel -= vel_increment;
      vel_increment -= 5;
      if(enemy_vel <= 0)
        enemy_vel = 2;
      if(vel_increment <= 0)
        vel_increment = 5;
      shot = false;
      shoot_x = 14;
      delay(25);
    }
    else if(enemy_x > 14)
      game = false;
 
    // other stuff
    delay(15);
    lcd.clear();
    bttn_last = bttn_val;
  }
  else
  { 
    lcd.setCursor(0, 0); 
    lcd.print("Game Over.");
    lcd.setCursor(0, 1); 
    lcd.print("Score: ");
    lcd.print(score);
    // reset Arduino to play again
  }
}

También puedes encontrar el código aquí: Dotship, an Arduino Game (LCD, Pot and Pushbutton)

La función de las LCD es mostrar caracteres (a-z, 0-9), sin embargo cada segmento tiene pixeles individuales que puede ser ‘explotados’ para hacer este tipo de juegos. La función lcd.createChar() te permite crear caracteres extras a los que admite la pantalla LCD, por medio de una matriz puedes decidir cual pixel se enciende y cual no. Además éstos caracteres especiales pueden ser creados dinámicamente, por lo que las posibilidades son bastante amplias.

Eso es todo, espero y alguien lo pruebe en su arduino y nos cuente que tal está.

Bueno, bueno, escribiré un poco más. Tumblr es un servicio para bloggear, tiene todas las herramientas básicas que un blogger necesita, sin embargo tiene un enfoque de red social: puedes seguir a personas y otras personas te pueden seguir. Cuando sigues a alguien todas sus publicaciones te llegan a tu dashboard, por lo tanto (si sigues a las personas indicadas) tu dashboard se convierte en un feed muy interesante.

La mejor herramienta de Tumblr es el botón reblog. Mientras que en este tipo de blogs ‘normales’ el reblog se considera como robar un post, en Tumblr es algo que todo mundo hace y es bien recibido. Claro que hay gente que crea el contenido, pero muchas otras personas (yo incluido) sólo nos dedicamos a rebloggear lo que sea que nos pegue la gana.

Así que si tienen Tumblr pueden seguirme aquí: thebatzuk.tumblr.com o si no pueden ver porqué vas a amar Tumblr.

Por ejemplo, mucha gente se enojó con el fin de Lost (la serie esa) porque dejó sin explicar muchísimas cosas. Pero todos los misterios de la isla (y los mismo escritores lo dijeron) eran sólo estrategias para tener enganchado al público, en realidad la serie trata de la vida personal (pasada, presente y hasta futura) de un puñado de personas que coincidieron en estar en un accidente de avión.

Pero bueno, el asunto es que (yo pienso) que los escritores se han estado fijando que a mucha gente simplemente no le gusta la fantasía, y para darles gusto han creado a los nuevos héroes, que simplemente son personas con alguna habilidad fuera de lo común pero sin salirse de la realidad. Ejemplos hay muchos:

• Lie to me. En esta serie el Dr. Cal Lightman tiene el ‘superpoder’ de reconocer microexpresiones faciales e interpretar el lenguaje corporal para detectar si una persona está mintiendo.
• Numb3rs. Charlie Eppes es un genio matemático que ayuda al FBI a resolver crímenes usando modelos matemáticos y demás cosas matemáticas.
• The Mentalist. Patrick Jane era un estafador que fingía ser psíquico y médium, sin embargo tiene la capacidad de analizar psicológicamente a las personas y es excelente para deducir (por eso era buen estafador). Por ciertas razones ahora trabaja como consultor resolviendo crímenes para el CBI.

Son exactamente como nuestros superhéroes de siempre pero sin trajes ridículos ni poderes increíbles. ¿A ustedes les gustan este tipo de héroes o prefieren los superhéroes?

¡BB King y Gary Moore juntos! ¡Tocando! ¡TOCANDO! *se desmaya de la emoción*

Xavier Rudd es un multi-instrumentalista y cantautor de algo que puede llegar a describirse como indie folk rock, que en mi opinión suena genial.

Esa fue Fortune Teller del álbum Food in the Belly, sin embargo mi rola recomendada es Food in the Belly, de la cual no hallé un buen video en vivo.

Y bueno, aquí es donde pondría un link a su página oficial, pero parece que está caída…

This post was translated by a not-so-clever bunch of trained parrots, sorry for the possible mistakes.
Original: Arduino, potenciómetro, puerto serial y C# (2)

- – - – - ! – - – - – - – - – - – - – - – - – - – - – - – - ! – - – - –

In the previous post on arduino we made a simple ASCII bar in a console window moved by a potentiometer. But now I realized that if instead of putting one potentiometer we put two potentiometers, we can do something like one of those toys to draw, where two knobs control a small magnet to make shapes on your screen (Etch A Sketch).

It’s a bit dark but you can reach to appreciate the delicate curves created by my surgeon-like pulse.

The idea

In our arduino we connected two knobs and a button for sensing. The arduino sends the data by serial port. Our C# program receives and manipulates the data for the potentiometers to represent a coordinate in the console window and pressing the button to clear the screen.

What is needed?

• Arduino (and its USB cable and IDE of course)
• Two potentiometers (any size is good)
• A pushbutton
• A resistor (10 kilo-ohms to below)
• A computer
• Visual C# 2010 Express . It’s for PC, is free and you can download it from the link I just put on.

The circuit

The problem

The problem we have here is that we have to send some diferent data by the serial port (values ​​of the potentiometers and the state of the button) and take them into the correct variables. What can we do for not mix them?

What I came up with (I don’t know if this is the best way to do it) is to put an identifier to each value you want to read. So:

1. In C# program we send a key to tell Arduino what data we want to receive.
2. Arduino program receives the key, so the right value is read and sent back.
3. C# program receives and stores the value in some variable.

This is done once for a pot and stored in a variable x, then for the other pot and saved in y, and then for the button and stored in b. Taking these two values ​​we move to the point (x, y) of the console and then print a character there. Putting this into an infinite loop have our Etch A Sketch :D

Programs

Arduino:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

int potx = A0;
int potvalx = 0;
int poty = A1;
int potvaly = 0;
int bttn = 2;
int bval = 0;
 
void setup()
{
  Serial.begin(9600);
}
 
void loop()
{
  if(Serial.available() > 0)
  {
    int in = Serial.read();
    if(in == 'x')
    {
      potvalx = analogRead(potx);
      Serial.println(potvalx);
      delay(10);
      in = 0;
    }
    if(in == 'y')
    {
      potvaly = analogRead(poty);
      Serial.println(potvaly);
      delay(10);
      in = 0;
    }
    if(in == 'b')
    {
      bval = digitalRead(bttn);
      Serial.println(bval);
      delay(10);
      in = 0;
    }
  }
}

Basically it read the value (line 17) that our C# program sends and then compares it to know what information you are requesting. As the case is, it read the value and sends it by serial port.

For C #:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

using System;
using System.IO.Ports;
 
namespace EtchaSketch
{
    class Program
    {
        static void Main(string[] args)
        {
            SerialPort port = new SerialPort("COM6", 9600);
            port.Open();
            if (port.IsOpen)
            {
                while (true)
                {
                    // Leer potenciómetro 1: coordenada x
                    port.Write("x");
                    string t = port.ReadLine();
                    int x = int.Parse(t);
                    x = map(x, 0, 79);
 
                    // Leer potenciómetro 2: coordenada y
                    port.Write("y");
                    t = port.ReadLine();
                    int y = int.Parse(t);
                    y = map(y, 0, 23);
 
                    // Leer botón: borrar
                    port.Write("b");
                    t = port.ReadLine();
                    int b = int.Parse(t);
 
                    // Si el botón se oprime, borrar
                    if (b == 1)
                        Console.Clear();
 
                    // Ir a la coordenada leída y dibujar
                    Console.SetCursorPosition(x, y);
                    Console.Write(".");
                }
            }
            port.Close();
        }
        static int map(int value, int start, int end)
        {
            return value * (end - start) / 1023 + start;
        }
    }
}

Within the infinite loop: first the arduino sends the key to know what value we need, then gets that value, it’s transformed into an int (integer) and then it’s mapped. All analog values ​​read by arduino are in a range from 0 to 1023. As our console is 80 × 24 characters, we have to transform the values ​​of the potentiometers on that scale, that is what the map function do.

In last post’s program we map the values ​​in the Arduino program, but I think is a better idea to map them in the C# program so we can use the same Arduino’s program for various purposes.

The button serves to clear the screen, constantly being read its value: when isn’t oppressed its value is zero, when oppressed is 1; so, when b is 1 we call the Console.Clear() function and go.

¡Casi 4 horas! ¡1226 muertes! No es para nada bueno, pero pues hay se va. 

Claro que lo obvio en estos días es comprarlo vía Humble Bundle o si se les pasaron los días pueden conseguirlo en su página thelettervsixtim.es o si no, pues ya saben que existe Taringa.

Muy buen juego. Recomendado.

Dato: No se si sea la verdadera razón del nombre del juego, pero los nombres de los personajes son: Viridian, Violet, Victoria, Vermillion, Vitellary y Verdigris; o tal vez el nombre solo sea una representación del principal enemigo del juego: los picos vvvvvv.

Ya siendo mas específicos les quiero hablar de The Humble Indie Bundle, es una iniciativa en la que podemos comprar al precio que queramos un paquete de 5 videojuegos indie. ¿O sea que puedo pagar $1USD por algo que me costaría $50? Sí y hasta menos (pero tampoco hay que ser tan codos). Después de elegir la cantidad que quieres pagar puedes elegir cómo quieres que se reparta tu dinero entre los desarrolladores, la EFF?, los promotores y la caridad. Es la tercera vez que se hace, así que debe de tener bastante éxito.

Esta promoción sólo dura 15 días, de los cuales sólo quedan ocho. Y hasta el momento han vendido alrededor de 195 mil bundles y recaudado ¡más de 900 mil dólares!

Los juegos son multiplataforma y una vez que haces la compra obtienes un link desde donde puedes bajarlos sin ninguna prisa (el link no caduca ni nada). Los juegos no tiene DRM, lo cual significa básicamente que los puedes instalar en todas tus computadoras sin problema; están completos, sin publicidad, perfectos. Los juegos son: Crayon Physics Deluxe, Cogs, VVVVVV, Hammerfight y And Yet It Moves.

El primero que bajé fue VVVVVV (supongo que me llamó la atención el nombre) y (después de haber jugado todos) creo que es el más adictivo. Es un juego de plataformas con estilo visual muy muy retro en dos dimensiones; te mueves a la izquierda, te mueves a la derecha, pero al intentar moverte hacia arriba te das cuenta que no brincas, sino que vuelas directo hacia el techo y empiezas a caminar sobre él, te mueves hacia abajo y todo normal otra vez. Aquí un Gameplay por si no me expliqué XD Te acostumbras muy fácil a esa forma de movimiento y el juego es en general bastante rápido, aunque hay algunas partes que son un verdadero dolor de cabeza pero que cuando al fin las logras pasar no te puedes evitar soltar un Fuck Yeah! Ah y la música es excelente.

El juego que más me sorprendió fue Crayon Physics Deluxe, después de iniciarlo y ver la interfaz tan infantil no tuve otra reacción mas que WTF!?, pero después de 2 minutos estoy seguro que fuí el ser humano más sorprendido y emocionado en al menos 24km a la redonda, creo que no despegué mis ojos de la pantalla como por dos horas. El objetivo del juego es hacer llegar una pequeña pelota a un lugar marcado con una estrella, para lograr eso se necesitan hacer dibujos, los dibujos adquieren propiedades físicas después de haberlos terminado; si dibujas un circulo en medio del aire éste va a caer como su fuera una piedra y, dependiendo del tamaño, con mayor o menor intensidad. Puedes dibujar simples rocas y cajas, pernos, pédulos, poleas, cuerdas, puentes. Les dejo el trailer del juego y recuerden que no se trata de encontrar una solución, se trata de encontrar la más asombrosa de todas.

Cogs es un juego de puzzles donde tienes que acomodar engranes, tuberías y demás objetos para hacer que una máquina funcione. Son 50 niveles e incluso los primeros tres ya te ponen a pensar. Definitivamente muy entretenido y nos sirve para hacer algo de ejercicio mental que nunca está demás. El trailer.

Hammerfight no lo pude jugar decentemente porque se supone que tú eres un helicoptercillo con una piedra colgando y tienes que hacer girar la piedra alrededor de tí para golpear a tus enemigos, lo cual requiere un movimiento bastante pronunciado del ratón y como yo no tengo ratón pues… pero se ve muy bien.

No se si sería porque lo jugué estando cansado o que, pero And Yet It Moves me hartó muy pronto. Es un juego de plataformas en dos dimensiones con un aspecto visual que nunca había visto (parece hecho de papel y cartón). El chiste es que con WASD mueves al personaje y con las flechas mueves el mundo alrededor de tí. Como se desarrolla dentro de una cueva no tardas en matarte a tí mismo porque pusiste un montón de piedras justo sobre tu cabeza jeje. Pero bueno, tal vez estaba cansado o tal vez fue la falta de historia (sólo apareces ahí sin más explicación y sin otra cosa que hacer mas que avanzar) o la música de tensión, pero cerré muy pronto este juego. El trailer.

Y bueno pues no hubiera hecho este post si no les quisiera recomendar que compraran el Humble Bundle ¿verdad? así que si pueden vayan y donen aunque sea un dólar y apoyen a los desarrolladores independientes, los juegos de verdad valen más que eso.

The Black Angels

Es una banda americana de Psychedelic Rock. Antes de conocer esta banda me imaginaba el rock psicodélico como ese sonido setentero como un exceso de órgano electrónico con ese extraño sonido como si se escuchara a través de un tubo. Pero no, el rock psicodélico trata de emular la sensación de estar drogado con LSD o al menos fueron escritas usando LSD o hablan del LSD o algo así.

Pero bueno su álbum Directions to See a Ghost de verdad, como su nombre lo dice, te transporta a otros lugares. Su ritmo repetitivo mas bien lento, la voz relajada (y relajante), los cambios de intensidad, todo eso hace que te vayas metiendo dentro de las canciones. Definitivamente un muy álbum para escuchar de principio a fin.

La rola recomendada es Science Killer. Es genial como se empieza con una línea de bajo y a partir de ahí se construye todo, y la línea se repite prácticamente durante toda la canción.

• The Black Angels Official Site
• The Black Angels Last.fm