INFO: Dieses Forum nutzt Cookies...
Cookies sind für den Betrieb des Forums unverzichtbar. Mit der Nutzung des Forums erklärst Du dich damit einverstanden, dass wir Cookies verwenden.

Es wird in jedem Fall ein Cookie gesetzt um diesen Hinweis nicht mehr zu erhalten. Desweiteren setzen wir Google Adsense und Google Analytics ein.

Antwort schreiben 
 
Themabewertung:
  • 2 Bewertungen - 3 im Durchschnitt
  • 1
  • 2
  • 3
  • 4
  • 5
Serial Monitor als Debughilfe für den ATtiny85 und andere ATMEL-Mikrocontroller
31.01.2015, 22:50 (Dieser Beitrag wurde zuletzt bearbeitet: 20.05.2015 16:53 von ardu_arne.)
Beitrag #1
Star Serial Monitor als Debughilfe für den ATtiny85 und andere ATMEL-Mikrocontroller
Hallo zusammen.

Mit dieser Projektvorstellung möchte ich zeigen, wie man den Serial Monitor der Arduino IDE auch dann nutzen kann wenn man über einen "Arduino as ISP" einen ATtiny oder einen ATmega programmiert. Der Zielcontroller brauch hierzu keine USB-Verbindung zum PC.

Zum Testen diente mir ein ATtiny85 mit 8MHz internem Takt, aber auch bei anderen Controllern sollte der beschriebene Weg funktionieren.
Die SoftwareSerial-Library beinhaltet nur Timingtabellen für 8,16 und 20MHz.
Deshalb funktioniert diese Anleitung bei einem Controller der mit 1MHz getaktet ist nicht.


In diesem Beitrag hatte ich u.A. beschrieben wie man einen ATtiny85 mit Hilfe eines Arduino UNO, welcher als ISP programmiert ist, flasht.
Um sich die Verbindung eines ATtiny25/45/85 mit dem UNO als ISP zu erleichtern gibt es für wenig Kohle kleine Adapter für die 8-Pinner wie z.B. diesen.
Danke an Bitklopfer für den Hinweis zu dem AdapterExclamation

Wenn man ein Arduino Board programmiert nutzt man normalerweise den Serial Monitor um sich Informationen zum Programmablauf und zur Fehlersuche anzeigen zu lassen. Dieses hilfreiche Werkzeug steht aber immer dann nicht zur Verfügung wenn man einen Mikrocontroller solo programmieren will.


Ich stelle hiermit eine Möglichkeit vor wie man sich Informationen aus dem ATtiny dennoch am Serial Monitor anzeigen lassen kann.
Das Prinzip ist recht einfach.
Idea Der ATtiny sendet die Ausgaben via SoftwareSerial-Library an den Arduino ISP und dieser leitet sie an den Serial Monitor weiter.Idea

Hier der Schaltplan zum flashen eines ATtiny45/85 mit einer zusätzlichen Verbindung für die serielle Kommunikation:
   
und der Schaltplan zum flashen eines ATtiny44/84 mit einer zusätzlichen Verbindung für die serielle Kommunikation:
   
Die grün gezeichneten Verbindungen entsprechen der Standartschaltung zum flashen des ATtiny.
Die zusätzliche blaue Leitung dient der seriellen Übertragung vom ATtiny zum UNO.

Mit dem oben verlinkten Adapter sieht das für einen ATtiny45/85 fertig aufgebaut dann so aus:
   
Die blaue Steckbrücke entspricht dabei der blauen Linie aus dem Schaltplan.


Um den "Arduino as ISP" zu überreden die vom ATtiny gesendeten Daten an den Serial Monitor weiterzuleiten, muss man dessen Programmcode etwas ergänzen.

Hier der modifizierte Sketch für den "Arduino as ISP":
Code:
// Modifizierte Version mit Feedbackfunktion fuer ATtiny via SoftwareSerial

