• Hallo Zusammen, Aufgrund der aktuellen Situation setzten wir die Möglichkeit aus, sich mit Gmail zu registrieren. Wir bitten um Verständnis Das RCMP Team

Tech-Frage 4 fach LED-Blitzer mit ATTiny für RC-LKW

BAXL

Admin
Mitarbeiter
Ok, dann machen wir es so.
Also 4 Kanäle, die nacheinander an und wieder ausgeschaltet werden sollen und das gleichzeitig auf beiden Seiten. Wahrscheinlich so wie bei KITT von Knight Rider oder eher benachbarte LEDs im Wechsel?

Als Prototyp können wir zum Testen einen von Deinen Nanos nehmen.

Hier ist schon eine fertige Programmlösung.

http://mikrocontrollerkochbuch.de/index.php?title=LED-Lauflicht_mit_8_LEDs

Als Gedankenstütze für mich
http://www.sachsendreier.com/asw/projekteundexperimente/arduinoasisp/arduinoasisp.php
 
Zuletzt bearbeitet:

BAXL

Admin
Mitarbeiter
@Chesleyn

So Ches, ich habe da mal quick and dirty ein Programm geschrieben, das nacheinander 4 LEDs kurz aufblitzen lässt.

void setup() {
// put your setup code here, to run once:
pinMode(10, OUTPUT);
pinMode(11, OUTPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);
digitalWrite(10, HIGH);
digitalWrite(11, LOW);
digitalWrite(12, LOW);
digitalWrite(13, LOW);
delay(50);
}

void loop() {
// put your main code here, to run repeatedly:
digitalWrite(11, HIGH);
digitalWrite(10, LOW);
delay(50);
digitalWrite(12, HIGH);
digitalWrite(11, LOW);
delay(50);
digitalWrite(13, HIGH);
digitalWrite(12, LOW);
delay(50);
digitalWrite(10, HIGH);
digitalWrite(13, LOW);
delay(50);

}

Jetzt muß das nur noch für den ATTiny umgeschrieben werden.

void setup() {
// put your setup code here, to run once:
pinMode(0, OUTPUT); // Pin 5
pinMode(1, OUTPUT); // Pin 6
pinMode(2, OUTPUT); // Pin 7
pinMode(3, OUTPUT); // Pin 2
digitalWrite(0, HIGH);
digitalWrite(1, LOW);
digitalWrite(2, LOW);
digitalWrite(3, LOW);
delay(50);
}

void loop() {
// put your main code here, to run repeatedly:
digitalWrite(1, HIGH);
digitalWrite(0, LOW);
delay(50);
digitalWrite(2, HIGH);
digitalWrite(1, LOW);
delay(50);
digitalWrite(3, HIGH);
digitalWrite(2, LOW);
delay(50);
digitalWrite(0, HIGH);
digitalWrite(3, LOW);
delay(50);

}

Probier das aber zuerst mal mit dem Arduino aus, ob die Zeitabstände von 50ms so passen. Wenn Du zufrieden mit der Blinkfrequenz bist, kannst Du den Code für den Tiny darauf anpassen und brennen. Die Pinbelegung für die Digitalkanäle stehen im Code.

5V kommen auf Pin 8 und Masse auf Pin 4
 
Zuletzt bearbeitet:

Chesleyn

Mitglied
Hallo Baxel,

Ich wollte mal fragen ob man das nicht auf 8 LEDs ausweiten kann bzw. wie müsste ich die Belegung der Kabel an die jeweilige Pins löten.
Wenn ich vom 9V mit einem Widerstand an den Attiny gehe so das nicht mehr wie 5V beträgt, Reicht das?

Gruß Ches
 

Chesleyn

Mitglied
Hallo Josho,

so ich hab mich daran versucht den Attiny zu Progamieren
Den Gestriegen tag habe ich mich Gequällt das Tool zuladen,
war zwar nicht einfach. ich habs dann doch irgendwwie hinbekommen,
keine Ahnung wie. Jetzt habe ich versucht das Beispiel Programm auf zu
spielen, jetzt zeigt er mir ein Fehler in diesem Program an.

Ich habe die stelle Markiert mit sehr vielen !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Gruß Ches


