Wipe clay pots with a damp cloth
For this project you will need four clay pots, which can be any size you like, as long as they come in four progressively smaller sizes: large, medium, small and extra small. Start by removing any possible dust and small debris from the pots with a damp cloth. Paint clay pots.
For the project, it is better to use outdoor acrylic, which is weather-resistant. Paint the rim of the pots one color and the body another. I decided to paint the headbands white. Apply the paint in several layers with preliminary drying of each layer. For now, paint only the large, medium and small pots.
Connecting the module to Arduino
Let's prepare the programmer for firmware:
Then we stitch this sketch into Nano:
Additional Information
// ArduinoISP // Copyright © 2008-2011 Randall Bohn // If you require a license, see // https://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). // Eg 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 ie 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 reset chosen_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 >> & 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 & 0xFFFFFFFE0; } if (param.pagesize == 128) { return here & 0xFFFFFFFC0; } 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 >> & 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 >> & 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 >> & 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); } }
After that, select your Pro Mini controller, specify the ArduinoISP programmer and sew the controller using the Sketch -> Upload via programmer
and press the Reset button on the Pro mini, the controller firmware will start flashing (for me it only works on the second try, I need to be patient):
As I said above, I really love attaching displays to all sorts of gadgets, it’s just creepy, so this “project”
my desire did not go unnoticed.
What do we need for all this:
In general, I collected all the trash that was lying around:
1. SD card module, very huge, so I tried to get rid of it as soon as possible.
2. Display based on the PCD8544 controller, the well-known Nokia display.
3. A 1GB memory card, with the unpopular MiniSD standard, I had no idea where to plug it in, but I wanted to put everything to work, so let it work for the benefit of navigation.
4. You will need a brain, a large Pro Mini brain on a 328P chip.
As I wrote above, we will sew through an Arduino Nano with a bootloader stitched into it.
In general, I tried very hard to fit the entire project into nano, well, just really. It doesn’t work, we either give up the memory card or the display.
5. Of course, the module itself + antenna, as I wrote above, you can make yourself.
6. Oh yes, I almost forgot, you will need another case, otherwise what kind of device is it without a case.
As a case, we purchased the same boxes again, but in silver, for testing. I will say this, I absolutely did not like the silver color, black looks better.
When all the components are available, you can connect and program it all.
We connect to Pro Mini according to the following scheme:
Display:
RST - D6 CE - D7 DC - D5 DIN - D4 CLK - D3 VCC - 5V (optional in my case, in others 3.3V) Light - GND GND - GND
I didn't need the backlight, so I didn't connect it.
SD card:
CS-D10 MOSI-D11 MISO-D12 SCK-D13 GND - GND 5V - VCC (optional in my case, in some with a converter we connect to 3.3V)
GPS module:
RX-D8 TX-D2 GND - GND VCC-3.3 (3.3 is the limit!)
Don't forget to connect the antenna to the module, I took the power from Nano Tk. was connected for debugging, then everything will be converted to the battery.
Approximate view:
The code is simple and straightforward; to use it you will need perhaps the easiest display library. Next is the library for GPS. The rest are built-in. According to the code, the line is time*0.000001+5, essentially I brought the time into a digestible form and added a time zone. You can skip this and still get clean results.
Another nuance regarding the display library is the following: the display, including the one with the zero line, has 6 lines in total. Which is quite small, so you need to immediately decide what information to display; some will have to be displayed in symbols, saving space. The display is redrawn every second, while updating and recording information coming from satellites.
If there is a file reading error or the SD card cannot be accessed, the message SD-
, in other cases
SD+
.
Sketch
#include #include #include #include //CS-D10, MOSI-D11, MISO-D12, SCK-D13, GND - GND, 5V - VCC (optional in my case, in some, if there is no converter, we connect to 3.3V) 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 (optional, if there is a converter on the 3.3V line), 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;}
After flashing the firmware, you will see something like this (in the sketch, the date output is edited to the right edge under the time):
You can play with the arrangement of the elements, there was such an option, but I realized that averaging the coordinates produces a huge error and refused.
What to do next? You can assemble everything into a case, you can use glue, you can place everything on double-sided tape, but I wanted to place everything on a breadboard:
I use LI-ion batteries as batteries. I buy batteries for action cameras in bulk and use them in my crafts, plus they can always come in handy for action cameras that I use on hikes. I bought it here.
Next comes the struggle for space, we cut off the excess from the contacts and align them with the height of the breadboard.
Using a breadboard, we put everything together:
I pasted a piece of electrical tape onto the case for the memory card, as it is in contact with the contacts of the battery charger. We flash the memory card in FAT16.
Then we launch and check, not forgetting to turn on the switch:
Making a decorative lighthouse
A master class for those who love experiments, are not afraid of a hammer, and creative but painstaking work!
1. Materials you will need:
- wooden panel 15-20 mm thick
- pencil, ruler, piece of thick paper (for making a lighthouse stencil)
- acrylic paints of two colors, brushes, water
- hammer, black nails 10-12mm, several nails with decorative heads
- artificial thread and sisal
- lighter, scissors
- 2. We cover the wooden base with paint on both sides and let it dry for about 1-1.5 hours; you need to cover it with a thin layer, applying the paint across the structure of the wood to preserve the texture.
- 3. We cut out the shape of a lighthouse from thick paper, apply it so that the middle of the stencil and the wooden blank coincide, trace the outline and mark the stripes. We paint the stripes in a contrasting color, applying the paint with light strokes, leaving it uneven so that the color of the base appears, let the paint dry for 30-40 minutes.
- 4. We take nails and nail them along the contour of the unpainted stripes; we nail the platform on the upper tier of the lighthouse with a rectangle. You can add several decorative carnations with an unusual carved head to those sections that will not be filled with weaving. It is important to try to nail the nails as evenly as possible relative to each other with the same distance between them. You need to drive in 2-4 mm.
- 5. We take a synthetic thread, tie one end of the thread to the outer stud (top or bottom of the section) into 2-4 knots, cut it at a distance of 1 cm and carefully set the edge on fire, the synthetic thread will melt and fix the knot. We create a cross-shaped weave and fasten the second end of the thread in the same way.
- 6. We take a thicker, textured rope - sisal and fasten it along the contour of the lighthouse with 4 nails, tie and trim the edges, additionally create a simple weave on sections where there is already weaving with thread. You can attach such a decorative beacon to a metal loop by screwing it on the reverse side. Anyone skilled in the art of using a drill can drill a small, blind hole on the reverse side!
Using a Smartphone for GPS Tracking
To use a GPS-enabled smartphone as a GPS tracker or beacon, you need to do a little tinkering with the software. Making your own GPS tracker from a phone running Android, Windows Mobile or iOS is very simple; no intervention in its design is required. If the smartphone is used as a car tracker, you will have to perform simple manipulations to connect it to the vehicle’s electrical network.
There are several applications that allow you to turn your smartphone into a tracker. For an Android device, you can download the Loki application from Google Play, launch it on your smartphone and configure the settings. It is recommended to activate the following functions:
- autostart;
- notifications (optional);
- external power (use of alternative settings when connecting to an external power source);
- full awakening (optional);
- command processing.
For navigation (location determination), it is recommended to set the data update interval once a minute; for sending SMS messages when communication with the server disappears, the time limit is 5 minutes. Make settings in the “Events” section in accordance with your own needs.
After completing the settings, all you have to do is register on the Asgard website and add your device, indicating the identifier defined by the Loki program. If, as a result, a mark of your location appears on the site map, then everything was done correctly, and the smartphone can be used as a tracker, tracking its location through Asgard.
You can also use the GPShome Tracker application for Android, and GpsGate Client for Pocket PC for Windows Mobile. When turning a smartphone into a tracker or beacon, it is extremely important to set the time zone correctly.
GPShome Tracker Settings
To determine coordinates via Wi-Fi and GSM networks, the device must have access to unlimited mobile Internet, so you need to choose a tariff that allows you to optimize costs. If the phone will be used exclusively as a tracker, it is better to install a SIM card only for accessing the Internet, and not for calls. Using a GPS receiver, which increases the accuracy of determining coordinates, is a very energy-intensive process, so care should be taken to provide power to the homemade tracker. To do this, you need to cut off the lower end of the car plug (cigarette lighter plug) and insert the phone charger cord into the USB connector. To connect the tracker directly to the on-board system, you need to buy a DC-DC step-down converter. And those who know a little about electronics can assemble an analog converter from a pair of capacitors and a stabilizer.
If you plan to use a homemade tracker (beacon) to covertly monitor the movement of a car, you need to think about where to hide it so that it can be easily retrieved if necessary. And don’t forget to activate silent mode if your phone has a card installed for the Internet and calls.
Master Class
each of us is a Master
Lighthouse . Decor in a marine style made from waste materials.
WE WANT TO THROW AWAY: coffee cans, newspaper (or paper egg cartons)
WE WILL MAKE:
decorative figurine “Lighthouse”
The sea season seems to be over, but the ideas remain. And I suggest you save tin cans in order to build a guiding lighthouse for the new season. The photo shows a small structure made from coffee cans for the home, but you can build a similar one from larger cans for the garden.
Craft on a “marine” theme. And, of course, we use everything unnecessary. This craft can be simply a decorative element at home or in the garden. Or maybe a toy for children. But if you wish, you can turn it into a lamp: only carefully, with the participation of an electrician and using a special “non-heating” light bulb. Well, or use an LED candle.
"Lighthouse" with your own hands.
WE WILL NEED:
1. Acrylic paints + varnish. 2. “Liquid nails” for joining cans. 3. Brushes. 4. Wire from "Champagne" - for handrails.
PROGRESS:
1-2. Clean the jars with sandpaper. We customize the design: cut holes where necessary. 3. We mold the missing parts - the roof, lifebuoys, stones - from paper dough (papier-mâché). Let's dry it. 4. We paint. 5.Assemble and decorate. Don't forget about varnish, and for use in the garden - yacht varnish.
Note: the “weather vane” can be cut from a tin can.
FOR THOSE WHO LIKE SIMPLE:
But, in general, you can get by with just tin cans: connect them using liquid nails or glue. All “decor” (stones, windows, etc.) should be drawn or pasted on (decoupage). And instead of the roof, insert a suitable (!) solar-powered garden lantern.
Source
An idea for decorating a country house by the sea. We create a lighthouse with our own hands: beautiful, labor-intensive, reliable
In this article, I propose to get acquainted with a simple idea for decorating a local area or garden, which will help you create a budget-friendly but attractive composition for you. Why a lighthouse? Near the sea. The sound of waves, the first sunny days, sea pebbles, their smooth, pleasant texture and variety of shapes inspire you to create a bright and unusual decorative item in a marine style!
Sea pebbles can be used to decorate flower beds, garden paths, create an alpine slide, a pond on your property, or create a fence. And we got creative and created a lighthouse!
I will be happy to share detailed instructions with the readers of this wonderful site, demonstrating every detail of creation.
We buy a plastic sewer pipe 2 m long and 160 mm in diameter.
Cut 0.5 m from the pipe (a pipe 1.5 m long is required).
In a good mood, we collect 3 kg of white and gray sea pebbles on the shore.
We attach the pebbles and wooden windows to the pipe using Sika adhesive sealant.
We prepare solutions of white and gray cement.
Using a syringe with a cement mixture, we fill the gaps between the stones.