// ArduinoISP version 04m3
// Copyright (c) 2008-2011 Randall Bohn
// If you require a license, see
//     http://www.opensource.org/licenses/bsd-license.php
//
// This sketch turns the Arduino into a AVRISP
// using the following arduino pins:
//
// pin name:    not-mega:         mega(1280 and 2560)
// slave reset: 10:               53
// MOSI:        11:               51
// MISO:        12:               50
// SCK:         13:               52
//
// Put an LED (with resistor) on the following pins:
// 9: Heartbeat   - shows the programmer is running
// 8: Error       - Lights up if something goes wrong (use red if that makes sense)
// 7: Programming - In communication with the slave
//
// 23 July 2011 Randall Bohn
// -Address Arduino issue 509 :: Portability of ArduinoISP
// http://code.google.com/p/arduino/issues/detail?id=509
//
// October 2010 by Randall Bohn
// - Write to EEPROM > 256 bytes
// - Better use of LEDs:
// -- Flash LED_PMODE on each flash commit
// -- Flash LED_PMODE while writing EEPROM (both give visual feedback of writing progress)
// - Light LED_ERR whenever we hit a STK_NOSYNC. Turn it off when back in sync.
// - Use pins_arduino.h (should also work on Arduino Mega)
//
// October 2009 by David A. Mellis
// - Added support for the read signature command
//
// February 2009 by Randall Bohn
// - Added support for writing to EEPROM (what took so long?)
// Windows users should consider WinAVR's avrdude instead of the
// avrdude included with Arduino software.
//
// January 2008 by Randall Bohn
// - Thanks to Amplificar for helping me with the STK500 protocol
// - The AVRISP/STK500 (mk I) protocol is used in the arduino bootloader
// - The SPI functions herein were developed for the AVR910_ARD programmer
// - More information at http://code.google.com/p/mega-isp

#include "pins_arduino.h"

#include <SoftwareSerial.h>                   // Tiny85 Feedback
SoftwareSerial softSerial(4, 99); // RX, TX   // Tiny85 Feedback, 99=Dummy weil TX nicht benötigt wird
unsigned long softserialtime;                 // Tiny85 Feedback
#define toSoftSerial 1000UL                   // Tiny85 Feedback
boolean softSerialAktiv = false;              // Tiny85 Feedback


#define RESET     SS

#define LED_HB    9
#define LED_ERR   8
#define LED_PMODE 7
#define PROG_FLICKER true

#define HWVER 2
#define SWMAJ 1
#define SWMIN 18

// STK Definitions
#define STK_OK      0x10
#define STK_FAILED  0x11
#define STK_UNKNOWN 0x12
#define STK_INSYNC  0x14
#define STK_NOSYNC  0x15
#define CRC_EOP     0x20 //ok it is a space...

void pulse(int pin, int times);

void setup() {
  Serial.begin(19200);
  pinMode(LED_PMODE, OUTPUT);
  pulse(LED_PMODE, 2);
  pinMode(LED_ERR, OUTPUT);
  pulse(LED_ERR, 2);
  pinMode(LED_HB, OUTPUT);
  pulse(LED_HB, 2);
}

int error=0;
int pmode=0;
// address for reading and writing, set by 'U' command
int here;
uint8_t buff[256]; // global block storage

#define beget16(addr) (*addr * 256 + *(addr+1) )
typedef struct param {
  uint8_t devicecode;
  uint8_t revision;
  uint8_t progtype;
  uint8_t parmode;
  uint8_t polling;
  uint8_t selftimed;
  uint8_t lockbytes;
  uint8_t fusebytes;
  int flashpoll;
  int eeprompoll;
  int pagesize;
  int eepromsize;
  int flashsize;
}
parameter;

parameter param;

// this provides a heartbeat on pin 9, so you can tell the software is running.
uint8_t hbval=128;
int8_t hbdelta=8;
void heartbeat() {
  if (hbval > 192) hbdelta = -hbdelta;
  if (hbval < 32) hbdelta = -hbdelta;
  hbval += hbdelta;
  analogWrite(LED_HB, hbval);
  delay(20);
}


void loop(void) {
  // is pmode active?
  if (pmode) digitalWrite(LED_PMODE, HIGH);
  else digitalWrite(LED_PMODE, LOW);
  // is there an error?
  if (error) digitalWrite(LED_ERR, HIGH);
  else digitalWrite(LED_ERR, LOW);


  if ((millis() > (softserialtime + toSoftSerial)) && !softSerialAktiv) {  // Tiny85 Feedback
    softSerial.begin(9600);      // Tiny85 Feedback
    softSerial.flush();          // Tiny85 Feedback
    softSerialAktiv = true;      // Tiny85 Feedback
  }

  // light the heartbeat LED
  if (!softSerialAktiv)          // Tiny85 Feedback
    heartbeat();
  else                           // Tiny85 Feedback
    analogWrite(LED_HB, 0);      // Tiny85 Feedback

  if (Serial.available()) {
    softserialtime = millis();   // Tiny85 Feedback
    softSerial.end();            // Tiny85 Feedback
    softSerialAktiv = false;     // Tiny85 Feedback
    avrisp();
  }
  
  if (softSerial.available() && !pmode && softSerialAktiv)  // Tiny85 Feedback
    Serial.write(softSerial.read());                        // Tiny85 Feedback
}


uint8_t getch() {
  while(!Serial.available());
  return Serial.read();
}
void fill(int n) {
  for (int x = 0; x < n; x++) {
    buff[x] = getch();
  }
}

#define PTIME 30
void pulse(int pin, int times) {
  do {
    digitalWrite(pin, HIGH);
    delay(PTIME);
    digitalWrite(pin, LOW);
    delay(PTIME);
  }
  while (times--);
}

void prog_lamp(int state) {
  if (PROG_FLICKER)
    digitalWrite(LED_PMODE, state);
}

void spi_init() {
  uint8_t x;
  SPCR = 0x53;
  x=SPSR;
  x=SPDR;
}

void spi_wait() {
  do {
  }
  while (!(SPSR & (1 << SPIF)));
}

uint8_t spi_send(uint8_t b) {
  uint8_t reply;
  SPDR=b;
  spi_wait();
  reply = SPDR;
  return reply;
}

uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
  uint8_t n;
  spi_send(a);
  n=spi_send(b);
  //if (n != a) error = -1;
  n=spi_send(c);
  return spi_send(d);
}

void empty_reply() {
  if (CRC_EOP == getch()) {
    Serial.print((char)STK_INSYNC);
    Serial.print((char)STK_OK);
  }
  else {
    error++;
    Serial.print((char)STK_NOSYNC);
  }
}

void breply(uint8_t b) {
  if (CRC_EOP == getch()) {
    Serial.print((char)STK_INSYNC);
    Serial.print((char)b);
    Serial.print((char)STK_OK);
  }
  else {
    error++;
    Serial.print((char)STK_NOSYNC);
  }
}

void get_version(uint8_t c) {
  switch(c) {
  case 0x80:
    breply(HWVER);
    break;
  case 0x81:
    breply(SWMAJ);
    break;
  case 0x82:
    breply(SWMIN);
    break;
  case 0x93:
    breply('S'); // serial programmer
    break;
  default:
    breply(0);
  }
}

void set_parameters() {
  // call this after reading paramter packet into buff[]
  param.devicecode = buff[0];
  param.revision   = buff[1];
  param.progtype   = buff[2];
  param.parmode    = buff[3];
  param.polling    = buff[4];
  param.selftimed  = buff[5];
  param.lockbytes  = buff[6];
  param.fusebytes  = buff[7];
  param.flashpoll  = buff[8];
  // ignore buff[9] (= buff[8])
  // following are 16 bits (big endian)
  param.eeprompoll = beget16(&buff[10]);
  param.pagesize   = beget16(&buff[12]);
  param.eepromsize = beget16(&buff[14]);

  // 32 bits flashsize (big endian)
  param.flashsize = buff[16] * 0x01000000
    + buff[17] * 0x00010000
    + buff[18] * 0x00000100
    + buff[19];

}

void start_pmode() {
  spi_init();
  // following delays may not work on all targets...
  pinMode(RESET, OUTPUT);
  digitalWrite(RESET, HIGH);
  pinMode(SCK, OUTPUT);
  digitalWrite(SCK, LOW);
  delay(50);
  digitalWrite(RESET, LOW);
  delay(50);
  pinMode(MISO, INPUT);
  pinMode(MOSI, OUTPUT);
  spi_transaction(0xAC, 0x53, 0x00, 0x00);
  pmode = 1;
}

void end_pmode() {
  pinMode(MISO, INPUT);
  pinMode(MOSI, INPUT);
  pinMode(SCK, INPUT);
  pinMode(RESET, INPUT);
  pmode = 0;
}

void universal() {
  int w;
  uint8_t ch;

  fill(4);
  ch = spi_transaction(buff[0], buff[1], buff[2], buff[3]);
  breply(ch);
}

void flash(uint8_t hilo, int addr, uint8_t data) {
  spi_transaction(0x40+8*hilo,
  addr>>8 & 0xFF,
  addr & 0xFF,
  data);
}
void commit(int addr) {
  if (PROG_FLICKER) prog_lamp(LOW);
  spi_transaction(0x4C, (addr >> 8) & 0xFF, addr & 0xFF, 0);
  if (PROG_FLICKER) {
    delay(PTIME);
    prog_lamp(HIGH);
  }
}

//#define _current_page(x) (here & 0xFFFFE0)
int current_page(int addr) {
  if (param.pagesize == 32)  return here & 0xFFFFFFF0;
  if (param.pagesize == 64)  return here & 0xFFFFFFE0;
  if (param.pagesize == 128) return here & 0xFFFFFFC0;
  if (param.pagesize == 256) return here & 0xFFFFFF80;
  return here;
}


void write_flash(int length) {
  fill(length);
  if (CRC_EOP == getch()) {
    Serial.print((char) STK_INSYNC);
    Serial.print((char) write_flash_pages(length));
  }
  else {
    error++;
    Serial.print((char) STK_NOSYNC);
  }
}

uint8_t write_flash_pages(int length) {
  int x = 0;
  int page = current_page(here);
  while (x < length) {
    if (page != current_page(here)) {
      commit(page);
      page = current_page(here);
    }
    flash(LOW, here, buff[x++]);
    flash(HIGH, here, buff[x++]);
    here++;
  }

  commit(page);

  return STK_OK;
}

#define EECHUNK (32)
uint8_t write_eeprom(int length) {
  // here is a word address, get the byte address
  int start = here * 2;
  int remaining = length;
  if (length > param.eepromsize) {
    error++;
    return STK_FAILED;
  }
  while (remaining > EECHUNK) {
    write_eeprom_chunk(start, EECHUNK);
    start += EECHUNK;
    remaining -= EECHUNK;
  }
  write_eeprom_chunk(start, remaining);
  return STK_OK;
}
// write (length) bytes, (start) is a byte address
uint8_t write_eeprom_chunk(int start, int length) {
  // this writes byte-by-byte,
  // page writing may be faster (4 bytes at a time)
  fill(length);
  prog_lamp(LOW);
  for (int x = 0; x < length; x++) {
    int addr = start+x;
    spi_transaction(0xC0, (addr>>8) & 0xFF, addr & 0xFF, buff[x]);
    delay(45);
  }
  prog_lamp(HIGH);
  return STK_OK;
}

void program_page() {
  char result = (char) STK_FAILED;
  int length = 256 * getch();
  length += getch();
  char memtype = getch();
  // flash memory @here, (length) bytes
  if (memtype == 'F') {
    write_flash(length);
    return;
  }
  if (memtype == 'E') {
    result = (char)write_eeprom(length);
    if (CRC_EOP == getch()) {
      Serial.print((char) STK_INSYNC);
      Serial.print(result);
    }
    else {
      error++;
      Serial.print((char) STK_NOSYNC);
    }
    return;
  }
  Serial.print((char)STK_FAILED);
  return;
}

uint8_t flash_read(uint8_t hilo, int addr) {
  return spi_transaction(0x20 + hilo * 8,
  (addr >> 8) & 0xFF,
  addr & 0xFF,
  0);
}

char flash_read_page(int length) {
  for (int x = 0; x < length; x+=2) {
    uint8_t low = flash_read(LOW, here);
    Serial.print((char) low);
    uint8_t high = flash_read(HIGH, here);
    Serial.print((char) high);
    here++;
  }
  return STK_OK;
}

char eeprom_read_page(int length) {
  // here again we have a word address
  int start = here * 2;
  for (int x = 0; x < length; x++) {
    int addr = start + x;
    uint8_t ee = spi_transaction(0xA0, (addr >> 8) & 0xFF, addr & 0xFF, 0xFF);
    Serial.print((char) ee);
  }
  return STK_OK;
}

void read_page() {
  char result = (char)STK_FAILED;
  int length = 256 * getch();
  length += getch();
  char memtype = getch();
  if (CRC_EOP != getch()) {
    error++;
    Serial.print((char) STK_NOSYNC);
    return;
  }
  Serial.print((char) STK_INSYNC);
  if (memtype == 'F') result = flash_read_page(length);
  if (memtype == 'E') result = eeprom_read_page(length);
  Serial.print(result);
  return;
}

void read_signature() {
  if (CRC_EOP != getch()) {
    error++;
    Serial.print((char) STK_NOSYNC);
    return;
  }
  Serial.print((char) STK_INSYNC);
  uint8_t high = spi_transaction(0x30, 0x00, 0x00, 0x00);
  Serial.print((char) high);
  uint8_t middle = spi_transaction(0x30, 0x00, 0x01, 0x00);
  Serial.print((char) middle);
  uint8_t low = spi_transaction(0x30, 0x00, 0x02, 0x00);
  Serial.print((char) low);
  Serial.print((char) STK_OK);
}
//////////////////////////////////////////
//////////////////////////////////////////


////////////////////////////////////
////////////////////////////////////
int avrisp() {
  uint8_t data, low, high;
  uint8_t ch = getch();
  switch (ch) {
  case '0': // signon
    error = 0;
    empty_reply();
    break;
  case '1':
    if (getch() == CRC_EOP) {
      Serial.print((char) STK_INSYNC);
      Serial.print("AVR ISP");
      Serial.print((char) STK_OK);
    }
    break;
  case 'A':
    get_version(getch());
    break;
  case 'B':
    fill(20);
    set_parameters();
    empty_reply();
    break;
  case 'E': // extended parameters - ignore for now
    fill(5);
    empty_reply();
    break;

  case 'P':
    start_pmode();
    empty_reply();
    break;
  case 'U': // set address (word)
    here = getch();
    here += 256 * getch();
    empty_reply();
    break;

  case 0x60: //STK_PROG_FLASH
    low = getch();
    high = getch();
    empty_reply();
    break;
  case 0x61: //STK_PROG_DATA
    data = getch();
    empty_reply();
    break;

  case 0x64: //STK_PROG_PAGE
    program_page();
    break;

  case 0x74: //STK_READ_PAGE 't'
    read_page();    
    break;

  case 'V': //0x56
    universal();
    break;
  case 'Q': //0x51
    error=0;
    end_pmode();
    empty_reply();
    break;

  case 0x75: //STK_READ_SIGN 'u'
    read_signature();
    break;

    // expecting a command, not CRC_EOP
    // this is how we can get back in sync
  case CRC_EOP:
    error++;
    Serial.print((char) STK_NOSYNC);
    break;

    // anything else we will return STK_UNKNOWN
  default:
    error++;
    if (CRC_EOP == getch())
      Serial.print((char)STK_UNKNOWN);
    else
      Serial.print((char)STK_NOSYNC);
  }
}
Die zusätzlichen Zeilen für die Durchreichefunktion sind mit dem Kommentar "// Tiny85 Feedback" versehen.
Während man den UNO als Programmer für den Tiny nutzt, wird der Datenempfang vom Tiny am UNO gestoppt.
Eine Sekunde nachdem der Tiny mit dem neuen Programm versehen ist wird die Durchreichefunktion wieder aktiviert.


Wer die Feedback-Funktion selbst mal ausprobieren möchte sollte zuerst das geänderte Programm für den "Arduino as ISP" auf den UNO übertragen.
In der IDE wird nach wie vor "Arduino as ISP" als Programmer ausgewählt.
Dann wird der ATtiny wie im Schaltplan dargestellt mit dem UNO verbunden.

Für einen schnellen Test und als Beispiel für eigene Anwendungen kann man dann folgendes Programm auf den ATtiny brennen.
Code:
/* ATtiny 84/85 SerialMonitor Test */

//    Senden via "SoftwareSerial" - TX an Pin  4 (= Pin3 am Attiny85-20PU)
//    Senden via "SoftwareSerial" - TX an Pin  7 (= Pin6 am Attiny84-10PU)
// Empfangen via "SoftwareSerial" - RX an Pin 99 (Dummy um Hardwarepin zu sparen)

#include <SoftwareSerial.h>

//SoftwareSerial softSerial(99, 7); // RX, TX   // bei Tiny 84
  SoftwareSerial softSerial(99, 4); // RX, TX   // bei Tiny 85


unsigned long laufzeit = 0;

void setup()  
{
  softSerial.begin(9600);
  delay(1000);  
}

void loop()
{
  softSerial.print  (F("ATtiny - Laufzeit "));
  softSerial.print  (laufzeit);
  softSerial.println(F(" Sekunden"));
  laufzeit+=2;
  delay(2000);
}
Jetzt den SerialMonitor öffnen und das Ergebnis sehen.



Hinweise:
Die Baudrate des SerialMonitor wird auf 19200 eingestellt (andere sind eventuell möglich aber nicht getestet)
Die Baudrate zwischen Tiny und UNO ist auf 9600 eingestellt. (Änderung ist möglich, aber man muss dann auch im Code für den ISP anpassen)
Wenn zu viele Zeichen am Stück ohne Pause übertragen werden sollen kommt es manchmal zum Verlust einzelner Zeichen. (Abhilfe schafft dann ein kurzes delay() während der Ausgabe. Im praktischen Einsatz wird dieser Umstand aber nur selten eine Einschränkung sein.

Hier noch ein kleines Spaßprogramm für den Tiny85 welches die Möglichkeit der Ausgabe zum SerialMonitor intensiv nutzt. Leider konnte ich das Programm nur mit der Arduino IDE 1.5.8 fehlerfrei übersetzen und auf den Tiny brennen. (mit Version 1.0.6 gab es bei mir Fehlermeldungen)
Code:
/* ATtiny85 SerialMonitor Test */

//    Senden via "SoftwareSerial" - TX an Pin  4 (= Pin3 am Attiny85-20PU)
// Empfangen via "SoftwareSerial" - RX an Pin 99 (Dummy um Hardwarepin zu sparen)

#include <SoftwareSerial.h>

SoftwareSerial softSerial(99, 4); // RX, TX

unsigned long zeit         = 0;
unsigned long zeitstart    = 0;
unsigned long laufzeit     = 0;
unsigned long loops        = 0;
int zufall                 = 0;
int zyklus_pin             = 3;

void setup()  
{
  // set the data rate for the SoftwareSerial port
  pinMode(zyklus_pin, OUTPUT);
  softSerial.begin(9600);
  delay(2000);  

}

void loop()

{
  zeit = millis() - zeitstart;
  if (zeit > 1000)
  {
    laufzeit +=1;
    zeitstart = millis();
    randomSeed(zeitstart);
    zufall = random(1, 11);
    sag_was();
  }
PORTB ^=(1<<PB3); // schnellstes Taktsignal ausgeben
loops++;
}


void sag_was(void)
{
  switch(zufall)
  {
    case  1: aktion_01(); break;
    case  2: aktion_02(); break;
    case  3: aktion_03(); break;
    case  4: aktion_04(); break;
    case  5: aktion_05(); break;
    case  6: aktion_06(); break;
    case  7: aktion_07(); break;
    case  8: aktion_08(); break;
    case  9: aktion_09(); break;
    case 10: aktion_10(); break;
    default: break;        
  }
  loops=0;
}


void aktion_01 (void)
{
  softSerial.println(F("Hallo, hier redet dein ATtiny85 mit dir!"));
  softSerial.println(F("."));
}  

void aktion_02 (void)
{
  softSerial.print(F("Mein letzter Neustart war vor "));
  softSerial.print(laufzeit/86400);       softSerial.print(F(" Tage "));
  softSerial.print((laufzeit/3600)%24);   softSerial.print(F(" Stunden "));
  softSerial.print((laufzeit/60)%60);     softSerial.print(F(" Minuten "));
  softSerial.print(laufzeit%60);          softSerial.println(F(" Sekunden."));
  softSerial.println(F("."));    
}

void aktion_03 (void)
{
  softSerial.print(F("Ich habe derzeit noch "));
  softSerial.print(freeRam());
  softSerial.println(F(" von 512 Byte in meinem RAM frei."));
  softSerial.println(F("."));
}

void aktion_04 (void)
{
  softSerial.println(F("Bei laengeren Ausgabezeilen hab ich Probleme "));
  softSerial.print(F("und man muss mir mit einem delay() ")); delay(50);
  softSerial.println(F("etwas Zeit geben."));
  softSerial.println(F("."));
}

void aktion_05 (void)
{
  softSerial.println(F("Mir ist langweilig!"));
  softSerial.println(F("."));
}

void aktion_06 (void)
{
  softSerial.println(F("So richtig zufaellig sind die Zufaelle auch nicht."));
  softSerial.println(F("."));
}

void aktion_07 (void)
{
  softSerial.println(F("RUF MICH AN ! ! !"));
  softSerial.println(F("."));
}

void aktion_08 (void)
{
  softSerial.print(F("So wie dieser Test programmiert ist"));
  softSerial.println(F(" wird mir von dem Code uebel."));
  softSerial.println(F("."));
}

void aktion_09 (void)
{
  softSerial.println(F("Habe fertig."));
  softSerial.println(F("."));
}

void aktion_10 (void)
{
  softSerial.print(F("Ich schaffe in meiner Freizeit "));
  softSerial.print(loops);
  softSerial.println(F(" Runden in loop() pro Sekunde;"));
  softSerial.println(F("."));
}

int freeRam ()
{
extern int __heap_start, *__brkval;
int v;
return (int) &v - (__brkval == 0 ? (int) &__heap_start : (int) __brkval);
}


Ich wünsche viel Erfolg mit der vorgestellten Möglichkeit und würde mich über Rückmeldungen und Erfahrungsberichte freuen.

Arne

ExclamationMit zunehmender Anzahl qualifizierter Informationen bei einer Problemstellung, erhöht sich zwangsläufig die Gefahr auf eine zielführende Antwort.Exclamation
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
21.02.2015, 16:30 (Dieser Beitrag wurde zuletzt bearbeitet: 21.02.2015 16:43 von Gelegenheitsbastler.)
Beitrag #2
RE: Serial Monitor als Debughilfe für den ATtiny85 und andere ATMEL-Mikrocontroller
Ein (software)serial.print ist genau das, was mir noch fehlt. Gemäß Deiner Anleitung habe ich die zusätzliche Strippe vom ATtiny85 (Hardware) Pin3 auf den digitalen Pin4 meines Nano gezogen.

Ich habe mir für das Programmieren der kleinen Käfer das hier gebaut: http://www.arduinoforum.de/arduino-Threa...grammierer

Nachdem ich die abgewandelte Form des ArduinoISP Sketches installiert hatte, fiel mir als erstes auf, dass die Heartbeat LED nicht mehr leuchtet. Ist das Absicht? Sie leuchtet nur noch, wenn Programmiert wird und erlischt dann wieder.

Dein Beispielsketch zeigt mir im seriellen Monitor die Laufzeit des ATtiny85 an, wobei allerdings das eine oder andere Zeichen nicht sauber übertragen wird, was aber das Ergebnis nicht schmälert.

Nun aber zu meiner eigentlichen Frage: Wenn ich den ATtiny85 extern beschalte, welche Leitungen müssen dann mindestens zum Nano gehen, damit der serielle Monitor brauchbare Infos wieder gibt? Nur Vcc, GND und Pin3 reichen nicht, da kommt nur Zeichenwirrwarr bei raus.

Konkret habe ich an den Kleinen wie folgt beschaltet:

Pin5 - Transistor (Basis)
Pin6 - Taster (Pin per 10 KOhm auf GND, Taster schaltet Vcc)
Pin7 - Fotowiderstand

Ich würde gerne den Wert von Pin7 auslesen um zu sehen, was der Fotowiderstand meldet.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
21.02.2015, 17:21 (Dieser Beitrag wurde zuletzt bearbeitet: 10.05.2015 01:49 von ardu_arne.)
Beitrag #3
RE: Serial Monitor als Debughilfe für den ATtiny85 und andere ATMEL-Mikrocontroller
Hallo,

erst mal bin ich erfreut über das Feedback und die Aussage dass die Idee grundsätzlich (wenn auch mit kleinen Fehlern) funktioniert.Smile

Es ist richtig, dass die Heartbeat LED nur dann leuchtet wenn ein neues Programm übertragen wird. Die Heartbeat LED wird abgeschaltet weil sie an meinem UNO so viele Ressourcen verbraucht hat, dass die SoftSerial Kommunikation stark beeinträchtigt wurde.

Eigentlich sollte es ausreichen VCC, GND und die Datenleitung zum NANO zu verbinden. Ich habe es aber selbst nur mit der im Bild gezeigten kleinen Adapterplatine probiert.
Ich werde es aber mal ohne diese Testen und dann berichten.

Ich hatte auch von einem anderen User mal die Rückmeldung dass es bei ihm auch nicht sauber lief. Möglicherweise war die Ursache die IDE-Version. Er hatte den "Arduino as ISP" Sketch mit der Version 1.0.5-r2 auf den UNO geladen während ich Version 1.0.6 dazu verwendet habe.
Welche Version hast du benutzt?

___________________________________
Nachtrag:

Ich habe jetzt beide Testprogramme nochmal ausprobiert und beide laufen bei mir sauber wenn nur VCC, GND und die Datenleitung angeschlossen werden.

Den ersten (kurzen) Test hatte ich mit IDE 1.0.6 via "Arduino as ISP" zum Tiny85 übertragen und beim zweiten Test die IDE 1.5.8 verwendet.

Gruß
Arne

ExclamationMit zunehmender Anzahl qualifizierter Informationen bei einer Problemstellung, erhöht sich zwangsläufig die Gefahr auf eine zielführende Antwort.Exclamation
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
21.02.2015, 20:24
Beitrag #4
RE: Serial Monitor als Debughilfe für den ATtiny85 und andere ATMEL-Mikrocontroller
Ich habe das alles mit der 1.0.5 unter Ubuntu gemacht. Das lief nicht. Daher habe ich es mit der 1.6.0 probiert. Ging auch nicht. Dann andere Kabel genommen und siehe da, es liegt nicht an der Version der IDE... Keine Ahnung, wo das Problem wirklich liegt. Ich tippe mal auf das Steckbrett. Gelegentlich haben diese verflixten Dinger bei mir einen Wackeligen. Aber in der endgültigen Schaltung ist das eh kein Thema mehr, da dann alles gelötet ist.

Soweit erst einmal vielen Dank für die Hilfe und die tolle Anleitung!
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
21.02.2015, 20:56
Beitrag #5
RE: Serial Monitor als Debughilfe für den ATtiny85 und andere ATMEL-Mikrocontroller
Hi,
da ich ja auch diesen Aufbau hier habe, also UNO Selbstbau und gleiches Tiny Board wie Arne verstehe ich ohnehin nicht wirklich warum die Funktion der Seriellen eine Abhängigkeit mit der IDE Version hat weil selbstgeschriebener Code immer gleich laufen sollte. Allerdings wissen wir ja nicht wirklich was in den Librarys drinsteht wo uns diese Funktionen so recht komfortabel anbieten.
Bei mir war es die IDE 1.0.5 mit der er es lief. Wobei man dann schon mal die Serielle Leitung unterbrechen mußte um den UNO wieder in den Programmiermodus zu bekommen. Hier hilft auch mal im Tiny eine größere Pause bei den Ausgaben einzulegen.
lg
bk

1+1 = 10 Angel ...und ich bin hier nicht der Suchmaschinen-Ersatz Dodgy...nur mal so als genereller Tipp..
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
21.02.2015, 21:10
Beitrag #6
RE: Serial Monitor als Debughilfe für den ATtiny85 und andere ATMEL-Mikrocontroller
Danke @Bitklopfer für die Bestätigung und auch an Gelegenheitsbastler für das Testen.

Ich habe jetzt auch nochmal einen Test mit den IDE Versionen 1.0.5-r2 und der brandneuen Version 1.6.0 gemacht.

1.
Die geänderte Version von "Arduino as ISP" mit der IDE 1.0.5-r2 auf den UNO gebrannt.
Den kleinen Testsketch für den Tiny85 damit auf den Tiny gebrannt.
Ergebnis: alles o.K.
Der große Testsketch für den Tiny85 lässt sich damit nicht fehlerfrei übersetzen. Huh

2.
Die geänderte Version von "Arduino as ISP" mit der IDE 1.6.0 auf den UNO gebrannt.
Den kleinen Testsketch für den Tiny85 damit auf den Tiny gebrannt.
Den großen Testsketch für den Tiny85 damit auf den Tiny gebrannt.
Ergebnis: alles o.K.

Die Vermutung liegt also nahe, dass bei Gelegenheitsbastler tatsächlich nur ein Verdrahtungsproblem besteht oder vielleicht auch die Versorgungsspannung nicht stabil genug ist.

Bei mir funktioniert es jedenfalls wenn UNO + Tiny über den USB-Anschluss versorgt werden. Ich weiß aber auch dass nicht jeder USB-Port an einem PC 500mA liefern kann. Vor allem bei älteren Mainboards kann es schon mal sein dass 100mA die Grenze ist.

Gruß
Arne

ExclamationMit zunehmender Anzahl qualifizierter Informationen bei einer Problemstellung, erhöht sich zwangsläufig die Gefahr auf eine zielführende Antwort.Exclamation
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
22.02.2015, 11:08
Beitrag #7
RE: Serial Monitor als Debughilfe für den ATtiny85 und andere ATMEL-Mikrocontroller
Ich habe den langen Sketch nicht probiert. Mir ging es nur um die Machbarkeit, mit drei Leitungen den seriellen Monitor nutzen zu können. Das klappt sowohl mit der 1.0.5 als auch mit der 1.6.0. An der Spannungsversorgung lag es nicht. Ich nehme an, der Tiny hatte Kontaktprobleme auf dem Steckbrett. Aber wie schon geschrieben, ist das Problem gelöst, wenn er fest im verlöteten Sockel der Schaltung steckt.

Das Projekt werde ich die Tage noch vorstellen.
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
26.02.2015, 17:32 (Dieser Beitrag wurde zuletzt bearbeitet: 26.02.2015 17:33 von Gelegenheitsbastler.)
Beitrag #8
RE: Serial Monitor als Debughilfe für den ATtiny85 und andere ATMEL-Mikrocontroller
Könnte es sein, dass die nicht richtig übermittelten Zeichen mit dem Takt des Tiny zusammen hängen? Ich habe diesen nicht von 1 auf 8 Mhz geändert und dann "Bootloader installieren" geklickt, sondern nur in der Auswahlliste der Arduinos den ATtiny85 mit intern 8 Mhz ausgewählt, da bei Auswahl des Modells mit 1 Mhz beim Kompilieren ein Fehler ausgeworfen wurde.

Darauf gekommen bin ich durch diese Info

http://highlowtech.org/?p=1695

By default, the ATtiny’s run at 1 MHz. To use the SoftwareSerial library, you need to do an extra step and configure the microcontroller to run at 8 MHz. Once you have the microcontroller connected, select “8 MHz (Internal)” from the Tools > Clock menu. (In Arduino 1.0.x, select the appropriate 8 MHz clock option from the main Tools > Board menu.) Warning: make sure you select “internal” not “external” or your microcontroller will stop working (until you connect an external clock to it). Then, run the “Burn Bootloader” command from the Tools menu. This configures the fuse bits of the microcontroller so it runs at 8 MHz. Note that the fuse bits keep their value until you explicitly change them, so you’ll only need to do this step once for each microcontroller. (Note this doesn’t actually burn a bootloader onto the board; you’ll still need to upload new programs using an external programmer.)

Sollte das die Ursache sein, könntest Du die Info noch in den ersten Beitrag ergänzen.

Was ist eigentlich bis auf die Tatsache, dass der Tiny schneller läuft, der Unterschied zwischen 1 und 8 Mhz interner Taktung?
Alle Beiträge dieses Benutzers finden
Diese Nachricht in einer Antwort zitieren
Antwort schreiben 


Möglicherweise verwandte Themen...
Thema: Verfasser Antworten: Ansichten: Letzter Beitrag
  ATtiny85 Programmierer Gelegenheitsbastler 2 1.774 20.02.2015 21:28
Letzter Beitrag: Gelegenheitsbastler
  Arduino Due mit Pixy-Cam und eigenem TFT-Monitor HaWe 4 2.175 30.01.2015 15:44
Letzter Beitrag: tito-t
Star ATTINY85 mit DS18B20 Temperatursensor und echtem Analogausgang ardu_arne 0 4.118 07.01.2015 21:28
Letzter Beitrag: ardu_arne
  1.8" Serial: UART/I2C/SPI True Color OLED160x128 OLED Module Georg 4 2.011 31.08.2014 19:03
Letzter Beitrag: Georg

Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste