La Cofradía Digital

¿Y el histórico del CONSOL?

vicm3 — Tue, 14 May 2013 17:32:43 +0000

Recién me preguntaron por un archivo que puse en línea, que es el disco de 2005 del CONSOL, el cual contiene una versión estática del sitio de 2002 a 2005 incluyendo las ponencias [1] de hecho yo mismo no hice el trabajo de pasar wget por consol.org.mx porque daba por sentado que la mayor parte del contenido estaría en archive.org en caso de que fallara la página o que de plano podría dirigirme a 2009/ y encontrar el sitio anterior, como decía anteriormente me preguntaron por el programa de conferencias de 2009 y resulta que no esta en 2009/ y peor aún el robots.txt de consol.org.mx bloquea a archive.org por lo que no se puede acceder por esa vía.

He escrito a comite arroba consol.org.mx, consol arroba consol.org.mx y a un par más de alias pero no he recibido respuesta, el whois del dominio me deja más dudas, pero como se que a mas de uno le interesa mejor pongo la pregunta por acá, ¿como podemos acceder a las ponencias de 2006-2009? y demás material. Parece preocupante que tenga uno que andar buscando en el histórico de la lista (o al menos de lo que esta archivado), o entre los blogs referencias a las ponencias, para ver si por ahí anda perdido el material de la ponencia o como en el caso de algunos, que no se pueda colocar el URL para ponerlo en el ridiculum o en los reportes de trabajo.

[1] http://ociologia.org/consol/

Asterisk y Open Hardware para controlar dispositivos desde un teléfono

El Pop — Mon, 13 May 2013 06:46:29 +0000

Pues jugando un poco con Arduino y Asterisk, se me ocurrió hacer una interface entre estos dos para activar luces, puertas, etc. utilizando una extensión telefónica.

http://www.youtube.com/watch?v=rcFMJC4n4dQ

También hice un sistema de sockets para que desde una página web se pudieran activar estos eventos.

Tablero con control de relay’s, Arduino UNO y un Raspberry Pi corriendo Asterisk

Primero conseguí un control de relays para 8 canales. Este lo compré en BuyInCoins.com. Costó aproximadamente $8.00 USD

Despues compré un Arduino UNO en 330 Ohms en unos $30.00 USD. Pueden comprar la versión china en BuyInCoins.com en $13.00 USD

Para utilizar Asterisk use un Raspberry Pi que compré en newark por $50.00 USD.

Más una tabla, cable, tornillos, sockets y contactos por unos $35.00 USD. Agregen a esto un adaptador WiFi EnGenius en otros $30.00 y una fuente de poder con salida USB para el Raspberry en $18 USD. En total unos $171.00 USD, mas el tiempo invertido en programación.

El armado de todo se ve así:

El controlador de relay’s se conecta con un cable plano al arduino uno, este a su vez se conecta con un cable USB al raspberry Pi, el cual se alimenta con una fuente USB y se monta un modem WiFi de EnGenius para su control.

Use en la Raspberry Pi una distribusión de Linux para ARM, basada en Debian Wheezy, que incorpora Asterisk 11 en www.raspberry-asterisk.org/.

Escribí el siguiente Sketch para Arduino para el control de relay’s:

/*
#===================================================================#
# Program => relay.ino (Arduino Sketch)                 version 1.0 #
#===================================================================#
# Autor         => Fernando "El Pop" Romo        (pop@cofradia.org) #
# Creation date => 11/may/2013                                      #
#-------------------------------------------------------------------#
# Info => This program control relays to turn on|off electric       #
#         circuits.                                                 #
#         Use Digital Pins 4 to 11 of Arduino UNO R3 and take the   #
#         commands from the USB.                                    #
#-------------------------------------------------------------------#
# This code are released under the GPL 3.0 License. Any change must #
# be report to the author                                           #
#                  (c) 2013 - Fernando Romo                         #
#-------------------------------------------------------------------#
*/
 
/* Init the board on Power On or serial connection */
void setup() {
   // initialize serial:
   Serial.begin(57600);
   // make the pins outputs:
   for (int i = 4; i <= 11; i++){
       pinMode(i, OUTPUT);
       // Turn off the signals to relays
       digitalWrite(i, HIGH);
   }
   Serial.print("\n");
   Status();
}
 
/* Send the state of the relays (on|off) */
void Status() {
     Serial.print("Status");
     for (int i = 4; i < 12; i++){
         if (digitalRead(i) == LOW) {
             Serial.print("|on");
          }
          else {
             Serial.print("|off");
          }
     }                 
     Serial.print("\n");
}
 
/* Turn off all the relays */
void All_On() {
    for (int i = 4; i <= 11; i++){
        digitalWrite(i, LOW);
    }
    Serial.print("all|on\n");
}
 
/* Turn off all the relays */
void All_Off() {
    for (int i = 4; i <= 11; i++){
        digitalWrite(i, HIGH);
    }
    Serial.print("all|off\n");
}
 
/* Turn ON a OFF relay and turn OFF and ON one*/
void Change_State (int digital_port) {
    if (digitalRead(digital_port+3) == HIGH) {
        digitalWrite((digital_port+3), LOW);
        Serial.print(digital_port);
        Serial.print("|on\n");
     }
     else {
         digitalWrite((digital_port+3), HIGH);
         Serial.print(digital_port);
         Serial.print("|off\n");
     }
}
 
/* Sequence to test the relays */
void Test() {
    Serial.print("test|on\n");
    All_Off();
    for (int i = 1; i <= 8; i++) {
        Change_State(i);
        delay(1000);
        Change_State(i);
    }
    delay(1000);
    for (int x = 1; x <= 2; x++) {
        for (int i = 1; i <= 8; i++) {
            Change_State(i);
            delay(1000);
        }
    }
    All_On();
    delay(1000);
    All_Off();    
    Serial.print("test|off\n");
}
 
/****************
 * Main program *
 ****************/
void loop() // run over and over
{
   while (Serial.available() > 0) {
       int sw = Serial.parseInt();
       if ((Serial.read() == '\n') ||
           (Serial.read() == '\r') )  {
           switch(sw) {
               case 0:
                   All_Off();
                   break;
               case 9:
                   All_On();
                   break;
               case 7828: // STAT
                   Status();
                   break;
               case 8378: // TEST
                   Test();
                   break;
               default:
                   if ((sw > 0) && (sw < 9)) {
                       Change_State(sw);
                   }
           }
       }
   }
}
/* End of program */

Este programa lo subí al arduino uno por medio del IDE de Arduino (se puede bajar desde la página del proyecto para Linux, Mac y Windows).

Despues escribí un programa en Perl un poco más complicado que usa un thread dedicado ala comunicación serial con el Arduino, y el proceso principal dialoga con Asterisk por medio del AMI (Asterisk Manager Interface). Ademas de manejar un socket para usar por medio de otros programas como CGI’s para usar vía WEB.

Use las siguientes librerias de Perl que se pueden obtener en cpan.org:

Device::SerialPort para el manejo de la comunicación serial con Arduino.

threads pare el control de Threads.

Thread::Queue para la comunicación entre threads.

Mas otras librerias comunes de Perl.

Aquí el código fuente del componente de interface entre el Arduino y Asterisk:

#!/usr/bin/perl
#===================================================================#
# Program => arduino_control.pl                       (In Perl 5.x) #
#===================================================================#
# Autor         => Fernando "El Pop" Romo        (pop@cofradia.org) #
# Creation date => 2/may/2013                                       #
#-------------------------------------------------------------------#
# Info => This program is a server who make a connection with a     #
#         asterisk server trough the TCP port 5038,take request     #
#         from a TPC clients and dispach messages to them.          #
#-------------------------------------------------------------------#
# This code are released under the GPL 3.0 License. Any change must #
# be report to the authors                                          #
#              (c) 2013 - Fernando Romo / Incuvox                   #
#-------------------------------------------------------------------#
#        For the change history use "cvs log" command               #
#===================================================================#
 
# Last update:
# $Id: arduino_control.pl,v 1.2 2013/05/15 23:57:10 pop Exp $
 
# Load Modules
use strict;
use DBI;
 
#use parms;
use POSIX;
use IO::Socket;
use IO::Select;
use Socket;
use Fcntl;
use Tie::RefHash;
use Time::Local;
use Time::HiRes qw(usleep);
use Proc::PID::File;
use File::Basename;
use Data::Dumper;
use threads;
use Thread::Queue;
use Device::SerialPort;
 
if (defined($ARGV[0])) {
    if ($ARGV[0] eq '-d') {
        defined(my $pid = fork) or die "Can't Fork: $!";
        exit if $pid;
        setsid or die "Can't start a new session: $!";
    }
}
 
# check PID File
die 'Already runnig' if Proc::PID::File->running( name => basename("$0",'.pl'));
 
#--------------------#
# Control Parameters #
#--------------------#
 
#--------------------------------------------------------------------
# [Pop] Developer Note: The Sys_Parms() load the necesary values from
# the Parameter table in the DB. I left this values comment for test
# and documentation purposes.
#--------------------------------------------------------------------
my %Parm = ();
 
##  Arduino server parameters
$Parm{arduino}{debug}            = 0;              # Flag to print debug information
$Parm{arduino}{port}             = 4446;           # port for clients
$Parm{arduino}{dev}              = '/dev/ttyACM0';
 
##  Asterisk manager parameters
$Parm{asterisk}{host}        = '127.0.0.1';    # IP address of * Server
$Parm{asterisk}{port}        = 5038;           # * manager port
$Parm{asterisk}{user}        = 'arduino';      # * Manager user
$Parm{asterisk}{pass}        = 'openhardware'; # * Manager password
$Parm{asterisk}{events}      = 1;              # Flag to request event log to * manager
#--------------------------------------------------------------------
 
my $PBX_ID = 1;
 
#-------------------#
# Working Variables #
#-------------------#
 
my $VERSION = q{$Id: arduino_control.pl,v 1.2 2013/05/15 23:57:10 pop Exp $};
   $VERSION =~ s/\$|Id:\s//g;
my $HELP = "$VERSION\n\nCommands:\n\n";
 
# Timers Info
my $Start_Time = time();
my $Reload_Time = 0;
 
# Socket handlers
my $asterisk_handler;
my $asterisk_select;
my $asterisk_client;
 
# signal traps
$SIG{PIPE} = 'IGNORE';
$SIG{INT}  = $SIG{TERM} = $SIG{HUP} = 'Terminate';
 
#Load_Parameters();
 
# Queues to pass data between Threads
my $Command_Queue   = Thread::Queue->new;
my $Response_Queue  = Thread::Queue->new;
my $tid                 = 0;
 
# Open Socket connection to accept clients requests
my $server = IO::Socket::INET->new(LocalPort => $Parm{arduino}{port},
                                   Listen    => 100,
                                   ReuseAddr => 1 )
  or die "Can't make server socket: $@\n";
Nonblock($server);
my $select = IO::Select->new($server);
 
# begin with empty buffers
my %inbuffer  = ();
my %outbuffer = ();
my %ready     = ();
my %sessions  = ();
my %who       = ();
 
tie %ready, 'Tie::RefHash';
my $event_str = q{};
my $XML_msg   = q{};
 
# Flags to connect to Asterisk
my $manager_connect_time = 0;
my $manager_connect_flag = 1;
 
#----------------------------------------------------------------------------------------------
# [Developer Note]: the process of each client request is declared in the %Client_Handler
#                   Hash and use references for speed operations in the event detection cycle.
#----------------------------------------------------------------------------------------------
 
my %Client_Handler = (
    #----------------------------------------------------------------------------------------------------------------
    # relay: [relay number]
    #----------------------------------------------------------------------------------------------------------------
    "relay" => sub {
        my $client = shift;
        my $control = shift;
        if (@{$control} < 1) {
            $outbuffer{$client} = "Missing relay number\n";
        }
        else {
            if ($control->[1] =~ /\d+/) {
                $Command_Queue->enqueue('relay|' . $control->[1]);
            } 
            else {
                $outbuffer{$client} = "Invalid relay number (must be digits)\n";
            }  # End if ($control->[1] =~ /\d+/)
        } # End if (@{$control} < 0)
    },
    #----------------------------------------------------------------------------------------------------------------
    # HELP
    #----------------------------------------------------------------------------------------------------------------
    "help" => sub {
        my $client = shift;
        $outbuffer{$client} = $HELP;
    },
    #----------------------------------------------------------------------------------------------------------------
    # PARM: List Process parameters
    #----------------------------------------------------------------------------------------------------------------
    "parm" => sub {
        my $client = shift;
        my $control = shift;
        if (@{$control} < 2) {
            $outbuffer{$client} = '';
            foreach my $category  (sort keys %Parm) {
                $outbuffer{$client} .= "$category\n";
                foreach my $keyword  (sort keys %{$Parm{$category}}) {
                    $outbuffer{$client} .= "    $keyword => $Parm{$category}{$keyword}\n";
                }
            }
        }
    },
    #----------------------------------------------------------------------------------------------------------------
    # QUIT or EXIT: terminate client session
    #----------------------------------------------------------------------------------------------------------------
    "quit" => sub {
        my $client = shift;
        delete $inbuffer{$client};
        delete $outbuffer{$client};
        delete $ready{$client};
        delete $sessions{$client};
        delete $who{$client};
        $select->remove($client);
        close($client);
    },
    #----------------------------------------------------------------------------------------------------------------
    # STATUS
    #----------------------------------------------------------------------------------------------------------------
    "status" => sub {
        my $client = shift;
        $Command_Queue->enqueue('relay|7828');
    },
    #----------------------------------------------------------------------------------------------------------------
    # UPTIME: elapsed time of the running service
    #----------------------------------------------------------------------------------------------------------------
    "uptime" => sub {
        my $client = shift;
        $outbuffer{$client} = Convert_To_Time(time() - $Start_Time) . "\n";
    },
    #----------------------------------------------------------------------------------------------------------------
    # TEST
    #----------------------------------------------------------------------------------------------------------------
    "test" => sub {
        my $client = shift;
        $Command_Queue->enqueue('relay|8378');
    },
    #----------------------------------------------------------------------------------------------------------------
    # TIME: current system time
    #----------------------------------------------------------------------------------------------------------------
    "time" => sub {
        my $client = shift;
        $outbuffer{$client} = Current_Time() . "\n";
    },
    #----------------------------------------------------------------------------------------------------------------
    # VERSION: Bring information about this program
    #----------------------------------------------------------------------------------------------------------------
    "version" => sub {
        my $client = shift;
        $outbuffer{$client} = "$VERSION\n";
    },
    #----------------------------------------------------------------------------------------------------------------
    # WHO: List agents and extensions active for control
    #----------------------------------------------------------------------------------------------------------------
    "who" => sub {
        my $client = shift;
        $outbuffer{$client} = "\nConnections " . (scalar keys %sessions) . "\n";
        foreach my $online (sort keys %who) {
            my ($port, $address) = unpack_sockaddr_in(getpeername($who{$online}));
            my $ip_address = inet_ntoa($address);
            $outbuffer{$client} .= "$ip_address\:$port\n";
         }
    },
);
 
#------------------------------------------------------------------#
# [Pop] Developer Note: I declare the "exit" command Out of the    #
# initial %Client_Handler Hash declaration to avoid perl compiler  #
# errors because i try to invoque a non declare hash into the      #
# same hash :P                                                     #
#                                                                  #
# The trick is receive the "exit" command and call the same        #
# rutine of the "quit" event.                                      #
#------------------------------------------------------------------#
 
$Client_Handler{exit} = (sub {
    my $client = shift;
    $Client_Handler{quit}->($client);
});
 
$Client_Handler{'?'} = (sub {
    my $client = shift;
    $Client_Handler{help}->($client);
});
 
foreach my $command (sort keys %Client_Handler) {
    $HELP .= "     $command\n";
}
 