Code:
// ArduinoISP
// 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 10 is used to reset the target microcontroller.
//
// By default, the hardware SPI pins MISO, MOSI and SCK are used to communicate
// with the target. On all Arduinos, these pins can be found
// on the ICSP/SPI header:
//
//  MISO °. . 5V (!) Avoid this pin on Due, Zero...
//  SCK  . . MOSI
//  . . GND
//
// On some Arduinos (Uno,...), pins MOSI, MISO and SCK are the same pins as
// digital pin 11, 12 and 13, respectively. That is why many tutorials instruct
// you to hook up the target to these pins. If you find this wiring more
// practical, have a define USE_OLD_STYLE_WIRING. This will work even when not
// using an Uno. (On an Uno this is not needed).
//
// Alternatively you can use any other digital pin by configuring
// software ('BitBanged') SPI and having appropriate defines for PIN_MOSI,
// PIN_MISO and PIN_SCK.
//
// IMPORTANT: When using an Arduino that is not 5V tolerant (Due, Zero, ...) as
// the programmer, make sure to not expose any of the programmer's pins to 5V.
// A simple way to accomplish this is to power the complete system (programmer
// and target) at 3V3.
//
// 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
//

#include "Arduino.h"
#undef SERIAL


#define PROG_FLICKER true

// Configure SPI clock (in Hz).
// E.g. for an ATtiny @ 128 kHz: the datasheet states that both the high and low
// SPI clock pulse must be > 2 CPU cycles, so take 3 cycles i.e. divide target
// f_cpu by 6:
//  #define SPI_CLOCK  (128000/6)
//
// A clock slow enough for an ATtiny85 @ 1 MHz, is a reasonable default:

#define SPI_CLOCK      (1000000/6)


// Select hardware or software SPI, depending on SPI clock.
// Currently only for AVR, for other architectures (Due, Zero,...), hardware SPI
// is probably too fast anyway.

#if defined(ARDUINO_ARCH_AVR)

#if SPI_CLOCK > (F_CPU / 128)
#define USE_HARDWARE_SPI
#endif

#endif

// Configure which pins to use:

// The standard pin configuration.
#ifndef ARDUINO_HOODLOADER2

#define RESET  10 // Use pin 10 to reset the target rather than SS
#define LED_HB  9
#define LED_ERR  8
#define LED_PMODE 7

// Uncomment following line to use the old Uno style wiring
// (using pin 11, 12 and 13 instead of the SPI header) on Leonardo, Due...

// #define USE_OLD_STYLE_WIRING

#ifdef USE_OLD_STYLE_WIRING

#define PIN_MOSI   11
#define PIN_MISO   12
#define PIN_SCK     13

#endif

// HOODLOADER2 means running sketches on the ATmega16U2 serial converter chips
// on Uno or Mega boards. We must use pins that are broken out:
#else

#define RESET     4
#define LED_HB     7
#define LED_ERR     6
#define LED_PMODE    5

#endif

// By default, use hardware SPI pins:
#ifndef PIN_MOSI
#define PIN_MOSI    MOSI
#endif

#ifndef PIN_MISO
#define PIN_MISO    MISO
#endif

#ifndef PIN_SCK
#define PIN_SCK    SCK
#endif

// Force bitbanged SPI if not using the hardware SPI pins:
#if (PIN_MISO != MISO) ||  (PIN_MOSI != MOSI) || (PIN_SCK != SCK)
#undef USE_HARDWARE_SPI
#endif


// Configure the serial port to use.
//
// Prefer the USB virtual serial port (aka. native USB port), if the Arduino has one:
//  - it does not autoreset (except for the magic baud rate of 1200).
//  - it is more reliable because of USB handshaking.
//
// Leonardo and similar have an USB virtual serial port: 'Serial'.
// Due and Zero have an USB virtual serial port: 'SerialUSB'.
//
// On the Due and Zero, 'Serial' can be used too, provided you disable autoreset.
// To use 'Serial': #define SERIAL Serial

#ifdef SERIAL_PORT_USBVIRTUAL
#define SERIAL SERIAL_PORT_USBVIRTUAL
#else
#define SERIAL Serial                                               ' Serial ' was not declared in this scope!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#endif


// Configure the baud rate:

#define BAUDRATE   19200
// #define BAUDRATE   115200
// #define BAUDRATE   1000000


#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);

#ifdef USE_HARDWARE_SPI
#include "SPI.h"
#else

#define SPI_MODE0 0x00

class SPISettings {
  public:
  // clock is in Hz
  SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode) : clock(clock) {
  (void) bitOrder;
  (void) dataMode;
  };

  private:
  uint32_t clock;

  friend class BitBangedSPI;
};

class BitBangedSPI {
  public:
  void begin() {
  digitalWrite(PIN_SCK, LOW);
  digitalWrite(PIN_MOSI, LOW);
  pinMode(PIN_SCK, OUTPUT);
  pinMode(PIN_MOSI, OUTPUT);
  pinMode(PIN_MISO, INPUT);
  }

  void beginTransaction(SPISettings settings) {
  pulseWidth = (500000 + settings.clock - 1) / settings.clock;
  if (pulseWidth == 0)
  pulseWidth = 1;
  }

  void end() {}

  uint8_t transfer (uint8_t b) {
  for (unsigned int i = 0; i < 8; ++i) {
  digitalWrite(PIN_MOSI, (b & 0x80) ? HIGH : LOW);
  digitalWrite(PIN_SCK, HIGH);
  delayMicroseconds(pulseWidth);
  b = (b << 1) | digitalRead(PIN_MISO);
  digitalWrite(PIN_SCK, LOW); // slow pulse
  delayMicroseconds(pulseWidth);
  }
  return b;
  }

  private:
  unsigned long pulseWidth; // in microseconds
};

static BitBangedSPI SPI;

#endif

void setup() {
  SERIAL.begin(BAUDRATE);

  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
unsigned 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;
  uint8_t flashpoll;
  uint16_t eeprompoll;
  uint16_t pagesize;
  uint16_t eepromsize;
  uint32_t 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() {
  static unsigned long last_time = 0;
  unsigned long now = millis();
  if ((now - last_time) < 40)
  return;
  last_time = now;
  if (hbval > 192) hbdelta = -hbdelta;
  if (hbval < 32) hbdelta = -hbdelta;
  hbval += hbdelta;
  analogWrite(LED_HB, hbval);
}

static bool rst_active_high;

void reset_target(bool reset) {
  digitalWrite(RESET, ((reset && rst_active_high) || (!reset && !rst_active_high)) ? HIGH : LOW);
}

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);
  }

  // light the heartbeat LED
  heartbeat();
  if (SERIAL.available()) {
  avrisp();
  }
}

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);
  }
}

uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) {
  SPI.transfer(a);
  SPI.transfer(b);
  SPI.transfer(c);
  return SPI.transfer(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 parameter 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];

  // AVR devices have active low reset, AT89Sx are active high
  rst_active_high = (param.devicecode >= 0xe0);
}

void start_pmode() {

  // Reset target before driving PIN_SCK or PIN_MOSI

  // SPI.begin() will configure SS as output, so SPI master mode is selected.
  // We have defined RESET as pin 10, which for many Arduinos is not the SS pin.
  // So we have to configure RESET as output here,
  // (reset_target() first sets the correct level)
  reset_target(true);
  pinMode(RESET, OUTPUT);
  SPI.begin();
  SPI.beginTransaction(SPISettings(SPI_CLOCK, MSBFIRST, SPI_MODE0));

  // See AVR datasheets, chapter "SERIAL_PRG Programming Algorithm":

  // Pulse RESET after PIN_SCK is low:
  digitalWrite(PIN_SCK, LOW);
  delay(20); // discharge PIN_SCK, value arbitrarily chosen
  reset_target(false);
  // Pulse must be minimum 2 target CPU clock cycles so 100 usec is ok for CPU
  // speeds above 20 KHz
  delayMicroseconds(100);
  reset_target(true);

  // Send the enable programming command:
  delay(50); // datasheet: must be > 20 msec
  spi_transaction(0xAC, 0x53, 0x00, 0x00);
  pmode = 1;
}

void end_pmode() {
  SPI.end();
  // We're about to take the target out of reset so configure SPI pins as input
  pinMode(PIN_MOSI, INPUT);
  pinMode(PIN_SCK, INPUT);
  reset_target(false);
  pinMode(RESET, INPUT);
  pmode = 0;
}

void universal() {
  uint8_t ch;

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

void flash(uint8_t hilo, unsigned int addr, uint8_t data) {
  spi_transaction(0x40 + 8 * hilo,
  addr >> 8 & 0xFF,
  addr & 0xFF,
  data);
}
void commit(unsigned 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);
  }
}

unsigned int current_page() {
  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;
  unsigned int page = current_page();
  while (x < length) {
  if (page != current_page()) {
  commit(page);
  page = current_page();
  }
  flash(LOW, here, buff[x++]);
  flash(HIGH, here, buff[x++]);
  here++;
  }

  commit(page);

  return STK_OK;
}

#define EECHUNK (32)
uint8_t write_eeprom(unsigned int length) {
  // here is a word address, get the byte address
  unsigned int start = here * 2;
  unsigned 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(unsigned int start, unsigned int length) {
  // this writes byte-by-byte, page writing may be faster (4 bytes at a time)
  fill(length);
  prog_lamp(LOW);
  for (unsigned int x = 0; x < length; x++) {
  unsigned 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;
  unsigned 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, unsigned 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);
}

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);
}
//////////////////////////////////////////
//////////////////////////////////////////


////////////////////////////////////
////////////////////////////////////
void avrisp() {
  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);
  }
  else {
  error++;
  SERIAL.print((char) STK_NOSYNC);
  }
  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':
  if (!pmode)
  start_pmode();
  empty_reply();
  break;
  case 'U': // set address (word)
  here = getch();
  here += 256 * getch();
  empty_reply();
  break;

  case 0x60: //STK_PROG_FLASH
  getch(); // low addr
  getch(); // high addr
  empty_reply();
  break;
  case 0x61: //STK_PROG_DATA
  getch(); // data
  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);
  }
}
 
Zuletzt bearbeitet:

BAXL

Admin
Mitarbeiter
Hmmm, ich finde keine Stelle mit gant vielen ! Rufzeichen. Wo soll die sein? Eher im ersten Drittel, in der Mitte oder im letzten Drittel.

Das sieht übrigens wie das Programm aus, das auf dem Arduino läuft und das eigentliche ATTiny Programm später zum ATTiny „durchreicht“
 

Chesleyn

Mitglied
HAllo Yoshi,

ich sehe es, in deiser Zeile!

#ifdef SERIAL_PORT_USBVIRTUAL
#define SERIAL SERIAL_PORT_USBVIRTUAL
#else
#define SERIAL Serial ' Serial ' was not declared in this scope!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
#endif
 

Chesleyn

Mitglied
http://www.sachsendreier.com/asw/projekteundexperimente/arduinoasisp/arduinoasisp.php

ich habe jetzt dein Programversucht Hoch zuladen, er zeigt folgende Fehlermeldung

Arduino: 1.8.9 (Windows Store 1.8.21.0) (Windows 10), Board: "ATtiny25/45/85, ATtiny85, Internal 1 MHz"

Der Sketch verwendet 776 Bytes (9%) des Programmspeicherplatzes. Das Maximum sind 8192 Bytes.
Globale Variablen verwenden 9 Bytes (1%) des dynamischen Speichers, 503 Bytes für lokale Variablen verbleiben. Das Maximum sind 512 Bytes.
Attempting to initiate BusPirate binary mode...
Binary mode not confirmed: ''
BusPirate: Internal error: buspirate_send_bin() called from ascii mode
avrdude: Failed to start binary mode, falling back to ASCII...
Attempting to initiate BusPirate ASCII mode...
avrdude: Fatal: Programmer is not responding.
avrdude: buspirate_readline(): programmer is not responding
avrdude: buspirate_readline(): programmer is not responding
avrdude: buspirate_readline(): programmer is not responding
avrdude: buspirate_readline(): programmer is not responding
avrdude: buspirate_readline(): programmer is not responding
avrdude: buspirate_readline(): programmer is not responding
avrdude: initialization failed, rc=-2
Double check connections and try again, or use -F to override
this check.

avrdude: buspirate_readline(): programmer is not responding
avrdude: buspirate_readline(): programmer is not responding
avrdude: buspirate_readline(): programmer is not responding
avrdude: buspirate_readline(): programmer is not responding
Der ausgewählte serielle Port avrdude: buspirate_readline(): programmer is not responding
ist nicht vorhanden oder das Board ist nicht angeschlossen

Dieser Bericht wäre detaillierter, wenn die Option
"Ausführliche Ausgabe während der Kompilierung"
in Datei -> Voreinstellungen aktiviert wäre.
 

BAXL

Admin
Mitarbeiter
Also, folgendes Ergebnis. Ich habe mir von hier: https://www.arduino.cc/en/Main/Donate eine komplett neue Arduino IDE heruntergeladen. Dann den Inhalt in ein ganz neues Unterverzeichnis ausgepackt. Die IDE gestartet und in der gestarteten IDE im Menü unter Datei/Beispiele/11.ArduinoISP/ArduinoISP den Sketch geladen und nur mit dem runden Kreis mit dem Haken, kompiliert.
Das ist durchgelaufen und hat folgende meldung gebracht:
Der Sketch verwendet 5064 Bytes (1%) des Programmspeicherplatzes. Das Maximum sind 253952 Bytes.
Globale Variablen verwenden 482 Bytes (5%) des dynamischen Speichers, 7710 Bytes für lokale Variablen verbleiben. Das Maximum sind 8192 Bytes.

Ich vermute also, dass Du mit einer bereits bestehenden Installation experimentiert hast. Für die Tinys würde ich immer eine zweite Version parallel laufen lassen.
 

Chesleyn

Mitglied
Ich hate versucht so wie im bespiel erst diese Program durchlaufen zu lassen ich habe noch nichtmal versucht es zu laden.
gerade eben habe ich versucht dein Program zu laden. Sollte ich einen neuen Tiny nehemen?
Was meinst du mit einer 2 Version parallee laufen lassen?
 

BAXL

Admin
Mitarbeiter
Mit 2. Version meinte ich folgendes. Wenn Du die Arduino IDE bereits installiert hattest (von früheren Experimenten), dann hast Du dort sicher schon das eine oder andere mit gemacht. Also evtl. schon Libraries nachinstalliert eigene kleine Programme gebastelt usw.

Mit einer 2. IDE meine ich jetzt, dass Du Dir von dem Link: https://www.arduino.cc/en/Main/Donate
noch einmal ein ZIP-File mit einer ganz neuen Arduino IDE heruterlädts. Dann erstellst Du Dir ein neues leeres Unterverzeichnis das z.B. "Arduino ATTiny" heißt. In diesem Verzeichnis packst Du die heruntergeladene Datei aus und startest dann die Arduino.exe, die Du neu ausgepackt hast.

Weil die Sache nun langsam komplexer wird, solltest Du in den Fragen Deiner Posts nun immer etwas genauer sein.
Ich hate versucht so wie im bespiel (welches Beispiel?) erst diese Program (welches Programm) durchlaufen zu lassen ich habe noch nichtmal versucht es zu laden.
gerade eben habe ich versucht dein Program (welches Programm, da waren zwei?) zu laden. Sollte ich einen neuen Tiny nehemen?
Was meinst du mit einer 2 Version parallee laufen lassen? (habe ich oben bereits erklärt)
 

Chesleyn

Mitglied
Hallo Baxl,

so hab das man so gemacht mit Licht auf HIGH gesetzt
und dann darunter das Blinken mit delay
so Kompilieren geht das laden auch, aber es leuchten alle
und nichts Blinkt

Code:
/* Beleuchtung für den Arocs
 *  
 *  22.06.2019
 *  Mit freundlicher Unterstützung
 *  von Joshi, Baxl und vielen anderen aus dem RC Modellbau Forum
 *  
 */
void setup () {
 
  pinMode ( 13, OUTPUT);
  pinMode ( 12, OUTPUT);
  pinMode ( 11, OUTPUT);
  pinMode ( 10, OUTPUT);
  pinMode (  9, OUTPUT);
  pinMode (  8, OUTPUT);
  pinMode (  7, OUTPUT);
  pinMode (  6, OUTPUT);
}

void loop() {

  digitalWrite  (13, HIGH);
  digitalWrite  (12, HIGH);   
  digitalWrite  (11, HIGH);  
  digitalWrite  (10, HIGH);

  digitalWrite  ( 9, HIGH);
  digitalWrite  ( 8, HIGH);
  delay(1000);
  digitalWrite  ( 9, HIGH);
  digitalWrite  ( 8, HIGH);
  delay(1000);
  digitalWrite  ( 9, HIGH);
  digitalWrite  ( 8, HIGH);
  delay(1000);
  digitalWrite  ( 9, HIGH);
  digitalWrite  ( 8, HIGH);
  delay(1000);
  digitalWrite  ( 9, HIGH);
  digitalWrite  ( 8, HIGH);
  delay(1000);

  digitalWrite  ( 7, HIGH);
  digitalWrite  ( 6, HIGH);
  delay(1000);
  digitalWrite  ( 7, HIGH);
  digitalWrite  ( 6, HIGH);
  delay(1000);
  digitalWrite  ( 7, HIGH);
  digitalWrite  ( 6, HIGH);
  delay(1000);
  digitalWrite  ( 7, HIGH);
  digitalWrite  ( 6, HIGH);
  delay(1000);
  digitalWrite  ( 7, HIGH);
  digitalWrite  ( 6, HIGH);
  delay(1000);
 
  digitalWrite  ( 9, HIGH);
  digitalWrite  ( 8, HIGH);
  digitalWrite  ( 7, HIGH);
  digitalWrite  ( 6, HIGH);
  delay(1000);
  digitalWrite  ( 9, HIGH);
  digitalWrite  ( 8, HIGH);
  digitalWrite  ( 7, HIGH);
  digitalWrite  ( 6, HIGH);
  delay(1000);
  digitalWrite  ( 9, HIGH);
  digitalWrite  ( 8, HIGH);
  digitalWrite  ( 7, HIGH);
  digitalWrite  ( 6, HIGH);
  delay(1000);
  digitalWrite  ( 9, HIGH);
  digitalWrite  ( 8, HIGH);
  digitalWrite  ( 7, HIGH);
  digitalWrite  ( 6, HIGH);
  delay(1000);
  digitalWrite  ( 9, HIGH);
  digitalWrite  ( 8, HIGH);
  digitalWrite  ( 7, HIGH);
  digitalWrite  ( 6, HIGH);
  delay(1000);
 
}
 

BAXL

Admin
Mitarbeiter
Da blinkt nichts, weil Du die Ports immer eingeschaltet hast, so wie einen Lichtschalter der immer an ist. Was war der Grund für die Programmänderung?

Da muss auch mal LOW drinstehen damit die Leuchten auch mal wieder ausgehen können :D
 

Chesleyn

Mitglied
OCH Nee nee, wat Blöd. ich lernst noch.

Jtzt was anderes. so hab das so gemacht mit der 2 IDE. Habe jetzt das Beispielprogramm Aduino ISP Kompiliert.
Letzt zeigt dat Dingen nee andere Fehlermeldeung.

Arduino: 1.8.9 (Windows 10), Board: "ATtiny25/45/85, ATtiny85, Internal 1 MHz"

Das Muster ctags fehlt

Fehler beim Kompilieren für das Board ATtiny25/45/85.

Dieser Bericht wäre detaillierter, wenn die Option
"Ausführliche Ausgabe während der Kompilierung"
in Datei -> Voreinstellungen aktiviert wäre.
 

Chesleyn

Mitglied
Sorry,

Das mit dem Dauerblinken war auf dem Arduino UNO zum Probieren ob es Funktioniert.
Mit 4 Leds als Dauerlicht und 4 Leds als Blinker, 2 Rechts, 2 Links. das soll später wenns gehen sollte auf den Nano,

Als das mit dem Dauerlicht war und ich nicht weiterkam wollte ich das mit dem
Attiny nochmal Probieren. Wie oben beschrieben habe ich es mit dem Beispielprogramm
hochgeladen, dann kam die Meldung. Ich habe gewartet was du dazu schreibst.
Deswegen habe ich auch nicht weiter versucht auf den Tiny was zu Laden.
 

BAXL

Admin
Mitarbeiter
Ok, bringen wir zuerst eine Sache auf den Uno zum laufen, dann transferieren wir das auf den Nano. Und erst, wenn die Blinkerei genau so läuft, wie Du Dir das vorstellest, kümmern wir uns um den ATTiny.

Wollen wir das so machen? Und keine Abweichungen und Nebenkriegsplätze und keine neuen Ideen zu Variationen bis eine Sache richtig läuft.:)
 
Top Bottom