Projekte

Abbildung 1:

Abbildung 2:

Abbildung 3:

Abbildung 4:

Abbildung 5:

Projekt "AOR - Automatic Object Recognition"

Mittels einer CMOS Kamera können Objekte automatisch erkannt und verfolgt werden.

Basis für dieses Projekt ist, neben der Kamera mit OV7670 Chip, ein ATMEGA32 und ein ili9325 TFT Display.
Die Komponenten sind auf einer Platine fertig bestückt im Handel erhältlich

Das Projekt teilt sich auf folgenden Phasen auf:

Phase 1: Erweiterung des vorhandenen Softwareumfangs um Funktionen zur Pixelverarbeitung und Objekterkennung.

Phase 2: Prototyping mit Einzelbildern und Validierung über TFT.

Phase 3: Umsetzung des entwickelten Umfangs auf bewegte Bilder und Anzeige der Objektverfolgung über TFT.

Unter Abbildung 5 gibt es eine Dokumentation

µC-Quellcode Pixelverarbeitung:

/*********** impro.c *********************/ uint16 LCD_get_pixel(uint32 ul_x, uint32 ul_y) { assert(ul_x <= LCD_LCD_WIDTH); assert(ul_y <= LCD_LCD_HEIGHT); /* Set cursor */ LCD_set_cursor_position(ul_x, ul_y); /* Prepare to write in GRAM */ LCD_read_ram_prepare(); return LCD_read_gram(); } uint16 LCD_read_gram(void) { uint8 value[2] = {1,1}; uint16 color; char text[35]; uint8 R,G,B; LCD_RD_DATA(value); color = value[1] << 8; color |= value[0]; /* itoa(color, text, 10); strcat(text,'\0'); LCD_draw_string(10,50,text); */ return color; } /************ lcd.c *************/ void LCD_RD_DATA(unsigned char *data) { DATA_INPUT(); LCD_RD_H(); LCD_RS_H(); LCD_CS_L(); LCD_RD_L(); _delay_us(1); data[0] = DATA_LCD_PIN; //dummy read _delay_us(1); LCD_RD_H(); LCD_RD_L(); _delay_us(1); data[1] = DATA_LCD_PIN; // dummy read _delay_us(1); LCD_RD_H(); LCD_RD_L(); _delay_us(1); data[1] = DATA_LCD_PIN; //high byte _delay_us(1); LCD_RD_H(); LCD_RD_L(); _delay_us(1); data[0] = DATA_LCD_PIN; // low byte _delay_us(1); LCD_RD_H(); LCD_CS_H(); DATA_OUTPUT(); }

µC-Quellcode Objekterkennung:

Abbildung 1:

Abbildung 2:

Abbildung 3:

Abbildung 4:

Abbildung 5:

Projekt "NETwet - Funk-Wetterstation mit Internetübertragung"

Über einen Internet-Browser lässt sich auf Temperatur/Feuchtedaten zugreifen.

Basis für dieses Projekt ist ein eigenentwickelter Webserver mit einem ATMEGA32 und einem ENC28J60 Baustein.
Die Sensordaten der Temperatur und Feuchte werden per Funk an den Webserver übermittelt, somit ist die Erfassung der Daten flexibel und mobil.

Die Umweltdaten können über ein Display auch direkt an dem Funksender ("Station") angezeigt werden.

Das Projekt teilt sich auf folgenden Phasen auf:

Phase 1: Aufbau des Funksenders inklusive Sensor/Messerfassung in einem eigenen Gehäuse (Betrieb über 9V Block).

Phase 2: Erweiterung der Basisfunktionen des Webservers um den Empfang der Sensordaten über Funk.

Phase 3: Umsetzung einer Informationsdarstellung der Sensordaten für den WEB-Browser.

Unter Abbildung 5 gibt es eine Dokumentation

µC-Quellcode NETwet base:

/* NETwet base author Daniel Nüsse date 2012-06-15 */ #include "main.h" #include <avr/io.h> #include <stdint.h> #include <stdio.h> #include <avr/delay.h> #include <avr/interrupt.h> #include <stdint.h> //#include "flashloader.h" //#include "softuart.h" //#include "dataflash.h" #include "plot.h" //#include "filesystem.h" #include "lm35.h" #include "mca25.h" //#include "mpf10.h" //#include "led.h" #include "rf12.h" //ACTIVATE DEBUG by editing this file: #include "debug.h" //#include "clock.h" #include "plot.h" //#include "servo.h" #include "mynic.h" #include "icmp.h" #include "ip.h" #include "arp.h" #include "tcp.h" #include "httpd.h" #include "ntp_client.h" #include "http_client.h" #include "base64.h" #include "string.h" #include <i2clcd.h> //interrupt: #include <avr/interrupt.h> #include <inttypes.h> #include <avr/signal.h> #define NOP() asm volatile ("nop"::); #include "config.h" //global ethernetbuffer unsigned char buffer[NIC_BUFFERSIZE]; volatile uint8_t z = 0, adcCnt = 0; unsigned char dataH[6]; unsigned char dataT[6]; unsigned char dataHT[32]; uint8_t iNT1 = 0, iNTC = 0; /***************/ unsigned char * ADCVal(unsigned char * val, char port) { double temp = 0; int i; unsigned char temp2[4]; ADMUX = port; // ADC Ref auf Avcc, PA6 gewählt sbi(ADCSRA,ADSC);//Messung starten while(bit_is_set(ADCSRA,ADSC));// Auf Ergebnis warten: cbi(ADCSRA,ADSC);//Messung stoppen temp=ADCW; // aufsummierung der samplewerte temp = 5.0 / 1023 * temp * 10; itoa ((int)temp,val,10); for(i=0;i<3;i++) { if(i == 0 || i == 2) { temp2[i] = *val; val++; } else temp2[i] = '.'; } temp2[3] = '\0'; strcpy(val, temp2); return val; } /***************/ unsigned char * receive(unsigned char * test) { rf12_rxdata(test,32); return test; // daten verarbeiten } /***************/ void send(unsigned char *data) { // unsigned char test[]="Das ist ein Test"; rf12_txdata(data,32); } /***************/ void boardFunc(void) { unsigned char test[16]; cli(); // display board temperature Gotoxy(2,0); SendStr("T:"); Gotoxy(2,3); SendStr(tempVal(test)); Gotoxy(2,5); SendStr("ßC"); // display board ADC values Gotoxy(2,8); SendStr("V"); Gotoxy(2,9); itoa((int)adcCnt,test,10); SendStr(test); Gotoxy(2,10); SendStr(":"); Gotoxy(2,12); SendStr(ADCVal(test,adcCnt)); Gotoxy(2,15); SendStr("V"); adcCnt++; if (adcCnt==8) adcCnt = 0; iNTC = 0; sei(); } /***************/ void rfm12Func(void) { int k = 0, l = 0; cli(); receive(dataHT); l=0; for(k=0; k<=9; k++) { if(k<=4) dataH[l] = dataHT[k]; if(k==5) l=0; if(k>=5) dataT[l] = dataHT[k]; l++; } dataH[5] = '\0'; dataT[5] = '\0'; Gotoxy(1,0); SendStr("H:"); Gotoxy(1,2); SendStr(dataH); Gotoxy(1,8); SendStr("T:"); Gotoxy(1,10); SendStr(dataT); iNT1 = 0; sei(); } ISR(TIMER0_COMP_vect) { z++; if(z==144) { iNTC = 1; z = 0; } } ISR(INT1_vect) { iNT1 = 1; } // Main function int main(void){ int len, i=0; unsigned int type; unsigned int port; // Init settings // PORTC DDRC = 0x9F; // set all to outputs, except PC5 (SDI and PC6 (µC RES) // SET_HIGH(PORTC,PC6); // Reset on // PORTA DDRA = 0x00; // set all to inputs //PORTD DDRD = 0xC4; // set PD2, PD6 and PD7 to output //Timer/Counter0 Compare Match Interrupt TCNT0=0; //Anfangszählerstand = 0 OCR0=199; //Zähler zählt bis 00: 14400/200 = 72 TCCR0=0x0D; //CTC-Modus: Takt intern von 14745600 Mhz /1024 = 14400Hz TIMSK|=(1<<OCIE0); //PORT settings SET_LOW(PORTD,PD6); // LCD backlight OFF SET_LOW(PORTD,PD7); // IR LED cluster OFF SET_HIGH(PORTC,PC7); // LED on // LCD init midas_lcd_init(); // radio wave init rf12_init(); // ein paar Register setzen (z.B. CLK auf 10MHz) rf12_setfreq(RF12FREQ(433.92)); // Sende/Empfangsfrequenz auf 433,92MHz einstellen rf12_setbandwidth(4, 1, 4); // 200kHz Bandbreite, -6dB Verstärkung, DRSSI threshold: -79dBm rf12_setbaud(19200); // 19200 baud rf12_setpower(0, 6); // 1mW Ausgangangsleistung, 120kHz Frequenzshift // Board temp sensor init lm35_init(); // Welcome WAC(); Gotoxy(1,0); SendStr((unsigned char *)"*** NETwork ***"); Gotoxy(2,0); SendStr((unsigned char *)"** by VoxSoft **"); WAC(); // Clock init clock_init(); // CAM init SET_HIGH(PORTD,PD2); SendStr((unsigned char *)"cam init start"); mca25_init(); mca25_configure(); Gotoxy(1,0); LCD_CLS(); SendStr((unsigned char *)"cam init done"); WAC(); // Network init nic_init(); ntp_client_init(); logger_init(); tcp_init(); http_client_init(); //wait some time (200ms) for(int t=0; t<20; t++) _delay_ms(10); // Send an ntp time request ntp_client_send_request(buffer); // prepare rfm12 module rf12_trans(0x82C8); // RX on rf12_trans(0xCA81); // set FIFO mode rf12_trans(0xCA83); // enable FIFO // Enable Interrupts //INT1 trigger negative slope MCUCR &= ~(1<<ISC10); MCUCR |= (1<<ISC11); GICR |= (1<<INT1); sei(); iNT1 = iNTC = 0; //main loop, never ends ! while(1) { // Interrupt routine for board informations if(iNTC) boardFunc(); // Interrupt routine for weather station informations if(iNT1) rfm12Func(); // show activity bar /* if(i<16) { Gotoxy(2,i); SendStr(">"); i++; } else if( i <32) { Gotoxy(2,i-16); SendStr(" "); i++; } else i = 0; */ len = nic_receive_packet(&buffer[0],NIC_BUFFERSIZE); if (len>0){ //softuart_puts_progmem("RX\n"); //packet type type = (buffer[12]<<8) + buffer[13]; if(type == ETHERNET_TYPE_ARP){ ///ARP packet arp_packet_in(buffer,len); //check if we have to call ntp_client: if (ntp_client_call_again == 1) ntp_client_send_request(buffer); }else if (type == ETHERNET_TYPE_IP){ ///IP packet //ip protocol: unsigned char ip_protocol = buffer[IP_POS_IPTYPE]; switch (ip_protocol){ ///icmp packet: case (IP_PROTOCOL_ICMP): icmp_packet_in(&buffer[0],len); break; ///tcp packet: case(IP_PROTOCOL_TCP): //port = (buffer[TCP_POS_DST_PORT]<<8) + buffer[TCP_POS_DST_PORT+1]; tcp_packet_in(buffer,len); break; ///udp packet: case(IP_PROTOCOL_UDP): port = (buffer[UDP_POS_DEST_PORT]<<8) + buffer[UDP_POS_DEST_PORT+1]; switch (port){ //packet for udp client ? case(IP_PORT_NTP_CLIENT): ntp_client_decode_packet(buffer, len); break; //unknown udp packet: default: #if UDP_DEBUG //softuart_puts_progmem("UDP : ?\r\n"); #endif break; } break; default: break; } } } //calc new time: clock_do(); //every new second: if (CLOCK_TEST_FLAG(CLOCK_SEC)) { //call tcp cleanup: tcp_ttl_cleanup(); //call mca25 cleanup: mca25_cleanup(); //call templogger: logger_do(); //clear flag: CLOCK_CLEAR_FLAG(CLOCK_SEC); } } }

µC-Quellcode NETwet station:

Abbildung 1:

Abbildung 2:

Abbildung 3:

Abbildung 4:

Abbildung 5:

Projekt "NETwork - Webserver mit Kamera und Sensoren"

Über einen Internet-Browser lässt sich auf eine Kamera zugreifen.

Basis für dieses Projekt ist ein eigenentwickelter Webserver mit einem ATMEGA32 und einem ENC28J60 Baustein. Die Kamera kommuniziert direkt mit dem RISC und die Bilder werden über das Internet an den aufrufenden Browser gesendet. Zusätzlich werden Sensordaten über den Browser angezeigt.

Das Projekt teilt sich auf folgenden Phasen auf:

Phase 1: Konzeption und Aufbau des Webservers mit Schnittstelle für ein Midas I²C LCD Display. Erweiterung der Basisfunktionen um einen Temperatursensor und eine MCA-25 Kamera.

Phase 2: Umsetzung einer Steueroberfläche für die Anzeige des Kamerabildes und der Sensordaten über einen WEB-Browser.

Unter Abbildung 5 gibt es eine Dokumentation

µC-Quellcode NETwork:

µC-Quellcode Midas LCD MCCOG21605D6W-BNMLWI:

// i2clcd.c #include "i2clcd.h" #include <util/delay.h> #include <avr/io.h> #define uint8 unsigned char // Set bit #define sbi(port, bit) (port) |= (1 << (bit)) // Clear bit #define cbi(port, bit) (port) &= ~(1 << (bit)) void DelayUs(unsigned char Xus) { while(Xus-- != 0) _delay_us(1); } // Delay Xms MS void DelayMs(unsigned int Xms) { while(Xms-- != 0) _delay_ms(1); } void SendStr(uint8 *ptString) { while((*ptString)!='\0') { SendByte(iDat, *ptString++); } } // Move Cursor or display void Move(uint8 dir) { SendByte(iCmd, dir); } // Goto specific location void Gotoxy(uint8 Row, uint8 Col) { switch (Row) { #if defined(LCD_L2) case 2: SendByte(iCmd, LCD_L2 + Col); break; #endif #if defined(LCD_L3) case 3: SendByte(iCmd, LCD_L3 + Col); break; #endif #if defined(LCD_L4) case 4: SendByte(iCmd, LCD_L4 + Col); break; #endif default: SendByte(iCmd, LCD_L1 + Col); } } // Wait some time and clear screen void wait_and_clear(void) { DelayMs(1000); LCD_CLS(); } // Call built-in Characters void CallBuiltinChar(void) { uint8 i, k; for (i = 0; i < LCD_COL; i += LCD_ROW) { SendByte(iCmd, LCD_L1); for (k = 0; k < LCD_CHAR; k++) { #if defined(LCD_L2) switch (k) { case LCD_COL: SendByte(iCmd, LCD_L2); break; #if defined(LCD_L3) case LCD_COL*2: SendByte(iCmd, LCD_L3); break; #endif #if defined(LCD_L4) case LCD_COL*3: SendByte(iCmd, LCD_L4); break; #endif default: break; } #endif SendByte(iDat, k + LCD_COL*i); } wait_and_clear(); } } void I2C_Start(void) { sbi(I2C_DataPort, I2C_SDA); sbi(I2C_DataPort, I2C_SCL); DelayUs(I2C_DELAY); cbi(I2C_DataPort, I2C_SDA); DelayUs(I2C_DELAY); cbi(I2C_DataPort, I2C_SCL); } // Stop an I2C Communication void I2C_Stop(void) { cbi(I2C_DataPort, I2C_SDA); sbi(I2C_DataPort, I2C_SCL); DelayUs(I2C_DELAY); sbi(I2C_DataPort, I2C_SDA); DelayUs(I2C_DELAY); } // Send a byte to I2C Bus void I2C_SendByte(uint8 dByte) { uint8 i; for (i = 0; i < 8; i++) { if (((dByte<<i) & 0x80) == 0x80) sbi(I2C_DataPort, I2C_SDA); else cbi(I2C_DataPort, I2C_SDA); sbi(I2C_DataPort, I2C_SCL); DelayUs(I2C_DELAY); cbi(I2C_DataPort, I2C_SCL); } // Release the bus and clock out ACK signal from Slave sbi(I2C_DataPort, I2C_SDA); sbi(I2C_DataPort, I2C_SCL); DelayUs(I2C_DELAY); cbi(I2C_DataPort, I2C_SCL); } // Read a byte from the slave uint8 I2C_ReadByte(void) { uint8 dByte = 0; uint8 i; for ( i = 0; i < 8; i++ ) { sbi(I2C_DataPort, I2C_SDA); // Release I2C_SDA sbi(I2C_DataPort, I2C_SCL); // Release I2C_SCL while((I2C_DataPins & (1<<I2C_SCL)) == 0); // Synchronize clock DelayUs(I2C_DELAY); dByte <<= 1; // Shift left the result if (I2C_DataPins & (1<<I2C_SDA)) dByte |= 0x01; // Set actual I2C_SDA state to LSB cbi(I2C_DataPort, I2C_SCL); // Force a clock cycle DelayUs(I2C_DELAY); } return dByte; } // Send an ACK or NACK signal to the slave void I2C_SendAck(uint8 ACK) { if (ACK != 0) sbi(I2C_DataPort, I2C_SDA); else cbi(I2C_DataPort, I2C_SDA); sbi(I2C_DataPort, I2C_SCL); while((I2C_DataPins & (1<<I2C_SCL)) == 0); // Synchronize clock DelayUs(I2C_DELAY); cbi(I2C_DataPort, I2C_SCL); } void SendByte(uint8 DatCmd, uint8 dByte) { I2C_Start(); I2C_SendByte(I2C_ADDR); if (DatCmd == iDat) { I2C_SendByte(0x40); } else { I2C_SendByte(0x00); } I2C_SendByte(dByte); I2C_Stop(); //DelayUs(100); // Special Delay for Character LCD } void LCD_CLS(void) { SendByte(iCmd, 0x01); DelayMs(5); // 2ms delay is Necessary after sending LCD_CLS command !!! } void midas_lcd_init(void) { // DDRC = 0x07; I2C_DataPort |= (1 < I2C_SDA)|(1 < I2C_SCL); SendByte(iCmd, 0x38); DelayUs(30); SendByte(iCmd, 0x39); // Function Set DelayUs(30); SendByte(iCmd, 0x14); // Internal OSC Frequency DelayUs(30); SendByte(iCmd, 0x7F); // Contrast Adjustment (Lower 4 bits) DelayUs(30); SendByte(iCmd, 0x5F); // Power/Icon/Contrast Control (Icon off/Booster On/C5C4=11) DelayUs(30); SendByte(iCmd, 0x6C); // Follower control DelayMs(200); SendByte(iCmd, LCD_ON); DelayUs(50); LCD_CLS(); SendByte(iCmd, LCD_ENTRY); // Entry Mode Set } /*************************************/ //i2clcd.h #define LCD_I2C // I2C Interface // --------------------------- Pins Definition --------------------------------- // I2C Interface #define I2C_DataPort PORTC #define I2C_CtrlPort PORTC #define I2C_DataPins PINC #define I2C_SCL 0 // LCD SCL #define I2C_SDA 1 // LCD SDA #define I2C_RST 3 // LCD Reset #define I2C_ADDR 0x7C // Slave Address of the LCM: 0111 110(R/W) // -------------------------- Constants definition ----------------------------- #define iDat 1 #define iCmd 0 #define LCD_ENTRY 0x06 // Set LCD Entry Mode #define LCD_ON 0x0C // Turn on LCD and Cursor #define LCD_OFF 0x08 // Turn off LCD #define I2C_DELAY 4 // Delay in Us for I2C Bus #define WAC() wait_and_clear() #define LCD_HOME 0x02 // LCD Return home #define LCD_C2L 0x10 // Move Cursor to the left #define LCD_C2R 0x14 // Move Cursor to the right #define LCD_D2L 0x18 // Move display to the left #define LCD_D2R 0x1C // Move display to the right #define LCD_CGRAM_ADDR 0x40 // Start address of LCD CGRAM #define LCD_CGMAX 64 // Max CGRAM bytes #define LCD_COL 16 #define LCD_ROW 2 #define LCD_CHAR LCD_COL*LCD_ROW #define LCD_L1 0x80 #define LCD_L2 0xC0 // LCD_Enable/Disable Macros #define LCD_Enable() cbi(LCD_CtrlPort, LCD_CS) #define LCD_Disable() sbi(LCD_CtrlPort, LCD_CS) // --------------------------- Functions Declaration --------------------------- // Port configuration of MCU void PortConfig(void); // Reset LCD void LCD_Reset(void); // Send a data or command to LCD void SendByte(unsigned char DatCmd, unsigned char dByte); unsigned char LCD_ReadData(void); // Send a byte overlayed with the orginal data void AndByte(unsigned char dByte); // Write a Byte of data to the LCD void LCD_WriteData(unsigned char dByte); // Init I2C LCD void midas_lcd_init(void); // Write a string to LCD void SendStr(unsigned char *ptString); // Move Cursor or display void Move(unsigned char dir); // Goto specific location void Gotoxy(unsigned char Row, unsigned char Col); // Tile LCD Screen with one data void Tile(unsigned char tData); // Clear LCD Screen void LCD_CLS(void); // Wait some time and clear screen void wait_and_clear(void); // Fill CGRAM with array CGRAM[] void FillCGRAM(void); // Show all patterns in CGRAM void ShowCGRAM(void); // Call built-in Charactors void CallBuiltinChar(void);

Abbildung 1:

Abbildung 2:

Abbildung 3:

Abbildung 4:

Abbildung 5:

Projekt "NETbee - Steuerung eines Roboter über WEB"

Über einen Internet-Browser lässt sich ein fahrender Roboter fernsteuern.

Basis für dieses Projekt ist ein RISC von Microchip, welcher als WEB-Server für die TCP-Kommunikation und zum übertragen der Befehle für den Roboter dient. Die Übertragungen der Signale vom WEB-Server zum Roboter erfolgen über Funk. Der WEB-Server und der Funksender, sowie der Funkempfänger mit dem Roboter, kommunizieren mittels SPI und UART.

Der Roboter ist ein Kaufteil, die Kamera ist eine CMOS Mini Cam, welche über einen DC/DC Wandler mit der Bordversorgung versorgt wird. Der Funksender wird mit einem Atmel Evaluationboard und über ein ATA-Kabel angeschlossenes Funkmodul realisiert. Der Funkempfänger wird direkt auf dem Roboter platziert.
Das Projekt teilt sich auf folgenden Phasen auf:

Phase 1: Aufbau des fahrenden Roboters und Umsetzung der notwendigen Implementierungen einer Fernsteuerung. Erweiterung der Basisfunktionen um eine Hinderniserkennung und ein LCD Display TC1602E, welches über ein I²C Modul angesteuert wird.

Phase 2: Umsetzung einer Steueroberfläche für die Steuerung über einen WEB-Browser. Die Steuerbefehle für die einzelnen Fahrfunktionen werden über Button im WEB-Browser ausgewählt und an den WEB-Server übermittelt. Die Steuerbefehle werden als einzelne ASCII-Zeichen über die UART-Schnittstelle des WEB-Servers an den Funksender übertragen. Im Funksender wird aus den ASCII-Zeichen die Steuerbefehle und die Check-Summe generiert.

Phase 3: Verbinden der Komponenten Roboterfernsteuerung und WEB-Server über Funkmodule. Die Sende- und Empfangsmodule RFM12 übermitteln die im Browser eingegebenen Daten an den Roboter und vice versa. Mittels UART werden die Daten vom WEB-Server (Typ PIC18F67J60) über einen ATtiny2313 und dann per SPI an das Sendemodul übergeben. Das Empfangsmodul überträgt die Daten wiederum per SPI direkt an die Robotersteuerung.

Unter Abbildung 5 gibt es eine Dokumentation

µC-Quellcode NETbee:

// //////////////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////// /* NETbee author Daniel Nüsse date 2011-12-30 */ // //////////////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////// /* port mapping X1 AN0 -> PA0 = DV (Sens Sek 9/12/3) AN1 -> PA1 = DV (Sens Sek 8/11/1/4) X2 AN2 -> PA2 = DV (IR LED) PC2 -> PC2 = DV (T2) X3 AN3 -> PA3 = DV (IR LED) PC3 -> PC3 = DV (T3) X4 PC0 -> PC0 = I2C (SCL) PC1 -> PC1 = I2C (SDA) X5 RxD -> PD0 = DV (T1) TxD -> PD1 = DV (T4) LED R Yellow PB0 -> LED0 LED R Red PB1 -> LED1 LED L Yellow PB3 -> LED3 LED L Red PB2 -> LED2 */ // NETbee includes #include <nibobee/iodefs.h> #include <nibobee/i2cmaster.h> //#include <nibobee/bgx1.h> #include <nibobee/analog.h> #include <nibobee/clock.h> #include <nibobee/usart.h> #include <nibobee/motpwm.h> #include <nibobee/delay.h> #include <nibobee/sens.h> #include <nibobee/led.h> //#include <nibobee/line.h> #include <nibobee/odometry.h> #include <nibobee/i2clcd.h> #include <nibobee/lcdi2c.h> // AVR includes #include <avr/interrupt.h> #include <avr/pgmspace.h> #include <avr/eeprom.h> #include <avr/io.h> #include <util/delay.h> // common includes #include <stdio.h> #include <stdlib.h> #include <string.h> // radio wave includes #include <nibobee/global.h> #include <nibobee/rf12.h> // distView defines #define AREF_VCC (_BV(REFS0) | _BV(REFS1)) #define T1 0x01 #define T2 0x04 #define T3 0x08 #define T4 0x02 #define IR_OFF 0x00 #define IR_A 0x04 #define IR_B 0x08 #define LED_YEL_L 0x01 #define LED_RED_L 0x02 #define LED_RED_R 0x04 #define LED_YEL_R 0x08 // distView defines #define REAR_LEFT 0x01 #define FRONT_LEFT 0x02 #define FRONT_RIGHT 0x04 #define REAR_RIGHT 0x08 #define SW_RADIO 0x01 #define SW_LED 0x00 // radio wave defines #define PRELOAD 55000 #define RF_PORT PORTB #define RF_DDR DDRB #define RF_PIN PINB #define LED_PORT PORTB #define SDI 5 #define SCK 7 #define CS 4 #define SDO 6 // common port defines #define SET_HIGH(PORT, BIT) ((PORT) |= (1<<BIT)) #define SET_LOW(PORT, BIT) ((PORT) &= (~(1<<BIT))) #define GET_LEVEL(PORT,BIT) ((PORT & (1<<BIT))) #define SET_INVERT(PORT,BIT) ((PORT) ^= (1<<BIT)) enum { MODE_STOP, MODE_DRIVE, MODE_BACK, MODE_STEER_R, MODE_STEER_L, MODE_AVOID_R, MODE_AVOID_L }; // global variables int16_t speed_l; int16_t speed_r; uint16_t counter_ms; uint8_t perform_check(uint8_t mode); uint8_t do_stop(); uint8_t do_drive(); uint8_t do_back(); uint8_t do_steer_r(); uint8_t do_steer_l(); uint8_t do_avoid_r(); uint8_t do_avoid_l(); unsigned char RF_RXBUF[22]; volatile int i = 0; // ISR Timer1-Ueberlauf ISR(TIMER1_OVF_vect) { TCNT1 = PRELOAD; // Preloadwert setzen i++; } /**************************************************************** Distance View */ uint16_t analog_measure(uint8_t mux) { ADMUX = mux; ADCSRA = _BV(ADPS2) // prescale faktor = 128 ADC laeuft | _BV(ADPS1) // mit 15 MHz / 128 = 120 kHz | _BV(ADPS0) | _BV(ADEN) // enable ADC | _BV(ADSC); // start conversion while (ADCSRA & _BV(ADSC)) { // ADC conversion } uint16_t result = ADC; return result; } void showState(uint8_t state) { PORTB &= (uint8_t)~0x0F; switch (state) { case 0: PORTB |= 0x00; break; case 1: PORTB |= LED_YEL_L; // barriers on the rear left side break; case 2: PORTB |= LED_RED_L; // barriers on the front left side break; case 4: PORTB |= LED_RED_R; // barriers on the front right side break; case 8: PORTB |= LED_YEL_R; // barriers on the rear right side break; } } void setupTransistor(uint8_t val) { PORTC |= (T2|T3); // PNP at X2 and X3 off PORTD |= (T1|T4); // PNP at X5 off if(val == T1 || val == T4) PORTD &= ~val; else PORTC &= ~val; } void setupIR(uint8_t val) { PORTA |= (IR_A | IR_B); PORTA &= ~val; } uint16_t measure(uint8_t i) { int16_t val = 0; setupIR(IR_OFF); // all IR-LEDs off PORTA &= ~0x03; // infrared sensors on switch (i) { case 0: setupTransistor(T1); break; case 1: setupTransistor(T1); break; case 2: setupTransistor(T2); break; case 3: setupTransistor(T2); break; case 4: setupTransistor(T3); break; case 5: setupTransistor(T3); break; case 6: setupTransistor(T4); break; case 7: setupTransistor(T4); break; } switch (i) { case 1: case 3: case 4: case 6: setupIR(IR_B); _delay_ms(1); val = analog_measure(0 | AREF_VCC); setupIR(IR_OFF); _delay_ms(1); val -= analog_measure(0 | AREF_VCC); break; case 0: case 2: case 5: case 7: setupIR(IR_A); _delay_ms(1); val = analog_measure(1 | AREF_VCC); setupIR(IR_OFF); _delay_ms(1); val -= analog_measure(1 | AREF_VCC); break; } if (val<0) { val=0; } return val; } void portSwitch(uint8_t action) { if(action) // switch port functions between radio wave transmission and Distance View { RF_DDR=(1<<SDI)|(1<<SCK)|(1<<CS); RF_PORT=(1<<CS); } else { led_init(); } } /**************************************************************** radio wave */ unsigned short rf12_trans(unsigned short wert) { unsigned short werti=0; unsigned char i; cbi(RF_PORT, CS); for (i=0; i<16; i++) { if (wert&32768) sbi(RF_PORT, SDI); else cbi(RF_PORT, SDI); werti<<=1; if (RF_PIN&(1<<SDO)) werti|=1; sbi(RF_PORT, SCK); wert<<=1; _delay_us(0.5); cbi(RF_PORT, SCK); } sbi(RF_PORT, CS); return werti; } void rf12_init(void) { RF_DDR=(1<<SDI)|(1<<SCK)|(1<<CS); RF_PORT=(1<<CS); _delay_us(10); rf12_trans(0xC0E0); // AVR CLK: 10MHz rf12_trans(0x80D7); // Enable FIFO rf12_trans(0xC2AB); // Data Filter: internal rf12_trans(0xCA81); // Set FIFO mode rf12_trans(0xE000); // disable wakeuptimer rf12_trans(0xC800); // disable low duty cycle rf12_trans(0xC4F7); // AFC settings: autotuning: -10kHz...+7,5kHz } void rf12_setbandwidth(unsigned char bandwidth, unsigned char gain, unsigned char drssi) { rf12_trans(0x9400|((bandwidth&7)<<5)|((gain&3)<<3)|(drssi&7)); } void rf12_setfreq(unsigned short freq) { if (freq<96) // 430,2400MHz freq=96; else if (freq>3903) // 439,7575MHz freq=3903; rf12_trans(0xA000|freq); } void rf12_setbaud(unsigned short baud) { if (baud<664) return; if (baud<5400) // Baudrate= 344827,58621/(R+1)/(1+CS*7) rf12_trans(0xC680|((43104/baud)-1)); else rf12_trans(0xC600|((344828UL/baud)-1)); } void rf12_setpower(unsigned char power, unsigned char mod) { rf12_trans(0x9800|(power&7)|((mod&15)<<4)); } void rf12_ready(void) { cbi(RF_PORT, SDI); cbi(RF_PORT, CS); while (!(RF_PIN&(1<<SDO))); // wait until FIFO ready } void rf12_txdata(unsigned char *data, unsigned char number) { unsigned char i; rf12_trans(0x8238); // TX on rf12_ready(); rf12_trans(0xB8AA); rf12_ready(); rf12_trans(0xB8AA); rf12_ready(); rf12_trans(0xB8AA); rf12_ready(); rf12_trans(0xB82D); rf12_ready(); rf12_trans(0xB8D4); for (i=0; i<number; i++) { rf12_ready(); rf12_trans(0xB800|(*data++)); } rf12_ready(); _delay_us(10); rf12_trans(0x8208); // TX off } void rf12_rxdata(unsigned char *data, unsigned char number) { unsigned char i; rf12_trans(0x82C8); // RX on rf12_trans(0xCA81); // set FIFO mode rf12_trans(0xCA83); // enable FIFO for (i=0; i<number; i++) { rf12_ready(); *data++=rf12_trans(0xB000); } rf12_trans(0x8208); // RX off } /****************************************************************/ unsigned char * receive(unsigned char * test) { rf12_rxdata(test,32); // daten verarbeiten return test; } /****************************************************************/ void send(unsigned char * test) { lcd_printlc(2,1,(unsigned char *)test); rf12_txdata(test,32); } /**************************************************************** Main */ int main() { unsigned char data[32]; unsigned char test[] = "A"; uint8_t cntDV = 0; // value for dist View uint8_t mode = MODE_STOP; char s[10]; unsigned char cmd[] = "S", crash = 0; uint8_t clear = 0; uint16_t value = 0; uint8_t dir = 0; // Timer init TCNT1 = PRELOAD; // set Preload value TCCR1B |= (1 << CS02) | (1 << CS00); // set Prescaler Timer1 to 1024 TIMSK |= (1 << TOIE1); // Timer 1 Overflow Interrupt enable // set port pins as outputs DDRA |= (IR_A|IR_B); DDRC |= (T2|T3); DDRD |= (T1|T4); sei(); // Interrupts einschalten portSwitch(SW_LED); led_set(LED_L_RD, 1); led_set(LED_R_RD, 1); led_set(LED_L_YE, 1); led_set(LED_R_YE, 1); /**************************************************************** LCD init */ i2c_init(); // TWI init lcd_init(); // LCD init lcd_command(LCD_CLEAR); lcd_backlight(OFF); lcd_printlc(1,1,(unsigned char *)"**** NETBee ****"); lcd_printlc(2,1,(unsigned char *)"Voxsoft, 2011"); lcd_wait_ms(1500); lcd_command(LCD_CLEAR); led_set(LED_L_RD, 0); /**************************************************************** actuator and sensor init */ motpwm_init(); led_set(LED_R_YE, 0); odometry_init(); odometry_reset(); led_set(LED_L_YE, 0); sens_init(); led_set(LED_R_RD, 0); /**************************************************************** cyclic main task */ rf12_init(); // RFM12 init rf12_setfreq(RF12FREQ(433.92)); // Sende/Empfangsfrequenz auf 433,92MHz einstellen rf12_setbandwidth(4, 1, 4); // 200kHz Bandbreite, -6dB Verstärkung, DRSSI threshold: -79dBm rf12_setbaud(19200); // 19200 baud rf12_setpower(0, 6); // 1mW Ausgangangsleistung, 120kHz Frequenzshift // Hauptschleife: while(1==1) { enable_interrupts(); delay(1); /* mode = perform_check(mode); wheel_cnt = odometry_getLeft(0); itoa(wheel_cnt, s, 8); // lcd_printlr(1, 8, (unsigned char *)s); wheel_cnt = odometry_getRight(0); itoa(wheel_cnt, s, 8); // lcd_printlr(2, 8, (unsigned char *)s); */ lcd_command(LCD_CLEAR); lcd_printlc(1,1,(unsigned char *)"Receiving......."); strcpy(cmd,receive(data)); lcd_printlc(2,1,(unsigned char *) cmd); _delay_ms(50); if(!strcmp(cmd, "S")) mode = MODE_STOP; else if (!strcmp(cmd, "R")) mode = MODE_STEER_R; else if (!strcmp(cmd, "L")) mode = MODE_STEER_L; else if (!strcmp(cmd, "B")) mode = MODE_BACK; else if (!strcmp(cmd, "F")) mode = MODE_DRIVE; else if(!strcmp(cmd, "SR")) { portSwitch(SW_LED); clear = 1; cntDV = 0; for (uint8_t i=0; i<8; ++i) { value = measure(i); switch (i) { case 0: case 1: dir = REAR_LEFT; break; case 2: case 3: dir = FRONT_LEFT; break; case 4: case 5: dir = REAR_RIGHT; break; case 6: case 7: dir = FRONT_RIGHT; break; } if (value>8) { // Reflexion > 8 clear = 0; showState(dir); cntDV |= dir; // sum value for dist view } else { if (!clear) { showState(0); } } } portSwitch(SW_RADIO); lcd_command(LCD_CLEAR); lcd_printlc(1,1,(unsigned char *)"Sending"); _delay_ms(100); send((unsigned char*) itoa(cntDV,test,10)); } else if (!strcmp(cmd, "A")) lcd_backlight(ON); else if (!strcmp(cmd, "C")) lcd_backlight(OFF); if(sens_getLeft()!=0 || sens_getRight()!=0) { mode = MODE_STOP; crash = 1; delay(1); } if(crash) { motpwm_setLeft(-200); motpwm_setRight(-200); crash = 0; } else switch (mode) { case MODE_STOP: speed_l = 0; speed_r = 0; break; case MODE_DRIVE: speed_l = 500; speed_r = 480; break; case MODE_BACK: speed_l = -500; speed_r = -500; break; case MODE_STEER_R: speed_l = 400; speed_r = 50; break; case MODE_STEER_L: speed_l = 50; speed_r = 200; break; case MODE_AVOID_R: speed_l = -400; speed_r = -600; break; case MODE_AVOID_L: speed_l = -600; speed_r = -400; break; } motpwm_setLeft(speed_l); motpwm_setRight(speed_r); } return 0; } /**************************************************************** end main() */ uint8_t perform_check(uint8_t mode) { if (sens_getLeft() && sens_getRight()) { if ((sens_getLeft()==-1) && (sens_getRight()==-1)) { mode = MODE_BACK; } else { mode = MODE_STOP; } } return mode; } uint8_t do_stop() { if ((sens_getLeft()==0) && (sens_getRight()==0)) { return MODE_DRIVE; } return MODE_STOP; } uint8_t do_back() { if (sens_getLeft()==0) { return MODE_AVOID_L; } if (sens_getRight()==0) { return MODE_AVOID_R; } return MODE_BACK; } uint8_t do_drive() { if (sens_getRight()==1) { return MODE_STEER_L; } if (sens_getLeft()==1) { return MODE_STEER_R; } if (sens_getRight()==-1) { return MODE_AVOID_L; } if (sens_getLeft()==-1) { return MODE_AVOID_R; } return MODE_DRIVE; } uint8_t do_steer_r() { if (sens_getLeft()==0) { return MODE_DRIVE; } return MODE_STEER_R; } uint8_t do_steer_l() { if (sens_getRight()==0) { return MODE_DRIVE; } return MODE_STEER_L; } uint8_t do_avoid_r() { if (counter_ms==0) { counter_ms=1000; } else { counter_ms--; } if (counter_ms) { return MODE_AVOID_R; } else { return MODE_DRIVE; } } uint8_t do_avoid_l() { if (counter_ms==0) { counter_ms=1000; } else { counter_ms--; } if (counter_ms) { return MODE_AVOID_L; } else { return MODE_DRIVE; } } // ----------------------------------------------------------- void print_hex (uint8_t val) { char c1=val/16; char c2=val%16; if (c1<10) c1+='0'; else c1+='a'-10; if (c2<10) c2+='0'; else c2+='a'-10; usart_putchar(c1); usart_putchar(c2); }

µC-Quellcode NETbee base(Funksendeempfänger):

µC-Quellcode WEB-Server (NETraction):
// //////////////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////// /* NETraction author Daniel Nüsse date 2011-12-30 */ // //////////////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////// #define NETRACTION_C #define BAUD 19200 #define SPBRG_VALUE ((PIC_CLK/(16UL * BAUD) -1)) #define BRGH_VALUE 1 // //////////////////////////////////////////////////////////////////////////// // Includes // //////////////////////////////////////////////////////////////////////////// #include "netraction.h" #include <delays.h> #include "eeprom.h" #include "serial.h" #include "projectdefs.h" // //////////////////////////////////////////////////////////////////////////// // Global variables // //////////////////////////////////////////////////////////////////////////// static unsigned char zustand1=0, zustand3=0, zustand4=0; #pragma idata g uint8_t distView[49] = { 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x01 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , }; #pragma idata // //////////////////////////////////////////////////////////////////////////// // Several delay routines // //////////////////////////////////////////////////////////////////////////// void Delay_1s(void) // Delay { unsigned int i,j; for (i=0;i<10;i++) { Delay_100ms(); } } void Delay_05s(void) { unsigned int i,j; for (i=0;i<5;i++) { Delay_100ms(); } } void Delay_10ms(void) { unsigned int i,j; for (i=0;i<7;i++) { Delay100TCYx(100); } } void Delay_100ms(void) { unsigned int i; for (i=0;i<10;i++) { Delay_10ms(); } } void Delay_10s(void) { unsigned int i; for (i=0;i<10;i++) { Delay_1s(); } } // //////////////////////////////////////////////////////////////////////////// // Subroutine to handle the different switch states // //////////////////////////////////////////////////////////////////////////// char switchReadIn (unsigned char swich) // read in of switch states { char rw = 0; switch(swich) { case SW1: if(zustand1 == 0 && bGPIOGetPinValue(swich)) //Taster wird gedrueckt (steigende Flanke) { zustand1 = 1; rw = 1; } else if (zustand1 == 1 && bGPIOGetPinValue(swich)) //Taster wird gehalten { zustand1 = 2; rw = 2; } else if (zustand1 == 2 && !bGPIOGetPinValue(swich)) //Taster wird losgelassen (fallende Flanke) { zustand1 = 3; rw = 3; } else if (zustand1 == 3 && !bGPIOGetPinValue(swich)) //Taster losgelassen { zustand1 = 0; rw = 4; } return rw; case SW3: if(zustand3 == 0 && bGPIOGetPinValue(swich)) //Taster wird gedrueckt (steigende Flanke) { zustand3 = 1; rw = 1; } else if (zustand3 == 1 && bGPIOGetPinValue(swich)) //Taster wird gehalten { zustand3 = 2; rw = 2; } else if (zustand3 == 2 && !bGPIOGetPinValue(swich)) //Taster wird losgelassen (fallende Flanke) { zustand3 = 3; rw = 3; } else if (zustand3 == 3 && !bGPIOGetPinValue(swich)) //Taster losgelassen { zustand3 = 0; rw = 4; } return rw; case SW4: if(zustand4 == 0 && bGPIOGetPinValue(swich)) //Taster wird gedrueckt (steigende Flanke) { zustand4 = 1; rw = 1; } else if (zustand4 == 1 && bGPIOGetPinValue(swich)) //Taster wird gehalten { zustand4 = 2; rw = 2; } else if (zustand4 == 2 && !bGPIOGetPinValue(swich)) //Taster wird losgelassen (fallende Flanke) { zustand4 = 3; rw = 3; } else if (zustand4 == 3 && !bGPIOGetPinValue(swich)) //Taster losgelassen { zustand4 = 0; rw = 4; } return rw; } } // //////////////////////////////////////////////////////////////////////////// // Initialisation of all used ports // //////////////////////////////////////////////////////////////////////////// void NETractionInit(void) { GPIOSetDirection(LEDyl, 0); GPIOSetPortValue(LEDyl, 1); GPIOSetDirection(LEDrd, 0); GPIOSetPortValue(LEDrd, 1); GPIOSetDirection(LEDgr, 0); GPIOSetPortValue(LEDgr, 0); GPIOSetDirection(SW1, 1); GPIOSetDirection(SW3, 1); GPIOSetDirection(SW4, 1); GPIOSetDirection(SBSW, 0); GPIOSetPortValue(SBSW, 0); GPIOSetDirection(LCD_CS, 0); GPIOSetPortValue(LCD_CS, 0); GPIOSetDirection(LCD_CL, 0); GPIOSetPortValue(LCD_CL, 0); GPIOSetDirection(LCD_SD, 0); GPIOSetPortValue(LCD_SD, 0); GPIOSetDirection(LCD_RS, 0); GPIOSetPortValue(LCD_RS, 0); } // //////////////////////////////////////////////////////////////////////////// // Handle LCD Standby over Switch 4 // //////////////////////////////////////////////////////////////////////////// void LCD_Standby_Handler_NET(void) { char text[30], start[20]; if(!bGPIOGetPinValue(SBSW)) { if(standbyFlag) { GPIOSetPortValue(SBSW, 1); } } else if(bGPIOGetPinValue(SBSW) && standbyFlag) { GPIOSetPortValue(SBSW, 0); Delay_100ms(); Delay_100ms(); lcd_init(); lcd_clear(GREEN,0,0,131,131); strcpypgm2ram(start,"Standby deactivated"); lcd_draw_text(BLACK, GREEN, 5, 5, start); GPIOSetPortValue(LEDrd, 1); Delay_1s(); standbyFlag = 0; } else if(bGPIOGetPinValue(SBSW) && !standbyFlag) { standbyFlag = 1; } } // //////////////////////////////////////////////////////////////////////////// // Handle LCD Standby over web page // //////////////////////////////////////////////////////////////////////////// void LCD_Standby_Handler_SW(void) { char start[20]; if(!bGPIOGetPinValue(SBSW)) { lcd_clear(RED,0,0,131,131); strcpypgm2ram(start,"Standby activated"); lcd_draw_text(BLACK, RED, 5, 5, start); Delay_1s(); GPIOSetPortValue(LEDrd, 0); GPIOSetPortValue(LEDgr, 1); GPIOSetPortValue(SBSW, 1); standbyFlag = 1; } else if(bGPIOGetPinValue(SBSW)) { GPIOSetPortValue(SBSW, 0); Delay_100ms(); Delay_100ms(); lcd_init(); lcd_clear(GREEN,0,0,131,131); strcpypgm2ram(start,"Standby deactivated"); lcd_draw_text(BLACK, GREEN, 5, 5, start); GPIOSetPortValue(LEDrd, 1); GPIOSetPortValue(LEDgr, 0); Delay_1s(); standbyFlag = 0; LCD_STARTPAGE(); } } // //////////////////////////////////////////////////////////////////////////// // INIT Task // //////////////////////////////////////////////////////////////////////////// void NETractionTask (void) // main { unsigned char switchState = 0; char getCH[6]; // Switch LCD reset switchState = switchReadIn(SW1); if(switchState == 1) GPIOSetPortValue(LEDyl, 0); else if(switchState == 4 /* || switchState == 3*/) { GPIOSetPortValue(LEDyl, 1); lcd_init(); LCD_STARTPAGE(); } // Switch empty switchState = switchReadIn(SW3); if(switchState == 1) GPIOSetPortValue(LEDyl, 0); else if(switchState == 4 /*|| switchState == 3*/) { GPIOSetPortValue(LEDyl, 1); } // Switch Standby switchState = switchReadIn(SW4); if(switchState == 1) { GPIOSetPortValue(LEDyl, 0); } else if(switchState == 4 /*|| switchState == 3*/) { GPIOSetPortValue(LEDyl, 1); LCD_Standby_Handler_SW(); } } unsigned char getch(void) { while(!PIR1bits.RCIF) //set when register is empty { /* clear_usart_errors_inline; CLRWDT();*/ } return RCREG; } void putch(unsigned char c) { while(!PIR1bits.TXIF) //set when register is empty { /* clear_usart_errors_inline; CLRWDT();*/ } TXREG=c; } /**************************************/ /* flight control */ /**************************************/ void driveCNT(char *text) { int i = 0; unsigned char c; char dispText[60]; int cur_len = strlen(dispText); if(!strcmppgm2ram(text,"BL on")) putch('A'); else if(!strcmppgm2ram(text,"BL off")) putch('C'); else if(!strcmppgm2ram(text,"DiVi")) { GPIOSetPortValue(LEDyl, 0); putch('D'); // get sensor information c = getch(); /* dispText[cur_len] = c; dispText[cur_len+1] = '\0'; lcd_clear(MAGENTA,0,0,131,131); lcd_draw_text(BLUE, MAGENTA, 5, 5, dispText); */ for (i = 0; i<49; i++) // clear Dist Viw matrix { distView[i] = 0; } distView[24] = 1; // set center point strcpypgm2ram(dispText,"DiVi: "); if(c & 0x01) { distView[21] = distView[22] = distView[29] = distView[30] = distView[36] = distView[43] = 1; strcatpgm2ram(dispText,"Rear Left - "); } if(c & 0x02) { distView[0] = distView[1] = distView[2] = distView[7] = distView[8] = distView[9] = distView[14] = distView[15] = 1; strcatpgm2ram(dispText,"Front Left - "); } if(c & 0x04) { distView[4] = distView[5] = distView[6] = distView[11] = distView[12] = distView[13] = distView[19] = distView[20] = 1; strcatpgm2ram(dispText,"Front Right - "); } if(c & 0x08) { distView[27] = distView[28] = distView[34] = distView[35] = distView[42] = distView[49] = 1; strcatpgm2ram(dispText,"Rear right - "); } GPIOSetPortValue(LEDyl, 1); lcd_clear(MAGENTA,0,0,131,131); draw_text_scale(BLUE, MAGENTA, 5, 5, dispText); } else if(!strcmppgm2ram(text,"Feature")) { for (i = 0; i<49; i++) { distView[i] = 0; } putch('E'); } else if(!strcmppgm2ram(text,"Right")) putch('R'); else if(!strcmppgm2ram(text,"Left")) putch('L'); else if(!strcmppgm2ram(text,"Forward")) putch('F'); else if(!strcmppgm2ram(text,"Backward")) putch('B'); else if(!strcmppgm2ram(text,"Hold")) putch('H'); } /**************************************/ /* distance view control */ /**************************************/ uint8_t GetDistView(unsigned long no) { unsigned long first = 0x00000071; // value of first depends on ID of DV1 in HTTPPrint.h if (distView[no-first] == 0x01) return 1; else return 0; }

Abbildung 1:

Abbildung 2:

Abbildung 3:

Abbildung 4:

Abbildung 5:

Abbildung 6:

Projekt "NETcopter - Steuerung eines RC Helis über WEB"

Über einen Internet-Browser lässt sich ein Modellhubschrauber fernsteuern.

Basis für dieses Projekt ist ein RISC von Microchip, welcher als WEB-Server für die TCP-Kommunikation und zum übertragen der Befehle für den Hubschrauber dient. Der Hubschrauber wird über Infrarot ferngesteuert, der IR-Sender ist mit einem ATtiny2313 realisiert und eine Übertragung der Signale vom WEB-Server zur Fernsteuerung erfolgen über Funk. Der WEB-Server und der Funksender, sowie der Funkempfänger und die IR-Fernsteuerung kommunizieren mittels SPI und UART.

Abbildung 1 bis 3 zeigen einige verwendete Komponenten des Projektes. Der RC-Hubschrauber ist ein Graupner Nano Star, die Kamera ist eine CMOS Mini Cam, welche über einen DC/DC Wandler mit der Helikopterversorgung versorgt wird. Der Funksender wird mit einem Atmel Evaluationboard und über ein ATA-Kabel angeschlossenes Funkmodul realisiert. Der Funkempfänger und Infrarotsender sind auf einer separaten Platine aufgebaut.
Das Projekt teilt sich auf folgenden Phasen auf:

Phase 1: Emulierung der Infrarotsteuerung des Helikopters mit einem eigenen Sendemodul und Rekonstruktion des Infrarotprotokolls zur Fremdsteuerung. Wie in Abbildung 4 zu sehen, wurde das Datenprotokoll mittels eines PDA IR-Fernbedienungsprogramm aufgenommen und anschließend in C und dem ATtiny2313 umgesetzt.

Graupner Nano Star IR code:

data frame

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

header up/down left/right forward/backward trim: left/right Channel A/B/C checksum Stop

value 1/0 value 1/0 value 3F/0 value 4/2/0

bit 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

example 1 1 1 1 0 0 1 1 1 1 1 1 1 0 0 0 0 0 0 1 0 1 1 1 0 1 0 0 0 1 0 1 0

checksum 15 3 15 8 1 7 4 5

calculation modulo16(15+3+15+8+1+7+4) = 5

Phase 2: Umsetzung einer Steueroberfläche für die Steuerung über einen WEB-Browser. Die Steuerbefehle für die einzelnen Helikopterfunktionen werden über Button im WEB-Browser ausgewählt und an den WEB-Server übermittelt. Die Steuerbefehle werden als einzelne ASCII-Zeichen über die UART-Schnittstelle des WEB-Servers an den Funksender übertragen. Im Funksender wird aus den ASCII-Zeichen der IR-Code und die Check-Summe generiert.

Phase 3: Verbinden der Komponenten IR-Fernsteuerung und WEB-Server über Funkmodule. Die Sende- und Empfangsmodule RFM01 und RFM02 übermitteln die im Browser eingegebenen Daten an die IR-Steuereinheit. Mittels UART werden die Daten vom WEB-Server (Typ PIC18F67J60) über einen ATtiny2313 per SPI an das Sendemodul übergeben. Das Empfangsmodul überträgt die Daten wiederum per SPI an einen ATtiny2313, welcher die Steuerdaten über Infrarot an den Helikopter sendet.

Phase 4: Implementierung aller Teilphasen zu einem Gesamtprojekt.

Unter Abbildung 6 gibt es eine Dokumentation

µC-Quellcode Funkempfänger und IR-Sender:

main.c /* IR_Transmitter with radiowave receiver Prozessor: ATtiny2313 @8MHz Frequenz: 434MHz Datenrate: 4.8kbps ----------------------- ATtiny2313 RFM01 ----------------------- SCK SCK MISO SDO MOSI SDI SS nSEL INT0 nIRQ PD6 LED2 PD5 LED1 **********************************************************************/ #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> //max 262,14ms / 8 MHz = 0,033ms -> _delay_ms(1/10ms) #include <stdlib.h> #include <stdio.h> #include <avr/sleep.h> #define DDR_IN 0 #define DDR_OUT 1 #define PORT_SEL PORTB #define PIN_SEL PINB #define DDR_SEL DDRB #define PORT_SDI PORTB #define PIN_SDI PINB #define DDR_SDI DDRB #define PORT_SCK PORTB #define PIN_SCK PINB #define DDR_SCK DDRB #define PORT_SDO PORTB #define PIN_SDO PINB #define DDR_SDO DDRB #define PORT_LED PORTD #define DDR_LED DDRD #define PB7 7 #define PB6 6 #define RFM01_SCK 7 #define RFM01_SDO 6 #define RFM01_SDI 5 #define RFM01_SEL 4 #define RFM01_DATA 3 #define PB0 0 #define SEL_OUTPUT() DDR_SEL |= (1<<RFM01_SEL) #define HI_SEL() PORT_SEL |= (1<<RFM01_SEL) #define LOW_SEL() PORT_SEL &= ~(1<<RFM01_SEL) #define SDI_OUTPUT() DDR_SDI |= (1<<RFM01_SDI) #define HI_SDI() PORT_SDI |= (1<<RFM01_SDI) #define LOW_SDI() PORT_SDI &= ~(1<<RFM01_SDI) #define SDO_INPUT() DDR_SDO &= ~(1<<RFM01_SDO) #define SDO_HI() PIN_SDO&(1<<RFM01_SDO) #define SCK_OUTPUT() DDR_SCK |= (1<<RFM01_SCK) #define HI_SCK() PORT_SCK |= (1<<RFM01_SCK) #define LOW_SCK() PORT_SCK &= ~(1<<RFM01_SCK) #define LED2_OUTPUT() DDR_LED |= (1<<6) #define LED2_OFF() PORT_LED &= ~(1<<6) #define LED2_ON() PORT_LED |= (1<<6) #define LED2_TRG() PORT_LED ^= (1<<6) #define SET_HIGH(PORT, BIT) ((PORT) |= (1<<BIT)) #define SET_LOW(PORT, BIT) ((PORT) &= (~(1<<BIT))) #define GET_LEVEL(PORT,BIT) ((PORT & (1<<BIT))) #define SET_INVERT(PORT,BIT) ((PORT) ^= (1<<BIT)) #define MAX_BITCOUNT 128 // modulation square wave generation // compare output mode: toggle OC0A on compare match // if COM0Ax are *all* unset, the waveform generation is disabled and // the normal PORTx value is seen on the OC0A pin. #define ENABLE_MODULATION (TCCR0A |= _BV(COM0A0)) #define DISABLE_MODULATION (TCCR0A &= ~_BV(COM0A0)) // activate half bit timer #define ENABLE_BIT_TIMER (TCCR1B |= _BV(CS10)) #define DISABLE_BIT_TIMER (TCCR1B &= ~_BV(CS10)) /* // button control // MCUCR is setup by rising edge of INT0, external // interrupt needs to be turned on or off #define ENABLE_BUTTONS (GIMSK |= _BV(INT0)) #define DISABLE_BUTTONS (GIMSK &= ~_BV(INT0)) */ // flight control commands #define CMD_STOPBIT 0b00000000; unsigned char RF_RXBUF[22]; volatile uint32_t data1 = 0; // data bits part 1 volatile uint8_t data2 = 0; // stop bit volatile uint32_t changer = 0; // change command values volatile uint32_t datsafer = 0; // safes the last command values volatile uint8_t header = 0; // volatile uint8_t headercnt = 0; volatile uint8_t bitcounter = MAX_BITCOUNT; volatile uint8_t bitstate = 0; volatile uint8_t start = 1; volatile uint8_t init = 1; /**********************************************************/ void flightControl(void) { uint8_t bit = 0; if(bitcounter <= 34) bit = ((data1 & 0x80000000) >> 31); // separate each bit for transmission else bit = ((data2 & 0x80) >> 7); // separate each bit for transmission SET_HIGH(PORTD, PD5); // displaying transmission if (bitstate == 0) // define header and active bit lenght ("high") { bitstate = 1; // bitstate toogles for low and high levels if(header) // transmit header bit { header = 0; // only once in a cycle ENABLE_MODULATION; // start modulation OCR1A = 12000; // set header bit lenght } else if(bit) // if data bit is "1" { ENABLE_MODULATION; // start modulation (40kHz) OCR1A = 7400; // set bit lenght for "1" data1 <<= 1; // shift data value to the left bitcounter++; // increment counter after sending bit } else if(!bit) // if data bit is "0" { ENABLE_MODULATION; // start modulation OCR1A = 2700; // set bit lenght for "0" data1 <<= 1; // shift data value to the left bitcounter++; // increment counter after sending bit } } else // define pause lenght after transmission of a data bit "low" { bitstate = 0; // stop sending a data bit DISABLE_MODULATION; // stop modulation OCR1A = 2700; // set bit lenght for "low" } if(bitcounter == 34) // after sending a data frame { // DISABLE_BUTTONS; // disable button interupt for wait state between frames DISABLE_MODULATION; // stop modulation DISABLE_BIT_TIMER; // stop timer interupt SET_LOW(PORTD, PD5); // displaying transmission _delay_ms(100); // define wait state between frames // ENABLE_BUTTONS; // enable button interupt for wait state between frames start = 1; // enable while loop in main() for next frame } } /****************************************************/ uint8_t checkSum(void) { uint8_t cs1 = 0, cs2 = 0, cs3 = 0, cs4 = 0, cs5 = 0, cs6 = 0, cs7 = 0; uint32_t temp = 0; // checksum calculation cs1 = (RF_RXBUF[6] & 0xF0) >> 4; // get value of bits 28-31... cs2 = (RF_RXBUF[6] & 0x0F); cs3 = (RF_RXBUF[7] & 0xF0) >> 4; cs4 = (RF_RXBUF[7] & 0x0F); cs5 = (RF_RXBUF[8] & 0xF0) >> 4; cs6 = (RF_RXBUF[8] & 0x0F); cs7 = (RF_RXBUF[9] & 0xF0) >> 4; temp = RF_RXBUF[6]; data1 = ((data1 & 0x00000000) | (temp << 24)); // set value of bits 24-31... temp = RF_RXBUF[7]; data1 = ((data1 & 0xFF000000) | (temp << 16)); temp = RF_RXBUF[8]; data1 = ((data1 & 0xFFFF0000) | (temp << 8)); temp = RF_RXBUF[9]; data1 = ((data1 & 0xFFFFFF00) | (temp)); // checksum is the modulo of 16 return (cs1 + cs2 + cs3 + cs4 + cs5 + cs6 + cs7) % 16; } /****************************************************/ void sendCMD(void) { start = 0; // stop while loop in main() to disable double sending bitcounter = 0; // stop reset bitcounter for transmission header = 1; // set header bit for transmit header first // sleep_disable(); // DISABLE_BUTTONS; // stop button interupt ENABLE_BIT_TIMER; // start timer interupt for transmission } /*****************************************************/ /* ISR(INT0_vect) { init = 1; // set ini bit for initialisation frame at startup start = 1; // aktivate while loop in main() global = !global; // global enable for start transmission at button interrupt }*/ /****************************************************/ ISR(TIMER1_COMPA_vect) { flightControl(); } /****************************************************/ void RFM01_PORT_INIT(void) { HI_SEL(); HI_SDI(); LOW_SCK(); SEL_OUTPUT(); SDI_OUTPUT(); SDO_INPUT(); SCK_OUTPUT(); } /***********************************************/ unsigned int RFM01_WRT_CMD(unsigned int aCmd) { unsigned char i; unsigned int temp = 0; LOW_SCK(); LOW_SEL(); for(i=0;i<16;i++) { temp<<=1; if(SDO_HI()) { temp|=0x0001; } LOW_SCK(); if(aCmd&0x8000) { HI_SDI(); } else { LOW_SDI(); } HI_SCK(); aCmd<<=1; }; LOW_SCK(); HI_SEL(); return(temp); } /**********************************************/ void readData(void) { unsigned char i, j, Result, number = 19; LOW_SDI(); for(i=0;i<number;i++) { LOW_SEL(); while(!(SDO_HI())); for(j=0;j<16;j++) {//skip status bits HI_SCK(); asm("nop"); LOW_SCK(); asm("nop"); } Result=0; for(j=0;j<8;j++) {//read fifo data byte Result<<=1; if(SDO_HI()) Result|=1; HI_SCK(); // asm("nop"); _delay_us(0.3); LOW_SCK(); }; RF_RXBUF[i] = Result; HI_SEL(); } } /*******************************************/ int main(void) { unsigned char i; // Timer configuration // setup rc oscillator clock divider to div 1 // (=> 8MHz with internal RC oscollator) CLKPR = _BV(CLKPCE); // enable clock prescale change CLKPR = 0; // div1 => 8 MHz // setup waveform generation to 40kHz on timer 0 TCCR0A |= _BV(WGM01); // Clear timer on compare match TCCR0B |= _BV(CS00); // timer source is system clock // verify correct frequency! The internal oscillator is not really accurate OCR0A = 104; //40,07kHz -> 105 // setup half-bit clock to header lenght on timer1 TCCR1A = 0; // no changes at register A TCCR1B = _BV(WGM12); // Clear timer on compare match // verify correct frequency! The internal oscillator is not really accurate OCR1A = 12000; // set header leanght TIMSK |= _BV(OCIE1A); // output compare interrupt enable 1a //PORT configuration // MCUCR |= _BV(ISC01); // INT0 on risig edge DDRB |= _BV(PB2); // PB2 as output PORTB &= ~_BV(PB2); // PB2 is low DDRD |= _BV(PD5); //LED output //general configuration ACSR |= _BV(ACD); // save energy, disable analog comaprator // ENABLE_BUTTONS; // setup external interrupt sei(); // enable interrupts //receive configuration RFM01_PORT_INIT(); RFM01_WRT_CMD(0x0000); RFM01_WRT_CMD(0x898A);//433BAND, 134kHz RFM01_WRT_CMD(0xA640);//434MHz RFM01_WRT_CMD(0xC847);//4.8kbps RFM01_WRT_CMD(0xC69B);//AFC setting RFM01_WRT_CMD(0xC42A);//Clock recovery manual control,Digital filter,DQD=4 RFM01_WRT_CMD(0xC240);//output 1.66MHz RFM01_WRT_CMD(0xC080); RFM01_WRT_CMD(0xCE88);//use FIFO before = CE88 RFM01_WRT_CMD(0xCE8B);//before = CE8B RFM01_WRT_CMD(0xC081);//OPEN RX , before C081 DDRD |= (1<<RFM01_DATA); DDRD &= ~(1<<2); //POWER ON indication: LED blink 3 times LED2_OUTPUT(); for(i=0;i<3;i++) { _delay_ms(500); LED2_ON(); _delay_ms(200); LED2_OFF(); } i=0; for(;;) { RFM01_WRT_CMD(0xCE88); //reset FIFO for next frame recognition RFM01_WRT_CMD(0xCE8B); readData(); if(checkSum() == (0x0F & RF_RXBUF[9])) //frame check { LED2_ON(); if(start) sendCMD(); // transmit IR Data if data received correctly _delay_ms(100); LED2_OFF(); } } // sleep and wait for external interrupt (from button press) // sleep_cpu(); }

µC-Quellcode Funksender:

main.c /* Radio wave transmitter for IR-Transmitter Prozessor: ATtiny2313 Frequenz: 434MHz Datenrate: 4.8kbps ----------------------- ATtiny2313 RFM02 ----------------------- SCK SCK MOSI SDI SS nSEL INT0 nIRQ PD7 FSK PD5 LED2 PD6 LED1 *********************************************************************/ #include <avr/io.h> #include <avr/interrupt.h> #include <util/delay.h> #define DDR_IN 0 #define DDR_OUT 1 #define DDR_LED DDRD #define PORT_LED PORTD #define PORT_SEL PORTB #define PIN_SEL PINB #define DDR_SEL DDRB #define PORT_SDI PORTB #define PIN_SDI PINB #define DDR_SDI DDRB #define PORT_SCK PORTB #define PIN_SCK PINB #define DDR_SCK DDRB #define PORT_SDO PORTB #define PIN_SDO PINB #define DDR_SDO DDRB #define PB7 7 #define PB6 6 #define RFM02_SCK 7 #define RFM02_SDO 6 #define RFM02_SDI 5 #define RFM02_SEL 4 #define PB1 1// #define PB0 0// #define RFM02_DATA 3// #define SEL_OUTPUT() DDR_SEL |= (1<<RFM02_SEL) #define HI_SEL() PORT_SEL|= (1<<RFM02_SEL) #define LOW_SEL() PORT_SEL&=~(1<<RFM02_SEL) #define SDI_OUTPUT() DDR_SDI |= (1<<RFM02_SDI) #define HI_SDI() PORT_SDI|= (1<<RFM02_SDI) #define LOW_SDI() PORT_SDI&=~(1<<RFM02_SDI) #define SDO_INPUT() DDR_SDO&= ~(1<<RFM02_SDO) #define SDO_HI() PIN_SDO&(1<<RFM02_SDO) #define SCK_OUTPUT() DDR_SCK |= (1<<RFM02_SCK) #define HI_SCK() PORT_SCK|= (1<<RFM02_SCK) #define LOW_SCK() PORT_SCK&=~(1<<RFM02_SCK) #define LED_OUTPUT() DDR_LED|=((1<<6)|(1<<5))//+FSKPIN+Module-Power #define LED1_TRG() PORT_LED^=(1<<5) #define LED1_ON() PORT_LED|=(1<<5) #define LED1_OFF() PORT_LED&=~(1<<5) #define LED2_OFF() PORT_LED &= ~(1<<6) #define LED2_ON() PORT_LED |= (1<<6) #define LED2_TRG() PORT_LED ^= (1<<6) #define CMD_INIT 0b00000010000010000001111101001110; // modulo16(0+2+0+8+1+15+4) = 14 #define CMD_STOPBIT 0b00000000; #define BAUD_RATE 43 // ~2400Baud volatile uint32_t data1 = CMD_INIT; volatile uint8_t data2 = CMD_STOPBIT; volatile uint32_t changer = 0; volatile uint8_t init = 0; volatile uint8_t state = 0; volatile uint8_t lastCMD = 'h'; volatile uint8_t newCMD = 0; /************************************************** USART ***************************************************/ void USART_INIT(void) { UBRRH = (uint8_t) (BAUD_RATE>>8); UBRRL = (uint8_t) BAUD_RATE; UCSRB = (1<<RXEN) | (1<<TXEN) | (1<<RXCIE); UCSRC = /*(1<<USBS) |*/ (3<<UCSZ0); } /**************************************************/ void USART_Transmit(unsigned char data) { while(!(UCSRA & (1<<UDRE))); UDR = data; } /**************************************************/ unsigned char USART_Receive(void) { LED2_ON(); while(!(UCSRA & (1<<RXC))); return UDR; LED2_OFF(); } /**************************************************/ ISR(USART_RX_vect) { newCMD = 1; lastCMD = UDR; LED2_ON(); _delay_ms(100); LED2_OFF(); } /************************************************** Radio Wave ***************************************************/ void RFM02_PORT_INIT(void) { HI_SEL(); HI_SDI(); LOW_SCK(); SEL_OUTPUT(); SDI_OUTPUT(); SDO_INPUT(); SCK_OUTPUT(); } unsigned int RFM02_WRT_CMD(unsigned int aCmd) { unsigned char i; unsigned int temp = 0; LOW_SCK(); LOW_SEL(); for(i=0;i<16;i++) { temp<<=1; if(SDO_HI()) temp|=0x0001; LOW_SCK(); if(aCmd&0x8000) HI_SDI(); else LOW_SDI(); HI_SCK(); aCmd<<=1; } LOW_SCK(); HI_SEL(); return(temp); } void RF02B_SEND(unsigned char aByte) { unsigned char i; for(i=0;i<8;i++) { while(PIND&(1<<2));//Polling nIRQ while(!(PIND&(1<<2))); if(aByte&0x80) PORTB|=(1<<RFM02_DATA); else PORTB&=~(1<<RFM02_DATA); aByte<<=1; } } /************************************************** Program functions ***************************************************/ void getCommand(void) { uint32_t rilefoba = 0; uint8_t stepping = 3; if(init<4) init++; else { if(lastCMD == 'u') { LED2_ON(); if(changer < (0x3F-stepping)) changer+=stepping; data1 = ((data1 & 0x3FFFFF0) | (changer << 26)); // insert new values in frame } else if(lastCMD == 'd') { LED2_ON(); if(changer > 0) changer-=stepping; data1 = ((data1 & 0x3FFFFF0) | (changer << 26)); // insert new values in frame } else if(lastCMD == 'r') { LED2_ON(); rilefoba = 0x0A; data1 = ((data1 & 0xFC0FFFF0) | (rilefoba << 20)); // insert new values in frame } else if(lastCMD == 'l') { LED2_ON(); rilefoba = 0x2A; data1 = ((data1 & 0xFC0FFFF0) | (rilefoba << 20)); // insert new values in frame } else if(lastCMD == 'f') { LED2_ON(); rilefoba = 0x0A; data1 = ((data1 & 0xFFF0CFF0) | (rilefoba << 14)); // insert new values in frame } else if(lastCMD == 'b') { LED2_ON(); rilefoba = 0x2A; data1 = ((data1 & 0xFFF0CFF0) | (rilefoba << 14)); // insert new values in frame } else if(lastCMD == 'h') { LED2_ON(); data1 = ((data1 & 0xFC003FF0)); } } } /********************************************/ void sendData(void) { uint8_t cs1 = 0, cs2 = 0, cs3 = 0, cs4 = 0, cs5 = 0, cs6 = 0, cs7 = 0; uint8_t dat0 = 0, dat1 = 0, dat2 = 0, dat3 = 0; uint8_t chksum = 0; // checksum calculation cs1 = (data1 & 0xF0000000) >> 28; // get value of bits 28-31... cs2 = (data1 & 0x0F000000) >> 24; dat0 = cs2 | (cs1<<4); cs3 = (data1 & 0x00F00000) >> 20; cs4 = (data1 & 0x000F0000) >> 16; dat1 = cs4 | (cs3<<4); cs5 = (data1 & 0x0000F000) >> 12; cs6 = (data1 & 0x00000F00) >> 8; dat2 = cs6 | (cs5<<4); cs7 = (data1 & 0x000000F0) >> 4; // checksum is the modulo of 16 chksum = (cs1 + cs2 + cs3 + cs4 + cs5 + cs6 + cs7) % 16; dat3 = chksum | (cs7<<4); RFM02_WRT_CMD(0xC039); //START TX RF02B_SEND(0xAA);//PREAMBLE RF02B_SEND(0xAA);//PREAMBLE RF02B_SEND(0xAA);//PREAMBLE RF02B_SEND(0x2D);//HEAD HI BYTE RF02B_SEND(0xD4);//HEAD LOW BYTE //transmit frame data RF02B_SEND(0x00); //0 - 5 dummy bytes RF02B_SEND(0x00); RF02B_SEND(0x00); RF02B_SEND(0x00); RF02B_SEND(0x34); RF02B_SEND(0x00); //5 RF02B_SEND(dat0);//DATA0 RF02B_SEND(dat1);//DATA1 RF02B_SEND(dat2); RF02B_SEND(dat3); RFM02_WRT_CMD(0xC001);//CLOSE TX } int main(void) { unsigned char i; //startup indication LED_OUTPUT(); for(i=0;i<2;i++) { LED2_ON(); _delay_ms(500); LED2_OFF(); _delay_ms(200); } USART_INIT(); RFM02_PORT_INIT(); // initialisation of transmitter RFM02 RFM02_WRT_CMD(0xCC00); RFM02_WRT_CMD(0x8B61); //+/-90kHz RFM02_WRT_CMD(0xA640); //434MHz RFM02_WRT_CMD(0xD040); //RATE/2 RFM02_WRT_CMD(0xC823); //4.8kbps RFM02_WRT_CMD(0xC220); //ENABLE BIT SYNC RFM02_WRT_CMD(0xC001); //CLOSE ALL PORTB|=(1<<RFM02_DATA); // Pullup enable DDRB|=(1<<RFM02_DATA); //SET DATA OUTPUT sei(); while(1) { getCommand(); LED2_OFF(); sendData(); LED1_ON(); _delay_ms(150); LED1_OFF(); _delay_ms(150); } }

µC-Quellcode WEB-Server (Ergänzungen zu NETraction):
netraction.c ////////////////////////////////////////////////////////////// void putch(unsigned char c) { while(!PIR1bits.TXIF) //set when register is empty { /* clear_usart_errors_inline; CLRWDT();*/ } TXREG=c; } /**************************************/ /* flight control */ /**************************************/ void flightCNT(char *text) { if(!strcmppgm2ram(text,"Up")) putch('u'); else if(!strcmppgm2ram(text,"Down")) putch('d'); else if(!strcmppgm2ram(text,"Right")) putch('r'); else if(!strcmppgm2ram(text,"Left")) putch('l'); else if(!strcmppgm2ram(text,"Forward")) putch('f'); else if(!strcmppgm2ram(text,"Backward")) putch('b'); else if(!strcmppgm2ram(text,"Hold")) putch('h'); }

Abbildung 1:

Abbildung 2:

Abbildung 3:

Abbildung 4:

Abbildung 5:

Abbildung 6:

Projekt "NETraction - Steuerung für Mikrocontroller über WEB"

Über einen Internet-Browser lassen sich Ports eines Mikrocontrollers ferngesteuert ansteuern und auswerten.

Basis für dieses Projekt ist ein RISC von Microchip über den die TCP-Kommunikation zum Schalten und Einlesen der Ports ermöglicht wurde. Auch Text kann über das Netz an ein Farbdisplay übertragen werden oder zeigt die aktuellen Verbindungsdaten an.

Abbildung 1 bis 3 zeigen den Schaltplan und die Platine des Versorgungs- und Schaltmoduls, über zwei Steckleisten wird die Platine mit dem µC verbunden.

Die projektspezifischen Softwareteile bestanden in der Integrierung des LCD-Displays, der Tasterabfragen und der dafür notwendigen Portkonfigurierungen. Die Erstellung der Software erfolgte, wie in Abbildung 4 zu sehen, mit der MPLAB IDE.

Die applikationsspezifischen Anpassungen wurden in der SW-Struktur des Elektor-Projektes "Netzer" vorgenommen. Die Abwandlung der im EEProm gespeicherten HTML-Seiten des WEB-Servers und die Möglichkeit von Textübertragungen bedingte einige Restrukturierungen des Quellcodes im Bereich der HTTP-Datentenübermittlung.

Unter Abbildung 6 gibt es eine Dokumentation.

µC-Quellcode:

netraction.c // //////////////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////// /* NETraction author Daniel Nüsse date 2011-12-30 */ // //////////////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////// #define NETRACTION_C // //////////////////////////////////////////////////////////////////////////// // Includes // //////////////////////////////////////////////////////////////////////////// #include "netraction.h" #include <delays.h> #include "eeprom.h" #include "projectdefs.h" // //////////////////////////////////////////////////////////////////////////// // Global variables // //////////////////////////////////////////////////////////////////////////// static unsigned char zustand1=0, zustand3=0, zustand4=0; // //////////////////////////////////////////////////////////////////////////// // Several delay routines // //////////////////////////////////////////////////////////////////////////// void Delay_1s(void) // Delay { unsigned int i,j; for (i=0;i<10;i++) { Delay_100ms(); } } void Delay_05s(void) { unsigned int i,j; for (i=0;5;i++) { Delay_100ms(); } } void Delay_10ms(void) { unsigned int i,j; for (i=0;i<7;i++) { Delay100TCYx(100); } } void Delay_100ms(void) { unsigned int i; for (i=0;i<10;i++) { Delay_10ms(); } } void Delay_10s(void) { unsigned int i; for (i=0;i<10;i++) { Delay_1s(); } } // //////////////////////////////////////////////////////////////////////////// // Subroutine to handle the different switch states // //////////////////////////////////////////////////////////////////////////// char switchReadIn (unsigned char swich) // read in of switch states { char rw = 0; switch(swich) { case SW1: if(zustand1 == 0 && bGPIOGetPinValue(swich)) //Taster wird gedrueckt (steigende Flanke) { zustand1 = 1; rw = 1; } else if (zustand1 == 1 && bGPIOGetPinValue(swich)) //Taster wird gehalten { zustand1 = 2; rw = 2; } else if (zustand1 == 2 && !bGPIOGetPinValue(swich)) //Taster wird losgelassen (fallende Flanke) { zustand1 = 3; rw = 3; } else if (zustand1 == 3 && !bGPIOGetPinValue(swich)) //Taster losgelassen { zustand1 = 0; rw = 4; } return rw; case SW3: if(zustand3 == 0 && bGPIOGetPinValue(swich)) //Taster wird gedrueckt (steigende Flanke) { zustand3 = 1; rw = 1; } else if (zustand3 == 1 && bGPIOGetPinValue(swich)) //Taster wird gehalten { zustand3 = 2; rw = 2; } else if (zustand3 == 2 && !bGPIOGetPinValue(swich)) //Taster wird losgelassen (fallende Flanke) { zustand3 = 3; rw = 3; } else if (zustand3 == 3 && !bGPIOGetPinValue(swich)) //Taster losgelassen { zustand3 = 0; rw = 4; } return rw; case SW4: if(zustand4 == 0 && bGPIOGetPinValue(swich)) //Taster wird gedrueckt (steigende Flanke) { zustand4 = 1; rw = 1; } else if (zustand4 == 1 && bGPIOGetPinValue(swich)) //Taster wird gehalten { zustand4 = 2; rw = 2; } else if (zustand4 == 2 && !bGPIOGetPinValue(swich)) //Taster wird losgelassen (fallende Flanke) { zustand4 = 3; rw = 3; } else if (zustand4 == 3 && !bGPIOGetPinValue(swich)) //Taster losgelassen { zustand4 = 0; rw = 4; } return rw; } } // //////////////////////////////////////////////////////////////////////////// // Initialisation of all used ports // //////////////////////////////////////////////////////////////////////////// void NETractionInit(void) { GPIOSetDirection(LEDyl, 0); GPIOSetPortValue(LEDyl, 1); GPIOSetDirection(LEDrd, 0); GPIOSetPortValue(LEDrd, 1); GPIOSetDirection(LEDgr, 0); GPIOSetPortValue(LEDgr, 0); GPIOSetDirection(SW1, 1); GPIOSetDirection(SW3, 1); GPIOSetDirection(SW4, 1); GPIOSetDirection(SBSW, 0); GPIOSetPortValue(SBSW, 0); GPIOSetDirection(LCD_CS, 0); GPIOSetPortValue(LCD_CS, 0); GPIOSetDirection(LCD_CL, 0); GPIOSetPortValue(LCD_CL, 0); GPIOSetDirection(LCD_SD, 0); GPIOSetPortValue(LCD_SD, 0); GPIOSetDirection(LCD_RS, 0); GPIOSetPortValue(LCD_RS, 0); } // //////////////////////////////////////////////////////////////////////////// // Handle LCD Standby over Switch 4 // //////////////////////////////////////////////////////////////////////////// void LCD_Standby_Handler_NET(void) { char text[30], start[20]; if(!bGPIOGetPinValue(SBSW)) { if(standbyFlag) { GPIOSetPortValue(SBSW, 1); } } else if(bGPIOGetPinValue(SBSW) && standbyFlag) { GPIOSetPortValue(SBSW, 0); Delay_100ms(); Delay_100ms(); lcd_init(); lcd_clear(GREEN,0,0,131,131); strcpypgm2ram(start,"Standby deactivated"); lcd_draw_text(BLACK, GREEN, 5, 5, start); GPIOSetPortValue(LEDrd, 1); Delay_1s(); standbyFlag = 0; } else if(bGPIOGetPinValue(SBSW) && !standbyFlag) { standbyFlag = 1; } } // //////////////////////////////////////////////////////////////////////////// // Handle LCD Standby over web page // //////////////////////////////////////////////////////////////////////////// void LCD_Standby_Handler_SW(void) { char start[20]; if(!bGPIOGetPinValue(SBSW)) { lcd_clear(RED,0,0,131,131); strcpypgm2ram(start,"Standby activated"); lcd_draw_text(BLACK, RED, 5, 5, start); Delay_1s(); GPIOSetPortValue(LEDrd, 0); GPIOSetPortValue(LEDgr, 1); GPIOSetPortValue(SBSW, 1); standbyFlag = 1; } else if(bGPIOGetPinValue(SBSW)) { GPIOSetPortValue(SBSW, 0); Delay_100ms(); Delay_100ms(); lcd_init(); lcd_clear(GREEN,0,0,131,131); strcpypgm2ram(start,"Standby deactivated"); lcd_draw_text(BLACK, GREEN, 5, 5, start); GPIOSetPortValue(LEDrd, 1); GPIOSetPortValue(LEDgr, 0); Delay_1s(); standbyFlag = 0; LCD_STARTPAGE(); } } // //////////////////////////////////////////////////////////////////////////// // Main routine for project specific actions // //////////////////////////////////////////////////////////////////////////// void NETractionTask (void) // main { unsigned char switchState = 0; // Switch LCD reset switchState = switchReadIn(SW1); if(switchState == 1) GPIOSetPortValue(LEDyl, 0); else if(switchState == 4 /* || switchState == 3*/) { GPIOSetPortValue(LEDyl, 1); lcd_init(); LCD_STARTPAGE(); } // Switch empty switchState = switchReadIn(SW3); if(switchState == 1) GPIOSetPortValue(LEDyl, 0); else if(switchState == 4 /*|| switchState == 3*/) { GPIOSetPortValue(LEDyl, 1); } // Switch Standby switchState = switchReadIn(SW4); if(switchState == 1) { GPIOSetPortValue(LEDyl, 0); } else if(switchState == 4 /*|| switchState == 3*/) { GPIOSetPortValue(LEDyl, 1); LCD_Standby_Handler_SW(); } } LCD.c // //////////////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////// /* NETraction author Daniel Nüsse date 2011-12-30 */ // //////////////////////////////////////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////// #define NOKIALCD_C // //////////////////////////////////////////////////////////////////////////// // Includes // //////////////////////////////////////////////////////////////////////////// #include "NokiaLCD.h" #include "netraction.h" #include <delays.h> #include "eeprom.h" #include "projectdefs.h" // //////////////////////////////////////////////////////////////////////////// // Defines // //////////////////////////////////////////////////////////////////////////// #define BL 1 #define CS 3 #define CLK 4 #define SDA 5 #define RESET 2 // Command Set Epson D1D15G10 #define DISON 0xaf #define DISOFF 0xae #define DISNOR 0xa6 #define DISINV 0xa7 #define COMSCN 0xbb #define DISCTL 0xca #define SLPIN 0x95 #define SLPOUT 0x94 #define PASET 0x75 #define CASET 0x15 #define DATCTL 0xbc #define RGBSET8 0xce #define RAMWR 0x5c #define RAMRD 0x5d #define PTLIN 0xa8 #define PTLOUT 0xa9 #define RMWIN 0xe0 #define RMWOUT 0xee #define ASCSET 0xaa #define SCSTART 0xab #define OSCON 0xd1 #define OSCOFF 0xd2 #define PWRCTR 0x20 #define VOLCTR 0x81 #define VOLUP 0xd6 #define VOLDOWN 0xd7 #define TMPGRD 0x82 #define EPCTIN 0xcd #define EPCOUT 0xcc #define EPMWR 0xfc #define EPMRD 0xfd #define EPSRRD1 0x7c #define EPSRRD2 0x7d #define NOP 0x25 #define PORTC LATC #define cbi(reg, bit) (reg&=~(1<<bit)) #define sbi(reg, bit) (reg|= (1<<bit)) #define CS0 cbi(PORTC,CS); #define CS1 sbi(PORTC,CS); #define CLK0 cbi(PORTC,CLK); #define CLK1 sbi(PORTC,CLK); #define SDA0 cbi(PORTC,SDA); #define SDA1 sbi(PORTC,SDA); #define RESET0 cbi(PORTC,RESET); #define RESET1 sbi(PORTC,RESET); #define BL0 cbi(PORTC,BL); #define BL1 sbi(PORTC,BL); // //////////////////////////////////////////////////////////////////////////// // Data fields for text output - Splitting for usage in PIC code // //////////////////////////////////////////////////////////////////////////// #pragma idata d BYTE const fontNum[255] = { 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x00 , 0x06 , 0x5F , 0x06 , 0x00 , // ! 0x07 , 0x03 , 0x00 , 0x07 , 0x03 , // , 0x24 , 0x7E , 0x24 , 0x7E , 0x24 , // # 0x24 , 0x2B , 0x6A , 0x12 , 0x00 , // $ 0x63 , 0x13 , 0x08 , 0x64 , 0x63 , // % 0x36 , 0x49 , 0x56 , 0x20 , 0x50 , // & 0x00 , 0x07 , 0x03 , 0x00 , 0x00 , // // 0x00 , 0x3E , 0x41 , 0x00 , 0x00 , // ( 0x00 , 0x41 , 0x3E , 0x00 , 0x00 , // ) 0x08 , 0x3E , 0x1C , 0x3E , 0x08 , // * 0x08 , 0x08 , 0x3E , 0x08 , 0x08 , // + 0x00 , 0xE0 , 0x60 , 0x00 , 0x00 , // , 0x08 , 0x08 , 0x08 , 0x08 , 0x08 , // - 0x00 , 0x60 , 0x60 , 0x00 , 0x00 , // . 0x20 , 0x10 , 0x08 , 0x04 , 0x02 , // / 0x3E , 0x51 , 0x49 , 0x45 , 0x3E , // 0 0x00 , 0x42 , 0x7F , 0x40 , 0x00 , // 1 0x62 , 0x51 , 0x49 , 0x49 , 0x46 , // 2 0x22 , 0x49 , 0x49 , 0x49 , 0x36 , // 3 0x18 , 0x14 , 0x12 , 0x7F , 0x10 , // 4 0x2F , 0x49 , 0x49 , 0x49 , 0x31 , // 5 0x3C , 0x4A , 0x49 , 0x49 , 0x30 , // 6 0x01 , 0x71 , 0x09 , 0x05 , 0x03 , // 7 0x36 , 0x49 , 0x49 , 0x49 , 0x36 , // 8 0x06 , 0x49 , 0x49 , 0x29 , 0x1E , // 9 0x00 , 0x6C , 0x6C , 0x00 , 0x00 , // : 0x00 , 0xEC , 0x6C , 0x00 , 0x00 , // ; 0x08 , 0x14 , 0x22 , 0x41 , 0x00 , // < 0x24 , 0x24 , 0x24 , 0x24 , 0x24 , // = 0x00 , 0x41 , 0x22 , 0x14 , 0x08 , // > 0x02 , 0x01 , 0x59 , 0x09 , 0x06 , // ? 0x3E , 0x41 , 0x5D , 0x55 , 0x1E }; // @ #pragma idata #pragma idata e BYTE const fontBig[255] = { 0x7E , 0x09 , 0x09 , 0x09 , 0x7E , // A 0x7F , 0x49 , 0x49 , 0x49 , 0x36 , // B 0x3E , 0x41 , 0x41 , 0x41 , 0x22 , // C 0x7F , 0x41 , 0x41 , 0x41 , 0x3E , // D 0x7F , 0x49 , 0x49 , 0x49 , 0x41 , // E 0x7F , 0x09 , 0x09 , 0x09 , 0x01 , // F 0x3E , 0x41 , 0x49 , 0x49 , 0x7A , // G 0x7F , 0x08 , 0x08 , 0x08 , 0x7F , // H 0x00 , 0x41 , 0x7F , 0x41 , 0x00 , // I 0x30 , 0x40 , 0x40 , 0x40 , 0x3F , // J 0x7F , 0x08 , 0x14 , 0x22 , 0x41 , // K 0x7F , 0x40 , 0x40 , 0x40 , 0x40 , // L 0x7F , 0x02 , 0x04 , 0x02 , 0x7F , // M 0x7F , 0x02 , 0x04 , 0x08 , 0x7F , // N 0x3E , 0x41 , 0x41 , 0x41 , 0x3E , // O 0x7F , 0x09 , 0x09 , 0x09 , 0x06 , // P 0x3E , 0x41 , 0x51 , 0x21 , 0x5E , // Q 0x7F , 0x09 , 0x09 , 0x19 , 0x66 , // R 0x26 , 0x49 , 0x49 , 0x49 , 0x32 , // S 0x01 , 0x01 , 0x7F , 0x01 , 0x01 , // T 0x3F , 0x40 , 0x40 , 0x40 , 0x3F , // U 0x1F , 0x20 , 0x40 , 0x20 , 0x1F , // V 0x3F , 0x40 , 0x3C , 0x40 , 0x3F , // W 0x63 , 0x14 , 0x08 , 0x14 , 0x63 , // X 0x07 , 0x08 , 0x70 , 0x08 , 0x07 , // Y 0x71 , 0x49 , 0x45 , 0x43 , 0x00 , // Z 0x00 , 0x7F , 0x41 , 0x41 , 0x00 , // [ 0x02 , 0x04 , 0x08 , 0x10 , 0x20 , // Back slash 0x00 , 0x41 , 0x41 , 0x7F , 0x00 , // ] 0x04 , 0x02 , 0x01 , 0x02 , 0x04 , // ^ 0x80 , 0x80 , 0x80 , 0x80 , 0x80 , // _ 0x00 , 0x03 , 0x07 , 0x00 , 0x00 }; // ` #pragma idata #pragma idata f BYTE const fontSmall[255] = { 0x20 , 0x54 , 0x54 , 0x54 , 0x78 , // a 0x7F , 0x44 , 0x44 , 0x44 , 0x38 , // b 0x38 , 0x44 , 0x44 , 0x44 , 0x28 , // c 0x38 , 0x44 , 0x44 , 0x44 , 0x7F , // d 0x38 , 0x54 , 0x54 , 0x54 , 0x18 , // e 0x08 , 0x7E , 0x09 , 0x09 , 0x00 , // f 0x18 , 0xA4 , 0xA4 , 0xA4 , 0x7C , // g 0x7F , 0x04 , 0x04 , 0x78 , 0x00 , // h 0x00 , 0x00 , 0x7D , 0x00 , 0x00 , // i 0x40 , 0x80 , 0x84 , 0x7D , 0x00 , // j 0x7F , 0x10 , 0x28 , 0x44 , 0x00 , // k 0x00 , 0x00 , 0x7F , 0x40 , 0x00 , // l 0x7C , 0x04 , 0x18 , 0x04 , 0x78 , // m 0x7C , 0x04 , 0x04 , 0x78 , 0x00 , // n 0x38 , 0x44 , 0x44 , 0x44 , 0x38 , // o 0xFC , 0x44 , 0x44 , 0x44 , 0x38 , // p 0x38 , 0x44 , 0x44 , 0x44 , 0xFC , // q 0x44 , 0x78 , 0x44 , 0x04 , 0x08 , // r 0x08 , 0x54 , 0x54 , 0x54 , 0x20 , // s 0x04 , 0x3E , 0x44 , 0x24 , 0x00 , // t 0x3C , 0x40 , 0x20 , 0x7C , 0x00 , // u 0x1C , 0x20 , 0x40 , 0x20 , 0x1C , // v 0x3C , 0x60 , 0x30 , 0x60 , 0x3C , // w 0x6C , 0x10 , 0x10 , 0x6C , 0x00 , // x 0x9C , 0xA0 , 0x60 , 0x3C , 0x00 , // y 0x64 , 0x54 , 0x54 , 0x4C , 0x00 , // z 0x08 , 0x3E , 0x41 , 0x41 , 0x00 , // { 0x00 , 0x00 , 0x7F , 0x00 , 0x00 , // | 0x00 , 0x41 , 0x41 , 0x3E , 0x08 , // } 0x02 , 0x01 , 0x02 , 0x01 , 0x00 // ~ }; #pragma idata /*************************************************************/ /* Function definitions */ /*************************************************************/ /**************************************/ /* Shifting SPI bit out */ /**************************************/ void shiftBits(BYTE b) { CLK0 if ((b&128)!=0) SDA1 else SDA0 CLK1 CLK0 if ((b&64)!=0) SDA1 else SDA0 CLK1 CLK0 if ((b&32)!=0) SDA1 else SDA0 CLK1 CLK0 if ((b&16)!=0) SDA1 else SDA0 CLK1 CLK0 if ((b&8)!=0) SDA1 else SDA0 CLK1 CLK0 if ((b&4)!=0) SDA1 else SDA0 CLK1 CLK0 if ((b&2)!=0) SDA1 else SDA0 CLK1 CLK0 if ((b&1)!=0) SDA1 else SDA0 CLK1 } /**************************************/ /* Put pixel to LCD */ /**************************************/ void LCD_put_pixel(WORD color, BYTE x, BYTE y) { sendCMD(CASET); // page start/end ram sendData(x); // for some reason starts at 2 sendData(x+1); sendCMD(PASET); // column start/end ram sendData(y); sendData(y+1); sendCMD(RAMWR); sendData(color); } /**************************************/ /* Sending data */ /**************************************/ void sendData(BYTE data) { CLK1 CS1 CS0 CLK0 SDA1 CLK1 shiftBits(data); } /**************************************/ /* Sending command */ /**************************************/ void sendCMD(BYTE data) { CLK1 CS1 CS0 CLK0 SDA0 CLK1 shiftBits(data); } /**************************************/ /* Set box LCD */ /**************************************/ void lcd_set_box(BYTE x1, BYTE y1, BYTE x2, BYTE y2) { sendCMD(CASET); // page start/end ram sendData(x1); // for some reason starts at 2 sendData(x2); sendCMD(PASET); // column start/end ram sendData(y1); sendData(y2); } /**************************************/ /* Clear LCD */ /**************************************/ void lcd_clear(WORD color, BYTE x1, BYTE y1, BYTE x2, BYTE y2) { unsigned int i; /* lcd_set_box(x1, y1, x2, y2); sendCMD(RAMWR); for(i = 0; i < (unsigned int)(((x2-x1+1)*(y2-y1+1)) / 2); i++) { sendData((color >> 4) & 0xFF); sendData(((color & 0xF) << 4) | ((color >> 8) & 0xF)); sendData(color & 0xFF); } */ sendCMD(CASET); // page start/end ram sendData(x1); // for some reason starts at 2 sendData(x2); sendCMD(PASET); // column start/end ram sendData(y1); sendData(y2); sendCMD(RAMWR); for(i=1;i<17424;i++) sendData(color); } /**************************************/ /* LCD initialisation */ /**************************************/ void lcd_init(void) { unsigned int i; // Hardware Reset LCD RESET0 Delay_10ms(); //delay of 10ms RESET1 // Initial state CS1 SDA1 CLK1 sendCMD(PWRCTR); // power ctrl sendData(0x0f); // everything on, no external reference resistors Delay_10ms(); Delay_10ms(); Delay_10ms(); Delay_10ms(); sendCMD(SLPOUT); // sleep out sendCMD(DISON); // display on sendCMD(OSCON); // oscon Delay_10ms(); Delay_10ms(); Delay_10ms(); Delay_10ms(); //Data Control sendCMD(DATCTL); sendData(0x07); //0x00 for normal, 0x01 for flip vertical -> old val 0x00 sendData(0x00); //0x00 for low color grainy, 0x01 for red lines above/below, 0x02 for color -> old val 0x02 for extra blueness sendData(0x01); //does nothing old val 0xFF // Display control /* sendCMD(DISCTL); sendData(0x03); // 2 divisions, Field swithcing period sendData(32); // 132 lines to be display sendData(12); // Inversely hightlighted lines - 1 sendData(0); */ sendCMD(COMSCN); // comscn sendData(0x01); /* sendCMD(VOLCTR); // electronic volume, this is kinda contrast/brightness sendData(0x24); // this might be different for individual LCDs sendData(0x03); */ sendCMD(DISINV); // display mode /* sendCMD(DATCTL); // datctl sendData(0x00); sendData(0); sendData(0x01); sendData(0); */ sendCMD(RGBSET8); // setup color lookup table // color table sendData(0); sendData(2); sendData(4); sendData(6); sendData(8); sendData(10); sendData(12); sendData(15); // GREEN sendData(0); sendData(2); sendData(4); sendData(6); sendData(8); sendData(10); sendData(12); sendData(15); //BLUE sendData(0); sendData(4); sendData(9); sendData(15); sendCMD(NOP); lcd_clear(0xff,0,0,131,131); for (i = 0; i < 150; i++) { //this loop adjusts the contrast, change the number of iterations to get sendCMD(VOLUP); // desired contrast. This might be different for individual LCDs Delay_10ms(); } } /**************************************/ /* Draw color bar */ /**************************************/ void draw_color_bar(void) { lcd_clear(RED,0,0,160,40); lcd_clear(GREEN,0,34,160,80); lcd_clear(BLUE,0,67,160,120); lcd_clear(WHITE,0,100,160,160); } /**************************************/ /* Draw text line to fit on LCD */ /**************************************/ void draw_text_scale(WORD fcolor, WORD bcolor,BYTE x, BYTE y, char *text) { unsigned int i = 0, j = 0, k = y, l = 20, buf = 0; char temp[20] = ""; char count[2] = ""; unsigned int strLen = strlen(text); if (strLen > 20) { for (j = 0; j<strLen; j++) { temp[i] = *text; i++; *text++; if(j == l) { lcd_draw_text(fcolor, bcolor, x, k, temp); for (buf = 0; buf<=20; buf++) temp[buf] = 0; l += 21; k += 10; if (*text == ' ') { j++; *text++; } i=0; } } lcd_draw_text(fcolor, bcolor, x, k, temp); } else { lcd_draw_text(fcolor, bcolor, x, k, text); } } /**************************************/ /* Draw text line */ /**************************************/ void draw_text_line(WORD fcolor, WORD bcolor,BYTE x, BYTE y, char c) { /* unsigned int i; lcd_set_box(x,y,x,y+15); sendCMD(RAMWR);// for(i=0;i<8;i++) { if (1<<i & c) { sendData((fcolor >> 4) & 0xFF); sendData(((fcolor & 0xF) << 4) | ((fcolor >> 8) & 0xF)); sendData(fcolor & 0xFF); } else { sendData((bcolor >> 4) & 0xFF); sendData(((bcolor & 0xF) << 4) | ((bcolor >> 8) & 0xF)); sendData(bcolor & 0xFF); } }*/ unsigned int i; lcd_set_box(x,y,x,y+7); sendCMD(RAMWR); for(i=0;i<8;i++) { if (1<<i & c) sendData(fcolor); else sendData(bcolor); } } /**************************************/ /* Print text */ /**************************************/ void lcd_draw_text(WORD fcolor, WORD bcolor, BYTE x, BYTE y,char *text) { BYTE c; BYTE t; unsigned int i, l = 0; unsigned int j,k; while(*text != 0) { t = *text; // example Hallo 72,97,108,111 -> 7*5(35) Big, 0 Small, 10*5(50) Small i = t - 32; k = i; // calculation to take out the right char from the slitted data field if(i < (65-32)) i = i; else if((i >= (65-32)) && (i < (97-32))) i -= (65-32); else if(i >= (97-32)) i -= (97-32); i = i * 5; for(j = i; j < i+5; j++) { if(k < (65-32)) c = fontNum[j]; else if((k >= (65-32)) && (k < (97-32))) c = fontBig[j]; else if(k >= (97-32)) c = fontSmall[j]; draw_text_line(fcolor, bcolor, x++, y, c); } draw_text_line(fcolor, bcolor, x++, y, 0); *text++; } } /**************************************/ /* LCD NET send */ /**************************************/ void LCD_NET_SEND(char *text) { char start[30]; LCD_Standby_Handler_NET(); lcd_clear(LIGHTBLUE,0,0,131,131); draw_text_scale(BLACK,LIGHTBLUE,5,5,text); } /**************************************/ /* LCD Task */ /**************************************/ void LCD_STARTPAGE(void) { char text [20]; draw_color_bar(); strcpypgm2ram(text, "NETraction (c)2011"); draw_text_scale(BLACK, RED, 5, 5,text); }

Abbildung 1:

Abbildung 2:

Abbildung 3:

Abbildung 4:

Projekt "Sprachsteuerung für Mikrocontroller"

In diesem Projekt wurde eine Verbindung zwischen einem Mikrocontroller und einer Spracherkennung geschaffen. Dabei können Sprachkommandos über eine serielle Schnittstelle eines Notebooks an einen Atmega128 gesendet werden, welcher dann über GPIOs LEDs an- und ausschaltet. Gleichzeitig werden die am µController ankommenden Befehle auf einem Display von Nokia ausgegeben.

Ein mit Quarz und Atmega128 ausgestattetes Miniboard wurde als erstes mittels eines HDD-Kabels über einen Zwischenadapter mit dem Steckbrett verbunden um alle benötigten Ports flexibel zur Verfügung zu haben. Zusätzlich wurden an einigen Ports Taster fest verdrahtet. Wie in Abbildung 1 zu sehen, ein nicht unerheblicher Lötaufwand bei 60 Controller-Pins.

Das Farbdisplay ist ein Handydisplay von Nokia und ist mit knapp € 40,- nicht ganz billig. Es kann mit 5V versorgt werden und ist mit nur vier Port-Leitungen ansteuerbar. Nach jedem Reset muss das Display vor der Benutzung mit einer bestimmten Sequenz über die Ansteuerleitungen initialisiert werden. Mit Hilfe des Datenblattes wurde diese Initialisierung in der Hochsprache C umgesetzt, besonders wichtig war dabei die Einhaltung des zeitlichen Ablaufs der Routine. Schriften, Zahlen und Grafiken wurden ebenfalls in C ausprogrammiert.

Für die Kommunikation zwischen dem Notebook und dem Mikrocontroller wurde ein MAX221 verwendet. Hierfür wurde ein Programm in C# entwickelt, welches die serielle Schnittstelle bedient und gleichzeitig das Inventar für die Sprachverarbeitung verwaltet. Wie in Abbildung 4 zu sehen, sollte auch grafisch angezeigt werden, welche LEDs aktiv und passiv geschaltet sind. Eine Rücklesung der Port-Zustände bestätigte die richtige Umsetzung des ausgeführten Sprachkommandos.
Neben der Möglichkeit der Sprachsteuerung wurde auch eine Uhr implementiert, welche mit dem C#-Programm eingestellt werden kann und auf dem Controller autark weiterläuft.

Eine drahtlose Kommunikation zwischen dem Notebook und Mikrocontroller ist grundsätzlich realisierbar und auch die LEDs durch Arme und Beine eines Kampfroboters zu ersetzen ist durchaus denkbar.

µC-Quellcode:

#include <avr/interrupt.h> #include <avr/signal.h> #include <avr/iom128.h> //#include <string.h> #include <inttypes.h> #include <stdio.h> #include <avr/io.h> #include <avr/pgmspace.h> #include "font6x8.h" #include "font12x16.h" #include "S1D15.h" #define sd 0 #define cl 2 #define cs 4 #define rs 6 #define lcd_port PORTB #define Blau 0B00000011 #define Gelb 0B11111100 #define Rot 0B11100000 #define Gruen 0B00011100 #define Schwarz 0B00000000 #define Weiss 0B11111111 #define Hellgruen 0B00111110 #define Dunkelgruen 0B00010100 #define Dunkelrot 0B10100000 #define Dunkelblau 0B00000010 #define Hellblau 0B00011111 #define Orange 0B11111000 #define kom 0 #define par 1 /* * global variables */ uint8_t color=0; uint8_t xCoord=0; uint8_t yCoord=0; uint8_t fontOffset=0; xypos sepos,mipos,hopos; font f; font smallFont, largeFont; int hor=0,min=0,sec=0,hortemp,mintemp; unsigned char prell=0; void Delay_1s(void) // Delay { unsigned int i,j; for (i=0;i<40000;i++) //115 { for (j=1;j<200;j++); } } void Delay_05s(void) { unsigned int i,j; for (i=0;i<20000;i++) //115 { for (j=1;j<200;j++); } } void Delay_10ms(void) // Delay { int i,j; for (i=0;i<4000;i++) //115 { for (j=1;j<20;j++); } } /*---------------------------------------------------- UART1 Anfang ----------------------------------------------------*/ void SendeString (char *szBuf) { while (*szBuf) { UDR1 = *szBuf; *szBuf++; while ( !( UCSR1A & (1<<UDRE1)) ); } } volatile unsigned char USART_Receive( void ) { /* Wait for data to be received */ while ( !(UCSR1A & (1<<RXC1)) ); /* Get and return received data from buffer */ return UDR1; } void USART_Transmit ( unsigned char data ) { /* Wait for empty transmit buffer */ while ( !( UCSR1A & (1<<UDRE1)) ); /* Put data into buffer, sends the data */ UDR1 = data; } /*---------------------------------------------------- UART1 Ende ----------------------------------------------------*/ /*---------------------------------------------------- LCD Routinen Anfang ----------------------------------------------------*/ void send( int befehl, unsigned char byte ) { lcd_port &= ~(1<<cs); lcd_port &= ~(1<<cl); //'Clock Leitung auf 0 if(befehl==0) lcd_port &= ~(1<<sd); //'0 für Kommando else lcd_port |= (1<<sd); // '1 für Parameter lcd_port |= (1<<cl); lcd_port &= ~(1<<cl); if((byte & 0x80) == 0x80) lcd_port |= (1<<sd); else lcd_port &= ~(1<<sd); lcd_port |= (1<<cl); lcd_port &= ~(1<<cl); if((byte & 0x40) == 0x40) lcd_port |= (1<<sd); else lcd_port &= ~(1<<sd); lcd_port |= (1<<cl); lcd_port &= ~(1<<cl); if((byte & 0x20) == 0x20) lcd_port |= (1<<sd); else lcd_port &= ~(1<<sd); lcd_port |= (1<<cl); lcd_port &= ~(1<<cl); if((byte & 0x10) == 0x10) lcd_port |= (1<<sd); else lcd_port &= ~(1<<sd); lcd_port |= (1<<cl); lcd_port &= ~(1<<cl); if((byte & 0x08) == 0x08) lcd_port |= (1<<sd); else lcd_port &= ~(1<<sd); lcd_port |= (1<<cl); lcd_port &= ~(1<<cl); if((byte & 0x04) == 0x04) lcd_port |= (1<<sd); else lcd_port &= ~(1<<sd); lcd_port |= (1<<cl); lcd_port &= ~(1<<cl); if((byte & 0x02) == 0x02) lcd_port |= (1<<sd); else lcd_port &= ~(1<<sd); lcd_port |= (1<<cl); lcd_port &= ~(1<<cl); if((byte & 0x01) == 0x01) lcd_port |= (1<<sd); else lcd_port &= ~(1<<sd); lcd_port |= (1<<cl); lcd_port &= ~(1<<cl); // 'Clock Leitung auf 1 lcd_port |= (1<<cs); // 'Cs auf 1 am Ende der Sequenz schalten } void Lcd_cls(unsigned char backclr) { unsigned int i; send(kom,0x15); send(par,0x00); send(par,131); send(kom,0x75); send(par,0x00); send(par,131); send(kom,0x5C); for(i=1;i<17424;i++) send(par,backclr); } int DrawChar(char c) { uint16_t index; uint8_t i, j, w, data, skipped=1, startY=yCoord; if(c == '\n') NewLine(); if(c < 32) return 0; c -= 32; index = c*f.width*(f.height/8); for(w=0; w<f.width; w++) { for(i=0; i<f.height/8; i++) { data = pgm_read_byte(f.charData + index++); for(j=0; j<8; j++) { if(data & 0x01) { if(skipped) { GotoXY(xCoord, yCoord); send(kom,MEM_WRITE); skipped=0; } DrawPixel(); yCoord++; } else { skipped=1; GotoXY(xCoord, ++yCoord); } data >>= 1; } } GotoXY(++xCoord, startY); } return 0; } void NewLine(void) { if(yCoord+f.height < 128) GotoXY(fontOffset, yCoord+f.height); else GotoXY(fontOffset, 0); } void DrawCircle(uint8_t xCenter, uint8_t yCenter, uint8_t radius) { int16_t tSwitch, y, x = 0; uint8_t d; d = yCenter - xCenter; y = radius; tSwitch = 3 - 2 * radius; while (x <= y) { DrawPixelXY(xCenter + x, yCenter + y); DrawPixelXY(xCenter + x, yCenter - y); DrawPixelXY(xCenter - x, yCenter + y); DrawPixelXY(xCenter - x, yCenter - y); DrawPixelXY(yCenter + y - d, yCenter + x); DrawPixelXY(yCenter + y - d, yCenter - x); DrawPixelXY(yCenter - y - d, yCenter + x); DrawPixelXY(yCenter - y - d, yCenter - x); if (tSwitch < 0) { tSwitch += (4 * x + 6); } else { tSwitch += (4 * (x - y) + 10); y--; } x++; } } void DrawLine(uint8_t x1, uint8_t y1, uint8_t x2, uint8_t y2) { uint8_t length, xTmp, yTmp, i, y, yAlt; int16_t m; if(x1 == x2) { // vertical line // x1|y1 must be the upper point if(y1 > y2) { xTmp = x1; yTmp = y1; x1 = x2; y1 = y2; x2 = xTmp; y2 = yTmp; } length = y2-y1; for(i=0; i<=length; i++) { DrawPixelXY(x1, y1+i); } } else if(y1 == y2) { // horizontal line // x1|y1 must be the left point if(x1 > x2) { xTmp = x1; yTmp = y1; x1 = x2; y1 = y2; x2 = xTmp; y2 = yTmp; } length = x2-x1; for(i=0; i<=length; i++) { DrawPixelXY(x1+i, y1); } } else { // x1 must be smaller than x2 if(x1 > x2) { xTmp = x1; yTmp = y1; x1 = x2; y1 = y2; x2 = xTmp; y2 = yTmp; } if((y2-y1) >= (x2-x1) || (y1-y2) >= (x2-x1)) { // angle larger or equal 45° length = x2-x1; // not really the length :) m = ((y2-y1)*200)/length; yAlt = y1; for(i=0; i<=length; i++) { y = ((m*i)/200)+y1; if((m*i)%200 >= 100) y++; else if((m*i)%200 <= -100) y--; DrawLine(x1+i, yAlt, x1+i, y); if(length<=(y2-y1) && y1 < y2) yAlt = y+1; else if(length<=(y1-y2) && y1 > y2) yAlt = y-1; else yAlt = y; } } else { // angle smaller 45° // y1 must be smaller than y2 if(y1 > y2) { xTmp = x1; yTmp = y1; x1 = x2; y1 = y2; x2 = xTmp; y2 = yTmp; } length = y2-y1; m = ((x2-x1)*200)/length; yAlt = x1; for(i=0; i<=length; i++) { y = ((m*i)/200)+x1; if((m*i)%200 >= 100) y++; else if((m*i)%200 <= -100) y--; DrawLine(yAlt, y1+i, y, y1+i); if(length<=(x2-x1) && x1 < x2) yAlt = y+1; else if(length<=(x1-x2) && x1 > x2) yAlt = y-1; else yAlt = y; } } } } void DrawPixel(void) { send(par,color); } void DrawPixelXY(uint8_t x, uint8_t y) { GotoXY(x, y); send(kom,MEM_WRITE); send(par,color); } void DrawRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height) { width--; height--; DrawLine(x, y, x+width, y); // top DrawLine(x, y, x, y+height); // left DrawLine(x, y+height, x+width, y+height); // bottom DrawLine(x+width, y, x+width, y+height); // right } void FillRect(uint8_t x, uint8_t y, uint8_t width, uint8_t height) { uint16_t i; SetDrawRect(x, x+width-1, y, y+height-1); send(kom,MEM_WRITE); for(i=0; i<width*height; i++) { send(par,color); } } void GotoXY(uint8_t x, uint8_t y) { SetDrawRect(x, DISP_X_END, y, DISP_Y_END); } void SetColor(uint8_t newColor) { color = newColor; } void SetFont(font newFont) { f = newFont; } void SetDrawRect(uint8_t startX, uint8_t endX, uint8_t startY, uint8_t endY) { send(kom,SET_X_ADDR); send(par,startX+1); send(par,endX+1); send(kom,SET_Y_ADDR); send(par,startY+1); send(par,endY+1); xCoord=startX; yCoord=startY; } void clock_set(unsigned char changed) // Clock { SetColor(Schwarz); if(changed==1) { mintemp=min+1; hortemp=hor+1; } if(sec<10) //sec { GotoXY(sepos.x1,sepos.y); printf("0"); SetColor(Hellblau); FillRect(sepos.x2,sepos.y,12,16); SetColor(Schwarz); GotoXY(sepos.x2,sepos.y); printf("%u",sec); } else { SetColor(Hellblau); FillRect(sepos.x1,sepos.y,25,16); SetColor(Schwarz); GotoXY(sepos.x1,hopos.y); printf("%u",sec); } if(mintemp!=min) { if(min<10) //min { GotoXY(mipos.x1,mipos.y); printf("0"); SetColor(Hellblau); FillRect(mipos.x2,mipos.y,12,16); SetColor(Schwarz); GotoXY(mipos.x2,mipos.y); printf("%u",min); } else { SetColor(Hellblau); FillRect(mipos.x1,mipos.y,25,16); SetColor(Schwarz); GotoXY(mipos.x1,mipos.y); printf("%u",min); } } if(hortemp!=hor) { if(hor<10) // hor { GotoXY(hopos.x1,hopos.y); printf("0"); SetColor(Hellblau); FillRect(hopos.x2,hopos.y,12,16); SetColor(Schwarz); GotoXY(hopos.x2,hopos.y); printf("%u",hor); } else { SetColor(Hellblau); FillRect(hopos.x1,hopos.y,25,16); SetColor(Schwarz); GotoXY(hopos.x1,hopos.y); printf("%u",hor); } } } void clock_reset(void) { sec=min=hor=0; Lcd_cls(Hellblau); SetColor(Schwarz); GotoXY(39,hopos.y); printf(":"); GotoXY(74,hopos.y); printf(":"); GotoXY(sepos.x1,mipos.y); printf("0"); GotoXY(sepos.x2,mipos.y); printf("0"); GotoXY(mipos.x1,mipos.y); printf("0"); GotoXY(mipos.x2,mipos.y); printf("0"); GotoXY(hopos.x1,mipos.y); printf("0"); GotoXY(hopos.x2,mipos.y); printf("0"); } /*---------------------------------------------------- LCD Routinen Ende ----------------------------------------------------*/ SIGNAL (SIG_USART1_RECV) { char* text = "empfangen"; unsigned char temp,func; unsigned int wert; SendeString(text); SetFont(smallFont); SetColor(Hellblau); FillRect(0,1,131,80); SetColor(Blau); GotoXY(0,1); printf("Data received:"); NewLine(); temp = USART_Receive(); if(temp=='c') { TCCR1B=0; // Timer off printf("empfangen: %c",temp); NewLine(); wert=USART_Receive(); hor = wert; printf("Stunde: %d",wert); NewLine(); wert=USART_Receive(); min = wert; printf("Minute: %d",wert); NewLine(); wert=USART_Receive(); sec = wert; printf("Sekunde: %d",wert); TCCR1B = ((1<<CS10) | (1<<CS12) | (1<<WGM12)); // Timer on SetFont(largeFont); clock_set(1); } else if(temp=='0') // light 0 { func = USART_Receive(); if(func=='0') // light 0 off { printf("empfangen: %c %c",temp,func); NewLine(); PORTA |=(1<<PIN0); printf("Light off"); } else if(func=='1') // light 0 on { printf("empfangen: %c %c",temp,func); NewLine(); PORTA &=~(1<<PIN0); printf("Light on"); } } else if(temp=='1') // light 1 { func = USART_Receive(); if(func=='0') // light 1 off { printf("empfangen: %c %c",temp,func); NewLine(); PORTA |=(1<<PIN1); printf("Light off"); } else if(func=='1') // light 1 on { printf("empfangen: %c %c",temp,func); NewLine(); PORTA &=~(1<<PIN1); printf("Light on"); } } else if(temp=='2') // light 2 { func = USART_Receive(); if(func=='0') // light 2 off { printf("empfangen: %c %c",temp,func); NewLine(); PORTA |=(1<<PIN2); printf("Light off"); } else if(func=='1') // light 2 on { printf("empfangen: %c %c",temp,func); NewLine(); PORTA &=~(1<<PIN2); printf("Light on"); } } else if(temp=='3') // light 3 { func = USART_Receive(); if(func=='0') // light 3 off { printf("empfangen: %c %c",temp,func); NewLine(); PORTA |=(1<<PIN3); printf("Light off"); } else if(func=='1') // light 3 on { printf("empfangen: %c %c",temp,func); NewLine(); PORTA &=~(1<<PIN3); printf("Light on"); } } else if(temp=='4') // light 4 { func = USART_Receive(); if(func=='0') // light 4 off { printf("empfangen: %c %c",temp,func); NewLine(); PORTA |=(1<<PINA4); printf("Light off"); } else if(func=='1') // light 4 on { printf("empfangen: %c %c",temp,func); NewLine(); PORTA &=~(1<<PIN4); printf("Light on"); } } else if(temp=='5') // light 5 { func = USART_Receive(); if(func=='0') // light 5 off { printf("empfangen: %c %c",temp,func); NewLine(); PORTA |=(1<<PIN5); printf("Light off"); } else if(func=='1') // light 5 on { printf("empfangen: %c %c",temp,func); NewLine(); PORTA &=~(1<<PIN5); printf("Light on"); } } else if(temp=='6') // light 6 { func = USART_Receive(); if(func=='0') // light 6 off { printf("empfangen: %c %c",temp,func); NewLine(); PORTA |=(1<<PIN6); printf("Light off"); } else if(func=='1') // light 6 on { printf("empfangen: %c %c",temp,func); NewLine(); PORTA &=~(1<<PIN6); printf("Light on"); } } else if(temp=='7') // light 7 { func = USART_Receive(); if(func=='0') // light 7 off { printf("empfangen: %c %c",temp,func); NewLine(); PORTA |=(1<<PIN7); printf("Light off"); } else if(func=='1') // light 7 on { printf("empfangen: %c %c",temp,func); NewLine(); PORTA &=~(1<<PIN7); printf("Light on"); } } SetFont(largeFont); } SIGNAL (SIG_INTERRUPT4) //interrupt 4 Zähler { if(prell==0) { prell=1; } } SIGNAL (SIG_INTERRUPT5)// Interrupt5 clock start { TCCR1B = ((1<<CS10) | (1<<CS12) | (1<<WGM12)); // Timer on clock_reset(); } /*---------------------------------------------------- Interrupt Timer 1 ----------------------------------------------------*/ SIGNAL (SIG_OUTPUT_COMPARE1A) { unsigned char sreg; sreg=SREG; prell=0; hortemp=hor; mintemp=min; sec++; if(sec==60) { sec = 0; SetColor(Hellblau); FillRect(sepos.x1,sepos.y,25,16); min++; if(min==60) { min=0; SetColor(Hellblau); FillRect(mipos.x1,mipos.y,25,16); hor++; if(hor==24) clock_reset(); } } clock_set(0); USART_Transmit(hor); USART_Transmit(min); USART_Transmit(sec); SREG=sreg; } /*---------------------------------------------------- Initialisierung ----------------------------------------------------*/ void Lcd_init(void) // LCD { unsigned char i=0; lcd_port &= ~(1<<rs); Delay_10ms(); // 'Initialisierung und Reset; Der Befehl Set setzt Ausgang auf 1, Reset auf 0 lcd_port |= (1<<rs); lcd_port |= (1<<cs); lcd_port |= (1<<sd); lcd_port |= (1<<cl); send(kom,0x20); // 'Power Control send(par,0x0f); Delay_10ms(); Delay_10ms(); Delay_10ms(); Delay_10ms(); send(kom,0x94); send(kom,0xAF); send(kom,0xD1); Delay_10ms(); Delay_10ms(); Delay_10ms(); Delay_10ms(); send(kom,0xBC); send(par,0x07); // 'Bei Zeichenausgabe werden die Pixel von oben nach unten geschrieben send(par,0x00); // 'H05 = Spiegelverkehrt; H07 = um 180° gedrehte Ausgabe send(par,0x01); // 'RGB Anordnung // '8-gray scale = 256 Farben send(kom,0xBB); // 'Common scan direction send(par,0x01); // 'Verdrahtung, fest definiert send(kom,0xA7); // 'Inverse Display; &HA6 wäre nicht invertiert (=andere Farben !!) send(kom,0xCE); // '256-Farben while(i<=2) { send(par,0x00); send(par,0x02); send(par,0x04); send(par,0x06); send(par,0x09); send(par,0x0B); send(par,0x0D); send(par,0x0F); i++; } } void ioinit (void) { //Counter für 1 sec OCR1A = 7900; TCNT1 = 0; timer_enable_int (1<<OCIE1A); enable_external_int ((1<<INT4) | (1<<INT5)); DDRB=0xFF; DDRA=0xFF; MCUCR=0x30; EICRB=0x0A; PORTA=0xff; // Led's aus // USART initialization // Communication Parameters: 8 Data, 1 Stop, No Parity // USART Baud rate: 57600 UCSR1A=0x00; UCSR1B=((1<<RXCIE1) | (1<<RXEN1) | (1<<TXEN1)); UCSR1C=0x06; UBRR1L=8; UBRR1H=0x00; sei (); } int main (void) // main { ioinit (); // PORTS und TIMER initialisieren Lcd_init (); // LCD initialisieren Lcd_cls(Schwarz); //LCD clear hopos.x1=15; hopos.x2=27; mipos.x1=50; mipos.x2=62; sepos.x1=85; sepos.x2=97; sepos.y=110; mipos.y=110; hopos.y=110; smallFont.width = FONT6X8_WIDTH; smallFont.height = FONT6X8_HEIGHT; smallFont.charData = Font6x8; largeFont.width = FONT12X16_WIDTH; largeFont.height = FONT12X16_HEIGHT; largeFont.charData = Font12x16; fdevopen(DrawChar, NULL, 0); SetColor(Weiss); SetFont(largeFont); GotoXY(30,1); printf("Hallo"); NewLine(); printf("Trottel!"); while(1) { // Endlosschleife } for(;;); return (0); }

Abbildung 1:

Abbildung 2:

Projekt "Bilderkennung für Autokennzeichen"

Ausgehend von einer Aufnahme eines Automobils wurde mittels einer Webkamera das Autokennzeichen erkannt.

Um die Bilder aus der Kamera auszuwerten, wurde die Kamera über die Twainschnittstelle angesteuert und die Bilder auf die Festplatte gespeichert. Der Programmstart erfolgt aus Matlab heraus, somit konnten die abgespeicherten Bilder gleich in Mattlab weiterverarbeitet werden.
Wie in Abbildung 1 zu sehen, wurde zuerst ein Grauwertbild aus dem Bild erzeugt und anschließend die Kanten mit einem Laplace-Operator herausgearbeitet.
Da die Form eines Autokennzeichens einer Norm unterliegt, wurde das bis dahin entstandene Bild mit einer Kennzeichenmaske korreliert. Weil eine Erkennung nicht nur in einem bestimmten Punkt (Abstand zum Fahrzeug) möglich sein soll, sondern fortlaufen (während der Fahrt), wird die Maske während der Korrelation gedreht und vergrößert. Wie in Abbildung 2 zu sehen, ist bei einem bestimmten Winkel und einer bestimmten Größe eine starke Korrelation im Bereich des Kennzeichens zu sehen.

Für eine endgültige Auswertung wird nach einem kompletten Durchgang der höchste Korrelationswert gespeichert und ein geeigneter Bereich um diesen Punkt ausgeschnitten. Nach einer Korrelation einzelner Buchstaben und einer Datenbank im Hintergrund könnte zusätzlich auch der Ort der Zulassung bestimmt werden.

Matlab-Quellcode:

image = imread('scan1.bmp','bmp'); imcor = imread('mask.tif','tif'); imgray = rgb2gray(image); oldim=imgray; oldmax=0; rot=0; tic % black and white imgray(imgray>125)=255; imgray(imgray<=125)=0; % Kanten finden A= [ 0 -1 0; -1 4 -1; 0 -1 0]; B=filter2(A,imgray,'same'); %figure(1), colormap gray %subplot(1,2,1); %imagesc(B); jinit=0; iinit=0.8; imrot=imrotate(imcor,jinit); imsize = imresize(imrot,iinit,'nearest'); for j=jinit+1:6 for i=iinit+0.1:0.1:2.0 % Nummernschild suchen C=xcorr2(double(B),double(imsize)); figure(2), colormap gray subplot(1,2,1); imagesc(C); subplot(1,2,2); imagesc(imsize); % Korrelationspeak suchen [maxx,x]=max(max(C)); [maxy,y]=max(max(C')); if maxx>oldmax oldmax=maxx; if j-1==jinit rotm=jinit; fx=x; fy=y; int=iinit; else rotm=j; fx=x; fy=y; int=i; end end imsize = imresize(imrot,i,'nearest'); end imrot=imrotate(imcor,j); imsize = imresize(imrot,iinit,'nearest'); end; % Streifenmaske %r=ones(1,40); %rc=r; %figure(3), colormap gray % Ausschneiden der Bilder %cut1=C(y-20:y+20,x-20:x+20); %cutx=oldim(y-60*int:y,x-200*int:x+20*int); if y>=60*2 cutx=oldim(y-60*int:y+60*int,x-100*int:x+100*int); else cutx=oldim(y:y,x:x+20*int); end %imagesc(imgray); % Suche der Rotation %{ oldval=oldmax; for i=0:10 subplot(1,2,1); imagesc(rc); D=xcorr2(rc,cut1); val=max(max(D)); subplot(1,2,2); imagesc(D); if val>oldval oldval=val; rot = i; end rc=imrotate(r,i); end %} % Drehen des Bildes cutfin=imrotate(cutx,-rotm); figure(4), colormap gray subplot(1,2,2); imagesc(cutfin); toc

Für Nachbauten der oben aufgeführten Projekte wird keine Haftung bei Defekten übernommen