#--------------------------------------------------------------------------------------#
# [Developer Note]: the process of each packet comming from the asteris manager (AMI), #
#                   is declared in the %Event_Handler Hash and use references for      #
#                   speed operations in the event detection cycle.                     #
#--------------------------------------------------------------------------------------#
 
my %Event_Handler = (
    #-----------------------------
    # Event: UserEvent
    # Privilege: user,all
    # UserEvent: RELAY|1
    # Action: UserEvent
    #-----------------------------
    "UserEvent" => sub {
        my $packet_content_ref = shift;
        my ($userevent) = $$packet_content_ref =~ /UserEvent\:\s(.*?)\n/isx;
        #----------------------------------------------------------------------------------------------------------------
        # UserEvent(RELAY|number)
        #----------------------------------------------------------------------------------------------------------------
        my @Response = split(/_/, $userevent);
        if ($Response[0] eq 'RELAY') {
            $Command_Queue->enqueue('relay|' . $Response[1]);
        }
    },
    #-----------------------
    # Event: Shutdown
    # Privilege: system,all
    # Shutdown: Cleanly
    # Restart: False
    #-----------------------
    "Shutdown" => sub  {
        my $packet_content_ref = shift;
        # Terminate(); # if asterisk end then stop pms server
    },
);
 
#---------------------------------------------------------#
#  Function: Terminate()                                  #
#---------------------------------------------------------#
# Objetive: catch the {INT}  signal and close connection  #
#           to sockets and terminate program.             #
#   Params: none                                          #
#    Usage:                                               #
#          $SIG{INT}  = 'Terminate';                      #
#---------------------------------------------------------#
 
sub Terminate
{
    #$thread_die = 1; # Flag to indicate to the child process die
    $Command_Queue->enqueue('stop');   
    my $client;
    # Clean up connections
    foreach $client (keys %sessions) {
        $select->remove($client);
        close($client);
    }
    close($server);                   # destroy socket handler
    close($asterisk_handler);         # destroy asterisk manager conection
    $tid->join() if ($tid);
    exit(0);                          # Exit without error
}
 
#-----------------------------------------------#
#  Function: Nonblock([TCP socket handler])     #
#-----------------------------------------------#
# Objetive: puts socket into nonblocking mode   #
#   Params: [TCP Socket Handler]                #
#    Usage:                                     #
#          Nonblock($socket);                   #
#-----------------------------------------------#
 
sub Nonblock {
    my $socket = shift;
    my $flags;
 
    $flags = fcntl($socket, F_GETFL, 0)
             or die "Can't get flags for socket: $!\n";
    fcntl($socket, F_SETFL, $flags | O_NONBLOCK)
             or die "Can't make socket nonblocking: $!\n";
}
 
#-----------------------------------------------#
#  Function: Manager_Login                      #
#-----------------------------------------------#
# Objetive: Send Login Action to Asterisk API   #
#   Params: none                                #
#    Usage:                                     #
#          Manager_Login();                     #
#-----------------------------------------------#
 
sub Manager_Login {
    my $command  = "Action: Login\r\n";
    $command .= "Username: $Parm{asterisk}{user}\r\n";
    $command .= "Secret: $Parm{asterisk}{pass}\r\n";
    $command .= "Events: ";
    if ($Parm{asterisk}{events}) {
        $command .= 'on';
    } 
    else {
        $command .= 'off';
    }
    $command .= "\r\n\r\n";
    print "---------------\n$command\n" if ($Parm{arduino}{debug});
    Send_To_Asterisk(\$command);
}
 
#--------------------------------------------------#
# Function: Connect_To_Asterisk()                  #
#--------------------------------------------------#
# Objetive: connect program with asterisk manager  #
#   Params: None                                   #
#    Usage:                                        #
#          Connect_To_Asterisk();                  #
#--------------------------------------------------#
 
sub Connect_To_Asterisk
{
    $asterisk_handler = new IO::Socket::INET->new( PeerAddr => $Parm{asterisk}{host},
                                                   PeerPort => $Parm{asterisk}{port},
                                                   Proto    => "tcp",
                                                   ReuseAddr => 1,
                                                   Type     => SOCK_STREAM );
    if ($asterisk_handler) {
        $asterisk_handler->autoflush(1);
        Nonblock($asterisk_handler);
        $select->add($asterisk_handler);
        $manager_connect_time = time;
        return 0;
    } 
    else {
        return 1;
    }
}
 
#--------------------------------------------------------#
# Function: Send_To_Asterisk([message])                  #
#--------------------------------------------------------#
# Objetive: Send  message to Asterik manager             #
#   Params: message, socket_handler                      #
#    Usage:                                              #
#          Send_To_Asterisk($message,$socket)            #
#--------------------------------------------------------#
 
sub Send_To_Asterisk
{
    my $command_ref = shift;
    unless ($$command_ref eq "" && $manager_connect_flag == 1) {
        #--------------------------------------------------------------------------------#
        # Developer Note: in some cases, the API Manager sufer of a requets override and #
        #                 is necesary put a little time wait between requests.           #
        #--------------------------------------------------------------------------------#
        # usleep 200_000;
 
        # if the socket exists send data, if not, turn on reconnection flag
        # if (defined(getpeername($asterisk_handler))) {
        unless($asterisk_handler eq "") {
            my $rv;
            eval { $rv = $asterisk_handler->send($$command_ref, 0) };
            unless (defined $rv) {
                # if send fails, turn on reconnection flag
                $manager_connect_flag = 1;
            }
        } 
        else {
            $manager_connect_flag = 1;
        }
    }
}
 
#-------------------------------------------------------#
#  Fuction: Trim([var|array])                           #
#-------------------------------------------------------#
# Objetive: Take out blank spaces in the rigth and left #
#           of the field                                #
#   Params: one string or array                         #
#    Usage:                                             #
#          $sample = Trim(" vs ");                      #
#          $sample = Trim($foo);                        #
#          @sample = Trim(@data);                       #
#-------------------------------------------------------#
 
sub Trim {
    my @out = @_;
    for (@out) {
        s/^\s+//g;
        s/\s+$//g;
    }
    return wantarray ? @out : $out[0];
}
 
#---------------------------------------------------#
# Function: Dial([phone number],[agent],[campaign], #
#                [Warehouse_id],[call_id])          #
#---------------------------------------------------#
# Objetive: originate a phone call via the asterisk #
#                                                   #
#   Params: phone number                            #
#    Usage:                                         #
#          Dial("85909000","1001")                  #
#---------------------------------------------------#
 
sub Dial {
    my ($tcp_client, $class, $number, $wid, $call_id) = @_;
    my $command  = "Action: Originate\r\n";
    # $command .= "Channel: Local/$number\@default/n\r\n";
    $command .= "Channel: $Parm{asterisk}{trunk}/$number\r\n";
    $command .= "Context: default\r\n";
    $command .= "Priority: 1\r\n";
    $command .= "Async: true\r\n";
    $command .= "Timeout: 30000\r\n";
    $command .= "Variable: TIMEOUT(absolute)=$Parm{arduino}{absolute_timeout}\r\n";
    $command .= "Variable: CDR(dnis)=$number\r\n";
    $command .= "Variable: CDR(call_type)=2\r\n";
    $command .= "Variable: CDR(origin)=4\r\n";
    $command .= "Variable: CDR(pbx)=$PBX_ID\r\n";
    $command .= "Callerid: $number\r\n";
    my ($tcp_client_hex_part) = $tcp_client =~ /\((.*?)\)/;
    $command .= "ActionID: C\|$tcp_client_hex_part\|$call_id\|$wid\|$number";
    $command .= "\r\n\r\n";
    Send_To_Asterisk(\$command);
}
 
#----------------------------------------------------#
# Function: User_Event([Message])                    #
#----------------------------------------------------#
# Objetive: Send a User Event to communicate state   #
#           with other process                       #
#   Params: Agent, mode                              #
#    Usage:                                          #
#          User_Event($msg);                         #
#----------------------------------------------------#
 
sub User_Event {
    my ($msg) = @_;
    my $command  = "Action: UserEvent\r\n";
    $command .= "UserEvent: $msg\r\n\r\n";
    Send_To_Asterisk(\$command);
}
 
#---------------------------------------------------------#
#  Fuction: Pad([string],[Width],[fill_char],[Direction]) #
#---------------------------------------------------------#
# Objetive: Fill with character selected one string in    #
#           the right or left                             #
#   Params: string, Max_Width, fill_char,                 #
#           Direction (0 = left, 1 = rigth)               #
#    Usage:                                               #
#          Pad($month,2,'0',0)                            #
#---------------------------------------------------------#
 
sub Pad {
    my ($string, $lmax, $char, $dir) = @_;
    my $l = length $string;
    if ($l > $lmax) {
        $string = substr($string, 0, $lmax);
    } 
    else {
        if ($dir) {
            $string = $string . ($char x ($lmax - $l));
        } 
        else {    
            $string = ($char x ($lmax - $l)) . $string;
        }
    }
    return $string;
}
 
#===========================================================#
# Convert_To_Time                                           #
#-----------------------------------------------------------#
# Fuction to convert elapsed time in seconds to a friendly  #
# format like hhh:mm:ss                                     #
#                                                           #
# Arguments:                                                #
#            a integer number that mean seconds             #
# Sample:                                                   #
#            $seconds = 11145;                              #
#            print "call elapsed time = ";                  #
#            print Convert_To_Time($seconds);               #
# Result:                                                   #
#            call elapsed time = 3:05'45                    #
#===========================================================#
 
sub Convert_To_Time {
    my $time=$_[0];
    my $days = int($time / 86400);
    my $aux = $time % 86400;
    my $hours = int($aux / 3600);
       $aux = $aux % 3600;
    my $minutes = int($aux / 60);
    my $seconds = $time % 60;
    my $result = "";
    if ($days == 1) {
        $result = "$days day ";
    } 
    elsif ($days > 1) {
        $result = "$days days ";
    }
    $result .= $hours.":".Pad($minutes,2,'0',0)."'".Pad($seconds,2,'0',0);
    return $result;
}
 
#-------------------------------------------------#
#  Function: Current_Time                         #
#-------------------------------------------------#
# Objetive: Return current formated date and time #
#   Params: none                                  #
#    Usage:                                       #
#          $date = CurrentTime_();                #
#-------------------------------------------------#
 
sub Current_Time {
    my ($second, $minute, $hour, $day, $month, $year) = (localtime(time()))[0,1,2,3,4,5];
    $month++;
    $year += 1900;
    return "$year-" . Pad($month,2,'0',0) . '-' .Pad($day,2,'0',0) .' ' .
            Pad($hour,2,'0',0) . ':' . Pad($minute,2,'0',0).':'.Pad($second,2,'0',0);
} 
 
#--------------------------------------------------------#
# Function: Arduino_Handler()                   [Thread] #
#--------------------------------------------------------#
# Objetive: Process serial comunication with Arduino USB #
#   Params: file device                                  #
#    Usage:                                              #
#       $tid = threads->create(\&Arduino_Handler,$dev);  #
#--------------------------------------------------------#
 
sub Arduino_Handler {
    my $arduino_dev = shift;
    my $port = undef;
    my $Serial_Connection_Flag = 1;
    #-----------------------------------------------------------------------------------
    # [Pop] Developer Note: This is tricky part of declare a sub into a sub to invoque
    #                       on the thread start and on reload :P
    #-----------------------------------------------------------------------------------
    # _Connect_Arduino() - Star serial communication with Arduino using USB
    #-----------------------------------------------------------------------------------
    local *_Connect_Arduino = sub {
        if (( -e $arduino_dev) && ($Serial_Connection_Flag == 1)) {
            $Serial_Connection_Flag = 0;
            eval { $port = Device::SerialPort->new("$arduino_dev") };
            unless ($port eq "") {
                $port->baudrate(57600); # you may change this value
                $port->databits(8); # but not this and the two following
                $port->parity("none");
                $port->stopbits(1);
                $port->handshake("none");
                $port->read_char_time(0);
                $port->read_const_time(20); 
            }
            else {
                $Serial_Connection_Flag = 1;
            }
        }
        else {
            $Serial_Connection_Flag = 1;
        }
    };
 
    #--------------------------------------------------------------------------
    # __Send_To_Arduino() - Send Info to Arduino
    #--------------------------------------------------------------------------
    local *_Send_To_Arduino = sub {
       my ($relay) = shift;
       my $count = 0;
       unless ($port eq "") {
           eval { $count = $port->write("$relay\n") };
           unless($count) {
              $Serial_Connection_Flag = 1;
           }
       }
       else {
            $Serial_Connection_Flag = 1;
       }
    };
 
    local *_Read_From_Arduino = sub {
        my $rx = '';
        eval { $rx = $port->lookfor() };
        if ($port eq "") {
              $Serial_Connection_Flag = 1;
        }
        else {
            return $rx;;
        }
    };
 
    #-------------------#
    # Main thread cycle #
    #-------------------#
 
    while (1) {
        if ($Serial_Connection_Flag) {
            _Connect_Arduino();
        }
 
        my $command = $Command_Queue->dequeue_nb;
        if ($command) {
            if ($command =~ /\|/) {
                my ($option,$value) = split(/\|/,$command);
                if ($option eq 'relay') {
                    _Send_To_Arduino($value);
                }
            }
            elsif ($command eq 'stop') {
                $port->close;
                return;
            } 
        }
 
        my $rx = _Read_From_Arduino();
        if ($rx) {
            $Response_Queue->enqueue($rx); 
        }
 
    }
    # End Main thread cycle 
}
 
#---------------------------------------------------------#
#  Function: Handle_Clients([Client TCP handler])         #
#---------------------------------------------------------#
# Objetive: Take the requests of client programs and      #
#           interface with Asterisk manager               #
#   Params: [client TCP handler]                          #
#    Usage:                                               #
#          Handle_Clients($client);                       #
#---------------------------------------------------------#
 
sub Handle_Clients {
    # requests are in $ready{$client}
    # send output to $outbuffer{$client}
    my $client = shift;
    my $request;
 
    foreach $request (@{$ready{$client}}) {
       $request =~ s/\r|\n//g;
       if ($request) {
           my @control = split (/\s+/, Trim($request));
           if (exists($Client_Handler{$control[0]})) {
               $Client_Handler{$control[0]}->($client,\@control); 
           } 
           else {
               $outbuffer{$client} = "Invalid command\n"; 
           }
       }
    }
    delete $ready{$client};
}
 
#---------------------------------------------------------#
#  Function: Handle_Events([Asterisk TCP handler])        #
#---------------------------------------------------------#
# Objetive: Take the requests of Asterisk and manipulate  #
#           the asterisk Manager events.                  #
#   Params: [Asterisk TCP handler]                        #
#    Usage:                                               #
#          Handle_Events($asterisk_handler);              #
#---------------------------------------------------------#
 
sub Handle_Events {
    # requests are in $ready{$client}
    # send output to $outbuffer{$client}
    my $client = shift;
    my $request;
    my @packet = ();
 
    foreach $request (@{$ready{$client}}) {
        $event_str .= $request if ($request);
    }
    if ($event_str =~ /\r\n\r\n/) {
 
       # put each packet in separate area
       @packet = $event_str =~ /(?:Action|Event|Message|Response).*?\r\n\r\n/isxg;
 
       # process each individual packet 
       foreach my $packet_content (@packet) {
           $packet_content =~ s/\r//g;
 
           # Analyze each packet header and process according
           my ($event) = $packet_content =~ /^Event\:\s(.*?)\n/isx;
           if (exists($Event_Handler{$event})) {
               $Event_Handler{$event}->(\$packet_content); 
           }
       }
 
       # if exists a remainder incomplet event, keep it to the next round  
       my $last_pos = rindex($event_str,"\r\n\r\n");
       $last_pos = $last_pos + 4;
       my $len = length($event_str);
       if ($len > $last_pos) {
           $event_str = substr($event_str,$last_pos);
       } 
       else {
           $event_str = "";
       }
    }
    delete $ready{$client};
}
 
#---------------------------------------------------------#
#  Function: Clean_Connection([TCP handler])              #
#---------------------------------------------------------#
# Objetive: Close client TCP connection                   #
#   Params: [TCP handler]                                 #
#    Usage:                                               #
#          Clean_Connection($client_handler);             #
#---------------------------------------------------------#
 
sub Clean_Connection {
    my $client_session = shift;
 
    # Delete working buffers
    delete $inbuffer{$client_session};
    delete $outbuffer{$client_session};
    delete $ready{$client_session};
    delete $sessions{$client_session};
    delete $who{$client_session};
 
    # Check if the connection to Asterisk Die and turn the reconnection Flag
    if ($client_session eq $asterisk_handler) {
        $manager_connect_flag =1;
    }
    $select->remove($client_session);
    close($client_session);
}
 
#======================#
#      Main block      #
#======================#
 
# $/="\0";
 
# Launch Configuration Thread for Arduino control
$tid = threads->create(\&Arduino_Handler,$Parm{arduino}{dev});
 
# Main loop 
while (1) { 
    my $client;
    my $rv;
    my $data;
    if ($manager_connect_flag) {
        $manager_connect_flag = Connect_To_Asterisk();
        unless ($manager_connect_flag) {
            Manager_Login();
        } 
    }
 
    # check for new information on the connections we have.
    # anything to read or accept?
    foreach $client ($select->can_read(1)) {
        if ($client == $server) {
            # accept a new connection
            $client = $server->accept();
            $select->add($client);
            Nonblock($client);
            $sessions{$client} = 1;
            $who{$client} = $client;
            $outbuffer{$client} = "$VERSION (? for help)\n";
        } 
        else {
            # read data
            $data = q{};
            eval { $rv   = $client->recv($data, POSIX::BUFSIZ, 0) };
            unless (defined($rv) && length $data) {
                # This would be the end of file, so close the client
                Clean_Connection($client);
                next;
            }
            $data =~ s/\0/\r\n/g;
            $inbuffer{$client} .= $data;
            # test whether the data in the buffer or the data we
            # just read means there is a complete request waiting
            # to be fulfilled.  If there is, set $ready{$client}
            # to the requests waiting to be fulfilled.
            while ($inbuffer{$client} =~ s/(.*\r\n)//) {
                push( @{$ready{$client}}, $1 );
            }
        }
    }
 
    # Read if exist response from Arduino
    my $response = $Response_Queue->dequeue_nb;
    if ($response) {
         foreach $client ($select->can_write(1)) {
             $outbuffer{$client} = $response . "\n";
         }
    }
 
    # Any complete requests to process?
    foreach $client (keys %ready) {
        if ($client eq $asterisk_handler) {
            Handle_Events($client);
        } 
        else {
            Handle_Clients($client);
        }
    }
 
    # Buffers to flush?
    foreach $client ($select->can_write(1)) {
        # Skip this client if we have nothing to say
        next unless exists $outbuffer{$client};
        # Check if the socket exists before send
        ## if (defined(getpeername($client))) {
        unless($client eq "") {
            eval { $rv = $client->send($outbuffer{$client}, 0) };
            unless (defined $rv) {
                # Whine, but move on.
                warn "I was told I could write, but I can't.\n";
                next;
            }
            if ($rv == length $outbuffer{$client} ||
                $! == POSIX::EWOULDBLOCK) {
                substr($outbuffer{$client}, 0, $rv) = q{};
                delete $outbuffer{$client} unless length $outbuffer{$client};
            } 
            else {
                Clean_Connection($client);
                next;
            }
        } 
        else {
            Clean_Connection($client);
            next;
        }
    }
 
    # Out of band data?
    foreach $client ($select->has_exception(0)) {  # arg is timeout
        # Deal with out-of-band data here, if you want to.
    }
} # End of main loop
 
#------------- End of Program ----------

Este programa lo arranco como servicio en Linux. usando este script en /etc/init.d/arduino

#!/bin/bash
### BEGIN INIT INFO
# Provides:          arduino
# Required-Start:    freepbx
# Required-Stop:     freepbx
# Default-Start:     2 3 4 5
# Default-Stop:      0 1 6
# Short-Description: Start Arduino Asterisk Control
# Description:       Start Arduino Asterisk Control
### END INIT INFO
 
#
# chkconfig: 35 99 99
# description: Arduino Server
# processname: arduino_control.pl
 
# source function library
. /lib/lsb/init-functions
#. /etc/rc.d/init.d/functions
 
DAEMON="/root/arduino/arduino_control.pl >> /dev/null 2>&1"
OPTIONS=-d
RETVAL=0
 
case "$1" in
  start)
	echo -n "Starting Arduino server: "
	daemon $DAEMON $OPTIONS
	RETVAL=$?
	echo
	[ $RETVAL -eq 0 ] && touch /var/lock/arduino_control.pl
	;;
  stop)
	echo -n "Shutting down Arduino server: "
	killproc arduino_control.pl
	RETVAL=$?
 
	echo
	[ $RETVAL -eq 0 ] && rm -f /var/lock/arduino_control.pl
	;;
  restart)
	$0 stop
	$0 start
	RETVAL=$?
	;;
  reload)
	echo -n "Reloading Arduino server: "
	killproc arduino_control.pl -HUP
	RETVAL=$?
	echo
	;;
  status)
	status arduino_control.pl
	RETVAL=$?
	;;
  *)
	echo "Usage: arduino_control {start|stop|status|restart|reload}"
	exit 1
esac
 
exit $RETVAL

En Asterisk hay que poner lo siguiente en el archivo /etc/asterisk/manager.conf, si usan el freepbx que viene incluido en la disto lo ponen en /etc/astrisk/manager_custom.conf:

[arduino]
secret=openhardware
writetimeout = 10000
;read = system,call,log,verbose,agent,user,config,dtmf,reporting,cdr,dialplan
eventfilter=!Event: RTCPSent
eventfilter=!Event: RTCPReceived
read = system,call,log,agent,user,config,dtmf,reporting,cdr,dialplan
write = system,call,agent,user,config,command,reporting,originate

Para probar, ponemos en el archivo de /etc/asterisk/extensions.ael esto:

context from-internal {
    888 => {
        goto ivr,s,1;
    };
 
    777 => {
        Answer;
        MusicOnHold();
        Hangup;
    };
 
    8378 => {
        Answer;
        Playback(beep);
        UserEvent(RELAY_8378,);
        Hangup;
    }; 
    666 => {
        Answer;
        Playback(beep);
        UserEvent(RELAY_1,);
        wait(1);
        UserEvent(RELAY_1,);
        UserEvent(RELAY_2,);
        wait(1);
        UserEvent(RELAY_2,);
        UserEvent(RELAY_3,);
        wait(1);
        UserEvent(RELAY_3,);
        UserEvent(RELAY_4,);
        wait(1);
        UserEvent(RELAY_4,);
        UserEvent(RELAY_5,);
        wait(1);
        UserEvent(RELAY_5,);
        UserEvent(RELAY_6,);
        wait(1);
        UserEvent(RELAY_6,);
        UserEvent(RELAY_7,);
        wait(1);
        UserEvent(RELAY_7,);
        UserEvent(RELAY_8,);
        wait(1);
        UserEvent(RELAY_8,);
        Playback(beep);
        Hangup;
    };
}
 
context ivr {
    s => {
        Answer;
        Background(silence/9);
    pregunta:
        Set(TIMEOUT(response)=5);
        Set(TIMEOUT(digit)=1);
        WaitExten();
        goto pregunta;
    };
    _X => {
       UserEvent(RELAY_${EXTEN},);
       goto s,pregunta;
    };
 
    t => {
        goto ivr,s,pregunta;
    };
 
    i => {
        goto ivr,s,pregunta;
    };
 
}

Si se fijan, use un llamado a la función “UserEvent” que permite mandar mensajes usando el core de Asterisk, estos los proceso como eventos de AMI en el programa “arduino_control.pl” y así puedo disparar eventos desde el plan de marcación de Asterisk.

UserEvent(RELAY_X,);

Donde “X” es el número de relay que deseo activar. dejo reservado el número “8378″ (TEST) para probar los relay’s. Uso el 7828 (STAT) para pedir el estatus de los relay’s.

Tambien se puede actuvar los eventos por medio de la interface por socket usando el puerto 4446 por TCP. por ejemplo usando Telnet:

$ telnet 192.168.1.89 4446
Trying 192.168.1.89...
Connected to raspbx.lan.
Escape character is '^]'.
arduino_control.pl v1.0 (? for help)
relay 8
8|on
relay 8
8|off
 
status
Status|off|off|off|off|off|off|off|off

Para ver mas opciones le dan “help”.

Y suscriben una extensión SIP al Asterisk del Raspberry Pi.

Espero se diviertan jugando con este tipo de proyectos

Autor: Fernando “El Pop” Romo (pop at cofradia.org), twitter @El_Pop

FLISOL Empresas y Software Libre

El Pop — Thu, 02 May 2013 11:33:38 +0000

El día de mañana 3 de mayo del 2013, se llevará al cabo una versión dirigida a Empresas del Festival Latinoamericano de Instalación de Software Libre (FLISoL). El objeto es acercar el potencial del Open Source a las empresas y público en general.

En el marco de este evento, daré una platica sobre Call Centers basados en Asterisk y Open Hardware y sus posibilidades.

La información del evento esta en flisoldf.mx.

La sede es el hotel Fiesta Inn Teatro Insurgentes. Dir. Calle Mercaderes No. 20, Col. San José Insurgentes, C.P. 03900 México D.F, Tel. 5482-9140

Photoduino: Open Hardware para control fotográfico

El Pop — Sun, 24 Mar 2013 06:26:40 +0000

Uno de las cosas que más me gustan, aparte de la tecnología y el desarrollo de software, es la fotografía, lo que me llevó a usar lo primero para ayudar a lo segundo.

Hace un tiempo me puse a investigar como hacer un “Time lapse” (ver Tomando fotos para crear un “Time Lapse”) y lo primero que tuve que hacer fue comprar un intervarómetro (un equipo que activa la cámara cada cierto tiempo), el equipo que compré fue un temporizador de Canon TC-80N3 que me costó alrededor de $300 USD.

Al ver lo caro que era y lo realmente poco que hacía, me dí a la tarea de ver si había proyectos libres con este enfoque, y me encontré con uno realizado por @kalanda llamado Photoduino, este es un controlador de fotografía para alta velocidad. Este está basado en la plataforma de Open Hardware Arduino y su objetivo es crear un “shield” (placa accesoria conectable a un Arduino ONE), que permite tener control de la cámara y diversos sensores que la activan, además de ser intervarómetro.

Modelo del circuito de Photoduino en un protoboard

Ví los diagramas del proyecto e hice mis pininos en un protoboard, funcionó y eso me animó a contactar con @kalanda para ver si había circuitos impresos y facilitar el ensamble. Me vendió algunas placas que tardaron mucho en llegar, ya que el está en España y sólo lo manda por correo ordinario.

Armado con la versión 2 del PCB

De allí armé un par de equipos con acabado “soviético”, con unas cajas de plåstico que compre en Steren y soldando conectores de RCA a la placa. Sin embargo, estos PCB’s no operaban correctamente con algunas cámaras.

Prototipo con acabado “Soviético”

Con el paso del tiempo @Kalanda liberó una versión nueva de su placa, pero para mi mala fortuna, él nunca tenía disponible los PCB’s (Printed Circuit Board), así que ví que tenía los planos del PCB hechos en un CAD para electrónica llamadao Eagle CAD, de los cuales puedes generar unos archivos conocidos como “Gerber“, estos son los archivos base para la fabricación de la tarjeta.

Todo parecía sencillo, pero la generación correcta de estos archivos es delicada (y si te falla costosa), por lo cual me puse a investigar cómo generarlos y encontré un tutoríal realizado por Sparkfun, que describe el proceso y uso de la herramienta de cración de PCB’s. De allí extraje un archivo llamado sfe-gerb274x.cam, que es le que me permitr generar los archivos de Gerber para mandar hacer el PCB.

Dí muchas vueltas y encontré una empresa conocida como PCB-México, me cotizarón y realizaron el trabajo, pero había un punto de decisión fuerte: mandar hacer 10 placas me costaba alrededor de $500 USD y hacer 100, me costaba $800 USD. Así que me lance a pedir 100 piezas.

El trabajo fue impecable, cuando recibí las placas y las revisé, me encantó. Conseguí los circuitos y empecé a soldar. Aquí me encontré con graves problemas: Muchos de los componentes de electrónica básica que se necesitan no existen en México.

PCB versión 3 de Photoduino hechos en México

Después de recorrer la calle de República del Salvador en el centro de la ciudad de México, famosa por ser la que tiene el mayor número de provedores de electrónica en el país, me puse a investigar en internet y sólo pude conseguir los componentes en Mouser Electronics. Esta es una tienda en Texas que manda los pedidos a México. Allí conseguí la mayoría de componentes: trisistores, optoacopladores y hasta resistencias.

Shield de Photoduino Versión 3 ya ensamblado

Una versión del Photoduino que quería ensamblar usaba baterías recargables de una empresa llamada Liquidware, algo caras pero se ajustaban al tamaño que tenía pensado.

Compré los Arduinos a una empresa llamada 330 Ohms y los LCD’s los conseguí en la mencionada calle del centro. No encontré una caja que tuviera las dimensiones requeridas, así que me dí a la tarea de diseñarla, lo cual me introdujo en la aventura del corte láser.

Diseñé mi caja con Adobe Ilustrator siguiendo medidas milimétricas y la exporté esto a formatos de Autocad para realizar el corte. La mencionada empresa de 330 Ohms tienen el cortador láser, así que lo mande a hacer con ellos.

Modelo inicial de la caja que diseñe

Las primeras cajas no tenían un ajuste perfecto, pero una vez que compré un Vernier y medí con precisión, quedó una caja que liberé al dominio público bajo licencia Creative Commons en Thingiverse.

Modelo final de la caja en acrílico transparente

Ahora vendo los Photoduinos ya ensamblados en Cofradía Store

Producto final en acrílico y MDF

Caída de una gota de agua tomanda usando Photoduino y una cámara Canon 60D

Aquí la aventura apenas empieza. Estoy viendo como armar mi propia cortadora láser y sigo un proyecto Open Source muy interesante llamado Lasersaur.

Pero no crean que aquí acaba esto, estoy aprendiendo como fabricar mi propio láser de alta intensidad. Referencias: How to Build a Cutting Laser y Make your own CO2 laser

Autor: Fernando “El Pop” Romo (pop at cofradia.org), twitter @El_Pop

Diez reglas para contratar personal tecnológico

El Pop — Fri, 22 Mar 2013 03:58:50 +0000

Bueno, esto lo publiqué en Twitter previamente, pero lo consolido para que se use de referencia para la posteridad:

Reglas para contratar personal tecnológico

Si llega a la entrevista trajeado… ¡córrelo!
Si llega fachoso como Richard Stallman, pero bañado, puede ser candidato
Si llegó y hackeó tu red WiFi para ver su mail… es un buen candidato
Si presume de certificaciones Java… dígale “despues le hablaremos”. Un buen programador no presume certificaciones, te muestra código que ha escrito
Si no puede armar un cubo Rubik en 3 minutos, no sabe trabajar bajo presión
Si no juega video juegos… ¿Por qué llegó a la entrevista?
Si es experto en Windows… tienes el derecho y la obligación de sacarlo a patadas
Si es mujer, programadora, gamer y guapa, no la contrates… cásate con ella
Si tiene 15 años, programa y es rico pídele empleo
Si cumple 8 de las 9 reglas anteriores y cobra poco… ¡contrátalo!

Así que úsenlo como base para cuando entrevisten candidatos

Buscando un sistema para implementar mediateca

LinuxNT — Sat, 09 Mar 2013 19:40:53 +0000

¡Buenas tardes, Cofrades!

Ando a la búsqueda de alguna sugerencia que me permita implementar una aplicación para el manejo de archivos de documentos, audio y video.

El caso es el siguiente: Una institución me ha hecho la encomienda de que busque la manera de publicar el acervo de la misma hacia la Internet. En un principio, lo ponían como una fácil tarea, lo cual se vino abajo cuando vi la cantidad de documentos que hay que organizar: la frisa de 50 GB entre documentos academicos, libros, programas de radio y programas de televisión.

El caso es que me piden que el sistema permita establecer una biblioteca digital que pueda accederse y organizarse con facilidad. A la vez, desean que tenga un buscador que permita localizar los documentos por rama, tema, categoría, etc.

Buscan algo así: http://dspace.unav.es/dspace/

De hecho, alguien sugirió que para evadir el problema del alojamiento, debieramos buscar una aplicación que pueda integrarse a Mega o a Dropbox (una sugerencia que hicieron en la junta).

Pues bien, ya me he dado vueltas por Open Source CMS y SourceForge además de Free Code y no he visto algo claro. La búsqueda la realizo por el concepto de “digital asset management system” y son solo dSpace y EnterMedia lo que me trae, siendo el segundo bastante enfocado al uso Interno.

Espero puedan sugerirme algunas aplicaciones para realizar pruebas. La idea es ponerlo en un servidor dedicado (o virtualizado) y que en ese mismo servidor estén alojados los contenidos.

De antemano, gracias.

Es importante verificar la caducidad de los certificados del SAT

El Pop — Wed, 06 Mar 2013 05:03:57 +0000

Pues al hacer mi reporte mensual ví que el sistema del SAT me denegó el servicio ya que mi FIEL (Firma electrónica avanzada) caducó hace 3 días. Ahora tengo que hacer un trámite engorroso en el SAT para que me den la renovación, siendo que si la FIEl está aún vigente, es muy fácil el trámite de reposición.

Por eso les dejo un pequeño programa que hice en Perl para verificar los datos de sus certificados del SAT (y de cualquier certificado que use x509):

#!/usr/bin/perl
 
use strict;
use File::Copy; 
use File::Path;
 
sub SAT_Path {
    my $file = shift;
    return substr($file,0,6) .
           '/' .
           substr($file,6,6) .
           '/' .
           substr($file,12,2) .
           '/' .
           substr($file,14,2) .
           '/' .
           substr($file,16,2) .
           '/';
}
 
sub Cert_Info {
    my $cert_file = shift;
    my $cert_info = qx(openssl x509 -inform DER -in $cert_file -serial -subject -startdate -enddate -noout);
    $cert_info =~ s/\\xD1/Ñ/g;
    $cert_info =~ s/\\xF1/ñ/g;
    $cert_info =~ s/\\xC1/Á/g;
    $cert_info =~ s/\\xC9/É/g;
    $cert_info =~ s/\\xCD/Í/g;
    $cert_info =~ s/\\xD3/Ó/g;
    $cert_info =~ s/\\xDA/Ú/g;
    $cert_info =~ s/\\xE1/á/g;
    $cert_info =~ s/\\xE9/é/g;
    $cert_info =~ s/\\xED/í/g;
    $cert_info =~ s/\\xF3/ó/g;
    $cert_info =~ s/\\xFA/ú/g;
    my ($serial_cn) = $cert_info =~ /subject\=.*\/CN=(.*?)(\/OU\=|\/O\=|\/name\=|\/serialNumber\=|\/x500UniqueIdentifier\=|\n)/;
    my ($rfc) = $cert_info =~ /subject\=.*\/x500UniqueIdentifier=(.*?)(\/CN\=|\/OU\=|\/O\=|\/name\=|\/serialNumber\=|\n)/;
    my ($curp) = $cert_info =~ /subject\=.*\/serialNumber=(.*?)(\/CN\=|\/OU\=|\/O\=|\/name\=|\/x500UniqueIdentifier\=|\n)/;
    my ($sucursal) = $cert_info =~ /subject.*\/OU=(.*?)(\/CN\=|\/O\=|\/name\=|\/serialNumber\=|\/x500UniqueIdentifier\=|\n)/;
    $curp =~ s/\s//g;
    $curp =~ s/^\///;
    my $rfc_rep = '';
    $rfc =~ s/\s//g;
    if ($rfc =~ /\//) {
        ($rfc, $rfc_rep) = split(/\//, $rfc);
    }
    my ($serial_hex) = $cert_info =~ /serial\=(.*)/;
    my ($notBefore) = $cert_info =~ /notBefore=(.*)/;
    my ($notAfter) = $cert_info =~ /notAfter=(.*)/;
    my $public_key = qx(openssl x509 -inform DER -in $cert_file -noout -pubkey);
    my $certificate = qx(openssl x509 -inform DER -in $cert_file);
    my $serial = '';
    my @pairs = $serial_hex =~ /(\d\d)/g;
    foreach my $hex (@pairs) {
        $serial = $serial . chr(hex($hex));
    }
        print "-" x 65;
        print "\n";
        print "RFC        => $rfc\n";
        print "Serial     => $serial\n";
        print "Nombre     => $serial_cn\n";
        print "RFC Rep.   => $rfc_rep\n";
        print "CURP       => $curp\n";
        print "sucursal   => $sucursal\n";
        print "Begin date => $notBefore\n";
        print "End date   => $notAfter\n";
        print "-" x 65;
        print "\n";
        print "$public_key\n$certificate\n";
        print "SAT file:  => ftp://ftp2.sat.gob.mx/Certificados/FEA/" . SAT_Path($serial) . "$serial.cer\n";
}
 
chomp;
my @Fields = split(/\|/,$_);
if ($ARGV[0] =~ /\.cer/) {
    if ( -e "$ARGV[0]" ) {
        Cert_Info("$ARGV[0]");
    }
}

Para usarlo sol le dan:

./cert_info.pl 00001000000103469712.cer

y les dará la siguiente información:

-----------------------------------------------------------------
RFC        => CAJU641218Q96
Serial     => 00001000000103469712
Nombre     => CAMANEI SA DE CV
RFC Rep.   => CAJU641218Q96
CURP       => CAJU641218HDFMLR54
sucursal   => 
Begin date => Dec  3 17:48:18 2010 GMT
End date   => Mar  2 17:48:18 2013 GMT
-----------------------------------------------------------------
-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCqIIggmHT4qclfBRsIO7fzgDUd
iYcSF46wqFu1cetJU+O/2G/E5o2LBj9dVyBwPxes5QvqcLxZUakXZH14EDAGlHm0
we5fr034OM/Mqj18o2dpSX3HKZyHnTgyaIxWVP9zSPrm2L4lwSdFS29kkQxx+VzE
ewj0b1mJAtghZZLM5QIDAQAC
-----END PUBLIC KEY-----
 
-----BEGIN CERTIFICATE-----
MIIENzCAAx+gAwIBAgIUMDAwDDEwMDAwMDAxMDIyOTY0ODIwDQYJKoZIhvcNAQEF
BQAwggE2MTgwNgYDVQQDDC9BLkMuIGRlbCBTZXJ2aWNpbyBkZSBBZG1pbmlzdHJh
Y2nDs24gVHJpYnV0YXJpYTEvMC0GA1UECgwmU2VydmljaW8gZGUgQWRtaW5pc3Ry
YWNpw7NuIFRyaWJ1dGFyaWExHzAdBgkqhkiG9w0BCQEWEGFjb2RzQHNhdC5nb2Iu
bXgxJjAkBgNVBAkMHUF2LiBIaWRhbGdvIDc3LCBDb2wuIEd1ZXJyZXJvMQ4wDAYD
VQQRDAUwNjMwMDELMAkGA1UEBhMCTVgxGTAXBgNVBAgMEERpc3RyaXRvIEZlZGVy
YWwxEzARBgNVBAcMCkN1YXVodGVtb2MxMzAxBgkqhkiG9w0BCQIMJFJlc3BvbnNh
YmxlOiBGZXJuYW5kbyBNYXJ0w61uZXogQ29zczAeFw0xMDEyMDMxNzQ4MThaFw0x
MzAzMDIxNzQ4MThaMIGlMRkwFwYDVQQDExBJTkNVVk9YIFNBIERFIENWMRkwFwYD
VQQpExBJTkNVVk9YIFNBIERFIENWMRkwFwYDVQQKExBJTkNVVk9YIFNBIERFIENW
MQswCQYDVQQGEwJNWDElMCMGA1UELRMcSU5DMTAxMTA5UTM2IC8gUk9BRjY0MTIx
N0s5NDEeMBwGA1UEBRMVIC8gUk9BRjY0MTIxN0hERk1MUjA4MIGfMA0GCSqGSIb3
DQEBAQUAA4GNADCBiQKBgQCqIIgggHT4qclfBRsIO7fzgDUdiYcSF46wqFu1cetJ
U+O/2G/E5o2LBj9dVyBwPxes5QvqcLxZUakXZH14EDAGlHm0we5fr034OM/Mqj18
o2dpSX3HKZyHnTgyaIxWVP9zSPrm2L4lwSdFS29kkQxx+VzEewj0b1mJAtghZuLM
5QIDAQABo08wTTAMBgNVHRMBAf8EAjAAMAsGA1UdDwQEAwID2DARBglghkgBhvhC
AQEEBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwQGCCsGAQUFBwMCMA0GCSqGSIb3
DQEBBQUAA4IBAQBLcKX2vawNdSjOZoA9lX5+KdBMCuKV74y4gQNnC+xNrN0Srjlr
1T7kwqdQJvQmz29RV9zc0dX7riM1S0xCrSzSrang9B6Actipz8QBFyCYvw1FDEZi
YOf89Z4pA7YlhuNOI7+nDgfJa3DXrW5lB2totGPZ82dfSSaSB5NHJGeUTqESel0G
7GpGowO+tEz8KAky54lAuod8kPlkEpo5rh2K3zFeFLHoG6MYIcFAhirt3b13ABuq
2ZWzcTaht87bCam1H4zMAOZF5xTHCfBNN7NSV+yAeb0Ssp48N6nstsZBIvIKF7JV
jW8PcylnhWsdW/3IQ7ENXE1S7fjKstDfkCdB
-----END CERTIFICATE-----

¿Cómo vender software de código abierto en México?

mahomedalid — Fri, 01 Mar 2013 01:22:53 +0000

Probablemente esta pregunta se ha hecho anteriormente pero no he encontrado las respuestas que requiero sobre todo en el ámbito legal. Mi pregunta es simple ¿cómo vender software de código abierto en México?

Tengo actualmente un programita que vamos a vender a otra compañía, es una utilería que realiza ciertas operaciones en una base de datos de un programa más grande. Queremos vender a esta compañía el programa acompañado de su código fuente, pero no queremos que está al final nos meta alguna demanda o algo para prohibirnos vender este software. Mis preguntas específicas:

- ¿Tengo que registrarlo en Indautor?

- ¿Cómo puedo demostrar que el software lo hice yo?

- ¿Qué tipo de contrato se tiene que realizar?

La idea sería liberarlo en una licencia simple no restrictiva como MIT.

Convocatoria para desarrollar plataforma de participación ciudadana

miguelbo — Sat, 16 Feb 2013 20:22:01 +0000

Estimados cofrades,

Los invitamos a que se sumen a un esfuerzo que estamos arrancando para tratar de cambiar la situación política del país, denominado Democracia 2.0. La idea es desarrollar una plataforma web, obviamente liberada como software libre, en la que cualquier ciudadano pueda participar para trabajar colaborativamente en el desarrollo de iniciativas de ley y otras propuestas para mejorar su comunidad. Para poder tener incidencia política, hemos iniciado el proceso de registro como partido político ante el IFE, pero no pretendemos ser un simple partido político más, sino que buscamos cambiar de fondo la forma en que se hace la política en México: queremos extrapolar la metodología de desarrollo del software libre a la política…

Imaginen una especie de GitHub pero que en lugar de alojar proyectos de software aloje proyectos de cualquier índole que puedan ser desde iniciativas de ley hasta proyectos sociales. Cada proyecto tendrá a su disposición herramientas de trabajo colaborativo tipo wiki con control de versiones, foros de discusión de nueva generación (algo tipo Discourse.org) y un chat. Además esta plataforma contará con una red social interna con la que se pretende que los usuarios puedan difundir viralmente los proyectos de su interés. Cuando un proyecto o iniciativa de ley haya madurado lo suficiente, el sistema permitirá que sea sometido a votación general entre todos los usuarios para su aprobación. De ser aprobado, los diputados y senadores que tenga Democracia 2.0 tendrán la obligación de presentarlo y defenderlo en el Congreso de la Unión. Este sistema también permitirá que los usuarios puedan nominar y votar por los ciudadanos de su predilección para que se les otorguen las candidaturas de Democracia 2.0. Sin embargo, los candidatos elegidos no tendrán voz ni voto propio, sino que serán simples voceros encargados de llevar al Congreso las decisiones que se tomen en la plataforma web, por lo que en caso de ganar tendrán que devolver la mayor parte del sueldo que reciban, excepto lo que los usuarios de la plataforma consideren que sea una justa retribución por los dos días a la semana que tendrán que asistir a las sesiones del Congreso.

Por otro lado, la plataforma que desarrollemos tendrá un sistema de contabilidad y auditoría que publique en tiempo real toda la información contable de Democracia 2.0 (incluyendo saldos y transferencias de sus cuentas bancarias) para que pueda ser revisada por cualquier persona. Pretendemos que sea un sistema de contabilidad colectiva que funcione de forma similar al desarrollo de software libre, solo que en lugar de buscar bugs, los usuarios buscarán irregularidades en las cuentas y también podrán decidir a dónde se van a destinar los recursos que el IFE otorgue a Democracia 2.0 en caso de alcanzar el registro como partido. Los usuarios podrán decidir si este dinero se debe devolver, si se debe utilizar para financiar alguno de los proyectos que se propongan en la plataforma (algo tipo Kickstarter pero con dinero público), o si se deben utilizar en cualquier otra cosa.

Este es un experimento que si se consolida y se logran los suficientes lugares en el Congreso, a mediano plazo se podría transformar la forma en que funciona el Poder Legislativo, para que en lugar de tener diputados y senadores que en teoría se supone que nos representan pero que en la práctica obedecen a intereses ajenos a la ciudadanía; cada ciudadano se pueda representar a sí mismo y pueda elaborar y votar las iniciativas y reformas de su interés.

Posteriormente, a largo plazo y si los ciudadanos así lo deciden mediante la plataforma, también se podría derogar el sistema de partidos políticos para que sea a través de esta plataforma web donde los ciudadanos se agrupen con otros ciudadanos afines a su ideología para proponer y votar por los candidatos a alcalde, gobernador y presidente de su elección (los diputados y senadores ya no deberían existir llegados a este punto).

Como pueden ver, es un proyecto bastante ambicioso, por lo que convocamos a todos los programadores amantes del software libre que estén interesados en rescatar al país de la partidocracia que lo tiene secuestrado.

Los invitamos a que visiten nuestra página web:

http://www.d20.org.mx

Y que nos sigan en Twitter: @d20mx

Si están interesados en participar en el desarrollo de esta plataforma, pónganse en contacto conmigo. Saludos cordiales,

Atentamente,

Miguel Barousse Ordóñez
miguel (en) d20 (punto) org (punto) mx

Este es el cerebro que toma las decisiones más importantes del pais.

propositivo — Fri, 08 Feb 2013 20:01:12 +0000

Factor decisivo para tomar las decisiones más importantes que nos afectan a todos los mexicanos.

http://mx.noticias.yahoo.com/blogs/corte-de-caja/crystal-tovar–la-diputada-con-la-minifalda-m%C3%A1s-corta-141146540.html