diff --git a/Arduino/ArduinoISP_ProMicro/ArduinoISP_ProMicro.ino b/Arduino/ArduinoISP_ProMicro/ArduinoISP_ProMicro.ino new file mode 100644 index 0000000..822990b --- /dev/null +++ b/Arduino/ArduinoISP_ProMicro/ArduinoISP_ProMicro.ino @@ -0,0 +1,734 @@ +// ArduinoISP +// Copyright (c) 2008-2011 Randall Bohn +// If you require a license, see +// https://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 16 + #define PIN_MISO 14 + #define PIN_SCK 15 + + #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 + +#if !defined(ARDUINO_API_VERSION) || ARDUINO_API_VERSION != 10001 // A SPISettings class is declared by ArduinoCore-API 1.0.1 +class SPISettings { + public: + // clock is in Hz + SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode) : clockFreq(clock) { + (void) bitOrder; + (void) dataMode; + }; + + uint32_t getClockFreq() const { + return clockFreq; + } + + private: + uint32_t clockFreq; +}; +#endif // !defined(ARDUINO_API_VERSION) + +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.getClockFreq() - 1) / settings.getClockFreq(); + 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 ISPError = 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 (ISPError) { + digitalWrite(LED_ERR, HIGH); + } else { + digitalWrite(LED_ERR, LOW); + } + + // light the heartbeat LED + heartbeat(); + if (SERIAL.available()) { + avrisp(); + } +} + +uint8_t getch() { + while (!SERIAL.available()); + return SERIAL.read(); +} +void fill(int n) { + for (int x = 0; x < n; x++) { + buff[x] = getch(); + } +} + +#define PTIME 30 +void pulse(int pin, int times) { + do { + digitalWrite(pin, HIGH); + delay(PTIME); + digitalWrite(pin, LOW); + delay(PTIME); + } while (times--); +} + +void prog_lamp(int state) { + if (PROG_FLICKER) { + digitalWrite(LED_PMODE, state); + } +} + +uint8_t spi_transaction(uint8_t a, uint8_t b, uint8_t c, uint8_t d) { + SPI.transfer(a); + SPI.transfer(b); + SPI.transfer(c); + return SPI.transfer(d); +} + +void empty_reply() { + if (CRC_EOP == getch()) { + SERIAL.print((char)STK_INSYNC); + SERIAL.print((char)STK_OK); + } else { + ISPError++; + 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 { + ISPError++; + SERIAL.print((char)STK_NOSYNC); + } +} + +void get_version(uint8_t c) { + switch (c) { + case 0x80: + breply(HWVER); + break; + case 0x81: + breply(SWMAJ); + break; + case 0x82: + breply(SWMIN); + break; + case 0x93: + breply('S'); // serial programmer + break; + default: + breply(0); + } +} + +void set_parameters() { + // call this after reading parameter packet into buff[] + param.devicecode = buff[0]; + param.revision = buff[1]; + param.progtype = buff[2]; + param.parmode = buff[3]; + param.polling = buff[4]; + param.selftimed = buff[5]; + param.lockbytes = buff[6]; + param.fusebytes = buff[7]; + param.flashpoll = buff[8]; + // ignore buff[9] (= buff[8]) + // following are 16 bits (big endian) + param.eeprompoll = beget16(&buff[10]); + param.pagesize = beget16(&buff[12]); + param.eepromsize = beget16(&buff[14]); + + // 32 bits flashsize (big endian) + param.flashsize = buff[16] * 0x01000000 + + buff[17] * 0x00010000 + + buff[18] * 0x00000100 + + buff[19]; + + // AVR devices have active low reset, AT89Sx are active high + rst_active_high = (param.devicecode >= 0xe0); +} + +void start_pmode() { + + // Reset target before driving PIN_SCK or PIN_MOSI + + // SPI.begin() will configure SS as output, so SPI master mode is selected. + // We have defined RESET as pin 10, which for many Arduinos is not the SS pin. + // So we have to configure RESET as output here, + // (reset_target() first sets the correct level) + reset_target(true); + pinMode(RESET, OUTPUT); + SPI.begin(); + SPI.beginTransaction(SPISettings(SPI_CLOCK, MSBFIRST, SPI_MODE0)); + + // See AVR datasheets, chapter "SERIAL_PRG Programming Algorithm": + + // Pulse RESET after PIN_SCK is low: + digitalWrite(PIN_SCK, LOW); + delay(20); // discharge PIN_SCK, value arbitrarily chosen + reset_target(false); + // Pulse must be minimum 2 target CPU clock cycles so 100 usec is ok for CPU + // speeds above 20 KHz + delayMicroseconds(100); + reset_target(true); + + // Send the enable programming command: + delay(50); // datasheet: must be > 20 msec + spi_transaction(0xAC, 0x53, 0x00, 0x00); + pmode = 1; +} + +void end_pmode() { + SPI.end(); + // We're about to take the target out of reset so configure SPI pins as input + pinMode(PIN_MOSI, INPUT); + pinMode(PIN_SCK, INPUT); + reset_target(false); + pinMode(RESET, INPUT); + pmode = 0; +} + +void universal() { + uint8_t ch; + + fill(4); + ch = spi_transaction(buff[0], buff[1], buff[2], buff[3]); + breply(ch); +} + +void flash(uint8_t hilo, unsigned int addr, uint8_t data) { + spi_transaction(0x40 + 8 * hilo, + addr >> 8 & 0xFF, + addr & 0xFF, + data); +} +void commit(unsigned int addr) { + if (PROG_FLICKER) { + prog_lamp(LOW); + } + spi_transaction(0x4C, (addr >> 8) & 0xFF, addr & 0xFF, 0); + if (PROG_FLICKER) { + delay(PTIME); + prog_lamp(HIGH); + } +} + +unsigned int current_page() { + if (param.pagesize == 32) { + return here & 0xFFFFFFF0; + } + if (param.pagesize == 64) { + return here & 0xFFFFFFE0; + } + if (param.pagesize == 128) { + return here & 0xFFFFFFC0; + } + if (param.pagesize == 256) { + return here & 0xFFFFFF80; + } + return here; +} + + +void write_flash(int length) { + fill(length); + if (CRC_EOP == getch()) { + SERIAL.print((char) STK_INSYNC); + SERIAL.print((char) write_flash_pages(length)); + } else { + ISPError++; + 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) { + ISPError++; + 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 { + ISPError++; + 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()) { + ISPError++; + 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()) { + ISPError++; + 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 + ISPError = 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 { + ISPError++; + 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 + ISPError = 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: + ISPError++; + SERIAL.print((char) STK_NOSYNC); + break; + + // anything else we will return STK_UNKNOWN + default: + ISPError++; + if (CRC_EOP == getch()) { + SERIAL.print((char)STK_UNKNOWN); + } else { + SERIAL.print((char)STK_NOSYNC); + } + } +} diff --git a/Kicad/PCB_AndroidAuto-backups/PCB_AndroidAuto-2026-04-06_182629.zip b/Kicad/PCB_AndroidAuto-backups/PCB_AndroidAuto-2026-04-06_182629.zip new file mode 100644 index 0000000..de8bb31 Binary files /dev/null and b/Kicad/PCB_AndroidAuto-backups/PCB_AndroidAuto-2026-04-06_182629.zip differ diff --git a/Kicad/PCB_AndroidAuto-backups/PCB_AndroidAuto-2026-04-19_230231.zip b/Kicad/PCB_AndroidAuto-backups/PCB_AndroidAuto-2026-04-19_230231.zip new file mode 100644 index 0000000..70b74a8 Binary files /dev/null and b/Kicad/PCB_AndroidAuto-backups/PCB_AndroidAuto-2026-04-19_230231.zip differ diff --git a/Kicad/PCB_AndroidAuto.kicad_pro b/Kicad/PCB_AndroidAuto.kicad_pro index 5453e54..461d08a 100644 --- a/Kicad/PCB_AndroidAuto.kicad_pro +++ b/Kicad/PCB_AndroidAuto.kicad_pro @@ -1,15 +1,21 @@ { "board": { + "3dviewports": [], "design_settings": { "defaults": { - "board_outline_line_width": 0.09999999999999999, - "copper_line_width": 0.19999999999999998, + "apply_defaults_to_fp_barcodes": false, + "apply_defaults_to_fp_dimensions": false, + "apply_defaults_to_fp_fields": false, + "apply_defaults_to_fp_shapes": false, + "apply_defaults_to_fp_text": false, + "board_outline_line_width": 0.1, + "copper_line_width": 0.2, "copper_text_italic": false, "copper_text_size_h": 1.5, "copper_text_size_v": 1.5, "copper_text_thickness": 0.3, "copper_text_upright": false, - "courtyard_line_width": 0.049999999999999996, + "courtyard_line_width": 0.05, "dimension_precision": 4, "dimension_units": 3, "dimensions": { @@ -20,7 +26,7 @@ "text_position": 0, "units_format": 1 }, - "fab_line_width": 0.09999999999999999, + "fab_line_width": 0.1, "fab_text_italic": false, "fab_text_size_h": 1.0, "fab_text_size_v": 1.0, @@ -45,7 +51,7 @@ "silk_text_upright": false, "zones": { "45_degree_only": false, - "min_clearance": 0.19999999999999998 + "min_clearance": 0.2 } }, "diff_pair_dimensions": [ @@ -62,35 +68,63 @@ "rule_severities": { "annular_width": "error", "clearance": "error", + "connection_width": "warning", "copper_edge_clearance": "error", + "copper_sliver": "warning", "courtyards_overlap": "error", + "creepage": "error", "diff_pair_gap_out_of_range": "error", "diff_pair_uncoupled_length_too_long": "error", "drill_out_of_range": "error", "duplicate_footprints": "warning", "extra_footprint": "warning", + "footprint": "error", + "footprint_filters_mismatch": "ignore", + "footprint_symbol_field_mismatch": "warning", + "footprint_symbol_mismatch": "warning", + "footprint_type_mismatch": "ignore", "hole_clearance": "error", "hole_near_hole": "error", + "hole_to_hole": "error", + "holes_co_located": "warning", "invalid_outline": "error", + "isolated_copper": "warning", "item_on_disabled_layer": "error", "items_not_allowed": "error", "length_out_of_range": "error", + "lib_footprint_issues": "warning", + "lib_footprint_mismatch": "warning", "malformed_courtyard": "error", "microvia_drill_out_of_range": "error", + "mirrored_text_on_front_layer": "warning", "missing_courtyard": "ignore", "missing_footprint": "warning", + "missing_tuning_profile": "warning", "net_conflict": "warning", + "nonmirrored_text_on_back_layer": "warning", "npth_inside_courtyard": "ignore", "padstack": "error", "pth_inside_courtyard": "ignore", "shorting_items": "error", + "silk_edge_clearance": "warning", "silk_over_copper": "error", "silk_overlap": "error", "skew_out_of_range": "error", + "solder_mask_bridge": "error", + "starved_thermal": "error", + "text_height": "warning", + "text_on_edge_cuts": "error", + "text_thickness": "warning", + "through_hole_pad_without_hole": "error", "too_many_vias": "error", + "track_angle": "error", "track_dangling": "warning", + "track_not_centered_on_via": "ignore", + "track_on_post_machined_layer": "error", + "track_segment_length": "error", "track_width": "error", "tracks_crossing": "error", + "tuning_profile_track_geometries": "ignore", "unconnected_items": "error", "unresolved_variable": "error", "via_dangling": "warning", @@ -102,22 +136,99 @@ "allow_microvias": false, "max_error": 0.005, "min_clearance": 0.15, - "min_copper_edge_clearance": 0.049999999999999996, + "min_connection": 0.0, + "min_copper_edge_clearance": 0.05, + "min_groove_width": 0.0, "min_hole_clearance": 0.0, "min_hole_to_hole": 0.25, - "min_microvia_diameter": 0.19999999999999998, - "min_microvia_drill": 0.09999999999999999, + "min_microvia_diameter": 0.2, + "min_microvia_drill": 0.1, + "min_resolved_spokes": 2, "min_silk_clearance": 0.0, - "min_through_hole_diameter": 0.19999999999999998, + "min_text_height": 0.8, + "min_text_thickness": 0.08, + "min_through_hole_diameter": 0.2, "min_track_width": 0.15, - "min_via_annular_width": 0.049999999999999996, - "min_via_diameter": 0.19999999999999998 + "min_via_annular_width": 0.05, + "min_via_diameter": 0.2, + "solder_mask_to_copper_clearance": 0.0, + "use_height_for_length_calcs": true }, + "teardrop_options": [ + { + "td_onpthpad": true, + "td_onroundshapesonly": false, + "td_onsmdpad": true, + "td_ontrackend": false, + "td_onvia": true + } + ], + "teardrop_parameters": [ + { + "td_allow_use_two_tracks": true, + "td_curve_segcount": 0, + "td_height_ratio": 1.0, + "td_length_ratio": 0.5, + "td_maxheight": 2.0, + "td_maxlen": 1.0, + "td_on_pad_in_zone": false, + "td_target_name": "td_round_shape", + "td_width_to_size_filter_ratio": 0.9 + }, + { + "td_allow_use_two_tracks": true, + "td_curve_segcount": 0, + "td_height_ratio": 1.0, + "td_length_ratio": 0.5, + "td_maxheight": 2.0, + "td_maxlen": 1.0, + "td_on_pad_in_zone": false, + "td_target_name": "td_rect_shape", + "td_width_to_size_filter_ratio": 0.9 + }, + { + "td_allow_use_two_tracks": true, + "td_curve_segcount": 0, + "td_height_ratio": 1.0, + "td_length_ratio": 0.5, + "td_maxheight": 2.0, + "td_maxlen": 1.0, + "td_on_pad_in_zone": false, + "td_target_name": "td_track_end", + "td_width_to_size_filter_ratio": 0.9 + } + ], "track_widths": [ 0.0, 0.15, 0.2 ], + "tuning_pattern_settings": { + "diff_pair_defaults": { + "corner_radius_percentage": 80, + "corner_style": 1, + "max_amplitude": 1.0, + "min_amplitude": 0.2, + "single_sided": false, + "spacing": 1.0 + }, + "diff_pair_skew_defaults": { + "corner_radius_percentage": 80, + "corner_style": 1, + "max_amplitude": 1.0, + "min_amplitude": 0.2, + "single_sided": false, + "spacing": 0.6 + }, + "single_track_defaults": { + "corner_radius_percentage": 80, + "corner_style": 1, + "max_amplitude": 1.0, + "min_amplitude": 0.2, + "single_sided": false, + "spacing": 0.6 + } + }, "via_dimensions": [ { "diameter": 0.0, @@ -127,9 +238,29 @@ "zones_allow_external_fillets": false, "zones_use_no_outline": true }, - "layer_presets": [] + "ipc2581": { + "bom_rev": "", + "dist": "", + "distpn": "", + "internal_id": "", + "mfg": "", + "mpn": "", + "sch_revision": "" + }, + "layer_pairs": [], + "layer_presets": [], + "viewports": [] }, "boards": [], + "component_class_settings": { + "assignments": [], + "meta": { + "version": 0 + }, + "sheet_component_classes": { + "enabled": false + } + }, "cvpcb": { "equivalence_files": [] }, @@ -310,6 +441,7 @@ ], "rule_severities": { "bus_definition_conflict": "error", + "bus_entry_needed": "error", "bus_label_syntax": "error", "bus_to_bus_conflict": "error", "bus_to_net_conflict": "error", @@ -317,11 +449,24 @@ "different_unit_net": "error", "duplicate_reference": "error", "duplicate_sheet_names": "error", + "endpoint_off_grid": "warning", "extra_units": "error", + "field_name_whitespace": "warning", + "footprint_filter": "ignore", + "footprint_link_issues": "warning", + "four_way_junction": "ignore", "global_label_dangling": "warning", + "ground_pin_not_ground": "warning", "hier_label_mismatch": "error", + "isolated_pin_label": "warning", "label_dangling": "error", + "label_multiple_wires": "warning", "lib_symbol_issues": "warning", + "lib_symbol_mismatch": "warning", + "missing_bidi_pin": "warning", + "missing_input_pin": "warning", + "missing_power_pin": "error", + "missing_unit": "warning", "multiple_net_names": "warning", "net_not_bus_member": "warning", "no_connect_connected": "warning", @@ -330,8 +475,16 @@ "pin_not_driven": "error", "pin_to_pin": "warning", "power_pin_not_driven": "error", + "same_local_global_label": "warning", + "similar_label_and_power": "warning", "similar_labels": "warning", + "similar_power": "warning", + "simulation_model_issue": "ignore", + "single_global_label": "ignore", + "stacked_pin_name": "warning", "unannotated": "error", + "unconnected_wire_endpoint": "warning", + "undefined_netclass": "error", "unit_value_mismatch": "error", "unresolved_variable": "error", "wire_dangling": "error" @@ -343,12 +496,12 @@ }, "meta": { "filename": "PCB_AndroidAuto.kicad_pro", - "version": 1 + "version": 3 }, "net_settings": { "classes": [ { - "bus_width": 12.0, + "bus_width": 12, "clearance": 0.1, "diff_pair_gap": 0.25, "diff_pair_via_gap": 0.25, @@ -358,14 +511,16 @@ "microvia_drill": 0.1, "name": "Default", "pcb_color": "rgba(0, 0, 0, 0.000)", + "priority": 2147483647, "schematic_color": "rgba(0, 0, 0, 0.000)", "track_width": 0.2, + "tuning_profile": "", "via_diameter": 0.6, "via_drill": 0.3, - "wire_width": 6.0 + "wire_width": 6 }, { - "bus_width": 12.0, + "bus_width": 12, "clearance": 0.2, "diff_pair_gap": 0.25, "diff_pair_via_gap": 0.25, @@ -374,18 +529,17 @@ "microvia_diameter": 0.5, "microvia_drill": 0.1, "name": "5V3A", - "nets": [ - "+5V" - ], "pcb_color": "rgba(0, 0, 0, 0.000)", + "priority": 0, "schematic_color": "rgba(0, 0, 0, 0.000)", "track_width": 1.37, + "tuning_profile": "", "via_diameter": 0.6, "via_drill": 0.3, - "wire_width": 6.0 + "wire_width": 6 }, { - "bus_width": 12.0, + "bus_width": 12, "clearance": 0.15, "diff_pair_gap": 0.25, "diff_pair_via_gap": 0.25, @@ -394,18 +548,17 @@ "microvia_diameter": 0.5, "microvia_drill": 0.1, "name": "Power", - "nets": [ - "+3V3" - ], "pcb_color": "rgba(0, 0, 0, 0.000)", + "priority": 1, "schematic_color": "rgba(0, 0, 0, 0.000)", "track_width": 0.5, + "tuning_profile": "", "via_diameter": 0.8, "via_drill": 0.4, - "wire_width": 6.0 + "wire_width": 6 }, { - "bus_width": 12.0, + "bus_width": 12, "clearance": 0.1, "diff_pair_gap": 0.25, "diff_pair_via_gap": 0.25, @@ -414,25 +567,38 @@ "microvia_diameter": 0.5, "microvia_drill": 0.1, "name": "smaller", - "nets": [], "pcb_color": "rgba(0, 0, 0, 0.000)", + "priority": 2, "schematic_color": "rgba(0, 0, 0, 0.000)", "track_width": 0.15, + "tuning_profile": "", "via_diameter": 0.5, "via_drill": 0.4, - "wire_width": 6.0 + "wire_width": 6 } ], "meta": { - "version": 0 + "version": 5 }, - "net_colors": null + "net_colors": null, + "netclass_assignments": null, + "netclass_patterns": [ + { + "netclass": "5V3A", + "pattern": "+5V" + }, + { + "netclass": "Power", + "pattern": "+3V3" + } + ] }, "pcbnew": { "last_paths": { "gencad": "", "idf": "", "netlist": "", + "plot": "", "specctra_dsn": "", "step": "3D/PCB_AndroidAuto.stp", "vrml": "" @@ -440,26 +606,113 @@ "page_layout_descr_file": "" }, "schematic": { + "annotate_start_num": 0, + "annotation": { + "method": 0, + "sort_order": 0 + }, + "bom_export_filename": "${PROJECTNAME}.csv", + "bom_fmt_presets": [], + "bom_fmt_settings": { + "field_delimiter": ",", + "keep_line_breaks": false, + "keep_tabs": false, + "name": "CSV", + "ref_delimiter": ",", + "ref_range_delimiter": "", + "string_delimiter": "\"" + }, + "bom_presets": [], + "bom_settings": { + "exclude_dnp": false, + "fields_ordered": [ + { + "group_by": false, + "label": "Reference", + "name": "Reference", + "show": true + }, + { + "group_by": false, + "label": "Qty", + "name": "${QUANTITY}", + "show": true + }, + { + "group_by": true, + "label": "Value", + "name": "Value", + "show": true + }, + { + "group_by": true, + "label": "DNP", + "name": "${DNP}", + "show": true + }, + { + "group_by": true, + "label": "Exclude from BOM", + "name": "${EXCLUDE_FROM_BOM}", + "show": true + }, + { + "group_by": true, + "label": "Exclude from Board", + "name": "${EXCLUDE_FROM_BOARD}", + "show": true + }, + { + "group_by": true, + "label": "Footprint", + "name": "Footprint", + "show": true + }, + { + "group_by": false, + "label": "Datasheet", + "name": "Datasheet", + "show": true + } + ], + "filter_string": "", + "group_symbols": true, + "include_excluded_from_bom": true, + "name": "Default Editing", + "sort_asc": true, + "sort_field": "Reference" + }, + "bus_aliases": {}, + "connection_grid_size": 50.0, "drawing": { + "dashed_lines_dash_length_ratio": 12.0, + "dashed_lines_gap_length_ratio": 3.0, "default_bus_thickness": 12.0, "default_junction_size": 40.0, "default_line_thickness": 6.0, "default_text_size": 50.0, "default_wire_thickness": 6.0, "field_names": [], + "hop_over_size_choice": 0, "intersheets_ref_own_page": false, "intersheets_ref_prefix": "", "intersheets_ref_short": false, "intersheets_ref_show": false, "intersheets_ref_suffix": "", "junction_size_choice": 3, + "label_size_ratio": 0.3, + "operating_point_overlay_i_precision": 3, + "operating_point_overlay_i_range": "~A", + "operating_point_overlay_v_precision": 3, + "operating_point_overlay_v_range": "~V", + "overbar_offset_ratio": 1.23, "pin_symbol_size": 25.0, "text_offset_ratio": 0.3 }, "legacy_lib_dir": "", "legacy_lib_list": [], "meta": { - "version": 0 + "version": 1 }, "net_format_name": "", "ngspice": { @@ -470,10 +723,20 @@ }, "page_layout_descr_file": "", "plot_directory": "", + "reuse_designators": true, "spice_adjust_passive_values": false, "spice_external_command": "spice \"%I\"", "subpart_first_id": 65, - "subpart_id_separator": 0 + "subpart_id_separator": 0, + "top_level_sheets": [ + { + "filename": "PCB_AndroidAuto.kicad_sch", + "name": "PCB_AndroidAuto", + "uuid": "00000000-0000-0000-0000-000000000000" + } + ], + "used_designators": "", + "variants": [] }, "sheets": [ [ @@ -481,5 +744,11 @@ "" ] ], - "text_variables": {} + "text_variables": {}, + "tuning_profiles": { + "meta": { + "version": 0 + }, + "tuning_profiles_impedance_geometric": [] + } } diff --git a/Photos/system_diagram.png b/Photos/system_diagram.png new file mode 100644 index 0000000..41afc41 Binary files /dev/null and b/Photos/system_diagram.png differ diff --git a/README.md b/README.md index d299bab..a5e0160 100644 --- a/README.md +++ b/README.md @@ -9,3 +9,4 @@ Android-Auto retrofit for Volvo RTI using a Raspberry pi and crankshaft ## Satus: Not working because of the too low resolution of the original screen. + \ No newline at end of file diff --git a/include/README b/include/README new file mode 100644 index 0000000..49819c0 --- /dev/null +++ b/include/README @@ -0,0 +1,37 @@ + +This directory is intended for project header files. + +A header file is a file containing C declarations and macro definitions +to be shared between several project source files. You request the use of a +header file in your project source file (C, C++, etc) located in `src` folder +by including it, with the C preprocessing directive `#include'. + +```src/main.c + +#include "header.h" + +int main (void) +{ + ... +} +``` + +Including a header file produces the same results as copying the header file +into each source file that needs it. Such copying would be time-consuming +and error-prone. With a header file, the related declarations appear +in only one place. If they need to be changed, they can be changed in one +place, and programs that include the header file will automatically use the +new version when next recompiled. The header file eliminates the labor of +finding and changing all the copies as well as the risk that a failure to +find one copy will result in inconsistencies within a program. + +In C, the convention is to give header files names that end with `.h'. + +Read more about using header files in official GCC documentation: + +* Include Syntax +* Include Operation +* Once-Only Headers +* Computed Includes + +https://gcc.gnu.org/onlinedocs/cpp/Header-Files.html diff --git a/lib/README b/lib/README new file mode 100644 index 0000000..9379397 --- /dev/null +++ b/lib/README @@ -0,0 +1,46 @@ + +This directory is intended for project specific (private) libraries. +PlatformIO will compile them to static libraries and link into the executable file. + +The source code of each library should be placed in a separate directory +("lib/your_library_name/[Code]"). + +For example, see the structure of the following example libraries `Foo` and `Bar`: + +|--lib +| | +| |--Bar +| | |--docs +| | |--examples +| | |--src +| | |- Bar.c +| | |- Bar.h +| | |- library.json (optional. for custom build options, etc) https://docs.platformio.org/page/librarymanager/config.html +| | +| |--Foo +| | |- Foo.c +| | |- Foo.h +| | +| |- README --> THIS FILE +| +|- platformio.ini +|--src + |- main.c + +Example contents of `src/main.c` using Foo and Bar: +``` +#include +#include + +int main (void) +{ + ... +} + +``` + +The PlatformIO Library Dependency Finder will find automatically dependent +libraries by scanning project source files. + +More information about PlatformIO Library Dependency Finder +- https://docs.platformio.org/page/librarymanager/ldf.html diff --git a/test/README b/test/README new file mode 100644 index 0000000..9b1e87b --- /dev/null +++ b/test/README @@ -0,0 +1,11 @@ + +This directory is intended for PlatformIO Test Runner and project tests. + +Unit Testing is a software testing method by which individual units of +source code, sets of one or more MCU program modules together with associated +control data, usage procedures, and operating procedures, are tested to +determine whether they are fit for use. Unit testing finds problems early +in the development cycle. + +More information about PlatformIO Unit Testing: +- https://docs.platformio.org/en/latest/advanced/unit-testing/index.html