avr-gcc

Byte auf parport schreiben

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <asm/io.h>

#define base 0x378           /* printer port base address */
#define value 255            /* numeric value to send to printer port */

main(int argc, char **argv)
{
   if (ioperm(base,1,1))
    fprintf(stderr, "Couldn't get the port at %x\n", base), exit(1);

   outb(value, base);
}

Integer to ASCII HEX

char *convert_hex(unsigned char data) {
        char *string = (char*) malloc(3*sizeof(char));
        *(string+1) = (char) (data & 0x0f) + (((data & 0x0f)<0x09)?0x30:0x57);
        *string = (char) ((data & 0xf0)>>4)+ ((((data & 0xf0)>>4)<0x09)?0x30:0x57);
        *(string+2) = '\0';
        return string;
}

Serielle Schnittselle

Stichwort: Serielle_Schnittstelle_(avr-gcc)

#include <avr/io.h>
#include <avr/interrupt.h>
#define F_CPU 12000000
#define BAUD 9600
#define UBRR_VAL F_CPU/16/BAUD-1
#define UART_MAX_BUFFER 15

volatile unsigned char uart_buffer[UART_MAX_BUFFER];
volatile int uart_read_pointer = 0;
volatile int uart_write_pointer = 0;

//Diese Interrupt Routine wird beim Empfang eines Zeichens ausgelößt
ISR(USART_RXC_vect) {
    if (uart_buffer[uart_write_pointer] == 0) {
        uart_buffer[uart_write_pointer] = UDR;
        uart_write_pointer++;
        if (uart_write_pointer > UART_MAX_BUFFER) {
            uart_write_pointer = 0;
            }
    }
}


//Verarbeitet ein eingelesenes Zeichen (mit Puffer)
unsigned char recive_char(void) {
    int recived_char = 0;
    if (uart_read_pointer > UART_MAX_BUFFER) {
        uart_read_pointer = 0;
    }
    if (uart_buffer[uart_read_pointer] != 0) {
        recived_char = uart_buffer[uart_read_pointer];
    }
    uart_buffer[uart_read_pointer] = 0;
    uart_read_pointer++;
    return recived_char;
}

//Initialisiert den UASRT
void init_uart(unsigned int ubrr) {
    UBRRH = (unsigned char)(ubrr>>8);
    UBRRL = (unsigned char)(ubrr);
    UCSRB = (1<<RXCIE)|(1<<RXEN)|(1<<TXEN);
    UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);
}

//Sendet ein einzelnes Zeichen über den USART
void send_char(unsigned char data) {
    while (!(UCSRA & (1<<UDRE)));
    UDR = data;
}

//Sendet einen String über den USART
void send_string(char *data) {
    while (*data) {
        send_char(*data);
        data++;
    }
}

int main(void) {
    unsigned char recived_char = 0;
    init_uart(UBRR_VAL);
    sei();
    while (1) {
        recived_char = recive_char();
        if (recived_char != 0) {
            send_char(recived_char);
        }
    }
    return 1;
}

twisted-web

Ajax Requests schleifen lassen (aka comet)

class EventsHandler(resource.Resource):
    def render_POST(self,request):
        reactor.callInThread(self.process,request,con_id,con)
        return server.NOT_DONE_YET

    def process(self,request,ident,conn):
        request.write(  str )
        request.finish()