Automatyczne otwieranie gołębnika.

Masz problem z Arduino? Tutaj możesz szukać pomocy.
ODPOWIEDZ
Awatar użytkownika
Pawel112534
Młodszy majsterkowicz
Posty: 4
Rejestracja: 9 wrz 2015, 20:52

Automatyczne otwieranie gołębnika.

Post autor: Pawel112534 » 9 wrz 2015, 21:16

Cześć.
Mam pytanie czy można zrobić "Automatyczne otwieranie gołębnika" na podstawie attiny85 , 2 serva i modułu czasu rzeczywistego?
Mam zamiar wypalić bootloader na attiny85 za pomocą Arduino.
Potem wgrać program...

Dzięki , Pozdrawiam!

Co miesiąc do wygrania nagrody o wartości ponad 1600 zł!


kazzik87
Starszy majsterkowicz
Posty: 440
Rejestracja: 14 lip 2014, 21:54
Lokalizacja: Lublin

Re: Automatyczne otwieranie gołębnika.

Post autor: kazzik87 » 10 wrz 2015, 15:35

Trochę dziwnie zadane pytanie.

Jeżeli chodzi o podpięcie do Attiny85 dwóch serw i RTC to można to zrobić.
---
Jeżeli pomogłem to kliknij "Pomógł".
Awatar użytkownika
Pawel112534
Młodszy majsterkowicz
Posty: 4
Rejestracja: 9 wrz 2015, 20:52

Re: Automatyczne otwieranie gołębnika.

Post autor: Pawel112534 » 10 wrz 2015, 16:08

kazzik87 pisze:Trochę dziwnie zadane pytanie.


Jeżeli chodzi o podpięcie do Attiny85 dwóch serw i RTC to można to zrobić.

No tak,ale jaki kod do tego napisać,do jakiej nogi podpiąć?

Jestem kompletnie zielony,arduino i attiny85 dostałem 3 dni temu :/

Na początku kodu mam :

Kod: Zaznacz cały

#include <Servo.h>

Servo s; 
Dalej mam kod na 2 przyciski a chciałem wykorzystać "RTC".
Awatar użytkownika
Pawel112534
Młodszy majsterkowicz
Posty: 4
Rejestracja: 9 wrz 2015, 20:52

Re: Automatyczne otwieranie gołębnika.

Post autor: Pawel112534 » 10 wrz 2015, 19:04

Krapi pisze:
No tak,ale jaki kod do tego napisać,do jakiej nogi podpiąć?
a wgrałes chociaż bootloadera do attiny? pewnie nie skoro nie orientujesz się gdzie ma odpowiednie nóżki
no to może napisz kod wpierw na arduino co? i zobacz jak tym się zająć
skoro nie wiesz jak ogarnąć attiny (do tego trzeba się zorientować jak zrobić z tego układ samodzielny - a nie tylko mikrokontroler i heja wszystko będzie działać) to wpierw napisz kod pod arduino (arduino ma w sobie wszystkie odpowiednie stabilizatory, rezystory podciągajace, kondensatory filtrujące itp)

jak ja uwielbiam teksty pt "arduino mam od kilku dni, ale już chcę zrobić rakietę na księżyc" i następnie pytanie na poziomie "co to napięcie?"
skoro mówisz, ze kupiłeś arduino to... na nim wpierw zrób takie coś - masz przykładowe kody
zrobiłes chociaż blinka?
wgrałes kod z przykładów pod serwa?
jeśli nie to... na co liczysz? skoro Ci się nawet PODSTAWY nie chce ogarnąć?
jeśli tak to... w czym konkretnie masz problem?
Dalej mam kod
pytanie, które powinno być chyba automatycznie dodawane jako post od razu pod 3/4 nowo zakładanych tematów tutaj: "jest problem? gdzie jest CAŁY kod?"

Ogarnij najpierw podstawy z każdą z rzeczy oddzielnie: programowanie Attiny, obsługa serw, obsługa RTC
jak opanujesz je to dopiero wtedy sklecaj z tego całość, a nie tak na hura "od jutra będę tworzył własne komputery" - to tak nie działa

Arduino daje mocnego kopa na start z mikrokontrolerami, ale pewnych rzeczy, jak nauki nie przeskoczysz z dnia na dzień
Mam cały kod , ale serwa sterowane przyciskami.


Attiny85 ma być jutro,teraz arduino jest gotowe do wgrania bootloadera :

Niestety nie moge dodac screena z konfiguracji bootloadera

Kod: Zaznacz cały

// ArduinoISP version 04m3
// Copyright (c) 2008-2011 Randall Bohn
// If you require a license, see
//     
//
// 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
// 
//
// 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 

#include "pins_arduino.h"
#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);

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

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);
  }
}
A tutaj kod na sterowanie 2 przyciskami typu tact switch:

Kod: Zaznacz cały

#include <Servo.h>

Servo s;

const int Dol = 2;     // Numer pinu do ktorego bedzie podlaczony Tact switch1.
const int Gora = 3;   // Numer pinu do ktorego bedzie podlaczony tact switch2.

int buttonState = 0;         // Status Tact switch'a.
int Dioda = 13;

void setup() {
  // Pin ktory steruje serwem
  s.attach(9);
  // Przycisk , ustawiony na wejscie:
  pinMode(Dioda, OUTPUT);
  pinMode(Gora, INPUT);   
  pinMode(Dol, INPUT);  
}

void loop(){
  digitalWrite(Dioda, HIGH);       //włączenie diody na pinie 13
  delay(500);                      //zatrzymanie stanu na 500 mili sekund
  digitalWrite(Dioda, LOW);        //Wylaczenie diody na pinie 13
  delay(500);                      //Zatrzymanie stanu na 500 mili sekund
  buttonState = digitalRead(Gora);

  if (buttonState == HIGH) {     
    // Program oczekuje 5 mili sekund aby sygnal sie unormowal:   
    delay(5);
    // Serwo obraca sie o 180 stopni w gore:
    s.write(180); 
  buttonState = digitalRead(Dol); 
  
  if (buttonState == HIGH) {
// Program oczekuje 5 mili sekund aby sygnal sie unormowal:    
    delay(5);
// Serwo obraca sie o -180 stopni w gore:
    s.write(-180);
// by pawel112534
  }
}
};
Awatar użytkownika
Pawel112534
Młodszy majsterkowicz
Posty: 4
Rejestracja: 9 wrz 2015, 20:52

Re: Automatyczne otwieranie gołębnika.

Post autor: Pawel112534 » 11 wrz 2015, 14:51

Krapi pisze:
Teraz mam problem z wypaleniem bootloadera ...

wyskakuje taki błąd :

Kod: Zaznacz cały

avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 1 of 10: not in sync: resp=0x03
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 2 of 10: not in sync: resp=0x03
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 3 of 10: not in sync: resp=0x03
avrdude: stk500_recv(): programmer is not responding
Problem z wgrywaniem na płyte. Sprawdź http:/000sugestii.
avrdude: stk500_getsync() attempt 4 of 10: not in sync: resp=0x03
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 5 of 10: not in sync: resp=0x03
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 6 of 10: not in sync: resp=0x03
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 7 of 10: not in sync: resp=0x03
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 8 of 10: not in sync: resp=0x03
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 9 of 10: not in sync: resp=0x03
avrdude: stk500_recv(): programmer is not responding
avrdude: stk500_getsync() attempt 10 of 10: not in sync: resp=0x03
Terminux
Młodszy majsterkowicz
Posty: 24
Rejestracja: 21 gru 2014, 14:09

Re: Automatyczne otwieranie gołębnika.

Post autor: Terminux » 15 wrz 2015, 09:46

Może nie do końca w temacie ale dawno temu zrobiłem znajomemu automat do otwierania/zamykania gołębnika na:
1/ elektrycznym siłowniku od drzwi,
2/ sterowniku zegarowym oraz
3/ jednym przekaźniku.
Tyle było materiału i sprzętu. Działa bezproblemowo do dzisiaj.
razorxx100
Starszy majsterkowicz
Posty: 329
Rejestracja: 1 sie 2014, 22:57

Re: Automatyczne otwieranie gołębnika.

Post autor: razorxx100 » 15 wrz 2015, 16:58

@Up
To w jaki sposob sterowales tym przekaznikiem, a wlasciwie to powinny byc tutaj 2 przekazniki, nie mowiac juz o tym jak jak sprawdziles ze jest juz calkowicie otwarty/zamkniety.
Terminux
Młodszy majsterkowicz
Posty: 24
Rejestracja: 21 gru 2014, 14:09

Re: Automatyczne otwieranie gołębnika.

Post autor: Terminux » 17 wrz 2015, 13:12

razorxx100 pisze:@Up
To w jaki sposob sterowales tym przekaznikiem, a wlasciwie to powinny byc tutaj 2 przekazniki, nie mowiac juz o tym jak jak sprawdziles ze jest juz calkowicie otwarty/zamkniety.
Proszę nie bić - zrobiłem szybki rysunek w Paincie i myślę, że on wszystko wyjaśni.

Obrazek
Terminux
Młodszy majsterkowicz
Posty: 24
Rejestracja: 21 gru 2014, 14:09

Re: Automatyczne otwieranie gołębnika.

Post autor: Terminux » 18 wrz 2015, 14:27

A i tak sobie pomyślałem, że można zrobić bardziej wypasione otwieranio/zamykanie poprzez zastosowanie zamiast układu czasowego zwykłego wyłącznika zmierzchowego. Wtedy wraz z zapadającym zmrokiem klapka się zamknie, niezależnie od czasu na zegarze. Przynajmniej teraz bym tak zrobił ;-).
ktrybula
Młodszy majsterkowicz
Posty: 24
Rejestracja: 19 sie 2014, 13:43

Re: Automatyczne otwieranie gołębnika.

Post autor: ktrybula » 18 wrz 2015, 14:42

Terminux pisze:A i tak sobie pomyślałem, że można zrobić bardziej wypasione otwieranio/zamykanie poprzez zastosowanie zamiast układu czasowego zwykłego wyłącznika zmierzchowego. Wtedy wraz z zapadającym zmrokiem klapka się zamknie, niezależnie od czasu na zegarze. Przynajmniej teraz bym tak zrobił ;-).
Przydałby się jeszcze czujnik obecności gołębia żeby go nie przytrzasnąć :)
Terminux
Młodszy majsterkowicz
Posty: 24
Rejestracja: 21 gru 2014, 14:09

Re: Automatyczne otwieranie gołębnika.

Post autor: Terminux » 18 wrz 2015, 14:44

Podobno gołębie się błyskawicznie nauczyły i żadnemu nic się nie stało. Z tego, co opowiadał właściciel, to przez kilka pierwszych dni pojedyncze sztuki zostawały na zewnątrz, a potem już wszystkie grzecznie wracały do "domu" ;).
mar00
Młodszy majsterkowicz
Posty: 1
Rejestracja: 8 lut 2017, 22:16

Re: Automatyczne otwieranie gołębnika.

Post autor: mar00 » 24 gru 2019, 14:54

Uszkodziłem bootloader w LGT8F328P LQFP32 miniEVB prawdopodobnie
posiadam jeszcze 1 sztuke sprawną .
Poproszę o informację jak wgrać ponownie bootloader ?
Mariusz
stiven
Złota rączka
Posty: 1629
Rejestracja: 13 maja 2014, 08:47
Lokalizacja: Zielona Góra

Re: Automatyczne otwieranie gołębnika.

Post autor: stiven » 24 gru 2019, 15:12

ODPOWIEDZ

Strony partnerskie: