Как спроектировать собственный квадрокоптер – «Хакер»

Notice: Undefined index: HTTP_ACCEPT in /home/n/newavtjc/radiocopter.ru/public_html/wp-content/plugins/realbig-media/textEditing.php on line 823

Gps-трекер на arduino | radiocopter.ru

#include <TinyGPS .h>

#include <SoftwareSerial.h>

#include <SD.h>

#include <SPI.h>

longstartMillis=millis();

staticconstintRXPin=6,TXPin=7;

staticconstuint32_tGPSBaud=9600;

// The TinyGPS object

TinyGPSPlusgps;

// Инициализируем подключение к GPS

SoftwareSerialss(RXPin,TXPin);

FileGPS_file;

constintchipSelect=4;

voidsetup()

{

  Serial.begin(115200);

  ss.begin(GPSBaud);

  // Инициализируем SD карту, для отладки можно раскомментировать.

{  

  if(!SD.begin(chipSelect)){

    //Serial.println(“Card failed, or not present”);

    // don’t do anything more:

    while(1);

  }

// Serial.println(“card initialized.”);

  FileGPS_file=SD.open(“GPSLOG.csv”,FILE_WRITE);

  // если файл существует

  if(GPS_file){

    // записываем название будущих данных на карту памяти

    GPS_file.println(“Lat, Long, Time”);

    // закрываем файл

    GPS_file.close();

}

}

}

voidloop()

{

  // Если данные декодированы корректно тогда начинаем запись.

  while(ss.available()>0)

    if(gps.encode(ss.read()))

    if(millis()startMillis>4900)

  {

    startMillis=millis();

       logGps();

  }    

  if(millis()>5000&& gps.charsProcessed() < 10)

  {

    Serial.println(F(“No GPS detected: check wiring.”));

    while(true);

  }

}

voidlogGps()

// Все закомментированные строки с Serial, нужны для отладки.

{

GPS_file=SD.open(“GPSLOG.csv”,FILE_WRITE);

if(GPS_file){

//Serial.print(F(“Location: “));

//GPS_file.print(F(“Location: “));

  if(gps.location.isValid())

  {

  /*Serial.print(gps.location.lat(), 6);

    Serial.print(F(“,”));

    Serial.print(gps.location.lng(), 6);

  */GPS_file.print(gps.location.lat(),6);

    GPS_file.print(F(“,”));

    GPS_file.print(gps.location.lng(),6);

  }

  else

  {

    //Serial.print(F(“INVALID”));

    GPS_file.print(F(“INVALID”));

  }

  //Serial.print(F(”  Date/Time: “));

  GPS_file.print(F(“, “));

  if(gps.date.isValid())

  {

    /*Serial.print(gps.date.month());

    Serial.print(F(“/”));

    Serial.print(gps.date.day());

    Serial.print(F(“/”));

    Serial.print(gps.date.year());

  */GPS_file.print(gps.date.month());

    GPS_file.print(F(“/”));

    GPS_file.print(gps.date.day());

    GPS_file.print(F(“/”));

    GPS_file.print(gps.date.year());

  }

  else

  {

   // Serial.print(F(“INVALID”));

    GPS_file.print(F(“INVALID”));

  }

// Serial.print(F(” “));

  GPS_file.print(F(” “));

  if(gps.time.isValid())

  {

    /*if (gps.time.hour() < 10) Serial.print(F(“0”));

    Serial.print(gps.time.hour());

    Serial.print(F(“:”));

    if (gps.time.minute() < 10) Serial.print(F(“0”));

    Serial.print(gps.time.minute());

    Serial.print(F(“:”));

    if (gps.time.second() < 10) Serial.print(F(“0”));

    Serial.print(gps.time.second());

    Serial.print(F(“.”));

    if (gps.time.centisecond() < 10) Serial.print(F(“0”));

    Serial.print(gps.time.centisecond());

    */

    if(gps.time.hour()<10)Serial.print(F(“0”));

    GPS_file.print(gps.time.hour());

    GPS_file.print(F(“:”));

    if(gps.time.minute()<10)Serial.print(F(“0”));

    GPS_file.print(gps.time.minute());

    GPS_file.print(F(“:”));

    if(gps.time.second()<10)Serial.print(F(“0”));

    GPS_file.print(gps.time.second());

    GPS_file.print(F(“.”));

    if(gps.time.centisecond()<10)Serial.print(F(“0”));

    GPS_file.print(gps.time.centisecond());

  }

  else

  {

    //Serial.print(F(“INVALID”));

    GPS_file.print(F(“INVALID”));

  }

  //Serial.println();

  GPS_file.println();

  GPS_file.close();

}

}

Hexapod или робот-паук, как способ автоматизации строительных работ.

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

    Строительство зданий и сооружений требует тщательной подготовки. Для этого необходимо большое количество высококлассных специалистов в области строительства: архитекторы, геологи, геодезисты, каменщики, электрики и др. Многие из них при выполнении работ подвергаются опасным факторам, таким как агрессивная среда, высотные работы, тяжелые климатические условия. Всё это требует высоких трудозатрат, материальных вложений и рисков.

HEXAPOD или робот-паук, как способ автоматизации строительных работ.

В настоящее время задачей прогрессивного строительства является автоматизация процессов и повышение производительности опасных и высокоточных работ.

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

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

    Манипулятор на гексаподе служит для захвата объектов и перемещения их в пространстве. Так же к нему могут крепиться различные установки, например для заливки стяжки полов или фундамента, для бурения или сверления, сварочный аппарат. За счет встроенных датчиков, таких как инфракрасные, ультразвуковые или оптические, гексапод сможет ориентироваться не только днем, но и в темное время суток. При помощи специально разработанного ПО робот построит трехмерную модель полигона (участок, в котором проходит строительство) и в режиме реального времени будет сообщать о процессе строительства по средством протокола MQTT или же иных средств для передачи данных.

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

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

HEXAPOD или робот-паук, как способ автоматизации строительных работ.

HEXAPOD или робот-паук, как способ автоматизации строительных работ.

В данной модели применяется большее количество приводов, улучшенная модель ног и платформы, повышающая мобильность и гибкость. В данном роботе используется микроконтроллер Arduino mega 2560, усовершенствованная схема питания и реализовано беспроводное управление. Для создания данного проекта потребовалось приобретение 3Д принтера, мультиметра и различного CAD инструмента, объединяющий процессы разработки проекта. В данный момент на гексаподе не установлен манипулятор, но для него предусмотрено место крепления, а так же запас питания и вычислительные мощности контроллера управления.

3Д печать

       Для изготовления деталей гексапода был приобретен FDM (Fused Depsition Modelling) 3д принтер Flying Bear Ghost 4s. Данный принтер является одним из лучших в своей ценовой категории. Он печатает пластиками PLA,Pet-G, ABS и другими. Хорошая кинематика этого принтера предотвращает повреждение деталей во время печати. Специально подогревающийся стол улучшает адгезивные свойства для лучшего сцепления детали с его поверхностью.

    Основным материалом для изготовления был выбран PET-G так как его физико-механические свойства отлично подходят для гексапода. Демпферы были напечатаны из материала Bflex. 

Слайсер – Cura.

HEXAPOD или робот-паук, как способ автоматизации строительных работ.

HEXAPOD или робот-паук, как способ автоматизации строительных работ.

Для улучшения качества напечатанных моделей, была доработана конструкция принтера. Вместо изначально установленного bowden экструдера, был напечатан и установлен direct. Откалиброван PID для стола и нагревательного элемента, шаги для мотора экструдера, заменены драйвера для шаговых двигателей на осях X,Y,E.  Собрана термокамера из верхнего бокса (фанера) и передней дверцы (акрил), заменено стоковое стекло на зеркало 3мм.

Так же был проведен расчет коэффициента усадки для точной печати отверстий.

Далее о создании данной модели гексапода

Разработка

HEXAPOD или робот-паук, как способ автоматизации строительных работ.

3д модель гексапода :

HEXAPOD или робот-паук, как способ автоматизации строительных работ.

    Робот разрабатывался на основе аналогичных существующих моделей, в том числе и роботов-гексаподов. В результате работы были значительно улучшены различные модули и усовершенствована конструкция ног, что потребовало использования 18 сервоприводов. Это позволило повысить мобильность и гибкость робота. Чертежи и модели частей корпуса робота полностью разрабатывались в CAD системе и производились при помощи аддитивных технологий. По 3д моделям можно производить технологические расчеты и использовать при дальнейшем производстве.

HEXAPOD или робот-паук, как способ автоматизации строительных работ.

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

    В гексаподе используется микроконтроллер Arduino mega 2560 с дополнительно установленной Raspberry pi 4. Это позволяет плавно и с большой точностью перемещать робота. Так же были усовершенствованы: схема питания, которая позволила включать и выключать робота при помощи контроллера, и беспроводное управление, которым осуществляется движение робота, манипулятора и управление камерой. Присутствует возможность подключиться к гексаподу дистанционно по средством передачи данных wi-fi, а так же можно расширить функционал и управлять мехатронным устройством дистанционно. Робот изготовлен с учетом промышленных стандартов во избежание травматизма, на нем располагается кнопка аварийной остановки, а вся электроника помещена корпус. Светодиодный индикатор для отладки и отображения состояния робота собран и представлен на фотографии.

HEXAPOD или робот-паук, как способ автоматизации строительных работ.

Манипулятор

HEXAPOD или робот-паук, как способ автоматизации строительных работ.

    Одним из основных частей гексапода является манипулятор. Он выполнен из PET-G пластика на 3д принтере. Манипулятор и его кинематика проектировались в CAD системе по собственным чертежам и наработкам. Манипулятор состоит из 3 звеньев и захвата, которые вращаются в одной плоскости. В роли двигателей используются сервоприводы, крутящий момент которых >10кг/см. Манипулятор способен поднимать объекты массой до 500 грамм и до 1000 в режиме удержания. Так же в роботе установлена FPV камера, которая позволяет управлять роботом дистанционно и камера для машинного зрения, обеспечивающая распознавание объектов и дальнейшим выводом их на монитор.

Программирование

    Программирование производилось в среде разработки Arduino IDE и sublime_text . Код состоит из функций, которые контролируют модули, и функций, которые ими управляют. В программе реализованы аварийные остановки и вывод ошибок при не правильном подключении или во время отклонений наклона корпуса от нормы. >60% программного обеспечения разрабатывалось вручную.

Управление

    Для управления гексаподом используется геймпад от PlayStation2 с ресивером. Он позволяет точно управлять движением, выбирать различные типы походки и выбирать режимы управления. Беспроводное управление реализуется за счет встроенного радио модуля на 2.4гц . Приемник устанавливается на верхнюю часть платформы корпуса гексапода и подключается к Arduino mega (для передачи сигнала используются пины 2-5, а так же пины 3.3в и Gnd для питания).

HEXAPOD или робот-паук, как способ автоматизации строительных работ.

HEXAPOD или робот-паук, как способ автоматизации строительных работ.Питание

В качестве источника питания для гексапода используются li-ion аккумуляторы. Для стабилизации напряжения используется стабилизатор бортового напряжения SBEC.

Аккумуляторы

В качестве батареи используются li-ion аккумуляторы формата 18650. К преимуществам можно отнести:

– Высокая энергетическая плотность.

– Низкий саморазряд.

– Отсутствие эффекта памяти.

– Простота обслуживания.

– Низкий удельный вес.

Аккумуляторы собираются последовательно в 3s батарею (12.6в).

Стабилизатор

В роли стабилизатора используется стабилизатор бортового напряжения YEP 20A HV (2 ~ 12S) SBEC. По причине того, что на каждом сервоприводе просадка напряжения достигает 0.3в., суммарно, со всех двигателей, просадка по напряжению принимает значение до 6в., вследствие чего многие приводы не работают. Так же каждый привод потребляет до 800мА, опытным путем было выявлено, что суммарный потребляемый ток примерно 15А.

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

• Максимальный ток 20А

• Выходное напряжение 5-7.2в

• Иметь теплоотвод

Данным требованиям соответствует стабилизатор бортового напряжения YEP 20A HV

 (2 ~ 12S) SBEC.

технические характеристики:

  • Ток: 20A
  • Входное напряжение: 2-12S
  • Выходное напряжение: 5V / 5.5V / 6V / 7В / 9В
  • PCB Размер: 57x26mm
  • Вес: 42g

HEXAPOD или робот-паук, как способ автоматизации строительных работ.

Видеоролик работы гексапода

” target=”_blank”>

#3dmay

Исходный код программы (скетча)

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

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

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

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

// ArduinoISP
// Copyright © 2008-2023 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, пойдет прошивка контроллера (у меня проходит только со второй попытки, нужно набраться терпения):

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

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

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

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.

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

Смотрите про коптеры:  ᐅ Квадрокоптер DJI Mavic Air отзывы — 38 честных отзыва покупателей о квадрокоптере Квадрокоптер DJI Mavic Air
Оцените статью
Радиокоптер.ру
Добавить комментарий