Matricular estudiantes de un curso en otro curso

Cuando utilizamos Moodle, muchas veces tenemos que crear un curso donde van a participar todos los estudiantes de otro curso, o de varios cursos.

Por ejemplo:

  • necesitamos un curso con todos/as los/as estudiantes de todas las materias de una carrera.
  • hay un curso para realizar unas actividades y otro curso para otras actividades, con el mismo grupo de estudiantes pero en uno se suman docentes
  • existe un espacio donde se matricula al total de estudiantes de todos los cursos, para brindar información general o administrativa

¿Cómo se hace?

Primero hay que activar en el sitio el método de matriculación, en “Gestionar plugins de inscripción”, haciendo clic en el icono del ojo:

Después, hay que ir al curso de destino, y elegir en el menú “Usuarios” “Métodos de inscripción”, el método “Meta-enlace a curso”

Allí se elige el curso del cual se deben tomar los usuarios, y si se los va a añadir a un grupo.

De esta manera, si se agrega un usuario al curso de origen, se agrega automáticamente a este otro curso, con el mismo rol.

Cómo agregar un usuario a la lista de sudoers

Ya es la segunda vez que me pasa este mes, jaja! Es porque estuve instalando linux en varias computadoras: Voy a instalar algo y la terminal me responde que no tengo permisos para eso, es decir, mi usuario no está en la lista de sudoers.

Así que esta vez lo voy a anotar en este blog para futuras referencias.

Si tu usuario es root, el primer paso es ir a la terminal y poner:

su

Es decir, acceder al nivel de administrador.

Después, escribir:

visudo

Con este comando editamos el archivo /etc/sudoers

Allí buscamos el renglón que dice:

root ALL=(ALL) ALL

Lo copiamos debajo y ponemos el nombre del usuario al que queremos darle todos los permisos. Tiene que quedar así:

root ALL=(ALL) ALL
tunombre ALL=(ALL) ALL

Otros casos serían:

Linux, linux y linux

Hoy estuve todo el día divirtiéndome con… ¡Linux!

Como dejó de funcionar el disco de mi computadora de escritorio, empecé a poner en orden viejitas netbooks (y también una no tan viejita All in one) que me “tiraron por la cabeza” personas que ya no las querían.

Netbook con Huayra Linux, All in one con Ubuntu y netbook con Debia

Tres computadoras, tres distros de Linux

En la primer computadora, una All in One con un procesador i3, instalé un Ubuntu. Me sorprendió lo fácil que fue todo, incluso.. ¡detectó solo la impresora inalámbrica y ahora puedo imprimir por wifi! (antes no podía). La impresora es una Samsung m2020, es maravillosa <3

En la segunda, un compañero de trabajo me había instalado un Debian, pero yo no podía acceder con el usuario administrador, así que tuve que hacer una pequeña investigación para:

En la tercera compu, la menos potente, más antigua, quise probar Huayra. La verdad, funciona bien. La compu es lenta de por sí, pero para llevar y traer archivos, o acceder a un sitio web, está perfecta así.

Ya me bajé lubuntu para probarlo en esa compu, pero será otro día…

Intentos de hacer un robot bípedo

Con cuatro servomotores, un arduino Uno, una batería de 9v. y otros materiales (palitos de helado, pistola de silicona), estuve tratando de hacer un robot bípedo que camine. El armado es similar al de la mano robótica del post anterior.

Fui corrigiendo diferentes defectos, tanto de programación como de diseño

Después me concentré en que la robota Thelma llevara la placa arduino, la batería, la protoboard… era imposible con el diseño anterior. Así que todo cambió: patitas cortas (intenté varios modelos y finalmente me quedé con las patitas del servomotor) y cuerpo de tupper:

Manito robótica: controlar 4 servos en un Arduino Uno

Hace unos meses me compré cinco servomotores Tower Pro SG90 para hacer una manito. Recién tuve tiempo hoy de empezar a armar algo.

Cinco motores servo SG90

