Прикормочный кораблик. Обзор Артура Дементьева

Прикормочный кораблик. Обзор Артура Дементьева Роботы

Подключение модуля к arduino

Подготовим программатор для прошивки:

Затем в Нано зашиваем этот скетч:

Дополнительная информация

// ArduinoISP
// Copyright © 2008-2021 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
#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©;
  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 © {
    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);
  }
}

После этого выбираем Ваш контроллер Pro Mini, указываем программатор ArduinoISP и шьем контроллер, используя команду Скетч -> Загрузить через программатор и нажимаем кнопку Reset на Pro mini, пойдет прошивка контроллера (у меня проходит только со второй попытки, нужно набраться терпения):

Смотрите про коптеры:  Управление роботом EV3 при помощи станицы аппаратных средств

Как выше говорил, я очень люблю ко всяким гаджетам подвязывать дисплеи, ну просто жуть как, поэтому данный «проект» мое желание не обошло стороной.

Что нам для всего этого потребуется:

В общем, собрал весь хлам, который валялся без дела:

1. SD card module, очень огромный, поэтому я старался как можно скорее избавится от него.

2. Дисплей на базе контроллера PCD8544, всем известный нокиа дисплей.

3. Карта памяти на 1Гб, с не популярным стандартом MiniSD, вообще был без идеи куда ее воткнуть, а хочется все пустить в дело, вот и пускай поработает на благо навигации.

4. Потребуется мозг, большой такой мозг Pro Mini на чипе 328P.

Как писал выше, будем шить через Arduino Nano с прошитым в нее загрузчиком.

Вообще я очень старался засунуть весь проект в нано, ну просто очень. Не получается, либо отказываемся от карты памяти, либо от дисплея.

5. Конечно же, сам модуль антенна, как писал выше можно изготовить самому.

6. Ах да, чуть не забыл, потребуется еще корпус иначе, что за устройство без корпуса.

В качестве корпуса были закуплены, еще раз те самые коробки, но в серебряном виде, на пробу. Скажу так, мне абсолютно не понравился серебряный цвет, черный смотрится лучше.

Когда все комплектующие есть в наличии, можно все это подключить и запрограммировать.

Подключаем к Pro Mini по следующей схеме:

Дисплей:

RST — D6CE — D7DC — D5DIN — D4CLK — D3VCC — 5V (опционально в моем случае, в остальных 3.3В )Light — GNDGND — GND

Подсветка мне была не нужна, и я не стал ее подключать.

SD карта:

CS-D10MOSI-D11MISO-D12SCK-D13GND — GND5V — VCC (опционально в моем случае, в некоторых при наличии преобразователя подключаем на 3.3В)

GPS модуль:

RX-D8TX-D2GND — GNDVCC-3.3 (3.3 это предел!)

Не забываем подключать антенну на модуль, питание я брал с Нано тк. была подключена для отладки, далее все будет переделано на аккумулятор.

Примерный вид:

Код прост и незамысловат, для использования Вам понадобится, пожалуй самая легкая библиотека для дисплея. Далее библиотека для GPS. Остальные являются встроенными. По коду, строка — time*0.000001 5, по сути я привел время в удобоваримый вид и добавил часовой пояс. Можно этого не делать и получать чистые результаты.

Ещё один нюанс по библиотеке дисплея заключается в следующем у дисплея, включая с нулевой строкой, всего влезет 6 строк. Что довольно мало, поэтому нужно сразу решать, какую информацию выводить, что-то придется выводить символами, экономя место. Дисплей перерисовывается каждую секунду, при этом обновляя и записывая информацию, поступающую со спутников.

При ошибке чтения файла или отсутствия доступа до карты SD будет выводиться сообщение SD-, в остальных случаях SD .

Скетч

#include <SoftwareSerial.h>
#include <TinyGPS.h>
#include <PCD8544.h>
#include <SD.h> //CS-D10, MOSI-D11, MISO-D12, SCK-D13, GND — GND, 5V — VCC (опционально в моем случае, в некоторых при отсутствии преобразователя подключаем на 3.3В)
File GPS_file;
TinyGPS gps;
SoftwareSerial gpsSerial(2, 8);//RX - 8 pin, TX - 2 pin

static PCD8544 lcd; //RST - D6, CE - D7, DC - D5, DIN - D4, CLK - D3, VCC - 5V (опционально, при наличии преобразователя на 3.3В линии), Light - GND, GND - GND
bool newdata = false;
unsigned long start;
long lat, lon;
unsigned long time, date;


void setup() {
  
lcd.begin(84, 48);
gpsSerial.begin(9600);
Serial.begin(9600);

pinMode(10, OUTPUT);
if (!SD.begin(10)){
lcd.setCursor(0, 0);
lcd.println("SD-");
return;}
lcd.setCursor(0, 0);
lcd.println("SD ");
GPS_file = SD.open("GPSLOG.txt", FILE_WRITE);
if (GPS_file){
Serial.print("Writing to test.txt...");
GPS_file.print("LATITUDE");
GPS_file.print(",");
GPS_file.print("LONGITUDE");
GPS_file.print(",");
GPS_file.print("DATE");
GPS_file.print(",");
GPS_file.print("TIME");
GPS_file.print(",");
GPS_file.print("ALTITUDE");
GPS_file.println();
GPS_file.close();
Serial.println("done.");
}else{
    Serial.println("error opening test.txt");
}

lcd.setCursor(0,3);
lcd.print("ALT: ");
lcd.setCursor(0,2);
lcd.print("SPD: ");
lcd.setCursor(0,4);
lcd.print("LAT: ");
lcd.setCursor(0,5);
lcd.print("LON: ");
}  
void loop() {
if (millis() - start > 1000){
newdata = readgps();
if (newdata){
start = millis();
gps.get_position(&lat, &lon);
gps.get_datetime(&date, &time);

lcd.setCursor(50,1);
lcd.print(date);
lcd.setCursor(55,0);
lcd.print(time*0.000001 5);
lcd.setCursor(22, 4);
lcd.print(lat);
lcd.setCursor(22, 5);
lcd.print(lon);
lcd.setCursor(22, 2);
lcd.print(gps.f_speed_kmph());
lcd.setCursor(22, 3);
lcd.print(gps.f_altitude());
}
}
GPS_file = SD.open("GPSLOG.txt", FILE_WRITE);
if(GPS_file){
GPS_file.print(lat);
GPS_file.print(",");
GPS_file.print(lon);
GPS_file.print(",");
GPS_file.print(date);
GPS_file.print(",");
GPS_file.print(time*0.000001 5);
GPS_file.print(",");
GPS_file.print(gps.f_altitude());
GPS_file.println();
GPS_file.close();
}else{
  lcd.setCursor(0, 0);
lcd.println("SD-");
}
}
bool readgps(){
while (gpsSerial.available()){
int b = gpsSerial.read();
if('r' != b){
if (gps.encode(b))
return true;}}
return false;}

После прошивки Вы увидите нечто подобное (в скетче вывод даты отредактирован к правому краю под временем):

С расположением элементов можно поиграться, был такой вариант, но понял, что усреднение координат выдает огромную погрешность и отказался.

Что делать дальше? Собирать в корпус, можно на клей, можно на двухсторонний скотч все разместить, мне же захотелось все разместить на макетной плате:

В качестве элементов питания я использую LI-ion аккумулятор. Покупаю акб для экшн — камер оптом и использую их в своих поделках ко всему всегда могут пригодиться для экшн — камеры, которой пользуюсь в походах. Покупал тут.

Далее идет борьба за место, отрезаем лишнее от контактов и ровняем их с высотой макетной платы.

Используя макетную плату, собираем все воедино:

На корпус для карты памяти наклеил кусок изоленты, тк он соприкасается с контактами зарядника для батареи. Карту памяти прошиваем в FAT16.

Потом запускаем и проверяем, не забыв поставить выключатель:

Радиоуправление для прикормочного карпового кораблика с автопилотом. sc-a2. arduino. своими руками. вторая версия

«В настоящее время рядом с нами их (азербайджанцев) проживает человек 150-200, и каждый месяц еще появляется человек десять… Мы боимся за жизнь своих детей и внуков… Мы обращались и к местной власти, и в милицию, но там нам сказали, что выселить их может лишь миграционная служба. Но, наверное, пока не грянет гром, как у нас обычно бывает, ничего не произойдет… Просим принять срочные меры к гражданам Азербайджана, которые проживают у нас в селе, пока не случилась трагедия. Они угрожают нашим жизням и жизням наших детей и внуков».

Смотрите про коптеры:  11. Беспроводные датчики, кодирование и установка адресов
Смотрите про коптеры:  Игра Мега Роботы 2 онлайн (Mega Mechs 2)

Робот-автопилот с управлением и программированием с ик пульта

Поломанную детскую машинку я захотел превратить в управляемого робота, с различными режимами работы. А именно, как контролируемого вручную с помощью пульта от телевизионной приставки, так и способного перемещаться по квартире самостоятельно, что называется “на автопилоте”. Плюс, в процессе игры, хотелось бы предоставить ребенку возможность задавать этому роботу произвольные последовательности действий или способы реакции на препятствия, то есть «программировать» его, так же с помощью пульта, без подключения к среде разработки.

За основу я взял вот такой, однажды поломанный, игрушечный квадроцикл.

От него я оставляю только корпус, а всю внутренность и механику ему придется заменить. Соответственно, разбираем полностью.

Электронной платформой для самоделки будет всем известная Arduino nano, точнее, её недорогой китайский аналог. Так же мне понадобились:
1. Arduino Nano
2. Мотор-редуктор с колесами для Ардуино 2шт. (ссылка на Алиэкспресс)
3. Драйвер мотора MX1508 1шт. (ссылка на Алиэкспресс)
4. Ультразвуковой датчик для измерения расстояния HC-SR04 1шт. (ссылка на Алиэкспресс)
5. Зарядный модуль для литий-ионных аккумуляторов TP4056 1шт. (ссылка на Алиэкспресс)
6. Повышающий преобразователь напряжения MT3608 1шт. (ссылка на Алиэкспресс)
7. Модуль инфракрасного приемника 1шт. (ссылка на Алиэкспресс)
8. Фоторезистор GL5528 (20кOм) 1шт. (ссылка на Алиэкспресс)
9. Светодиоды 2шт.
10. Пьезоизлучатель, зуммер 1шт. (ссылка на Алиэкспресс)
11. Выключатель 1шт.
12. Аккумулятор литий-ионный 18650 1шт. (ссылка на Алиэкспресс)
13. Провода.
14. Еще одно маленькое колесо.
15. ИК пульт дистанционного управления.

Инструментарий составили

:

1. Паяльник.
2. Отвертка.
3. Нож.
4. Кусачки.
5. Пилка.
6. Клеевой пистолет.

Первым делом избавляемся от старых колес и примеряем, как на их месте будут располагаться моторы с редукторами и новыми колесами.

Затем необходимо подобрать и подготовить места под всю электронную начинку внутри корпуса игрушки. Для этого кое-какие элементы пришлось подпилить, а также, выломать некоторые перегородки между внутренними отделениями. После доработки примеряем каждый модуль на его будущее место расположения в корпусе.

Например, сам контроллер я решил установить под сиденьем

Драйвер моторов – в задней части машинки, поближе к движкам. Для этого пришлось укоротить выхлопную трубу.

Пьезоизлучатель будет находиться на том же месте, где стоял родной динамик машинки

Преобразователь напряжения и контроллер аккумулятора установятся внутри корпуса

Светодиоды, имитирующие фары – в передней части

Там же будет установлен фоторезистор

И сверху расположатся датчик расстояния и инфракрасный приемник

Собирать будем по следующей схеме:

Здесь АКБ Li-ion 18650 – это аккумуляторная батарея питающая устройство. Для заряда батареи и защиты от переразряда, она подключается к схеме, через контроллер TP4056 на выводы B и B-. Далее с выходов контроллера TP4056 напряжение подается на повышающий преобразователь MT3608, где поднимется с 4.2 до 5 В, а также на драйвер моторов MX1508. И уже с выходов MT3608, питание подается на контроллер Ардуино nano и на подключенные к его пинам датчики.

Собственно, из датчиков мы имеем на борту только три: это ультразвуковой датчик расстояния, датчик освещенности в виде фоторезистора и инфракрасный приемник для управления роботом с ИК пульта. Фоторезистор подключен к аналоговому пину А6 на Ардуино, с подтягивающим резистором 10 кОм на массу. А датчик расстояния к цифровым пинам D10 и D12, на контакты trig и echo, соответственно. Инфракрасный датчик подсоединен к цифровому пину D8.

Помимо датчиков к Ардуино подключены также входящие контакты драйвера моторов IN1, IN2, IN3, IN4, на пины: D5, D4, D6, D7, соответственно. Пьезо пищалка для звукового сопровождения – пин D11. И два красных индикационных светодиода, для подсветки робота в темноте. Светодиоды подключаются анодами к цифровым пинам D2 и D3, и катодом к GND c ограничивающим резистором на 160 Ом.

Для возможности физического отключения питания, в цепь батареи будет вставлен выключатель.

Чтобы паять контакты прямо к Ардуино, и тем самым сэкономить пространство и обеспечить компактность расположения элементов внутри робота, мне пришлось удалить все ножки с контроллера.

После чего я приступил к распайке .

И настройке повышающего преобразователя MT3608 с помощью подстроечного резистора так, чтобы на out контактах было 5V.

Соединив все модули согласны схеме,

Я занялся сборкой робота в его окончательном виде, стараясь максимально скрыть внутри все компоненты и соединительные провода. Так же, с помощью термоклея, я установил моторы с колесами и выключатель.

Аккумулятор будет располагаться сзади, над моторами. Я подпаял провода прямо к батарее, хоть это делать и нежелательно, но так всё будет немного компактнее.

В задней части сиденья я проделал отверстие для подключения mini USB кабеля к разъему на Ардуино, чтобы иметь возможность программировать контроллер ничего не раскручивая.

Зарядный модуль я расположил внутри с таким расчетом, чтобы разъем для подключения кабеля выходил снизу, в днище корпуса.

Пока аккумулятор заряжается, индикатор на модуле светится красным. Как только зарядится, загорится синий.

Еще я решил прикрыть тыльную часть ультразвукового датчика расстояния небольшим пластиковым прямоугольником. Так и симпатичнее и безопасней для электроники.

Получился вот такой робот, и он уже почти готов к работе.

Осталось составить скетч в Arduino IDE и залить его в контроллер.

В процессе написания программы, я, хоть и не использовал никаких экзотических библиотек, только стандартные и проверенные временем, столкнулся с необычной проблемой: после обновления до последней версии, библиотека IRremote, ответственная за обработку сигналов получаемых с инфракрасного приемника, перестала работать. Но после отката на версию 2.8.0, все снова заработало, как надо. Так что, если кто будет использовать аналогичный моему код, имейте ввиду, что версия указанной библиотеки должна быть не выше 2.8.0. Так же, возможно, вам придется изменить в этой библиотеке таймер по умолчанию в файле:

Users###DocumentsArduinolibrariesIRremotesrcprivateIRremoteBoardDefs.h

(Более подробно об этом сказано в самом

скетче

)

И еще по поводу ИК управления. Поскольку ваш пульт ДУ почти наверняка будет отличаться от моего,

то и коды клавиш у вас будут другими. Определить их можно раскомментировав строчку:

//Serial.println(irrecv.results.value);

Находящуюся внутри функции

void changeMode()

и открыв “монитор порта”.

При нажатии кнопок на ИК пульте в мониторе появятся соответствующие цифры. Их нужно будет вставить после команд:

 switch (irrecv.results.value) {
    case ******** :
      …

на место “********”, которые ответственны за обработку сигналов от нужных кнопок. Будьте внимательны, операторы

switch (irrecv.results.value)

в программе встречаются аж целых 4 раза.

Скачать скетч можно здесь

.

Первые испытания показали, что сдвоенные передние колеса сильно снижают манёвренность.

Поэтому я заменил их на одинарное.

И после этого способность робота делать повороты сразу возросла.
Кстати поворачивать он может за счет разного направления и скорости вращения задних колес с моторами. Например, если заставить левое колесо крутиться вперед, а правое назад, то робот будет совершать разворот вправо, стоя при этом на месте. Тот же принцип, но с обратным направлением вращения колес, развернет робота влево. Это достигается подачей разных сигналов на цифровые выходы подключенные к контроллеру моторов. Подробнее о комбинациях сигналов определяющих разные направления движения робота можно ознакомиться в функции

void drive(byte d)

.

Вкратце программа работает следующим образом:

Сразу после включения, робот попадает в режим ожидания, после чего игрок должен выбрать режим дальнейшей работы. Всего же предусмотрено 6 режимов. 4 из них предназначены для различных способов управления и 2 для программирования:

1.Ручное управление. Полный контроль передвижений робота пультом. Куда жмем, туда и едет.

2.Простой автопилот. В этом режиме робот сам определяет направление своего движения, избегая при этом столкновений с близкими препятствиями с помощью метода “отъезд назад, разворот” и т.д..

3.Программируемый пультом автопилот. Войдя в этот режим робот будет передвигаться реагируя на разные расстояния до препятствий такими действиями, которые пропишет в его память игрок с помощью ИК пульта.

4.В этом режиме робот просто выполнит те действия, которые запрограммирует в него игрок, не обращая никакого внимания на препятствия.

И еще 2 режима для программирования действий в режимах 3 и 4.

И функция ожидания.

Чтобы выйти из “сна” и начать управлять роботом, на моем пульте надо нажать одну из цветных кнопок:
Например, нажатие на красную кнопку позволяет манипулировать роботом, просто, как радиоуправляемой игрушкой.

Из доступных действий в него заложены:

1.Движение вперед.
2.Назад.
3.Вперед и направо, налево.
4.Развороты на месте.
5.Движение назад с поворотом направо или налево.
6.Остановка.

Выполнение роботом команд задаваемых с ИК пульта:

Управление роботом с пульта:

Зеленая кнопка включает простой автопилот, после чего робот действует полностью самостоятельно, постоянно двигаясь вперед и всячески избегая любых препятствий. Делая небольшой отъезд назад и затем поворачиваясь на месте в поисках свободного пространства. Программу этого автопилота нельзя изменить в процессе игры.

Робот на автопилоте:

Желтая кнопка – включает автопилот в котором изначально отсутствуют заданные действия, кроме движения веред. Их нужно прописывать вручную с помощью пульта. Делается это в специальном режиме, войдя в который нужно установить робота на определенном расстоянии до препятствия и последовательно нажимая на нужные кнопки, прописать в память те действия, которые робот должен выполнить наткнувшись на стены впереди. Причем, если прописать несколько вариантов действий (до 20 вариантов от 1 до 20 действий в каждом), то выбран будет тот, в котором записана наиболее подходящая дистанция до преграды.

Программирование с пульта:

Робот катается сам, реагируя на препятствия серией из 20 команд, введенных с ИК пульта:

Синяя кнопка запускает серию действий (до 100 шагов) записанных в память, при этом препятствия игнорируются. Первоначально это будут 100 случайных команд продолжительностью выполнения по 500 мсек каждая.

Но есть возможность изменить эту последовательность, запрограммировав пультом любые другие команды в количестве от 1 до 100, и робот их так же выполнит, не обращая внимания на препятствия.

Последние два режима позволяют ребенку не только развлекаться с помощью робота, как с забавной игрушкой, но и в игровой форме приобщаться к понятиям алгоритмизации и принципов робототехники.

Более подробно о том, как управлять и программировать робота описано в комментариях к скетчу.

Также, созданные вручную серии команд можно сохранять в энергонезависимой памяти робота, которая продолжает хранить данные даже после выключения.

Считывая данные с датчика света, робот автоматически включает фары, если попадает в затененную область, благодаря чему, его всегда будет видно в темноте или «под диваном», при этом издавая серию рандомных звуков.

Радиус действия пульта ограничен несколькими метрами, но для квартиры этого достаточно.

Если говорить о затратах, то на покупку всех необходимых модулей у меня ушло меньше 1Круб. Аккумулятор, пульт, светодиоды и ИК приемник были добыты из разного хлама.

В заключение хочу прояснить, что не являюсь специалистом в области электроники, программирования и роботостроения, так что, возможны ошибки, недочеты и недоработки, видимые более опытному глазу.

Тем не менее, считаю, что подобный эксперимент по созданию такого небольшого робота, может послужить стимулом для тех, кто, как и я, не обладая глубокими познаниями, все же желает приобщиться к миру робототехники и создать что-то своими руками, порадовав себя и своих детишек забавным изобретением.

Оцените статью
Радиокоптер.ру
Добавить комментарий

Adblock
detector