-         

Ergebnis 1 bis 4 von 4

Thema: Vorstellung - Xmega Tutorial - Linksammlung - Atmega32U4 Beispiel

  1. #1

    Vorstellung - Xmega Tutorial - Linksammlung - Atmega32U4 Beispiel

    Anzeige

    Guten Morgen,

    Meine Seiten werden zurzeit komplett überarbeitet!

    Gruß Florian
    Geändert von stromflo (16.05.2012 um 18:16 Uhr)

  2. #2
    Moderator Robotik Visionär Avatar von radbruch
    Registriert seit
    27.12.2006
    Ort
    Stuttgart
    Alter
    54
    Beiträge
    5.781
    Blog-Einträge
    8
    Hallo

    Über den ATMega32U4 bin ich auch schon gestolpert:
    http://www.roboternetz.de/community/...l=1#post539603

    Aus Zeitmangel bin ich aber über die einfache USB-Kommunikation nicht hinausgekommen:

    Code:
    /* Simple example for Teensy USB Development Board
     * http://www.pjrc.com/teensy/
     * Copyright (c) 2008 PJRC.COM, LLC
     *
     * Permission is hereby granted, free of charge, to any person obtaining a copy
     * of this software and associated documentation files (the "Software"), to deal
     * in the Software without restriction, including without limitation the rights
     * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
     * copies of the Software, and to permit persons to whom the Software is
     * furnished to do so, subject to the following conditions:
     *
     * The above copyright notice and this permission notice shall be included in
     * all copies or substantial portions of the Software.
     *
     * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
     * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
     * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
     * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
     * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
     * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
     * THE SOFTWARE.
     */
    
    #include <avr/io.h>
    #include <avr/pgmspace.h>
    #include <stdint.h>
    #include <util/delay.h>
    #include "usb_serial.h"
    
    #define LED_CONFIG	(DDRE |= (1<<6)) // PE6 ist die grüne LED mic 5.2.2012
    #define LED_ON		(PORTE |= (1<<6))
    #define LED_OFF		(PORTE &= ~(1<<6))
    #define CPU_PRESCALE(n) (CLKPR = 0x80, CLKPR = (n))
    
    void send_str(const char *s);
    uint8_t recv_str(char *buf, uint8_t size);
    void parse_and_execute_command(const char *buf, uint8_t num);
    
    #if 1
    // Very simple character echo test
    int main(void)
    {
    	CPU_PRESCALE(0);
    	LED_CONFIG;
    	LED_ON;
    	usb_init();
    	_delay_ms(1000);
    	LED_OFF;
    	while (1) {
    		int n = usb_serial_getchar();
    		if (n >= 0) {
    			usb_serial_putchar(n+1);
    		}
    	}
    }
    
    #else
    
    // Basic command interpreter for controlling port pins
    int main(void)
    {
    	char buf[32];
    	uint8_t n;
    
    	// set for 16 MHz clock, and turn on the LED
    	CPU_PRESCALE(0);
    	LED_CONFIG;
    	LED_ON;
    
    	// initialize the USB, and then wait for the host
    	// to set configuration.  If the Teensy is powered
    	// without a PC connected to the USB port, this
    	// will wait forever.
    	usb_init();
    	while (!usb_configured()) /* wait */ ;
    	_delay_ms(1000);
    
    	while (1) {
    		// wait for the user to run their terminal emulator program
    		// which sets DTR to indicate it is ready to receive.
    		while (!(usb_serial_get_control() & USB_SERIAL_DTR)) /* wait */ ;
    
    		// discard anything that was received prior.  Sometimes the
    		// operating system or other software will send a modem
    		// "AT command", which can still be buffered.
    		usb_serial_flush_input();
    
    		// print a nice welcome message
    		send_str(PSTR("\r\nTeensy USB Serial Example, "
    			"Simple Pin Control Shell\r\n\r\n"
    			"Example Commands\r\n"
    			"  B0?   Read Port B, pin 0\r\n"
    			"  C2=0  Write Port C, pin 1 LOW\r\n"
    			"  D6=1  Write Port D, pin 6 HIGH  (D6 is LED pin)\r\n\r\n"));
    
    		// and then listen for commands and process them
    		while (1); {
    			send_str(PSTR("> "));
    			n = recv_str(buf, sizeof(buf));
    			if (n == 255) break;
    			send_str(PSTR("\r\n"));
    			parse_and_execute_command(buf, n);
    		}
    	}
    }
    #endif
    
    // Send a string to the USB serial port.  The string must be in
    // flash memory, using PSTR
    //
    void send_str(const char *s)
    {
    	char c;
    	while (1) {
    		c = pgm_read_byte(s++);
    		if (!c) break;
    		usb_serial_putchar(c);
    	}
    }
    
    // Receive a string from the USB serial port.  The string is stored
    // in the buffer and this function will not exceed the buffer size.
    // A carriage return or newline completes the string, and is not
    // stored into the buffer.
    // The return value is the number of characters received, or 255 if
    // the virtual serial connection was closed while waiting.
    //
    uint8_t recv_str(char *buf, uint8_t size)
    {
    	int16_t r;
    	uint8_t count=0;
    
    	while (count < size) {
    		r = usb_serial_getchar();
    		if (r != -1) {
    			if (r == '\r' || r == '\n') return count;
    			if (r >= ' ' && r <= '~') {
    				*buf++ = r;
    				usb_serial_putchar(r);
    				count++;
    			}
    		} else {
    			if (!usb_configured() ||
    			  !(usb_serial_get_control() & USB_SERIAL_DTR)) {
    				// user no longer connected
    				return 255;
    			}
    			// just a normal timeout, keep waiting
    		}
    	}
    	return count;
    }
    
    // parse a user command and execute it, or print an error message
    //
    void parse_and_execute_command(const char *buf, uint8_t num)
    {
    	uint8_t port, pin, val;
    
    	if (num < 3) {
    		send_str(PSTR("unrecognized format, 3 chars min req'd\r\n"));
    		return;
    	}
    	// first character is the port letter
    	if (buf[0] >= 'A' && buf[0] <= 'F') {
    		port = buf[0] - 'A';
    	} else if (buf[0] >= 'a' && buf[0] <= 'f') {
    		port = buf[0] - 'a';
    	} else {
    		send_str(PSTR("Unknown port \""));
    		usb_serial_putchar(buf[0]);
    		send_str(PSTR("\", must be A - F\r\n"));
    		return;
    	}
    	// second character is the pin number
    	if (buf[1] >= '0' && buf[1] <= '7') {
    		pin = buf[1] - '0';
    	} else {
    		send_str(PSTR("Unknown pin \""));
    		usb_serial_putchar(buf[0]);
    		send_str(PSTR("\", must be 0 to 7\r\n"));
    		return;
    	}
    	// if the third character is a question mark, read the pin
    	if (buf[2] == '?') {
    		// make the pin an input
    		*(uint8_t *)(0x21 + port * 3) &= ~(1 << pin);
    		// read the pin
    		val = *(uint8_t *)(0x20 + port * 3) & (1 << pin);
    		usb_serial_putchar(val ? '1' : '0');
    		send_str(PSTR("\r\n"));
    		return;
    	}
    	// if the third character is an equals sign, write the pin
    	if (num >= 4 && buf[2] == '=') {
    		if (buf[3] == '0') {
    			// make the pin an output
    			*(uint8_t *)(0x21 + port * 3) |= (1 << pin);
    			// drive it low
    			*(uint8_t *)(0x22 + port * 3) &= ~(1 << pin);
    			return;
    		} else if (buf[3] == '1') {
    			// make the pin an output
    			*(uint8_t *)(0x21 + port * 3) |= (1 << pin);
    			// drive it high
    			*(uint8_t *)(0x22 + port * 3) |= (1 << pin);
    			return;
    		} else {
    			send_str(PSTR("Unknown value \""));
    			usb_serial_putchar(buf[3]);
    			send_str(PSTR("\", must be 0 or 1\r\n"));
    			return;
    		}
    	}
    	// otherwise, error message
    	send_str(PSTR("Unknown command \""));
    	usb_serial_putchar(buf[0]);
    	send_str(PSTR("\", must be ? or =\r\n"));
    }

    Wenn möglich würde ich dieses Board gerne mit LunaAVR programmieren:
    Code:
    avr.device = atmega32u4
    avr.clock = 16000000
    
    porte.6.mode = output, pulldown		' grüne LED aus
    
    Do
      waitms 500
      toggle porte.6
      waitms 100
      toggle porte.6
    Loop

    Gruß

    mic
    Angehängte Dateien Angehängte Dateien
    Geändert von radbruch (01.05.2012 um 10:40 Uhr)

    Atmel’s products are not intended, authorized, or warranted for use
    as components in applications intended to support or sustain life!

  3. #3
    LunaAVR kannte ich bisher noch nicht.
    Hab das ganze mal ein wenig überfolgen und es schaut sehr interessant aus.
    Mal schauen ob ich mal dazu komm, da ein wenig zu probieren.

    Gruß Flo

  4. #4
    Falls ein paar Tipps hilfreich sind, stehe ich gerne zur Verfügung.
    Einige der Ausdrücke in C existieren auch in luna, beispielsweise BitShift mit << und >>.

    Die Portierung von C-Source ist möglich, zum Großteil wird der geschriebene Code kürzer, beispielsweise beim setzen von Portpins.
    Auch ist es sinnvoll in solchen Fällen eine entsprechende Klasse anzulegen, um den Code modular aufzubauen.
    Ein gutes Beispiel hierfür sind die Klassen zur Ansteuerung von SD-Karten mit FAT32 und langen Dateinamen.

    Zu beachten ist, dass in luna im Unterschied zu C ein anderes Parameterkonzept für Methoden verwendet wird. D.h. Variablen/Arrays und Strukturen befinden sich in einem geschlossenen Namensraum, sodass die Übergabe von referenzierten Variablen oder Arrays in der Regel nicht notwendig ist. Die Implementation ist jedoch zusätzlich geplant.

    Beispiel:

    in vielen C-Funktionen werden Buffer-Arrays als Referenz/Zeiger übergeben:
    Code:
    uint8_t recv_str(char *buf, uint8_t size) { .. }
    in luna erstellt man für die meisten Anwendungen bestenfalls eine Klasse, in welcher globale Arrays Klassenweit verfügbar sind. Hierdurch ist eine Referenzübergabe nicht notwendig, da es auf das Selbe hinausläuft:
    Code:
    class USB
    
      dim buf(31) as byte
    
      function recv_str(size as byte) as byte
        dim i as byte
        if size then
          for i=0 to size
            buf(i) = readByte()
          next
          return 1 ' success
        endif
        return 0 ' failed
      endfunc
    
      function readByte() as byte
        return [...]
      endfunc
    
    endclass
    aus dem Hautprogramm ist der Buffer ebenfalls über die Klasse erreichbar:

    Code:
    a = usb.buf(0)
    Einfacher ist es jedoch, man nutzt die dynamische Speicherverwaltung in luna und damit die Möglichkeit dynamische Datenlängen einzulesen:
    Code:
    class USB
    
      function recv_str(size as byte) as string
        dim i as byte
        dim s as string
        if size then
          s = spc(size) ' buffer erzeugen (schneller wenn Speicherbereich bereits angelegt)
          for i=1 to size
            s.ByteValue(i) = readByte()
          next
        endif
        return s
      endfunc
    
      function readByte() as byte
        return [...]
      endfunc
    
    endclass
    Man benötigt prinzipiell also keinen Byte-Buffer für das Einlesen von Strings, sondern überlässt das der Speicherverwaltung.
    Bei großen, festen Blöcken wie im Beispiel der SD-Karten-Sektoren und -Daten ist es demgegenüber dann natürlich sinnvoller und schneller einen innerhalb der Klasse globalen Speicherbereich zu allozieren. Hierfür gibt es die MemoryBlocks, auf die dann alle möglichen Zugriffe vorgenommen werden können.

    Gruß, rgf
    Geändert von rgf (02.05.2012 um 15:45 Uhr)

Ähnliche Themen

  1. Vorstellung
    Von Patroclus im Forum Offtopic und Community Tratsch
    Antworten: 1
    Letzter Beitrag: 23.11.2011, 09:04
  2. Xmega auf MAC?
    Von Snow Wolf im Forum Microcontroller allgemeine Fragen/Andere Microcontroller
    Antworten: 1
    Letzter Beitrag: 18.09.2011, 02:18
  3. Vorstellung SPR-VI
    Von BlueNature im Forum Vorstellungen+Bilder von fertigen Projekten/Bots
    Antworten: 15
    Letzter Beitrag: 05.06.2010, 10:52
  4. Vorstellung InTra
    Von JollyJumper8 im Forum Vorstellungen+Bilder von fertigen Projekten/Bots
    Antworten: 4
    Letzter Beitrag: 04.10.2009, 00:47
  5. 2D-, 3D ...Echtzeit - Bahnverfolgung Ideen- und Linksammlung
    Von sigo im Forum Sensoren / Sensorik
    Antworten: 1
    Letzter Beitrag: 09.02.2006, 22:53

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •