Temas

Hace algún tiempo hice un Cubecraft de Richard Stallman y luce genial sobre el escritorio. Luego pensé que me gustaría uno de Linus Torlvads, quizás uno de Denis Ritchie y Eric Raymod...

Entonces hice un repositorio para este menester y los iré haciendo poco a poco, espero a alguien más le agrade:

https://github.com/alx741/hackers_cubecraft



Aquí una muestra de la intención:


Saludos!

Saludos comunidad, vengo a compartir con uds una entrada de





Cualquier persona que se dedique a actividades relacionadas con la informática (y hoy en día prácticamente cualquier persona independientemente de sus actividades) sabe que su principal herramienta es siempre su teclado, y más vale que estemos los más cómodos y contentos con él, pues es nuestro fiel compañero.

Hay varias cosas que influyen en como lo usemos, y dependiendo de sus características podremos disfrutar más o menos al usarlo, veamos algunas cosas:


Continuar leyendo:

http://silly-bytes.blogspot.com/2014/12/el-teclado-es-tu-amigo.html

Saludos Comunidad!

Comparto con ustedes un cómico cube craft (armable de papel) de el padre del software libre Richard M. Stallman



Saludos.

[PICUSBFW.c:38: error: token -> 'char' ; column 12 *** Salida con estado: 1 ***]

Saludos comunidad!

Me gustaría que me echaran una mano con esto:

Quiero hacer un "helloled", es decir encender un led con un comando desde el host GNU/Linux por USB, pero todos los firmwares que he encontrado tienen algo que me lo imposibilita.

PUF: No me funciona en lo absoluto (ni siquiera el bootloader) (No quiero un bootloader por ahora)

Enzman FW: con el FirmWare precompilado el dispositivo se enumera correctamente, pero todo el código esta echo y se puede compilar con SDCC en windows (no logro compilarlo con SDCC en Linux)

Maccioni FW: Tanto el FW como la aplicación del host estan echos para Linux, pero el FW esta echo con MPLAB y compila con MC18 pero una versión "antigua" y no lo logro compilar tampoco (y el FW precompilado no logra enumerar el dispositivo)

Y de otro FW que he encontrado (para SDCC):

Código (cpp) [Seleccionar] Expandir

/*
* Firmware framework for USB I/O on PIC 18F2455 (and siblings)
* Copyright (C) 2005 Alexander Enzmann
* adapted to MCC18 by Alberto Maccioni on 1/8/09
* re-adapted to SDCC 2.9.0 by Enrique Olivares (EOL) on 22/06/10
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
* or see <http://www.gnu.org/licenses/>
*/


#include <pic18f4550.h>

#include <stdio.h>
#include <string.h>
#include "usb.h"
// Note: there are timing related problems associated with GET_FEATURE
// when run at less than 48 MHz
#define CLK_48MHZ 1

// Define configuration registers (fuses)

#if defined(pic18f2550) || defined(pic18f2455) || defined(pic18f4550) || defined(pic18f4455)

#if CLK_48MHZ
  code char at 0x300000 CONFIG1L = 0x24; // USBDIV=2(0x20), CPUDIV=no dividido(0x00),PLLDIV=5(0x04) 20MHz
#else
  code char at 0x300000 CONFIG1L = 0x3c; // USB, /6 post (16MHz), /5 pre (20 MHz)
#endif

  code char at 0x300001 CONFIG1H = 0x0e; // (FOSC xtal alta velocidad,PLL enable) (0x01),FCMEN disable(0x00), IESO disable (0x00)
  code char at 0x300002 CONFIG2L = 0x3d; // PWRTE disa(0x01),BODEN ena at start, disa on sleep (0x04),BORV 2.0(0x18),VREGEN ena (0x20)
  code char at 0x300003 CONFIG2H = 0x1e; // WDT disable(0x00), WDTPS post scaler 1:32768(0x1e)
  code char at 0x300004 CONFIG3L = 0xff; // Unused configuration bits
  code char at 0x300005 CONFIG3H = 0x00; // CCP2MX RB3(0x00), PBADEN digital(0x00), LPT1OSC disa(0x00), MCLRE disa (a Vdd)(0x00)
  code char at 0x300006 CONFIG4L = 0x81; // STVREN ena pila llena(0x01), LVP disa(0x00),XINST disa(0x00), DEBUG disa in-circuit(0x80)
  code char at 0x300007 CONFIG4H = 0xff; // Unused configuration bits
  code char at 0x300008 CONFIG5L = 0x0f; // Proteccion de codigo: disable CP_0(0x0), CP_1(0x02), CP_2(0x04), CP_3(0x08)
  code char at 0x300009 CONFIG5H = 0xc0; // CPB disable(0x40)
  code char at 0x30000A CONFIG6L = 0x0f; // WRT disable: WRT_0(0x01), WRT_1(0x02), WRT_2(0x04), WRT_3(0x08)
  code char at 0x30000B CONFIG6H = 0xe0; // WRTC disable: WRTC disa (0x20), WRTB disa (0x40)
  code char at 0x30000C CONFIG7L = 0x0f; // EBTR disable: EBTR_0 disa(0x01), EBTR_1 disa (0x02), EBTR_2 disa (0x04), EBTR_3 disa (0x08)
  code char at 0x30000D CONFIG7H = 0x40; // EBTRB disable (0x40)