Si nunca usaste un servo, empezá por aprender a manejar un solo motor. Cada marca y modelo tiene diferentes colores de cables.

Atención: si lo conectás mal, el servo se quema. Yo ya quemé dos…

En el caso del Tower Pro SG90:

  • el cable naranja es de datos,
  • el rojo es positivo,
  • el marrón negativo.

Tenemos que conectar los cuatro servos a positivo, negativo (GND) y después el cable naranja de cada servo va a un pin PWM diferente.

Los pines PWM son los que tienen el símbolo ~

Fuentes de energía

Cuando usamos cuatro servos, es necesario agregar energía externa, ya que exigen más de lo que la placa Arduino puede darles. Yo conecté un portapilas de cada lado, y dos servos de cada lado:

Portapilas

  • Cable rojo al positivo, cable marrón al negativo.
  • Cable naranja de cada servo a un pin PWM diferente.

El código

Como siempre, comencé por abrir el archivo de ejemplo para manejar servos. Y después lo modifiqué.

Para poder pegar los motores con cinta de papel a una cajita, empecé con un programita que apunta los cuatro servos a la posición 0.

#include <Servo.h>

Servo myservo; // esto está en el programa de ejemplo, yo agregué los otros 
Servo myservo2;
Servo myservo3;
Servo myservo4;

void setup() {

myservo.attach(5); // un servo en cada pin
myservo2.attach(9);
myservo3.attach(10);
myservo4.attach(11);
}

void loop() {

myservo.write(0); // todos los servos van a la posición 0
myservo2.write(0);
myservo3.write(0);
myservo4.write(0);
delay(5000);}

apuntar los motores

Recién cuando pude poner los cuatro servos en la posición cero, los pegué en una cajita de cartón. Los dedos los hice con “limpiapipas” (alambre forrado, se usa en manualidades)

Ahora sólo queda programar el movimiento:

#include <Servo.h>

Servo myservo; // crear un objeto servo para cada motor
Servo myservo2;
Servo myservo3;
Servo myservo4;

void setup() {

myservo.attach(5); // declarar el pin en que se conecta cada servo
myservo2.attach(9);
myservo3.attach(10);
myservo4.attach(11);
}

void loop() {

myservo.write(0); // pongo todos los dedos en 0
myservo2.write(0);
myservo3.write(0);
myservo4.write(0);
delay(5000); // espero cinco segundos
myservo.write(90); // pongo todos los dedos en 90º
myservo2.write(90);
myservo3.write(90);
myservo4.write(90);
delay(1500); // espero un segundo y medio
myservo.write(180); // pongo todos los servos en 180º
myservo2.write(180);
myservo3.write(180);
myservo4.write(180);
delay(1500); // espero un segundo y medio

}

Este es el primer resultado:

En un segundo intento utilicé palitos de helado. Y armé una estructura de tres dedos, dos de ellos con una articulación (ahora con cinco servos).

Como los pares de pilas anteriores parecían insuficientes, ahora puse todos los motores en la misma fila y le conecté una batería de 9v.

conexionesBateria de 9v conectada a los servos

El resultado me gusta más que en la prueba anterior:

Acá con unos movimientos más suaves (usando bucles for para cada movimiento):

 

Arduino desde cero. Parte 2.

En la entrada anterior, expliqué cómo descargar el IDE de Arduino (“Integrated Development Environment”, es decir “Entorno de Desarrollo Integrado”). Después conectamos la placa Arduino y descargamos un ejemplo que hace titilar una luz led que está integrada a la placa.

Ahora vamos a empezar a entender un poco del programa que descargamos. Vemos tres secciones:

  • La primera parte, que se ve toda de color gris comienza con /* y termina con */. Todo eso se llama “comentarios”, y es un texto en inglés que explica de qué se trata el programa. Lo podemos eliminar para aclarar el panorama.

Todo lo que figure entre /* y */ va a ser ignorado por Arduino, así que podemos escribir algo allí que no va a influir en nada:

/* Eliminamos los comentarios en inglés pero podemos escribir algo en castellano */

Otra forma de escribir comentarios es comenzar con doble barra:

// Esto es un comentario, sirve para poner anotaciones para uno mismo

  • Después viene un segundo bloque que comienza con “void setup()”. Todo lo que figura entre llaves { } dentro de “void setup()”, son órdenes que se van a ejecutar una sola vez al comienzo del programa. En este caso hay dos renglones. Un comentario en inglés, que lo eliminamos, y una orden que es “PinMode”. En un rato la analizamos.

void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}

  • Por último el bloque “void loop()”. Todo lo que viene entre llaves después de “void loop()” se ejecutará en bucle, una y otra vez, hasta que desenchufemos el Arduino.

void loop() {
digitalWrite(LED_BUILTIN, HIGH);
delay(1000);
digitalWrite(LED_BUILTIN, LOW);
delay(100);
}

digitalWrite(LED_BUILTIN, HIGH); Encender el led integrado a la placa (“led built-in”). La orden significa “escribir en un pin digital el valor 1”. Un pin digital puede valer 1 o 0. O lo que es lo mismo, “high” o “low” (“encendido” o “apagado”).
delay(1000); Esperar un segundo (mil milisegundos)
digitalWrite(LED_BUILTIN, LOW); Apagar el led “built-in”
delay(1000); Esperar un segundo (mil milisegundos)

Entonces, vamos a hacer unos cambios al programa para entenderlo más.

Donde dice:

delay(1000)

Vamos a poner otros números:

delay(500)

delay(2000)

Y cada vez que hacemos un cambio, probamos usar el botón “subir” para pasar ese programa a la placa. Recordemos que hay dos “delay”. El primero es el tiempo que espera el led estando encendido, y el segundo el tiempo que espera apagado.

Conectando un led

Ahora vamos a conectar un led, dejando de utilizar el “built-in”.

Antes de hacer cualquier conexión, desenchufamos la placa (siempre).

Cada led (“diodo emisor de luz”) tiene una pata más larga y una más corta. La pata más larga se llama “ánodo” y es la positiva. La pata corta “cátodo” y es la pata negativa.

Como primer experimento, vamos a conectar el LED en el pin 13. Es decir, la pata larga del LED en el pin 13, y la pata corta en “tierra” (GND, “ground”).

Led conectado en el pin 13Aclaración importantísima: el pin 13 es el único que tiene resistencia propia. En todos los demás pines no podemos conectar un led directamente porque se quema.

Si volvemos a conectar la placa (que ya tiene cargado el programa anterior) vamos a ver que el led que conectamos en el pin 13 titila igual que el led integrado a la placa (built-in). Esto es porque el led built-in y el pin 13 están interconectados.

Utilización de un led en otro pin

Para conectar un led en cualquier otro pin digital (los que están numerados y no comienzan con A), por ejemplo el pin número 8, deberíamos agregar una resistencia. ¿Por qué? Porque la resistencia impide que el LED reciba más electricidad de la que puede soportar. Se usa para que el componente no se queme.

Por lo tanto, deberíamos hacer algo como esto (los negros son cables):

Led y resistencia

Pero claro, sería muy incómodo realizar estas soldaduras y que después no funcione el circuito. Entonces, en lugar de soldar, utilizamos una placa de pruebas.

Entendiendo la protoboard

La protoboard es la placa de pruebas que viene generalmente acompañando a la placa Arduino. Se trata de una superficie con agujeritos donde podemos ver unos números, un signo + y un signo –

¿Para qué sirve? Para poder hacer circuitos de prueba, sin necesidad de soldar las conecciones.

Para entender cómo se usa, hay que saber que los agujeritos están conectados entre sí. Pero no todos con todos:

  • Las dos filas que tienen el signo + y el signo – tienen todos sus agujeritos conectados entre sí.
  • Las columnitas que están numeradas, tienen cinco agujeritos interconectados.

Entonces, para repetir el esquema anterior tenemos que conectar:

  • La pata larga del LED en la misma columnita que el cable que se conecta al pin número 8
  • La pata corta del LED en la misma columnita que una pata de la resistencia
  • La otra pata de la resistencia en la misma columnita que el cable que lleva a GND (cualquier GND, ya que todos son iguales).

Conectar un led mediante la protoboard

Es decir, no importa en qué columnita conectamos cada cosa, lo importante es que estén en la misma columna las cosas que deben ir interconectadas. Aquí lo muestro con líneas rojas:

Conexiones del led en la protoboard

El programa

Hasta ahora teníamos un programa que encendía y apagaba el led conectado en el pin 13, y el led “built-in” a la vez. Ahora lo vamos a modificar para que encienda y apague el led conectado en el pin digital número 8. Para eso, cada vez que dice “led_builtin”, lo cambiamos por el número 8:

void setup() {
    pinMode(8, OUTPUT);
}

void loop() {
digitalWrite(8, HIGH);
delay(1000);
digitalWrite(8, LOW);
delay(100);
}

Lo descargamos (con el botón “subir”) y… ¡Listo! El led conectado en el pin número 8 está titilando.

PinMode

Algo que quedó “para después”, fue el comando “pinMode” que está en void setup():

void setup() {
pinMode(8, OUTPUT);
}

Esa línea de código lo que le indica al Arduino es que determinado pin va a estar en modo salida (“output”). En este caso sería el pin número 8, va a salir información (encender o apagar el led).

Si tuviésemos un botón conectado en ese pin, le diríamos que será un pin de entrada (“input”).

 

Arduino desde cero (y sin teoría). Parte 1.

Cada vez que algún amigo, amiga o amigue comienza a usar Arduino yo me pongo a buscar tutoriales que vayan directo a la parte práctica, dejando para después la teoría. Creo fervientemente que la teoría viene como respuesta al “¿Por qué es así?”, después de lograr algo a nivel práctico. Como no encuentro un tutorial así, decidí escribir el mío propio. Aquí va.

Primer paso: descargar el software

El software se descarga de este enlace: https://www.arduino.cc/en/Main/Software .

Descargar software para Windows o para Linux

Te va a ofrecer la posibilidad de colaborar con unos dólares, o de descargar el software gratis (“Just download”, es decir, “sólo descargar”)

Just Download

Una vez descargado el instalador, hay que ejecutarlo.

Segundo paso: conectar la placa

La placa Arduino Uno tiene un conector similar al de las impresoras (“USB tipo A/B”). Simplemente conectamos el USB tipo A (el plano) a la computadora, y el más cuadradito (tipo B), al Arduino. Si todo sale bien, deben encenderse algunas luces.

Conector USB tipo B

Tercer paso: usar un programa de ejemplo para ver cómo titila un led

Ahora que nuestro Arduino está conectado, vamos a abrir un programa de ejemplo que hará titilar el led “Built-in”, es decir, una luz que está incorporada a la placa.

Para ello vamos al menú Archivo / Ejemplos / Básicos / Blink

Abrir ejemplo titilar led

Ahora el programa está en la computadora, pero no en la placa Arduino. Para que el programa pase de la computadora a la placa, hay que pulsar el botón “Subir” (que para mí debería llamarse “descargar”, pero bue…)

Descargar programa a la placa

Si esto da error, es porque hay que elegir la placa y el puerto en el menú Herramientas. La placa probablemente sea “Arduino Uno” (lo dice en la placa), y el puerto -si usás Windows- puede ser “Com 1” (en mi captura se ve un nombre diferente porque uso Linux):

Elegir la placa y el puerto

Lo que debe ocurrir ahora, al volver a “subir” el programa, es que la luz que tiene la placa comience a titilar, manteniéndose encendida por un segundo y apagada por un segundo.

Próxima práctica de Arduino: utilizar un led y la protoboard.

Para leer más sobre qué es Arduino, Hardware Libre, Software libre, recomiendo este post de Xataca.

¡Felices fiestas! Con cuatro matrices MAX7219CNG

¿Qué se necesita para hacer este cartel?

  • Cuatro matrices led MAX7219CNG 
  • Una placa Arduino Uno
  • Una protoboard
  • Muchos cables

Matrices led

Estas matrices tienen la posibilidad de conectarse “en cadena”. En la parte de arriba tiene cuatro conectores, y debajo otros cuatro.

Los conectores de la parte superior y los de la parte inferior son equivalentes, exceptuando el que se utiliza para conectar unos con otros:

  • DIN / entrada de datos
  • DOUT / salida de datos

Ahora, las conexiones para utilizar este código van de la siguiente manera:

  • Todos los VCC se conectan al pin 5v del Arduino UNO
  • Todos los GND se conectan a tierra, a uno de los pines GND del Arduino UNO
  • Todos los CS van al pin 10 del Arduino
  • Todos los CLK van al pin 11 del Arduino
  • Los pines DIN y DOUT se conectan en cadena de la siguiente manera:

Conexiones pin de datos

 

El código lo tomé de este enlace, es el último, funciona perfecto: http://kio4.com/arduino/15bmatriz8x8.htm

Regalar un kit de robótica Arduino para estas fiestas

Si hay un regalo maravilloso para que hagamos en las fiestas, es uno que permita el crecimiento de la otra persona, y no un consumo de objetos caros donde no hay posibilidad de crear.

Una de las mejores cosas que podemos regalar, entonces, es un kit de robótica: una hermosa cajita llena de elementos para explorar, uno a uno, creando cientos de proyectos.

¿Cómo comprar un kit de robótica?

La primer pregunta que yo haría es “cuánto dinero podés gastar”, o “qué es lo que más te interesa hacer con el kit”.

Como hay tantas posibilidades, voy a describir algunos componentes diferentes, más o menos por orden de precio y/o dificultad. Por supuesto, me concentro en kits Arduino, que son de hardware libre y software libre

Un kit super básico, consistiría en:

  • Una placa Arduino Uno
  • Una protoboard
  • Leds (una bolsita)
  • Resistencias (una bolsita o dos de distintas capacidades)
  • Pulsadores (botones de encendido)
  • Cables (macho-macho y hembra-hembra, los que son flexibles, porque hay unos rígidos que son incómodos de usar)
  • Un servo motor de 9v
  • Un buzzer
  • Un sensor de distancia

¿Qué se puede hacer con este kit? Un semáforo, algunos proyectos con luces y sonido, una barrera de tren que se abra al detectar algo con el sensor de distancia, programar un jueguito simple, un theremin rústico, etc.

Un kit de precio medio, podría consistir en todo lo anterior más algunas de estas cosas, dependiendo de lo que uno tenga ganas de hacer:

Y ya para empezar con algo de domótica:

  • Relé, para encender y apagar artefactos de 220 volts (una lámpara, o cualquier aparato) – dificultad bastante alta y sobre todo peligroso para chicos
  • Módulo Bluetooth (para manejar cosas desde el celular)
  • Módulo Ethernet para conectar a Internet lo que armemos.

Si tenemos realmente mucho dinero, podemos comprar todo lo anterior, y agregar un set de sensores de los que venden en la web, los hay de variadas combinaciones pero no puedo recomendar ninguno porque no tuve la suerte de poder comprarme uno…

¡Felices fiestas!

Beta Weblog cumple 14 años!

El 29 de noviembre de 2004, se inauguraba BETA Weblog como blog colectivo. Catorce años bloggeando… es una cifra, ¿no?*

Ya tengo que ir planificando la fiesta de quince de mi blog, pero mientras tanto, festejo estrenando mis cuatro matrices de led MAX7219CNG:

*Me estoy citando a mí misma, cuando en el cumpleaños número cinco puse lo mismo y me parecía mucho…

¿Cómo se conectan y se programan colecciones de matrices? Acá hay un tutorial de Prometec sumamente completo.