#endif


// HID feature buffer
//~ volatile unsigned char HIDFeatureBuffer[HID_FEATURE_REPORT_BYTES];

/******************************************************************************/
void high_isr(void) shadowregs interrupt 1
{
if(PIR2bits.USBIF)
   {
       ProcessUSBTransactions();
       UIRbits.SOFIF = 0;
       UIRbits.URSTIF = 0;
       PIR2bits.USBIF = 0;
       UEIR = 0;
   }
}

/******************************************************************************/
void low_isr(void) shadowregs interrupt 2
{
;
;
}


// Allocate buffers in RAM for storage of bytes that have either just
// come in from the SIE or are waiting to go out to the SIE.
volatile char txBuffer[HID_INPUT_REPORT_BYTES];
volatile char rxBuffer[64];
unsigned int timestamp=0;
extern byte transferType;

//Probando ADC.

//Espacio temporal para el resultado de la conversion.
unsigned char adch = 0x00;
unsigned char adcl = 0x00;

//Cachureos para probar.
unsigned char       adchaux = 0x00;
unsigned char       adclaux = 0x00;
unsigned char     esperaaux = 0x00;
unsigned char cuentasumaaux = 0x00;

//Campos de bits para banderas y semaforos.
typedef struct {
unsigned char flag01: 1;
unsigned char flag02: 1;
unsigned char flag03: 1;
} banderas;

//Un valor de 16 bit para el ADC.
unsigned int valor = 0;

//El resultado de la sumatoria de conversiones.
unsigned int sumavalor = 0;

//El promedio de las sumatorias.
unsigned int promedio = 0;

//El contador de las sumas de conversiones.
unsigned char cuentasumavalor = 0;

//Probando el ADC. Aqui el estado ADC  GO/DONE. y otras cosas.
banderas estado_adc;

//Un contador para construir un tiempo de espera
unsigned char espera = 0;

/******************************************************************************/
// Entry point for user initialization.

void UserInit(void)
{
LATA=0;
TRISA=0b11111111;  //Todas son entradas ahora, cuando pruebo el ADC.
LATB=0;
TRISB=0;
T0CON=0x80; // Timer0 period = T*2^16:2 = 5.46ms:2 = 10.93ms (PS=2)
LATC=0;
TRISC=0b00000000;
ADCON1 = 0b00001110; //Vref+=vss. Vref-=vdd. AN0 es entrada analoga, el resto es I/O digital.
TRISAbits.TRISA0=1;
ADCON0 = 0b00000000; //canal 0 (AN0). ADC en espera.  ADC deshabilitado.
ADCON2 = 0b10000101; //justificado a la derecha. 0 Tad (inicio manual). Fosc/16
ADCON0bits.ADON = 1;  //modulo ADC habilitado.
ADCON0bits.GO   = 1;  //Comienza conversion AD.
//Inicializa flags.
estado_adc.flag01 = 0;
estado_adc.flag02 = 0;
estado_adc.flag03 = 0;
//Inicializa cosas para el ADC.
sumavalor = 0;
espera = 0;
valor = 0;
cuentasumavalor = 0;
promedio = 0;
}
#define LOBYTE(x) (*((char *)&x))
#define HIBYTE(x) (*(((char *)&x)+1))
/******************************************************************************/
// If we got some bytes from the host, then echo them back.
static void USBEcho(void)
{
byte rxCnt,i=0;
if ((deviceState < CONFIGURED) || (UCONbits.SUSPND==1))
return;
   
    // Find out if an Output report has been received from the host.
rxCnt=CDCgets(rxBuffer);
// If no bytes in, then nothing to do
if (rxCnt == 0)
return;
// Copy input bytes to the output buffer
// for (i=0;i<rxCnt;i++)
// txBuffer[i] = rxBuffer[i];
for(i=0;i<=32;i++)
{
while ( ADCON0bits.GO == 1 ){;}
txBuffer[2*i]=ADRESH;
if(i<32)
txBuffer[2*i+1]=ADRESL;
ADCON0bits.GO=1;
}
// As long as the SIE is owned by the processor, we let USB tasks continue.
while (EP_IN_BD(CDC_DATA_EP_NUM).Stat.UOWN)
// ProcessUSBTransactions();
;
if(strncmp(rxBuffer,"hola\r\n",6)==0)
CDCputs(txBuffer,62);
else
CDCputs("nada",4);
}

/******************************************************************************/
void ProcessIO(void)
{
// User Application USB tasks
if ((deviceState < CONFIGURED) || (UCONbits.SUSPND==1))
return;
// Process USB: Echo back any bytes that have come in.
USBEcho();
// Probando el ADC.
   if ( ADCON0bits.GO == 0 )
{
if ( estado_adc.flag01 == 0 )
{
adch = ADRESH;
adcl = ADRESL;
estado_adc.flag01 = 1;
//Dos bytes de 8 en un word de 16.
           valor = (int)ADRESL | ( (int)ADRESH << 8 );
sumavalor = sumavalor + valor;
           cuentasumavalor++;
           if ( cuentasumavalor >= 20 )
{
               //Rescata el numero de sumatorias.
cuentasumaaux = cuentasumavalor;
//Calcula el promedio.
promedio = sumavalor / 20;
//Desarma el promedio de 16 bit en dos partes de 8 bits.
adchaux = HIBYTE(promedio);
adclaux = LOBYTE(promedio);
//Reinicia las areas de trabajo.
sumavalor = 0;
cuentasumavalor = 0;
promedio = 0;
}
}
espera++;
if ( espera >= 100 )
{
//Rescata tiempo de espera.
esperaaux = espera;
//Reinicia ADC.
ADCON0bits.GO=1;
//Reinicia flag de entrada.
estado_adc.flag01 = 0;
espera = 0;
}
}
}
/******************************************************************************/
// Handle control out.  This might be an alternate way of processing
// an output report, so all that's needed is to point the output
// pointer to the output buffer
// Initialization for a SET_REPORT request.  This routine will be
// invoked during the setup stage and is used to set up the buffer
// for receiving data from the host.
// void SetupOutputReport(byte reportID)
// {
// if (reportID == 0)
// {
// // When the report arrives in the data stage, the data will be  
// // stored in HIDFeatureBuffer
// // inPtr = (byte*)&HIDRxBuffer;
// }
// }
/******************************************************************************/
// Post processing for a SET_REPORT request.  After all the data has
// been delivered from host to device, this will be invoked to perform
// application specific processing.
// void SetOutputReport(byte reportID)
// {
//
// #if DEBUG_PRINT
// printf("SetOutputReport(0x%hx)\r\n", reportID);
// #endif
//
// // Currently only handling report 0, ignore any others.
// if (reportID != 0)
// return;
//
// // LATB=HIDRxBuffer[0];
//
// // x11 to signal SET_REPORT transfer
// LATBbits.LATB1=1;
// LATBbits.LATB0=1;
//
//
// // TBD: do something.  Not currently implemented because the output
// // report is being handled by an interrupt endpoint.
// }

/******************************************************************************/
// Handle a control input report.

// void GetInputReport(byte reportID)
// {
//
// #if DEBUG_PRINT
// printf("GetInputReport: 0x%uhx\r\n", reportID);
// #endif
//
// if (reportID == 0)
// {
// byte i;
// // Send back the contents of the HID report
// // TBD: provide useful information...
// // outPtr = (byte *)&HIDTxBuffer;
//
// // // HIDTxBuffer[0]=PORTA;
// // // HIDTxBuffer[1]=0xF2; //this is to differentiate between different transfer types
// // // HIDTxBuffer[2]=HIBYTE(timestamp);
// // // HIDTxBuffer[3]=LOBYTE(timestamp);
// for(i=4;i<HID_INPUT_REPORT_BYTES;i++)
// //                     HIDTxBuffer[i]=HIDRxBuffer[i];
//
// // The number of bytes in the report (from usb.h).
// wCount = HID_INPUT_REPORT_BYTES;
// transferType=0;
// }
// }
void init_CDC()
{
INTCON=0;
INTCON2=0xC0;
UCON=0;
UCFG=0;
UEP0=0;UEP1=0;UEP2=0;UEP3=0;UEP4=0;UEP5=0;
UEP6=0;UEP7=0;UEP8=0;UEP9=0;UEP10=0;UEP11=0;
UEP12=0;UEP13=0;UEP14=0;UEP15=0;
// Initialize USB for CDC
UCFG = 0x14; // Enable pullup resistors; full speed mode
deviceState = DETACHED;
remoteWakeup = 0x00;
currentConfiguration = 0x00;
// And enable USB module
while(deviceState != CONFIGURED)
{
EnableUSBModule();
if(UCFGbits.UTEYE != 1)
ProcessUSBTransactions();
}
}
/******************************************************************************/
// Entry point of the firmware.

void main(void)
{
byte led_cnt=0;

   // Set all I/O pins to digital
ADCON1 |= 0x0F;
PIE1=0;
PIE2=0;
   // Initialize USB
//     UCFG = 0x14; // Enable pullup resistors; full speed mode
//
//     deviceState = DETACHED;
//     remoteWakeup = 0x00;
//     currentConfiguration = 0x00;
init_CDC();
PIE2bits.USBIE = 1;
INTCON = 0xC0;  
   // Call user initialization function
UserInit();

#define LED1              LATCbits.LATC0
//#define LED2              LATAbits.LATA2

   while(1)
       {
               // Ensure USB module is available
// EnableUSBModule(); //esto es de usb.c, lo deja en el estado powered
//
// // As long as we aren't in test mode (UTEYE), process
// // USB transactions.
// if(UCFGbits.UTEYE != 1)//no se debe conectar el usb si UTEYE esta activo por que este genera un testeo
// ProcessUSBTransactions();//esta en usb.c tmb

               // Application specific tasks
//                 ProcessIO();
USBEcho();

               //Blink LED2 @ 1Hz when configured
if(INTCONbits.TMR0IF){
INTCONbits.TMR0IF=0;
timestamp++;
led_cnt++;
if (deviceState<CONFIGURED&&led_cnt>=10){
//LED2 = !LED2;
LED1 = !LED1;
led_cnt=0;
}
else if (deviceState == CONFIGURED&&led_cnt>=46){
//LED2 = !LED2;
LED1 = !LED1;
led_cnt=0;
}
}
       }
}


Simplemente no compila, arroja:

sdcc --use-non-free -mpic16 -p18f4550 -V --debug -I/home/alx/silly-bytes/usb/para piclinux/ -c PICUSBFW.c

+ "/usr/bin/sdcpp" -nostdinc -Wall -I/home/alx/silly-bytes/usb/para\ piclinux/ -Dpic18f4550 -D__18f4550 -D__SDCC_PIC18F4550 -DSTACK_MODEL_SMALL -D__STACK_MODEL_SMALL -obj-ext=.o -D__SDCC_USE_NON_FREE -DSDCC_USE_NON_FREE -D__SDCC=3_2_0 -DSDCC=320 -D__SDCC_REVISION=8008 -DSDCC_REVISION=8008 -D__SDCC_pic16 -DSDCC_pic16 -D__pic16 -D__STDC_NO_COMPLEX__ -D__STDC_NO_THREADS__ -D__STDC_NO_ATOMICS__ -D__STDC_NO_VLA__ -isystem "/usr/bin/../share/sdcc/include/pic16" -isystem "/usr/share/sdcc/include/pic16" -isystem "/usr/bin/../share/sdcc/include" -isystem "/usr/share/sdcc/include" -isystem "/usr/bin/../share/sdcc/non-free/include/pic16" -isystem "/usr/share/sdcc/non-free/include/pic16" -isystem "/usr/bin/../share/sdcc/non-free/include" -isystem "/usr/share/sdcc/non-free/include" "PICUSBFW.c"  

PICUSBFW.c:38: error: token -> 'char' ; column 12
*** Salida con estado: 1 ***

Alguien sabe de un proyecto libre para hacer esto? o alguien lo ha echo antes, como puedo hacerlo?

Muchas gracias!, Saludos.

Saludos comunidad!

Soy nuevo con esto de la electrónica y resulta que compré un PIC18F4550 por que leí que es bueno para aprender a controlar USB

Pero quiero programarlo usando el puerto paralelo por que no puedo gastar ahora en un programador USB como el pickit2 , así que encontré en la web un par de esquemas de programadores por puerto paralelo y los he montado en una protoboard pero resulta que ninguno funciona, además me han icho que no es posible programar este PIC (muy nuevo) con puerto paralelo, pero en el datasheet dice que es compatible con ICSP y los programadores que he montado funcionan con ICSP, como debo hacerlo? será quizás que al no tener un ejemplo con este PIC lo estoy conectado mal? como puedo programar este PIC por puerto paralelo??

PD: Lo estoy haciendo desde GNU/Linux usando el software odyssey

Muchas gracias!

Hola comunidad!

Necesito escribir un código que obtenga la pulsación de una tecla sin tener que presionar "enter" para saber cuando se presionan las teclas de dirección, quiero hacerlo en c++ y linux , pero no tengo idea de como hacerlo y no quiero usar SDL, alguien me da luz porfavor?

Gracias y saludos!

[Hola a todos! hermosa comunidad!]

Hola a todos! hermosa comunidad!

Hace unos meses hice un tema en el que los usuarios de elhacker.net presentaban a los demas específicamente sus blogs, para que todos podamos conocerlos y nutrirnos de esa información, pero resulto evidente que centrarse en "blogs" es una visión muy pobre y se quedo claramente limitada.

Así que hoy me gustaría invitar a que todos aquellos que alguna ves han escrito (o escriben) algún tipo documento o libro, o mantengan una pagina web de cualquier tipo, o un blog, o vlog, etc,etc; Que tenga que ver con los temas que nos competen aquí en elhacker.net (programación, hacking, y un largo etc), porfavor lo publique en este tema, para que todos podamos deleitarnos y a su ves nutrirnos de lo que todos ofrecemos a todos!

Tampoco debemos olvidar <comentar/dar "like"/twittear/etc/etc> cuando pasemos por los blogs, paginas,etc,etc de los demás, pues recuerden que al igual que ustedes, este tipo de cosas nos animan a seguir ofreciendo ideas/conocimiento/etc a la web.

Con esto y un cordial saludo a toda la comunidad, os invito a empezar a "publicarse" y conocer lo que los demás usuarios tienen por ofrecer!  

Hola compañeros!

hace unos días vi esos nuevos "cheat cube" que salieron de distintas distribuciones GNU/Linux, y pensé en hacer algo más útil (por que rara vez tenemos que como crear directorios y cosas por el estilo ¬¬) así que hice un bonito dodecaedro para recordar los comandos y maravillas de VIM, el cual publique en mi blog así que más información esta en el: http://www.silly-bytes.blogspot.com/

aquí se los dejo:



Creo que todos entendemos que hacer con el no..

El tamaño se ajusta al A4.

Saludos!

PD: lo hice en ingles para que llegue a más personas.. creo que se comprende eso..

Hola a todos!

Ayer se me ocurrió esto por este tema http://foro.elhacker.net/gnulinux/blog_introduccion_al_sinsentido_de_gnulinux_y_linux-t367008.0.html;topicseen y pues.. por que no hacerlo¿? ...

La idea es que este tema sea un espacio para que los usuarios dejen un link a su blog personal para que los demás podamos verlo y con suerte nutrirnos de la información/conocimientos que estos puedan ofrecer.

Así pues dejen sus blogs y visiten los de los demás! , si los visitan no olviden comentar en ellos felicitando a los Autores de los blogs por su trabajo.

...Nunca se sabe cuando ni donde se va a encontrar una verdadera fuente "de oro" en información...

Saludos!

PD: Dejo aquí el mio. Me da pena por que no le he prestado mucha atención, está algo descuidado y prácticamente sin nada realmente valioso o útil, pero bueno... prometo hacer algo al respecto..
www.silly-bytes.blogspot.com

Hola a todos!

He estado estudiando el lenguaje assembly, pero la mayoría de los textos definen entre programación windows (DOS más especificamente) y Unix, Unix-like, pero lo que a mi me interesa realmente es aprender/entender el funcionamiento interno/básico de una computadora por lo cual me resulta insatisfactorio mostrar una cadena por pantalla haciendo uso de una interrupción o syscall al kerndel del SO local  ... me gustaría me recomendaran o me contaran algo al respecto de la programación sin depender del SO, como se maneja el "video" (aun no tengo remota idea de como funciona), teclado, etc,etc... uds me entienden.. quiero saber como funciona.. 

PD: me refiero a algo como esto  http://mikeos.berlios.de/   (no sé lo suficiente como para intentar entender esto) 

Saludos! y gracias!