summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--Makefile_op2
-rw-r--r--Makefile_opgui2
-rw-r--r--common.h3
-rw-r--r--common_functions.c4
-rw-r--r--deviceRW.c2543
-rw-r--r--fileIO.c49
-rw-r--r--fileIO.h8
-rw-r--r--instructions.h4
-rw-r--r--op.c14
-rw-r--r--opgui.c29
-rw-r--r--opgui.glade19
-rw-r--r--progP16.c243
-rw-r--r--progP18.c626
-rw-r--r--readme9
-rw-r--r--strings.c13
-rw-r--r--strings.h5
16 files changed, 2047 insertions, 1526 deletions
diff --git a/Makefile_op b/Makefile_op
index 792653f..90ddb07 100644
--- a/Makefile_op
+++ b/Makefile_op
@@ -1,5 +1,5 @@
# equivalent to #define in c code
-VERSION = 0.12.0
+VERSION = 0.12.4
CC = gcc
CFLAGS = '-DVERSION="$(VERSION)"' -w -Os -s #size
#CFLAGS = -w -O3 -s
diff --git a/Makefile_opgui b/Makefile_opgui
index 3ec07f3..c911202 100644
--- a/Makefile_opgui
+++ b/Makefile_opgui
@@ -1,5 +1,5 @@
# equivalent to #define in c code
-VERSION = 0.12.2
+VERSION = 0.12.4
CC = gcc
PREFIX = /usr/local
diff --git a/common.h b/common.h
index 6dfe998..4ca23e9 100644
--- a/common.h
+++ b/common.h
@@ -121,9 +121,10 @@ extern char LogFileName[512];
extern char loadfile[512],savefile[512];
extern WORD *memCODE_W;
extern int size,sizeW,sizeEE,sizeCONFIG,sizeUSERID;
-extern unsigned char *memCODE,*memEE,memID[64],memCONFIG[48],memUSERID[8];
+extern unsigned char *memCODE,*memEE,memID[512],memCONFIG[48],memUSERID[8];
extern double hvreg;
extern int RWstop;
+extern int useSAFLOCK_flag;
int StartHVReg(double V);
void msDelay(double delay);
diff --git a/common_functions.c b/common_functions.c
index 2c042cb..f8528d8 100644
--- a/common_functions.c
+++ b/common_functions.c
@@ -28,7 +28,7 @@ char loadfile[512]="",savefile[512]="";
char CoffFileName[512]="";
WORD *memCODE_W=0;
int size=0,sizeW=0,sizeEE=0,sizeCONFIG=0,sizeUSERID=0;
-unsigned char *memCODE=0,*memEE=0,memID[64],memCONFIG[48],memUSERID[8];
+unsigned char *memCODE=0,*memEE=0,memID[512],memCONFIG[48],memUSERID[8];
double hvreg=0;
int RWstop=0;
int forceConfig=0;
@@ -215,7 +215,7 @@ int CheckS1()
return i?1:0; //A7=1 when switch pressed (active high)
}
else { //std board
- i=bufferI[j+3]&0x8; //i=E3
+ i=bufferI[j+3]&0x8; //i=E3
return i?0:1; //S1 open -> E3=1 (active low)
}
}
diff --git a/deviceRW.c b/deviceRW.c
index aed1384..5a792a4 100644
--- a/deviceRW.c
+++ b/deviceRW.c
@@ -1,1250 +1,1293 @@
-/*
- * deviceRW.c - Read-write calls for various devices
- * Copyright (C) 2010-2022 Alberto Maccioni
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
- * or see <http://www.gnu.org/licenses/>
- */
-
-//configure for GUI or command-line
-#include "common.h"
-#include "progP12.h"
-#include "progP16.h"
-#include "progP18.h"
-#include "progP24.h"
-#include "progEEPROM.h"
-#include "progAVR.h"
-//#include "progP32.h"
-
-#ifdef __GTK_H__
-#define _GTKGUI
-#endif
-
-#include "deviceRW.h"
-
-char* devices[]={
-"10F200","10F202","10F204","10F206","10F220","10F222",
-"10F320","10F322",
-"12C508","12C508A","12C509","12C509A","12F508","12F509","12F510","12F519",
-"12F609","12F615","12F617","12F629","12F635","12C671","12C672","12CE673","12CE674","12F675","12F683",
-"12F752",
-"12F529T39","12F529T48",
-"12F1501","12F1571","12F1572","12F1612","12F1822","12F1840",
-"16F505","16F506","16F526","16F527","16F54","16F57","16F570","16F59",
-"16F610","16F616","16F627","16F627A","16F628","16F628A","16F630","16F631",
-"16F636","16F639","16F648A","16F676","16F677","16F684","16F685","16F687",
-"16F688","16F689","16F690",
-"16F707","16F716","16F72","16F720","16F721","16F722","16F722A","16F723","16F723A",
-"16F724","16F726","16F727","16F73","16F737","16F74","16F747","16F753","16F76",
-"16F767","16F77","16F777","16F785",
-"16F818","16F819","16C83","16F83","16F83A","16C84","16F84","16F84A","16F87","16F870","16F871","16F872",
-"16F873","16F873A","16F874","16F874A","16F876","16F876A","16F877","16F877A",
-"16F88","16F882","16F883","16F884","16F886","16F887",
-"16F913","16F914","16F916","16F917","16F946",
-"16F1454","16F1455","16F1459",
-"16F1503","16F1507","16F1508","16F1509","16F1512","16F1513","16F1516","16F1517","16F1518","16F1519",
-"16F1526","16F1527","16LF1554","16LF1559","16F1574","16F1575","16F1578","16F1579",
-"16F1613","16F1614","16F1615","16F1618","16F1619",
-"16F1703","16F1704","16F1705","16F1707","16F1708","16F1709","16F1713","16F1716","16F1717","16F1718","16F1719",
-"16F1764","16F1765","16F1768","16F1769","16F1773","16F1776","16F1777","16F17784","16F1779",
-"16F1782","16F1783","16F1784","16F1786","16F1787","16F1788","16F1789",
-"16F1823","16F1824","16F1825","16F1826","16F1827","16F1828","16F1829","16F1847",
-"16LF1902","16LF1903","16LF1904","16LF1906","16LF1907",
-"16F1933","16F1934","16F1936","16F1937","16F1938","16F1939","16F1946","16F1947",
-"16F15213","16F15214","16F15223""16F15224","16F15225","16F15243","16F15244","16F15245",
-"16F15254","16F15255","16F15256","16F15274","16F15275","16F15276",
-"16F15313","16F15323","16F15324","16F15325","16F15344","16F15345","16F15354","16F15355","16F15356",
-"16F15375","16F15376","16F15385","16F15386",
-"16F17114","16F17115","16F17124","16F17125","16F17126","16F17144","16F17145","16F17146",
-"16F17154","16F17155","16F17156","16F17174","16F17175","16F17176",
-"16F18013","16F18014","16F18015","16F18023","16F18024","16F18025","16F18026","16F18044","16F18045","16F18046",
-"16F18054","16F18055","16F18056","16F18074","16F18075","16F18076",
-"16F18114","16F18115","16F18124","16F18125","16F18126","16F18144","16F18145","16F18146",
-"16F18154","16F18155","16F18156","16F18174","16F18175","16F18176",
-"16F18313","16F18323","16F18324","16F18325","16F18326","16F18344","16F18345","16F18346",
-"16F18424","16F18425","16F18426","16F18444","16F18445","16F18446","16F18455","16F18456",
-"16F18854","16F18855","16F18856","16F18857","16F18875","16F18876","16F18877",
-"16F19155","16F19156","16F19175","16F19176","16F19185","16F19186","16F19195","16F19196","16F19197",
-"18F04Q40","18F04Q41","18F05Q40","18F05Q41","18F06Q40","18F06Q41","18F14Q40","18F14Q41","18F15Q40","18F15Q41","18F16Q40","18F16Q41",
-"18F242","18F248","18F252","18F258","18F442","18F448","18F452","18F458",
-"18F1220","18F1230","18F1320","18F1330","18F13K22","18F13K50","18F14K22","18F14K50",
-"18F2220","18F2221","18F2320","18F23K20","18F23K22","18F2321","18F2331","18F2410",
-"18F24J10","18F24J11","18F2420","18F24K20","18F24K22","18F2423","18F2431","18F2439",
-"18F2450","18F24J50","18F24K50","18F2455","18F2458","18F24Q71","18F2480",
-"18F2510","18F25J10","18F25J11","18F2515","18F2520","18F25K20","18F25K22","18F2523",
-"18F2525","18F2539","18F25K42","18F25Q43","18F2550","18F25J50","18F25K50","18F2553","18F25Q71","18F2580","18F25K80","18F25K83","18F2585",
-"18F2610","18F26J11","18F26J13","18F2620","18F26K20","18F26K22","18F26K42","18F26Q43","18F26J50","18F26K50",
-"18F26J53","18F26Q71","18F2680","18F26K80","18F2682","18F26K83","18F26Q83","18F26Q84","18F2685",
-"18F27J13","18F27K42","18F27Q43","18F27J53","18F27Q83","18F27Q84",
-"18F4220","18F4221","18F4320","18F43K20","18F43K22","18F4321","18F4331",
-"18F4410","18F44J10","18F44J11","18F4420","18F44K20","18F44K22","18F4423","18F4431",
-"18F4439","18F4450","18F44J50","18F4455","18F4458","18F44Q71","18F4480",
-"18F4510","18F45J10","18F45J11","18F4515","18F4520","18F45K20","18F45K22","18F4523",
-"18F4525","18F4539","18F45K42","18F45Q43","18F4550","18F45J50","18F45K50","18F4553","18F45Q71","18F4580","18F45K80","18F4585",
-"18F4610","18F46J11","18F46J13","18F4620","18F46K20","18F46K22","18F46K42","18F46Q43","18F46J50","18F46K50",
-"18F46J53","18F46Q71","18F4680","18F46K80","18F4682","18F46Q83","18F46Q84","18F4685",
-"18F47J13","18F47K42","18F47Q43","18F47J53","18F47Q83","18F47Q84",
-"18F54Q71","18F55K42","18F55Q43","18F55Q71","18F56K42","18F56Q43","18F56Q71","18F56Q83","18F56Q84","18F57K42","18F57Q43","18F57Q83","18F57Q84",
-"18F63J11","18F63J90","18F64J11","18F64J90",
-"18F65J10","18F65J11","18F65J15","18F65J50","18F65J90","18F65K80",
-"18F66J10","18F66J11","18F66J15","18F66J16","18F66J50","18F66J55","18F66J60","18F66J65","18F66J90","18F66J93",
-"18F67J10","18F67J11","18F67J50","18F67J60","18F66K80","18F67J90","18F67J93",
-"18F83J11","18F83J90","18F84J11","18F84J90","18F85J10","18F85J11","18F85J15","18F85J50","18F85J90",
-"18F8520","18F86J10","18F86J11","18F86J15","18F86J16","18F86J50","18F86J55","18F86J60","18F86J65",
-"18F86J72","18F86J90","18F86J93",
-"18F8722","18F87J10","18F87J11","18F87J50","18F87J60","18F87J72","18F87J90","18F87J93",
-"18F96J60","18F96J65","18F97J60",
-"24F04KA200","24F04KA201",
-"24F08KA101","24F08KA102",
-"24F16KA101","24F16KA102",
-"24FJ16GA002","24FJ16GA004",
-"24FJ32GA002","24FJ32GA004","24FJ32GA102","24FJ32GA104",
-"24FJ32GB002","24FJ32GB004",
-"24FJ48GA002","24FJ48GA004",
-"24FJ64GA002","24FJ64GA004","24FJ64GA006","24FJ64GA008","24FJ64GA010",
-"24FJ64GA102","24FJ64GA104","24FJ64GA306","24FJ64GA308","24FJ64GA310",
-"24FJ64GB002","24FJ64GB004","24FJ64GB106","24FJ64GB108","24FJ64GB110",
-"24FJ64GC006","24FJ64GC008","24FJ64GC010",
-"24FJ96GA006","24FJ96GA008","24FJ96GA010",
-"24FJ128GA006","24FJ128GA008","24FJ128GA010","24FJ128GA106","24FJ128GA108","24FJ128GA110",
-"24FJ128GA306","24FJ128GA308","24FJ128GA310",
-"24FJ128GB106","24FJ128GB108","24FJ128GB110","24FJ128GB206","24FJ128GB210",
-"24FJ128GC006","24FJ128GC008","24FJ128GC010",
-"24FJ128DA106","24FJ128DA110","24FJ128DA206","24FJ128DA210",
-"24FJ192GA106","24FJ192GA108","24FJ192GA110",
-"24FJ192GB106","24FJ192GB108","24FJ192GB110",
-"24FJ256GA106","24FJ256GA108","24FJ256GA110",
-"24FJ256GB106","24FJ256GB108","24FJ256GB110",
-"24FJ256GB206","24FJ256GB210",
-"24FJ256DA106","24FJ256DA110","24FJ256DA206","24FJ256DA210",
-"24EP32GP202","24EP32GP203","24EP32GP204",
-"24EP32MC202","24EP32MC203","24EP32MC204",
-"24EP64GP202","24EP64GP203","24EP64GP204","24EP64GP206",
-"24EP64MC202","24EP64MC203","24EP64MC204","24EP64MC206",
-"24EP128GP202","24EP128GP204","24EP128GP206",
-"24EP128MC202","24EP128MC204","24EP128MC206",
-"24EP256GP202","24EP256GP204","24EP256GP206",
-"24EP256MC202","24EP256MC204","24EP256MC206",
-"24EP512GP202","24EP512GP204","24EP512GP206",
-"24EP512MC202","24EP512MC204","24EP512MC206",
-"24HJ12GP201","24HJ12GP202",
-"24HJ16GP304",
-"24HJ32GP202","24HJ32GP204","24HJ32GP302","24HJ32GP304",
-"24HJ64GP202","24HJ64GP204","24HJ64GP206","24HJ64GP210","24HJ64GP502",
-"24HJ64GP504","24HJ64GP506","24HJ64GP510",
-"24HJ128GP202","24HJ128GP204","24HJ128GP206","24HJ128GP210",
-"24HJ128GP306","24HJ128GP310","24HJ128GP502","24HJ128GP504","24HJ128GP506","24HJ128GP510",
-"24HJ256GP206","24HJ256GP210","24HJ256GP610",
-"30F1010","30F2010","30F2011","30F2012","30F2020","30F2023",
-"30F3010","30F3011","30F3012","30F3013","30F3014",
-"30F4011","30F4012","30F4013",
-"30F5011","30F5013","30F5015","30F5016",
-"30F6010","30F6011","30F6012","30F6013","30F6014","30F6015",
-//"32MX270F256",
-"33FJ06GS101","33FJ06GS102","33FJ06GS202",
-"33FJ12GP201","33FJ12GP202","33FJ12MC201","33FJ12MC202",
-"33FJ16GP304","33FJ16GS402","33FJ16GS404","33FJ16GS502","33FJ16GS504","33FJ16MC304",
-"33FJ32GP202","33FJ32GP204","33FJ32GP302","33FJ32GP304",
-"33FJ32GS406","33FJ32GS606","33FJ32GS608","33FJ32GS610",
-"33FJ32MC202","33FJ32MC204","33FJ32MC302","33FJ32MC304",
-"33FJ64GP202","33FJ64GP204","33FJ64GP206","33FJ64GP306","33FJ64GP310",
-"33FJ64GP706","33FJ64GP708","33FJ64GP710","33FJ64GP802","33FJ64GP804",
-"33FJ64GS406","33FJ64GS606","33FJ64GS608","33FJ64GS610",
-"33FJ64MC202","33FJ64MC204","33FJ64MC506","33FJ64MC508","33FJ64MC510",
-"33FJ64MC706","33FJ64MC710","33FJ64MC802","33FJ64MC804",
-"33FJ128GP202","33FJ128GP204","33FJ128GP206","33FJ128GP306","33FJ128GP310","33FJ128GP706",
-"33FJ128GP708","33FJ128GP710","33FJ128GP802","33FJ128GP804",
-"33FJ128MC202","33FJ128MC204","33FJ128MC506","33FJ128MC510","33FJ128MC706","33FJ128MC708",
-"33FJ128MC710","33FJ128MC802","33FJ128MC804",
-"33FJ256GP506","33FJ256GP510","33FJ256GP710",
-"33FJ256MC510","33FJ256MC710",
-"33EP32GP502","33EP32GP503","33EP32GP504",
-"33EP32MC202","33EP32MC203","33EP32MC204","33EP32MC502","33EP32MC503","33EP32MC504",
-"33EP64GP502","33EP64GP503","33EP64GP504","33EP64GP506",
-"33EP64MC202","33EP64MC203","33EP64MC204","33EP64MC206","33EP64MC502","33EP64MC503","33EP64MC504","33EP64MC506",
-"33EP128GP502","33EP128GP504","33EP128GP506",
-"33EP128MC202","33EP128MC204","33EP128MC206","33EP128MC502","33EP128MC504","33EP128MC506",
-"33EP256GP502","33EP256GP504","33EP256GP506",
-"33EP256MC202","33EP256MC204","33EP256MC206","33EP256MC502","33EP256MC504","33EP256MC506",
-"33EP512GP502","33EP512GP504","33EP512GP506",
-"33EP512MC202","33EP512MC204","33EP512MC206","33EP512MC502","33EP512MC504","33EP512MC506",
-"AT90S1200","AT90S2313",
-"AT90S8515","AT90S8535","ATmega48","ATmega8","ATmega88","ATmega8515",
-"ATmega8535","ATmega16","ATmega164","ATmega168","ATmega32","ATmega324",
-"ATmega328","ATmega64","ATmega644","ATmega1284",
-"ATtiny11","ATtiny12","ATtiny13",
-"ATtiny2313","ATtiny24","ATtiny25","ATtiny26","ATtiny261","ATtiny4313","ATtiny44","ATtiny45",
-"ATtiny461","ATtiny48","ATtiny84","ATtiny85","ATtiny88","ATtiny861",
-"2400","2401","2402","2404","2408","2416","2432","2464","24128","24256","24512","241024","241025",
-"25010","25020","25040","25080","25160","25320","25640","25128","25256","25512","251024",
-"95010","95020","95040","95080","95160","95320","95640","95128","95256","95512","95M01","95M02",
-"251005","252005","254005","258005","251605",
-"25X05","25X10","25X20","25X40","25X80","25X16","25X32","25X64","25X128","25Q40",
-"93S46","93x46","93x46A","93S56","93x56","93x56A","93S66","93x66", "93x66A","93x76","93x76A","93x86","93x86A",
-"DS2430","DS2431","DS2433","DS28EC20","DS1820",
-"11010","11020","11040","11080","11160"
-};
-
-int Ndevices=sizeof(devices)/sizeof(char*);
-
-struct DEVICES DEVLIST[]={
-//-------------PIC10-16---------------------------------------------------------
- {"10F200,10F204,10F220",
- PIC12,13.0,0,Read12F5xx,{0x100,5},0x40,Write12F5xx,{0x100,0xFF},0}, //256
- {"10F320",
- PIC16,9.0,1,Read16Fxxx,{0x100,0,10,0},0x80,Write12F6xx,{0x100,0,-10},0}, //256, vpp, 3.3V
- {"12C508,12C508A",
- PIC12,13.0,0,Read12F5xx,{0x200,4},0x40,Write12C5xx,{0x200,0},0}, //512
- {"12F508,10F202,10F206,10F222",
- PIC12,13.0,0,Read12F5xx,{0x200,5},0x40,Write12F5xx,{0x200,0x1FF},0}, //512
- {"16F54",
- PIC12,13.0,0,Read12F5xx,{0x200,4},0x40,Write12F5xx,{0x200,-1},0}, //512, no osccal
- {"10F322",
- PIC16,9.0,1,Read16Fxxx,{0x200,0,10,0},0x80,Write12F6xx,{0x200,0,-10},0}, //512, vpp, 3.3V
- {"12C509,12C509A",
- PIC12,13.0,0,Read12F5xx,{0x400,4},0x40,Write12C5xx,{0x400,0},0}, //1K
- {"12F509,12F510,16F505,16F506",
- PIC12,13.0,0,Read12F5xx,{0x400,5},0x40,Write12F5xx,{0x400,0x3FF},0}, //1K
- {"12F519,16F526,16F527",
- PIC12,13.0,0,Read12F5xx,{0x440,8},0x60,Write12F5xx,{0x440,0x3FF},0}, //1K + 64
- {"12F529T39,12F529T48",
- PIC12,13.0,0,Read12F5xx,{0x640,8},0x78,Write12F5xx,{0x640,0x5FF},0}, //1.5K + 64
- {"16F57,16F59",
- PIC12,13.0,0,Read12F5xx,{0x800,4},0x40,Write12F5xx,{0x800,-1},0}, //2K
- {"16F570",
- PIC12,13.0,0,Read12F5xx,{0x840,8},0x70,Write12F5xx,{0x840,0x7FF},0}, //2K + 64
- {"16C83,16F83,16F83A",
- PIC16,13.0,0,Read16Fxxx,{0x200,0x40,8,1},0x10,Write16F8x,{0x200,0x40,-10},0}, //512, 64, vdd
- {"12C671,12CE673",
- PIC16,13.0,0,Read16Fxxx,{0x400,0,0,0},0x100,0,{},0}, //1K, vpp
- {"12F1501",
- PIC16,8.5,1,Read16F1xxx,{0x400,0,11,0},0x100,Write16F1xxx,{0x400,0,0},0}, //1K, vpp, 3.3V
- {"12F1571",
- PIC16,8.5,1,Read16F1xxx,{0x400,0,12,0},0x200,Write16F1xxx,{0x400,0,0},0}, //1K, vpp, 3.3V
- {"12F609,12F615,16F610",
- PIC16,13.0,0,Read16Fxxx,{0x400,0,9,0},0x40,Write12F61x,{0x400,0,0},0}, //1K, vpp, cal1
- {"12F752",
- PIC16,13.0,0,Read16Fxxx,{0x400,0,10,0},0x80,Write12F61x,{0x400,0,0},0}, //1K, vpp, cal1
- {"16C84,16F84,16F84A",
- PIC16,13.0,0,Read16Fxxx,{0x400,0x40,8,1},0x10,Write16F8x,{0x400,0x40,-10},0}, //1K, 64, vdd
- {"12F635",
- PIC16,13.0,0,Read16Fxxx,{0x400,0x80,10,0},0x80,Write12F6xx,{0x400,0x80,-10},0}, //1K, 128, vpp, cal1 + cal2
- {"16F631",
- PIC16,13.0,0,Read16Fxxx,{0x400,0x80,9,0},0x80,Write12F6xx,{0x400,0x80,-10},0}, //1K, 128, vpp, cal1
- {"12F629,12F675,16F630,16F676",
- PIC16,13.0,0,Read16Fxxx,{0x400,0x80,8,0},0x20,Write12F62x,{0x400,0x80,-10},0}, //1K, 128, vpp
- {"16F627",
- PIC16,13.0,0,Read16Fxxx,{0x400,-0x80,8,0},0x10,Write16F62x,{0x400,0x80,-10},0}, //1K, 128, vpp, ee@0x2200
- {"16F627A",
- PIC16,13.0,0,Read16Fxxx,{0x400,0x80,8,0},0x10,Write12F6xx,{0x400,0x80,-10},0}, //1K, 128, vpp
- {"16F818",
- PIC16,13.0,0,Read16Fxxx,{0x400,0x80,8,2},0x10,Write16F81x,{0x400,0x80,-10},0}, //1K, 128, vdd short delay
- {"16F72",
- PIC16,8.5,1,Read16Fxxx,{0x800,0,8,1},0x20,Write16F7x,{0x800,0,-10},0}, //2K, vdd, 3.3V
- {"16F720,16F722,16F722A",
- PIC16,13.0,0,Read16Fxxx,{0x800,0,11,0},0x100,Write16F72x,{0x800,0,0},0}, //2K, vpp, config1-2 + cal1-2, 3.3V
- {"12C672,12CE674",
- PIC16,13.0,0,Read16Fxxx,{0x800,0,0,0},0x100,0,{},0}, //2K, vpp
- {"16F716",
- PIC16,13.0,0,Read16Fxxx,{0x800,0,8,2},8,Write16F71x,{0x800,1,-10},0}, //2K, vdd
- {"16F616,12F617",
- PIC16,13.0,0,Read16Fxxx,{0x800,0,9,0},0x40,Write12F61x,{0x800,0,0},0}, //2K, vpp, cal1
- {"16F753",
- PIC16,12.5,0,Read16Fxxx,{0x800,0,10,0},0x80,Write12F61x,{0x800,0,0},0}, //2K, vpp, cal1
- {"16LF1902,16F1503,16F1507,16F1512",
- PIC16,8.5,1,Read16F1xxx,{0x800,0,11,0},0x200,Write16F1xxx,{0x800,0,0},0}, //2K, vpp, 3.3V
- {"12F1572",
- PIC16,8.5,1,Read16F1xxx,{0x800,0,12,0},0x200,Write16F1xxx,{0x800,0,0},0}, //2K, vpp, 3.3V
- {"16F1703,16F1707",
- PIC16,8.5,1,Read16F1xxx,{0x800,0,13,0},0x200,Write16F1xxx,{0x800,0,0},0}, //2K, vpp, 3.3V
- {"12F1612,16F1613",
- PIC16,8.5,1,Read16F1xxx,{0x800,0,13,4},0x200,Write16F1xxx,{0x800,0,4},0}, //2K, vpp, 3.3V
- {"16F15213,16F15223,16F15243,16F15313,16F15323",
- PIC16,8.5,1,Read16F18xxx,{0x800,0,0,0},0,Write16F18xxx,{0x800,0,0},0}, //2K, vpp, 3.3V, 8b commands
- {"16F870,16F871,16F872",
- PIC16,13.0,0,Read16Fxxx,{0x800,0x40,8,1},0x100,Write16F87x,{0x800,0x40,-10},0}, //2K, 64, vdd
- {"16F628",
- PIC16,13.0,0,Read16Fxxx,{0x800,-0x80,8,0},0x10,Write16F62x,{0x800,0x80,-10},0}, //2K, 128, vpp, ee@0x2200
- {"16F628A",
- PIC16,13.0,0,Read16Fxxx,{0x800,0x80,8,0},0x10,Write12F6xx,{0x800,0x80,-10},0}, //2K, 128, vpp
- {"16F882",
- PIC16,13.0,0,Read16Fxxx,{0x800,0x80,10,0},0x80,Write16F88x,{0x800,0x80,-10},0}, //2K, 128, vpp, config2 + cal1
- {"16F819",
- PIC16,13.0,0,Read16Fxxx,{0x800,0x100,8,2},0x10,Write16F81x,{0x800,0x100,-10},0}, //2K, 256, vdd short delay
- {"12F683,16F684",
- PIC16,13.0,0,Read16Fxxx,{0x800,0x100,9,0},0x40,Write12F6xx,{0x800,0x100,-10},0}, //2K, 256, vpp, cal1
- {"16F636,16F639,16F785",
- PIC16,13.0,0,Read16Fxxx,{0x800,0x100,10,0},0x40,Write12F6xx,{0x800,0x100,-10},0}, //2K, 256, vpp, cal1 + cal2
- {"16F677,16F687",
- PIC16,13.0,0,Read16Fxxx,{0x800,0x100,9,0},0x80,Write12F6xx,{0x800,0x100,-10},0}, //2K, 256, vpp, cal1
- {"12F1822,16F1823,16F1826",
- PIC16,8.5,1,Read16F1xxx,{0x800,0x100,11,0},0x200,Write16F1xxx,{0x800,0x100,0},0}, //2K, 256, vpp, 3.3V
- {"16F1782",
- PIC16,8.5,1,Read16F1xxx,{0x800,0x100,19,0},0x200,Write16F1xxx,{0x800,0x100,0},0}, //2K, 256, vpp, 3.3V
- {"16F18313,16F18323",
- PIC16,8.5,1,Read16F1xxx,{0x800,0x100,11,0x1C},0x20,Write16F1xxx,{0x800,0x100,0x1C},0}, //2K, 256, vpp, 3.3V, new cmd
- {"16F18013,16F18023",
- PIC16,8.5,1,Read16F18xxx,{0x800,1,0,0},0,Write16F18xxx,{0x800,0x100,0},0}, //2K, 256, vpp, 3.3V, 8b commands
- {"16F73,16F74",
- PIC16,13.0,0,Read16Fxxx,{0x1000,0,8,1},0x20,Write16F7x,{0x1000,0,-10},0}, //4K, vdd
- {"16F737,16F747",
- PIC16,13.0,0,Read16Fxxx,{0x1000,0,9,2},9,Write16F7x,{0x1000,1,-10},0}, //4K, vdd short/no delay
- {"16F721,16F723,16F723A,16F724",
- PIC16,13.0,0,Read16Fxxx,{0x1000,0,11,0},0x100,Write16F72x,{0x1000,0,0},0}, //4K, vpp, config1-2 + cal1-2, 3.3V
- {"16LF1903,16LF1904,16F1508,16F1513,16LF1554",
- PIC16,8.5,1,Read16F1xxx,{0x1000,0,11,0},0x200,Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
- {"16F1574,16F1578",
- PIC16,8.5,1,Read16F1xxx,{0x1000,0,12,0},0x200,Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
- {"16F1704,16F1708",
- PIC16,8.5,1,Read16F1xxx,{0x1000,0,13,0},0x200,Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
- {"16F1614,16F1618",
- PIC16,8.5,1,Read16F1xxx,{0x1000,0,13,4},0x200,Write16F1xxx,{0x1000,0,4},0}, //4K, vpp, 3.3V
- {"16F1713",
- PIC16,8.5,1,Read16F1xxx,{0x1000,0,17,0},0x200,Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
- {"16F1783,16F1784",
- PIC16,8.5,1,Read16F1xxx,{0x1000,0,19,0},0x200,Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
- {"16F1764,16F1768",
- PIC16,8.5,1,Read16F1xxx,{0x1000,0,20,0},0x200,Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
- {"16F1773",
- PIC16,8.5,1,Read16F1xxx,{0x1000,0,24,0},0x200,Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
- {"16F15214,16F15224,16F15244,16F15254,16F15274,16F15324,16F15344,16F15354",
- PIC16,8.5,1,Read16F18xxx,{0x1000,0,0,0},0,Write16F18xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V, 8b commands
- {"16F873A,16F874A",
- PIC16,13.0,0,Read16Fxxx,{0x1000,0x80,8,1},0x100,Write16F87xA,{0x1000,0x80,1},0}, //4K, 128, vdd
- {"16F873,16F874",
- PIC16,13.0,0,Read16Fxxx,{0x1000,-0x80,8,1},0x100,Write16F87x,{0x1000,-0x80,-10},0}, //4K, 128, vdd, ee@0x2200
- {"16F685,16F689,16F690",
- PIC16,13.0,0,Read16Fxxx,{0x1000,0x100,9,0},0x80,Write12F6xx,{0x1000,0x100,-10},0}, //4K, 256, vpp, cal1
- {"16F688",
- PIC16,13.0,0,Read16Fxxx,{0x1000,0x100,9,0},0x40,Write12F6xx,{0x1000,0x100,-10},0}, //4K, 256, vpp, cal1
- {"16F883,16F884",
- PIC16,13.0,0,Read16Fxxx,{0x1000,0x100,10,0},0x80,Write16F88x,{0x1000,0x100,-10},0}, //4K, 256, vpp, config2 + cal1
- {"16F648A",
- PIC16,13.0,0,Read16Fxxx,{0x1000,0x100,8,0},0x10,Write12F6xx,{0x1000,0x100,-10},0}, //4K, 256, vpp
- {"16F87,16F88",
- PIC16,13.0,0,Read16Fxxx,{0x1000,0x100,9,2},0x10,Write16F81x,{0x1000,0x100,-10},0}, //4K, 256, vdd short delay
- {"16F913,16F914",
- PIC16,13.0,0,Read16Fxxx,{0x1000,0x100,10,0},0x40,Write12F6xx,{0x1000,0x100,-10},0}, //4K, 256, vpp, cal1 + cal2
- {"16F1933,16F1934,16F1824,16F1827,16F1828,12F1840",
- PIC16,8.5,1,Read16F1xxx,{0x1000,0x100,11,0},0x200,Write16F1xxx,{0x1000,0x100,0},0}, //4K, 256, vpp, 3.3V
- {"16F18324,16F18344",
- PIC16,8.5,1,Read16F1xxx,{0x1000,0x100,11,0x1C},0x20,Write16F1xxx,{0x1000,0x100,0x1C},0}, //4K, 256, vpp, 3.3V, new cmd
- {"16F17114,16F17124,16F17144,16F17154,16F17174,16F18014,16F18024,16F18044,16F18054,16F18074,16F18114,16F18124,16F18144,\
- 16F18154,16F18174,16F18424,16F18444",
- PIC16,8.5,1,Read16F18xxx,{0x1000,1,0,0},0,Write16F18xxx,{0x1000,0x100,0},0}, //4K, 256, vpp, 3.3V, 8b commands
- {"16F18854",
- PIC16,8.5,1,Read16F18xxx,{0x1000,0x100,0,0x10},0,Write16F18xxx,{0x1000,0x100,0x10},0}, //4K, 256, vpp, 3.3V, 8b commands no DIA
- {"16F76,16F77",
- PIC16,13.0,0,Read16Fxxx,{0x2000,0,8,1},0x20,Write16F7x,{0x2000,0,-10},0}, //8K, vdd
- {"16F767,16F777",
- PIC16,13.0,0,Read16Fxxx,{0x2000,0,9,2},0x40,Write16F7x,{0x2000,1,-10},0}, //8K, vdd short delay
- {"16F726,16F727,16F707",
- PIC16,8.5,1,Read16Fxxx,{0x2000,0,11,0},0x100,Write16F72x,{0x2000,0,0},0}, //8K, vpp, config1-2 + cal1-2, 3.3V
- {"16LF1906,16LF1907,16F1509,16F1454,16F1455,16F1459,16F1516,16F1517,16F1526,16LF1559",
- PIC16,8.5,1,Read16F1xxx,{0x2000,0,11,0},0x200,Write16F1xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V
- {"16F1575,16F1579",
- PIC16,8.5,1,Read16F1xxx,{0x2000,0,12,0},0x200,Write16F1xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V
- {"16F1705,16F1709",
- PIC16,8.5,1,Read16F1xxx,{0x2000,0,13,0},0x200,Write16F1xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V
- {"16F1615,16F1619",
- PIC16,8.5,1,Read16F1xxx,{0x2000,0,13,4},0x200,Write16F1xxx,{0x2000,0,4},0}, //8K, vpp, 3.3V
- {"16F1716,16F1717",
- PIC16,8.5,1,Read16F1xxx,{0x2000,0,17,0},0x200,Write16F1xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V
- {"16F1765,16F1769",
- PIC16,8.5,1,Read16F1xxx,{0x2000,0,20,0},0x200,Write16F1xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V
- {"16F1776,16F1777",
- PIC16,8.5,1,Read16F1xxx,{0x2000,0,24,0},0x200,Write16F1xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V
- {"16F15225,16F15245,16F15255,16F15275,16F15325,16F15345,16F15355,16F15375,16F15385",
- PIC16,8.5,1,Read16F18xxx,{0x2000,0,0,0},0,Write16F18xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V, 8b commands
- {"16F876A,16F877A",
- PIC16,13.0,0,Read16Fxxx,{0x2000,0x100,8,1},0x100,Write16F87xA,{0x2000,0x100,1},0}, //8K, 256, vdd
- {"16F876,16F877",
- PIC16,13.0,0,Read16Fxxx,{0x2000,-0x100,8,1},0x100,Write16F87x,{0x2000,-0x100,-10},0}, //8K, 256, vdd, ee@0x2200
- {"16F886,16F887",
- PIC16,11.0,0,Read16Fxxx,{0x2000,0x100,10,0},0x80,Write16F88x,{0x2000,0x100,-10},0}, //8K, 256, vpp, config2 + cal1
- {"16F916,16F917,16F946",
- PIC16,13.0,0,Read16Fxxx,{0x2000,0x100,10,0},0x40,Write12F6xx,{0x2000,0x100,-10},0}, //8K, 256, vpp, cal1 + cal2
- {"16F1936,16F1937,16F1946,16F1825,16F1829,16F1847",
- PIC16,8.5,1,Read16F1xxx,{0x2000,0x100,11,0},0x200,Write16F1xxx,{0x2000,0x100,0},0}, //8K, 256, vpp, 3.3V
- {"16F1786,16F1787",
- PIC16,8.5,1,Read16F1xxx,{0x2000,0x100,19,0},0x200,Write16F1xxx,{0x2000,0x100,0},0}, //8K, 256, vpp, 3.3V
- {"16F18325,16F18345",
- PIC16,8.5,1,Read16F1xxx,{0x2000,0x100,11,0x1C},0x20,Write16F1xxx,{0x2000,0x100,0x1C},0}, //8K, 256, vpp, 3.3V, new cmd
- {"16F17115,16F17125,16F17145,16F17155,16F17175,16F18015,16F18025,16F18045,16F18055,16F18075,16F18115,16F18125,16F18145,16F18155,16F18175,\
- 16F18425,16F18445,16F18455,16F19155,16F19175,16F19185,16F19195",
- PIC16,8.5,1,Read16F18xxx,{0x2000,1,0,0},0,Write16F18xxx,{0x2000,0x100,0},0}, //8K, 256, vpp, 3.3V, 8b commands
- {"16F18855,16F18875",
- PIC16,8.5,1,Read16F18xxx,{0x2000,0x100,0,0x10},0,Write16F18xxx,{0x2000,0x100,0x10},0}, //8K, 256, vpp, 3.3V, 8b commands no DIA
- {"16F1518,16F1519,16F1527",
- PIC16,8.5,1,Read16F1xxx,{0x4000,0,11,0},0x200,Write16F1xxx,{0x4000,0,0},0}, //16K, vpp, 3.3V
- {"16F1718,16F1719",
- PIC16,8.5,1,Read16F1xxx,{0x4000,0,17,0},0x200,Write16F1xxx,{0x4000,0,0},0}, //16K, vpp, 3.3V
- {"16F1778,16F1779",
- PIC16,8.5,1,Read16F1xxx,{0x4000,0,24,0},0x200,Write16F1xxx,{0x4000,0,0},0}, //16K, vpp, 3.3V
- {"16F15256,16F15276,16F15356,16F15376,16F15386",
- PIC16,8.5,1,Read16F18xxx,{0x4000,0,0,0},0,Write16F18xxx,{0x4000,0,0},0}, //16K, vpp, 3.3V, 8b commands
- {"16F1938,16F1939,16F1947",
- PIC16,8.5,1,Read16F1xxx,{0x4000,0x100,11,0},0x200,Write16F1xxx,{0x4000,0x100,0},0}, //16K, 256, vpp, 3.3V
- {"16F1788,16F1789",
- PIC16,8.5,1,Read16F1xxx,{0x4000,0x100,19,0},0x200,Write16F1xxx,{0x4000,0x100,0},0}, //16K, 256, vpp, 3.3V
- {"16F18326,16F18346",
- PIC16,8.5,1,Read16F1xxx,{0x4000,0x100,11,0x1C},0x20,Write16F1xxx,{0x4000,0x100,0x1C},0}, //16K, 256, vpp, 3.3V, new cmd
- {"16F17126,16F17146,16F17156,16F17176,16F18026,16F18046,16F18056,16F18076,16F18126,16F18146,16F18156,16F18176,\
- 16F18426,16F18446,16F18456,16F19156,16F19176,16F19186,16F19196",
- PIC16,8.5,1,Read16F18xxx,{0x4000,1,0,0},0,Write16F18xxx,{0x4000,0x100,0},0}, //16K, 256, vpp, 3.3V, 8b commands
- {"16F18856,16F18876",
- PIC16,8.5,1,Read16F18xxx,{0x4000,0x100,0,0x10},0,Write16F18xxx,{0x4000,0x100,0x10},0}, //16K, 256, vpp, 3.3V, 8b commands no DIA
- {"16F19197",
- PIC16,8.5,1,Read16F18xxx,{0x8000,1,0,0},0,Write16F18xxx,{0x8000,0x100,0},0}, //32K, 256, vpp, 3.3V, 8b commands
- {"16F18857,16F18877",
- PIC16,8.5,1,Read16F18xxx,{0x8000,0x100,0,0x10},0,Write16F18xxx,{0x8000,0x100,0x10},0}, //32K, 256, vpp, 3.3V, 8b commands no DIA
-//-------------PIC18---------------------------------------------------------
-// Read18Fx options:
-// bit [3:0]
-// 0 = vdd before vpp (12V)
-// 1 = vdd before vpp (9V)
-// 2 = low voltage entry with 32 bit key
-// bit [7:4]
-// 0 = normal control registers address
-// 1 = new control registers address (18FxxK80)
-//
-// Write18Fx options:
-// bit [3:0]
-// 0 = vdd before vpp (12V)
-// 1 = vdd before vpp (9V)
-// 2 = low voltage entry with 32 bit key
-// bit [7:4]
-// 0 = normal eeprom write algoritm
-// 1 = with unlock sequence 55 AA
-// bit [11:8]
-// 0 = 15ms erase delay, 1ms code write time, 5ms EE write, 5ms config write
-// 1 = 550ms erase delay, 1.2ms code write time, no config or EEPROM
-// 2 = 550ms erase delay, 3.4ms code write time, no config or EEPROM
-// 3 = separate block erase with 5ms delay, 1ms code write, 5ms EE write, 5ms config write
-// + new control registers address (18FxxK80)
- {"18F1230",
- PIC18,12,0,Read18Fx,{0x1000,0x80,0},0,Write18Fx,{0x1000,0x80,8,0x0F0F,0x8787,0},0}, //4K, 128, 8
- {"18F2221,18F4221",
- PIC18,12,0,Read18Fx,{0x1000,0x100,0},0,Write18Fx,{0x1000,0x100,8,0x3F3F,0x8F8F,0},0}, //4K, 256, 8
- {"18F1220,18F2220,18F4220",
- PIC18,12,0,Read18Fx,{0x1000,0x100,0},0,Write18Fx,{0x1000,0x100,8,0x10000,0x80,0x10},0}, //4K, 256, 8, EE with unlock
- {"18F63J11,18F63J90,18F83J11,18F83J90",
- PIC18,-1,1,Read18Fx,{0x2000,0,2},0,Write18Fx,{0x2000,0,64,0x0101,0x8080,0x202},0}, //8K, 0, 64, LV
- {"18F1330",
- PIC18,12,0,Read18Fx,{0x2000,0x80,0},0,Write18Fx,{0x2000,0x80,8,0x0F0F,0x8787,0},0}, //8K, 128, 8
- {"18F2321,18F4321",
- PIC18,12,0,Read18Fx,{0x2000,0x100,0},0,Write18Fx,{0x2000,0x100,8,0x3F3F,0x8F8F,0},0}, //8K, 256, 8
- {"18F1320,18F2320,18F4320,18F2331,18F4331",
- PIC18,12,0,Read18Fx,{0x2000,0x100,0},0,Write18Fx,{0x2000,0x100,8,0x10000,0x80,0x10},0}, //8K, 256, 8, EE with unlock
- {"18F13K50,18F13K22",
- PIC18,8.5,1,Read18Fx,{0x2000,0x100,1},0,Write18Fx,{0x2000,0x100,8,0x0F0F,0x8F8F,1},0}, //8K, 256, 8, 9V
- {"18F23K20,18F43K20",
- PIC18,8.5,1,Read18Fx,{0x2000,0x100,1},0,Write18Fx,{0x2000,0x100,16,0x0F0F,0x8F8F,1},0}, //8K, 256, 16, 9V
- {"18F23K22,18F43K22",
- PIC18,8.5,1,Read18Fx,{0x2000,0x100,1},0,Write18Fx,{0x2000,0x100,64,0x0F0F,0x8F8F,1},0}, //8K, 256, 64, 9V
- {"18F2439,18F4439",
- PIC18,12,0,Read18Fx,{0x3000,0x100,0},0,Write18Fx,{0x3000,0x100,8,0x10000,0x80,0x10},0}, //12K, 256, 8, EE with unlock
- {"18F2410,18F4410",
- PIC18,12,0,Read18Fx,{0x4000,0,0},0,Write18Fx,{0x4000,0,32,0x3F3F,0x8F8F,0},0}, //16K, 0, 32
- {"18F24J10,18F44J10,18F64J11,18F64J90,18F84J11,18F84J90",
- PIC18,-1,1,Read18Fx,{0x4000,0,2},0,Write18Fx,{0x4000,0,64,0x0101,0x8080,0x202},0}, //16K, 0, 64, LV
- {"18F24J11,18F24J50,18F44J11,18F44J50",
- PIC18,-1,1,Read18Fx,{0x4000,0,2},0,Write18Fx,{0x4000,0,64,0x0101,0x8080,0x102},0}, //16K, 0, 64, LV
- {"18F2420,18F2423,18F4420,18F4423,18F2480,18F4480",
- PIC18,12,0,Read18Fx,{0x4000,0x100,0},0,Write18Fx,{0x4000,0x100,32,0x3F3F,0x8F8F,0},0}, //16K, 256, 32
- {"18F2431,18F4431,18F242,18F248,18F442,18F448",
- PIC18,12,0,Read18Fx,{0x4000,0x100,0},0,Write18Fx,{0x4000,0x100,8,0x10000,0x80,0x10},0}, //16K, 256, 8, EE with unlock
- {"18F2450,18F4450",
- PIC18,12,0,Read18Fx,{0x4000,0,0},0,Write18Fx,{0x4000,0,16,0x3F3F,0x8F8F,0},0}, //16K, 0, 16
- {"18F14K50,18F14K22",
- PIC18,8.5,1,Read18Fx,{0x4000,0x100,1},0,Write18Fx,{0x4000,0x100,16,0x0F0F,0x8F8F,1},0}, //16K, 256, 16, 9V
- {"18F24K20,18F44K20",
- PIC18,8.5,1,Read18Fx,{0x4000,0x100,1},0,Write18Fx,{0x4000,0x100,32,0x0F0F,0x8F8F,1},0}, //16K, 256, 32, 9V
- {"18F24K22,18F44K22,18F24K50",
- PIC18,8.5,1,Read18Fx,{0x4000,0x100,1},0,Write18Fx,{0x4000,0x100,64,0x0F0F,0x8F8F,1},0}, //16K, 256, 64, 9V
- {"18F04Q40,18F14Q40,18F04Q41,18F14Q41,18F24Q71,18F44Q71,18F54Q71",
- PIC18,8.5,1,Read18FKx,{0x4000,1,0x10},0,Write18FKx,{0x4000,0x200,0x10,0,0,0},0}, //16K, 256, --, LV
- {"18F2455,18F2458,18F4455,18F4458",
- PIC18,12,0,Read18Fx,{0x6000,0x100,0},0,Write18Fx,{0x6000,0x100,32,0x3F3F,0x8F8F,0},0}, //24K, 256, 32
- {"18F2539,18F4539",
- PIC18,12,0,Read18Fx,{0x6000,0x100,0},0,Write18Fx,{0x6000,0x100,8,0x10000,0x80,0x10},0}, //24K, 256, 8, EE with unlock
- {"18F2510,18F4510",
- PIC18,12,0,Read18Fx,{0x8000,0,0},0,Write18Fx,{0x8000,0,32,0x3F3F,0x8F8F,0},0}, //32K, 0, 32
- {"18F25J10,18F45J10,18F65J10,18F65J11,18F65J50,18F65J90,18F85J10,18F85J11,18F85J50,18F85J90",
- PIC18,-1,1,Read18Fx,{0x8000,0,2},0,Write18Fx,{0x8000,0,64,0x0101,0x8080,0x202},0}, //32K, 0, 64, LV
- {"18F25J11,18F25J50,18F45J11,18F45J50",
- PIC18,-1,1,Read18Fx,{0x8000,0,2},0,Write18Fx,{0x8000,0,64,0x0101,0x8080,0x102},0}, //32K, 0, 64, LV
- {"18F252,18F258,18F452,18F458",
- PIC18,12,0,Read18Fx,{0x8000,0x100,0},0,Write18Fx,{0x8000,0x100,8,0x10000,0x80,0x10},0}, //32K, 256, 8, EE with unlock
- {"18F2550,18F2553,18F4550,18F4553,18F2520,18F2523,18F4520,18F4523,18F2580,18F4580",
- PIC18,12,0,Read18Fx,{0x8000,0x100,0},0,Write18Fx,{0x8000,0x100,32,0x3F3F,0x8F8F,0},0}, //32K, 256, 32
- {"18F25K20,18F45K20",
- PIC18,8.5,1,Read18Fx,{0x8000,0x100,1},0,Write18Fx,{0x8000,0x100,32,0x0F0F,0x8F8F,1},0}, //32K, 256, 32, 9V
- {"18F25K22,18F45K22,18F25K50,18F45K50",
- PIC18,8.5,1,Read18Fx,{0x8000,0x100,1},0,Write18Fx,{0x8000,0x100,64,0x0F0F,0x8F8F,1},0}, //32K, 256, 64, 9V
- {"18F25K42,18F45K42,18F55K42",
- PIC18,8.5,1,Read18FKx,{0x8000,1,0},0,Write18FKx,{0x8000,0x100,0,0,0,0},0}, //32K, 256, --, LV
- {"18F05Q40,18F15Q40,18F05Q41,18F15Q41,18F25Q71,18F45Q71,18F55Q71",
- PIC18,8.5,1,Read18FKx,{0x8000,1,0x10},0,Write18FKx,{0x8000,0x200,0x10,0,0,0},0}, //32K, 256, --, LV
- {"18F25K80,18F45K80,18F65K80",
- PIC18,8.5,1,Read18Fx,{0x8000,0x400,0x13},0,Write18Fx,{0x8000,0x400,64,0,0,0x303},0}, //32K, 1K, 64, 9V, xxK80
- {"18F8520",
- PIC18,12,0,Read18Fx,{0x8000,0x400,0},0,Write18Fx,{0x8000,0x400,8,0x10000,0x0080,0x10},0},//32K, 1K, 8, EE with unlock
- {"18F25Q43,18F45Q43,18F55Q43",
- PIC18,8.5,1,Read18FKx,{0x8000,1,0x10},0,Write18FKx,{0x8000,0x400,0x10,0,0,0},0}, //32K, 1k, --, LV
- {"18F25K83",
- PIC18,8.5,1,Read18FKx,{0x8000,1,0},0,Write18FKx,{0x8000,0x400,0,0,0,0},0}, //32K, 1k, --, LV
- {"18F2515,18F4515",
- PIC18,12,0,Read18Fx,{0xC000,0,0},0,Write18Fx,{0xC000,0,64,0x3F3F,0x8F8F,0},0}, //48K, 0, 64
- {"18F65J15,18F85J15",
- PIC18,-1,1,Read18Fx,{0xC000,0,2},0,Write18Fx,{0xC000,0,64,0x0101,0x8080,0x202},0}, //48K, 0, 64, LV
- {"18F2525,18F2585,18F4525,18F4585",
- PIC18,12,0,Read18Fx,{0xC000,0x400,0},0,Write18Fx,{0xC000,0x400,64,0x3F3F,0x8F8F,0},0}, //48K, 1K, 64
- {"18F2610,18F4610",
- PIC18,12,0,Read18Fx,{0x10000,0,0},0,Write18Fx,{0x10000,0,64,0x3F3F,0x8F8F,0},0}, //64K, 0, 64
- {"18F26J11,18F26J13,18F26J50,18F26J53,18F46J11,18F46J13,18F46J50,18F46J53",
- PIC18,-1,1,Read18Fx,{0x10000,0,2},0,Write18Fx,{0x10000,0,64,0x0101,0x8080,0x102},0}, //64K, 0, 64, LV
- {"18F66J60,18F86J60,18F96J60,18F66J10,18F66J11,18F66J50,18F66J90,18F66J93,18F86J10,18F86J11,18F86J50,18F86J72,18F86J90,18F86J93",
- PIC18,-1,1,Read18Fx,{0x10000,0,2},0,Write18Fx,{0x10000,0,64,0x0101,0x8080,0x202},0}, //64K, 0, 64, LV
- {"18F2620,18F2680,18F4620,18F4680",
- PIC18,12,0,Read18Fx,{0x10000,0x400,0},0,Write18Fx,{0x10000,0x400,64,0x3F3F,0x8F8F,0},0},//64K, 1K, 64
- {"18F26K20,18F46K20,18F26K22,18F46K22,18F26K50,18F46K50",
- PIC18,12,0,Read18Fx,{0x10000,0x100,1},0,Write18Fx,{0x10000,0x100,64,0x0F0F,0x8F8F,1},0},//64K, 256, 64, 9V
- {"18F06Q40,18F16Q40,18F06Q41,18F16Q41,18F26Q71,18F46Q71,18F56Q71",
- PIC18,8.5,1,Read18FKx,{0x10000,1,0x10},0,Write18FKx,{0x10000,0x200,0x10,0,0,0},0}, //64K, 256, --, LV
- {"18F26K80,18F46K80,18F66K80",
- PIC18,8.5,1,Read18Fx,{0x10000,0x400,0x13},0,Write18Fx,{0x10000,0x400,64,0,0,0x303},0}, //64K, 1K, 64, 9V, xxK80
- {"18F26Q43,18F46Q43,18F56Q43",
- PIC18,8.5,1,Read18FKx,{0x10000,1,0x10},0,Write18FKx,{0x10000,0x400,0x10,0,0,0},0}, //64K, 1k, --, LV
- {"18F26K42,18F46K42,18F56K42,18F26K83",
- PIC18,8.5,1,Read18FKx,{0x10000,1,0},0,Write18FKx,{0x10000,0x400,0,0,0,0},0}, //64K, 1k, --, LV
- {"18F26Q83,18F26Q84,18F46Q83,18F46Q84,18F56Q83,18F56Q84",
- PIC18,8.5,1,Read18FKx,{0x10000,1,0x20},0,Write18FKx,{0x10000,0x400,0x20,0,0,0},0}, //64K, 1k, --, LV
- {"18F2682,18F4682",
- PIC18,12,0,Read18Fx,{0x14000,0x400,0},0,Write18Fx,{0x14000,0x400,64,0x3F3F,0x8F8F,0},0},//80K, 1K, 64
- {"18F66J65,18F86J65,18F96J65,18F66J15,18F66J16,18F66J55,18F86J15,18F86J16,18F86J55",
- PIC18,-1,1,Read18Fx,{0x18000,0,2},0,Write18Fx,{0x18000,0,64,0x0101,0x8080,0x202},0}, //96K, 0, 64, LV
- {"18F2685,18F4685",
- PIC18,12,0,Read18Fx,{0x18000,0x400,0},0,Write18Fx,{0x18000,0x400,64,0x3F3F,0x8F8F,0},0},//96K, 1K, 64
- {"18F27J13,18F27J53,18F47J13,18F47J53,18F67J10,18F87J10",
- PIC18,-1,1,Read18Fx,{0x20000,0,2},0,Write18Fx,{0x20000,0,64,0x0101,0x8080,0x102},0}, //128K, 0, 64, LV
- {"18F67J60,18F87J60,18F97J60,18F67J11,18F67J50,18F67J90,18F67J93,18F87J11,18F87J50,18F87J72,18F87J90,18F87J93",
- PIC18,-1,1,Read18Fx,{0x20000,0,2},0,Write18Fx,{0x20000,0,64,0x0101,0x8080,0x202},0}, //128K, 0, 64, LV
- {"18F8722",
- PIC18,12,0,Read18Fx,{0x20000,0x400,0},0,Write18Fx,{0x20000,0x400,64,0xFFFF,0x8787,0},0},//128K, 1K, 64
- {"18F27Q43,18F47Q43,18F57Q43",
- PIC18,8.5,1,Read18FKx,{0x20000,1,0x10},0,Write18FKx,{0x20000,0x400,0x10,0,0,0},0}, //128K, 1k, --, LV
- {"18F27K42,18F47K42,18F57K42",
- PIC18,8.5,1,Read18FKx,{0x20000,1,0},0,Write18FKx,{0x20000,0x400,0,0,0,0},0}, //128K, 1k, --, LV
- {"18F27Q83,18F27Q84,18F47Q83,18F47Q84,18F57Q83,18F57Q84",
- PIC18,8.5,1,Read18FKx,{0x20000,1,0x20},0,Write18FKx,{0x20000,0x400,0x20,0,0,0},0}, //128K, 1k, --, LV
-//-------------PIC24---------------------------------------------------------
-// options:
-// bit [3:0]
-// 0 = low voltage ICSP entry
-// 1 = High voltage ICSP entry (6V)
-// 2 = High voltage ICSP entry (12V) + PIC30F sequence (additional NOPs)
-// 3 = low voltage ICSP entry (5V power supply)
-// bit [7:4]
-// 0 = config area in the last 2 program words
-// 1 = config area in the last 3 program words
-// 2 = config area in the last 4 program words
-// 3 = 0xF80000 to 0xF80010 except 02 (24F)
-// 4 = 0xF80000 to 0xF80016 (24H-33F)
-// 5 = 0xF80000 to 0xF8000C (x16 bit, 30F)
-// 6 = 0xF80000 to 0xF8000E (30FSMPS)
-// bit [11:8]
-// 0 = code erase word is 0x4064, row write is 0x4004
-// 1 = code erase word is 0x404F, row write is 0x4001
-// 2 = code erase word is 0x407F, row write is 0x4001, 55AA unlock and external timing (2 ms)
-// 3 = code erase word is 0x407F, row write is 0x4001, 55AA unlock and external timing (200 ms)
-// bit [15:12]
-// 0 = eeprom erase word is 0x4050, write word is 0x4004
-// 1 = eeprom erased with bulk erase, write word is 0x4004
-// 2 = eeprom erased with special sequence, write word is 0x4004
-// bit [19:16]
-// 0 = config write is 0x4000
-// 1 = config write is 0x4003
-// 2 = config write is 0x4004
-// 3 = config write is 0x4008
- {"24F04KA200,24F04KA201",
- PIC24,6,1,Read24Fx,{0xB00,0,0x31,0x05BE},0x800,Write24Fx,{0xB00,0,0x20031,0x05BE,32},2.0}, //1.375KW, HV
- {"24F08KA101,24F08KA102",
- PIC24,6,1,Read24Fx,{0x1600,0x200,0x31,0x05BE},0x800,Write24Fx,{0x1600,0x200,0x20031,0x05BE,32},2.0}, //2.75KW, HV, 512
- {"24F16KA101,24F16KA102",
- PIC24,6,1,Read24Fx,{0x2C00,0x200,0x31,0x05BE},0x800,Write24Fx,{0x2C00,0x200,0x20031,0x05BE,32},2.0}, //5.5KW, HV, 512
- {"24FJ16GA002,24FJ16GA004",
- PIC24,-1,1,Read24Fx,{0x2C00,0,0,0x05BE},0x800,Write24Fx,{0x2C00,0,0x10100,0x05BE,64},2.0}, //5.5KW
- {"24FJ32GA002,24FJ32GA004",
- PIC24,-1,1,Read24Fx,{0x5800,0,0,0x05BE},0x800,Write24Fx,{0x5800,0,0x10100,0x05BE,64},2.0}, //11KW
- {"24FJ32GA102,24FJ32GA104,24FJ32GB002,24FJ32GB004",
- PIC24,-1,1,Read24Fx,{0x5800,0,0x20,0x07F0},0x800,Write24Fx,{0x5800,0,0x10120,0x07F0,64},2.0}, //11KW 4 Config Word
- {"24FJ48GA002,24FJ48GA004",
- PIC24,-1,1,Read24Fx,{0x8400,0,0,0x05BE},0x800,Write24Fx,{0x8400,0,0x10100,0x05BE,64},2.0}, //16.5KW
- {"24FJ64GA002,24FJ64GA004,24FJ64GA006,24FJ64GA008,24FJ64GA010",
- PIC24,-1,1,Read24Fx,{0xAC00,0,0,0x05BE},0x800,Write24Fx,{0xAC00,0,0x10100,0x05BE,64},2.0}, //22KW
- {"24FJ64GA102,24FJ64GA104,24FJ64GB002,24FJ64GB004",
- PIC24,-1,1,Read24Fx,{0xAC00,0,0x20,0x07F0},0x800,Write24Fx,{0xAC00,0,0x10120,0x07F0,64},2.0}, //22KW 4 Config Word
- {"24FJ64GA306,24FJ64GA308,24FJ64GA310,24FJ64GC006,24FJ64GC008,24FJ64GC010",
- PIC24,-1,1,Read24Fx,{0xAC00,0,0x120,0x07F0},0x800,Write24Fx,{0xAC00,0,0x110120,0x07F0,64},2.0}, //22KW 4 Config Word new TABLPAG
- {"24FJ64GB106,24FJ64GB108,24FJ64GB110",
- PIC24,-1,1,Read24Fx,{0xAC00,0,0x10,0x07F0},0x800,Write24Fx,{0xAC00,0,0x10110,0x07F0,64},2.0}, //22KW 3 Config Word
- {"24FJ96GA006,24FJ96GA008,24FJ96GA010",
- PIC24,-1,1,Read24Fx,{0x10000,0,0,0x05BE},0x800,Write24Fx,{0x10000,0,0x10100,0x05BE,64},2.0}, //32KW
- {"24FJ128GA006,24FJ128GA008,24FJ128GA010",
- PIC24,-1,1,Read24Fx,{0x15800,0,0,0x05BE},0x800,Write24Fx,{0x15800,0,0x10100,0x05BE,64},2.0}, //44KW
- {"24FJ128GA106,24FJ128GA108,24FJ128GA110,24FJ128GB106,24FJ128GB108,24FJ128GB110",
- PIC24,-1,1,Read24Fx,{0x15800,0,0x10,0x07F0},0x800,Write24Fx,{0x15800,0,0x10110,0x07F0,64},2.0}, //44KW 3 Config Word
- {"24FJ128GA306,24FJ128GA308,24FJ128GA310,24FJ128GB206,24FJ128GB210,24FJ128GC006,24FJ128GC008,\
-24FJ128GC010,24FJ128DA106,24FJ128DA110,24FJ128DA206,24FJ128DA210",
- PIC24,-1,1,Read24Fx,{0x15800,0,0x120,0x07F0},0x800,Write24Fx,{0x15800,0,0x110120,0x07F0,64},2.0}, //44KW 4 Config Word new TABLPAG
- {"24FJ192GA106,24FJ192GA108,24FJ192GA110,24FJ192GB106,24FJ192GB108,24FJ192GB110",
- PIC24,-1,1,Read24Fx,{0x20C00,0,0x10,0x07F0},0x800,Write24Fx,{0x20C00,0,0x10110,0x07F0,64},2.0}, //68KW 3 Config Word
- {"24FJ256GA106,24FJ256GA108,24FJ256GA110,24FJ256GB106,24FJ256GB108,24FJ256GB110",
- PIC24,-1,1,Read24Fx,{0x2AC00,0,0x10,0x07F0},0x800,Write24Fx,{0x2AC00,0,0x10110,0x07F0,64},2.0}, //88KW 3 Config Word
- {"24FJ256DA106,24FJ256DA110,24FJ256DA206,24FJ256DA210,24FJ256GB206,24FJ256GB210",
- PIC24,-1,1,Read24Fx,{0x2AC00,0,0x120,0x07F0},0x800,Write24Fx,{0x2AC00,0,0x110120,0x07F0,64},2.0}, //88KW 4 Config Word new TABLPAG
- {"33FJ06GS101,33FJ06GS102,33FJ06GS202",
- PIC24,-1,1,Read24Fx,{0x1000,0,0x40,0x07F0},0x800,Write24Fx,{0x1000,0,0x00140,0x07F0,64},2.0}, //2KW
- {"24HJ12GP201,24HJ12GP202,33FJ12GP201,33FJ12GP202,33FJ12MC201,33FJ12MC202",
- PIC24,-1,1,Read24Fx,{0x2000,0,0x40,0x07F0},0x800,Write24Fx,{0x2000,0,0x00140,0x07F0,64},2.0}, //4KW
- {"24HJ16GP304,33FJ16GP304,33FJ16GS402,33FJ16GS404,33FJ16GS502,33FJ16GS504,33FJ16MC304",
- PIC24,-1,1,Read24Fx,{0x2C00,0,0x40,0x07F0},0x800,Write24Fx,{0x2C00,0,0x00140,0x07F0,64},2.0}, //5.5KW
- {"24HJ32GP202,24HJ32GP204,24HJ32GP302,24HJ32GP304,33FJ32GP202,33FJ32GP204,33FJ32GP302,\
-33FJ32GP304,33FJ32GS406,33FJ32GS606,33FJ32GS608,33FJ32GS610,33FJ32MC202,33FJ32MC204,33FJ32MC302,33FJ32MC304",
- PIC24,-1,1,Read24Fx,{0x5800,0,0x40,0x07F0},0x1000,Write24Fx,{0x5800,0,0x00140,0x07F0,64},2.0}, //11KW
- {"24HJ64GP202,24HJ64GP204,24HJ64GP206,24HJ64GP210,24HJ64GP502,24HJ64GP504,24HJ64GP506,24HJ64GP510,\
-33FJ64GP202,33FJ64GP204,33FJ64GP206,33FJ64GP306,33FJ64GP310,33FJ64GP706,33FJ64GP708,33FJ64GP710,33FJ64GP802,\
-33FJ64GP804,33FJ64GS406,33FJ64GS606,33FJ64GS608,33FJ64GS610,33FJ64MC202,33FJ64MC204,33FJ64MC506,33FJ64MC508,33FJ64MC510,\
-33FJ64MC706,33FJ64MC710,33FJ64MC802,33FJ64MC804",
- PIC24,-1,1,Read24Fx,{0xAC00,0,0x40,0x07F0},0x1000,Write24Fx,{0xAC00,0,0x00140,0x07F0,64},2.0}, //22KW
- {"24HJ128GP202,24HJ128GP204,24HJ128GP206,24HJ128GP210,24HJ128GP306,24HJ128GP310,24HJ128GP502,\
-24HJ128GP504,24HJ128GP506,24HJ128GP510,\
-33FJ128GP202,33FJ128GP204,33FJ128GP206,33FJ128GP306,33FJ128GP310,33FJ128GP706,33FJ128GP708,33FJ128GP710,\
-33FJ128GP802,33FJ128GP804,33FJ128MC202,33FJ128MC204,33FJ128MC506,33FJ128MC510,33FJ128MC706,33FJ128MC708,\
-33FJ128MC710,33FJ128MC802,33FJ128MC804",
- PIC24,-1,1,Read24Fx,{0x15800,0,0x40,0x07F0},0x1000,Write24Fx,{0x15800,0,0x00140,0x07F0,64},2.0}, //44KW
- {"24HJ256GP206,24HJ256GP210,24HJ256GP610,\
-33FJ256GP506,33FJ256GP510,33FJ256GP710,33FJ256MC510,33FJ256MC710",
- PIC24,-1,1,Read24Fx,{0x2AC00,0,0x40,0x07F0},0x1000,Write24Fx,{0x2AC00,0,0x00140,0x07F0,64},2.0}, //88KW
- {"24EP32GP202,24EP32GP203,24EP32GP204,33EP32GP502,33EP32GP503,33EP32GP504,\
-24EP32MC202,24EP32MC203,24EP32MC204,33EP32MC202,33EP32MC203,33EP32MC204,33EP32MC502,33EP32MC503,33EP32MC504",
- PIC24,-1,1,Read24Ex,{0x5800,0,0,0x0FF0},0x1000,Write24Ex,{0x5800,0,0,0,0,0},2.0}, //11KW 10 Config Word
- {"24EP64GP202,24EP64GP203,24EP64GP204,24EP64GP206,33EP64GP502,33EP64GP503,33EP64GP504,33EP64GP506,\
-24EP64MC202,24EP64MC203,24EP64MC204,24EP64MC206,33EP64MC202,33EP64MC203,33EP64MC204,33EP64MC206,\
-33EP64MC502,33EP64MC503,33EP64MC504,33EP64MC506",
- PIC24,-1,1,Read24Ex,{0xB000,0,0,0x0FF0},0x1000,Write24Ex,{0xB000,0,0,0,0,0},2.0}, //22.5KW 10 Config Word
- {"24EP128GP202,24EP128GP204,24EP128GP206,33EP128GP502,33EP128GP504,33EP128GP506,\
-24EP128MC202,24EP128MC204,24EP128MC206,33EP128MC202,33EP128MC204,33EP128MC206,\
-33EP128MC502,33EP128MC504,33EP128MC506",
- PIC24,-1,1,Read24Ex,{0x15800,0,0,0x0FF0},0x1000,Write24Ex,{0x15800,0,0,0,0,0},2.0}, //44KW 10 Config Word
- {"24EP256GP202,24EP256GP204,24EP256GP206,33EP256GP502,33EP256GP504,33EP256GP506,\
-24EP256MC202,24EP256MC204,24EP256MC206,33EP256MC202,33EP256MC204,33EP256MC206,\
-33EP256MC502,33EP256MC504,33EP256MC506",
- PIC24,-1,1,Read24Ex,{0x2B000,0,0,0x0FF0},0x1000,Write24Ex,{0x2B000,0,0,0,0,0},2.0}, //88KW 10 Config Word
- {"24EP512GP202,24EP512GP204,24EP512GP206,33EP512GP502,33EP512GP504,33EP512GP506,\
-24EP512MC202,24EP512MC204,24EP512MC206,33EP512MC202,33EP512MC204,33EP512MC206,\
-33EP512MC502,33EP512MC504,33EP512MC506",
- PIC24,-1,1,Read24Ex,{0x56000,0,0,0x0FF0},0x1000,Write24Ex,{0x56000,0,0,0,0,0},2.0}, //175KW 10 Config Word
- {"30F1010",
- PIC24,-1,0,Read24Fx,{0x1000,0,0x63,0x05BE},0x600,Write24Fx,{0x1000,0,0x30263,0x05BE,32},2.0}, //1KW, LV5V
- {"30F2020,30F2023",
- PIC24,-1,0,Read24Fx,{0x2000,0,0x63,0x05BE},0x600,Write24Fx,{0x2000,0,0x30263,0x05BE,32},2.0}, //2KW, LV5V
- {"30F2010",
- PIC24,12,0,Read24Fx,{0x2000,0x400,0x52,0x05BE},0x600,Write24Fx,{0x2000,0x400,0x31252,0x05BE,32},2.0}, //4KW, 1K, HV12
- {"30F2011,30F2012",
- PIC24,12,0,Read24Fx,{0x2000,0,0x52,0x05BE},0x600,Write24Fx,{0x2000,0,0x31252,0x05BE,32},2.0}, //4KW, HV12
- {"30F3010,30F3011,30F3012,30F3013,30F3014",
- PIC24,12,0,Read24Fx,{0x4000,0x400,0x52,0x05BE},0x600,Write24Fx,{0x4000,0x400,0x31252,0x05BE,32},2.0}, //8KW, 1K, HV12
- {"30F4011,30F4012,30F4013",
- PIC24,12,0,Read24Fx,{0x8000,0x400,0x52,0x05BE},0x600,Write24Fx,{0x8000,0x400,0x31252,0x05BE,32},2.0}, //16KW, 1K, HV12
- {"30F5011,30F5013,30F5015,30F5016",
- PIC24,12,0,Read24Fx,{0xB000,0x400,0x52,0x05BE},0x600,Write24Fx,{0xB000,0x400,0x31252,0x05BE,32},2.0}, //22KW, 1K, HV12
- {"30F6011,30F6013",
- PIC24,12,0,Read24Fx,{0x16000,0x800,0x52,0x05BE},0x600,Write24Fx,{0x16000,0x800,0x31252,0x05BE,32},2.0}, //44KW, 2K, HV12
- {"30F6010,30F6012,30F6014,30F6015",
- PIC24,12,0,Read24Fx,{0x18000,0x1000,0x52,0x05BE},0x600,Write24Fx,{0x18000,0x1000,0x31252,0x05BE,32},2.0}, //49KW, 4K, HV12
-//-------------PIC32---------------------------------------------------------
-// options:
-// {"32MX270F256",
-// PIC32,-1,1,Read32x,{0x40000,0},0x800,0,{0,0,0,0,0},0.0}, //256K
-//-------------ATMEL---------------------------------------------------------
- {"AT90S1200",
- AVR,-1,0,ReadAT,{0x400,0x40,0},0,WriteAT,{0x400,0x40,0,0},0}, //1K, 64
- {"ATtiny11",
- AVR,12,0,ReadAT_HV,{0x400,0,LOCK+FUSE+CAL},0,WriteAT_HV,{0x400,0,0,0},0}, //1K, HV
- {"ATtiny12",
- AVR,12,0,ReadAT_HV,{0x400,0x40,LOCK+FUSE+CAL},0,WriteAT_HV,{0x400,0x40,0,0},0}, //1K, 64, HV
- {"ATtiny13",
- AVR,12,0,ReadAT_HV,{0x400,0x40,LOCK+FUSE+FUSE_H+CAL},0,WriteAT_HV,{0x400,0x40,16,0},0}, //1K, 64, HV
- {"AT90S2313",
- AVR,-1,0,ReadAT,{0x800,0x80,0},0,WriteAT,{0x800,0x80,0,0},0}, //2K, 128
- {"ATtiny2313",
- AVR,-1,0,ReadAT,{0x800,0x80,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x800,0x80,16,0},0},//2K, 128
- {"ATtiny24,ATtiny25",
- AVR,12,0,ReadAT_HV,{0x800,0x80,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteAT_HV,{0x800,0x80,16,0},0}, //2K, 128, HV
- {"ATtiny26",
- AVR,-1,0,ReadAT,{0x800,0x80,LOCK+FUSE+FUSE_H+CAL},0,WriteATmega,{0x800,0x80,16,0},0}, //2K, 128
- {"ATtiny261",
- AVR,-1,0,ReadAT,{0x800,0x80,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x800,0x80,16,0},0}, //2K, 128
- {"ATtiny44,ATtiny45",
- AVR,12,0,ReadAT_HV,{0x1000,0x100,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteAT_HV,{0x1000,0x100,32,0},0}, //4K, 256, HV
- {"ATtiny461,ATtiny4313,ATmega48",
- AVR,-1,0,ReadAT,{0x1000,0x100,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x1000,0x100,32,0},0}, //4K, 256
- {"ATtiny48",
- AVR,-1,0,ReadAT,{0x1000,0x40,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x1000,0x40,32,0},0}, //4K, 64
- {"ATtiny88",
- AVR,-1,0,ReadAT,{0x2000,0x40,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x2000,0x40,32,0},0}, //8K, 64
- {"AT90S8515,AT90S8535",
- AVR,-1,0,ReadAT,{0x2000,0x100,0},0,WriteAT,{0x2000,0x100,0,0},0}, //8K, 256
- {"ATmega8,ATmega8515,ATmega8535",
- AVR,-1,0,ReadAT,{0x2000,0x200,LOCK+FUSE+FUSE_H+CAL},0,WriteATmega,{0x2000,0x200,32,0},0}, //8K, 512
- {"ATmega88,ATtiny861",
- AVR,-1,0,ReadAT,{0x2000,0x200,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x2000,0x200,32,0},0}, //8K, 512
- {"ATtiny84,ATtiny85",
- AVR,12,0,ReadAT_HV,{0x2000,0x200,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteAT_HV,{0x2000,0x200,32,0},0}, //8K, 512, HV
- {"ATmega16",
- AVR,-1,0,ReadAT,{0x4000,0x200,LOCK+FUSE+FUSE_H+CAL},0,WriteATmega,{0x4000,0x200,64,0},0}, //16K, 512
- {"ATmega164,ATmega168",
- AVR,-1,0,ReadAT,{0x4000,0x200,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x4000,0x200,64,0},0}, //16K, 512
- {"ATmega32",
- AVR,-1,0,ReadAT,{0x8000,0x400,LOCK+FUSE+FUSE_H+CAL},0,WriteATmega,{0x8000,0x400,64,0},0}, //32K, 1K
- {"ATmega324,ATmega328",
- AVR,-1,0,ReadAT,{0x8000,0x400,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x8000,0x400,64,0},0}, //32K, 1K
- {"ATmega64,ATmega644",
- AVR,-1,0,ReadAT,{0x10000,0x800,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x10000,0x800,128,0},0}, //64K, 2K
- {"ATmega1284",
- AVR,-1,0,ReadAT,{0x20000,0x1000,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,WriteATmega,{0x20000,0x1000,128,0},0},//128K, 4K
-//-------------I2C---------------------------------------------------------
- {"2400",
- I2CEE,-1,0,ReadI2C,{0x10,0},0,WriteI2C,{0x10,0,1},0}, //16, 1B addr.
- {"2401",
- I2CEE,-1,0,ReadI2C,{0x80,0},0,WriteI2C,{0x80,0,8},0}, //128, 1B addr.
- {"2402",
- I2CEE,-1,0,ReadI2C,{0x100,0},0,WriteI2C,{0x100,0,8},0}, //256, 1B addr.
- {"2404",
- I2CEE,-1,0,ReadI2C,{0x200,0},0,WriteI2C,{0x200,0,16},0}, //512, 1B addr.
- {"2408",
- I2CEE,-1,0,ReadI2C,{0x400,0},0,WriteI2C,{0x400,0,16},0}, //1K, 1B addr.
- {"2416",
- I2CEE,-1,0,ReadI2C,{0x800,0},0,WriteI2C,{0x800,0,16},0}, //2K, 1B addr.
- {"2432",
- I2CEE,-1,0,ReadI2C,{0x1000,1},0,WriteI2C,{0x1000,1,32},0}, //4K, 2B addr.
- {"2464",
- I2CEE,-1,0,ReadI2C,{0x2000,1},0,WriteI2C,{0x2000,1,32},0}, //8K, 2B addr.
- {"24128",
- I2CEE,-1,0,ReadI2C,{0x4000,1},0,WriteI2C,{0x4000,1,64},0}, //16K, 2B addr.
- {"24256",
- I2CEE,-1,0,ReadI2C,{0x8000,1},0,WriteI2C,{0x8000,1,64},0}, //32K, 2B addr.
- {"24512",
- I2CEE,-1,0,ReadI2C,{0x10000,1},0,WriteI2C,{0x10000,1,128},0}, //64K, 2B addr.
- {"241024",
- I2CEE,-1,0,ReadI2C,{0x20000,0x201},0,WriteI2C,{0x20000,0x201,256},0}, //128K, 2B addr.
- {"241025",
- I2CEE,-1,0,ReadI2C,{0x20000,0x841},0,WriteI2C,{0x20000,0x841,128},0}, //128K, 2B addr.
-//-------------Microwire EEPROM---------------------------------------------------------
- {"93S46",
- UWEE,-1,0,Read93x,{0x80,6,0},0,Write93Sx,{0x80,6,8},0}, //128, 6b addr, 4W page
- {"93x46",
- UWEE,-1,0,Read93x,{0x80,6,0},0,Write93Cx,{0x80,6,0},0}, //128, 6b addr
- {"93x46A",
- UWEE,-1,0,Read93x,{0x80,7,1},0,Write93Cx,{0x80,7,1},0}, //128, 6b addr x8
- {"93S56",
- UWEE,-1,0,Read93x,{0x100,8,0},0,Write93Sx,{0x100,8,8},0}, //256, 8b addr, 4W page
- {"93x56",
- UWEE,-1,0,Read93x,{0x100,8,0},0,Write93Cx,{0x100,8,0},0}, //256, 8b addr
- {"93x56A",
- UWEE,-1,0,Read93x,{0x100,9,1},0,Write93Cx,{0x100,9,1},0}, //256, 8b addr x8
- {"93S66",
- UWEE,-1,0,Read93x,{0x200,8,0},0,Write93Sx,{0x200,8,8},0}, //512, 8b addr, 4W page
- {"93x66",
- UWEE,-1,0,Read93x,{0x200,8,0},0,Write93Cx,{0x200,8,0},0}, //512, 8b addr
- {"93x66A",
- UWEE,-1,0,Read93x,{0x200,9,1},0,Write93Cx,{0x200,9,1},0}, //512, 8b addr x8
- {"93x76",
- UWEE,-1,0,Read93x,{0x400,10,0},0,Write93Cx,{0x400,10,0},0}, //1k, 10b addr
- {"93x76A",
- UWEE,-1,0,Read93x,{0x400,11,1},0,Write93Cx,{0x400,11,1},0}, //1k, 10b addr x8
- {"93x86",
- UWEE,-1,0,Read93x,{0x800,10,0},0,Write93Cx,{0x800,10,0},0}, //2k, 10b addr
- {"93x86A",
- UWEE,-1,0,Read93x,{0x800,11,1},0,Write93Cx,{0x800,11,1},0}, //2k, 10b addr x8
-//-------------SPI---------------------------------------------------------
- {"25010,95010",
- SPIEE,-1,0,Read25xx,{0x80},0,Write25xx,{0x80,16},0}, //128
- {"25020,95020",
- SPIEE,-1,0,Read25xx,{0x100},0,Write25xx,{0x100,16},0}, //256
- {"25040,95040",
- SPIEE,-1,0,Read25xx,{0x200},0,Write25xx,{0x200,16},0}, //512
- {"25080,95080",
- SPIEE,-1,0,Read25xx,{0x400},0,Write25xx,{0x400,16},0}, //1K
- {"25160,95160",
- SPIEE,-1,0,Read25xx,{0x800},0,Write25xx,{0x800,16},0}, //2K
- {"25320,95320",
- SPIEE,-1,0,Read25xx,{0x1000},0,Write25xx,{0x1000,32},0}, //4K
- {"25640,95640",
- SPIEE,-1,0,Read25xx,{0x2000},0,Write25xx,{0x2000,32},0}, //8K
- {"25128,95128",
- SPIEE,-1,0,Read25xx,{0x4000},0,Write25xx,{0x4000,64},0}, //16K
- {"25256,95256",
- SPIEE,-1,0,Read25xx,{0x8000},0,Write25xx,{0x8000,64},0}, //32K
- {"25512,95512",
- SPIEE,-1,0,Read25xx,{0x10000},0,Write25xx,{0x10000,128},0}, //64K
- {"251024,95M01",
- SPIEE,-1,0,Read25xx,{0x20000},0,Write25xx,{0x20000,256},0}, //128K
- {"95M02",
- SPIEE,-1,0,Read25xx,{0x40000},0,Write25xx,{0x40000,256},0}, //256K
- {"25X05",
- SPIEE,-1,0,Read25xx,{0x10000},0,Write25xx,{0x10000,0x1000+256},0}, //64K flash 3.3V
- {"251005,25X10",
- SPIEE,-1,0,Read25xx,{0x20000},0,Write25xx,{0x20000,0x1000+256},0}, //128K flash 3.3V
- {"252005,25X20",
- SPIEE,-1,0,Read25xx,{0x40000},0,Write25xx,{0x40000,0x1000+256},0}, //256K flash 3.3V
- {"254005,25X40",
- SPIEE,-1,0,Read25xx,{0x80000},0,Write25xx,{0x80000,0x1000+256},0}, //512K flash 3.3V
- {"25Q40",
- SPIEE,-1,0,Read25xx,{0x80000},0,Write25xx,{0x80000,0x3000+256},0}, //512K flash 3.3V STATUS2
- {"258005,25X80",
- SPIEE,-1,0,Read25xx,{0x100000},0,Write25xx,{0x100000,0x1000+256},0},//1M flash 3.3V
- {"251605,25X16",
- SPIEE,-1,0,Read25xx,{0x200000},0,Write25xx,{0x200000,0x1000+256},0},//2M flash 3.3V
- {"25X32",
- SPIEE,-1,0,Read25xx,{0x400000},0,Write25xx,{0x400000,0x1000+256},0},//4M flash 3.3V
- {"25X64",
- SPIEE,-1,0,Read25xx,{0x800000},0,Write25xx,{0x800000,0x1000+256},0},//8M flash 3.3V
- {"25X128",
- SPIEE,-1,0,Read25xx,{0x1000000},0,Write25xx,{0x1000000,0x1000+256},0},//16M flash 3.3V
-//-------------One wire devices---------------------------------------------------------
- {"DS2430",
- OWEE,-1,0,ReadOneWireMem,{0x20,1},0,WriteOneWireMem,{0x20,1},0}, //32
- {"DS2431",
- OWEE,-1,0,ReadOneWireMem,{0x80,2},0,WriteOneWireMem,{0x80,0},0}, //128
- {"DS2433",
- OWEE,-1,0,ReadOneWireMem,{0x200,0},0,WriteOneWireMem,{0x200,1},0}, //512
- {"DS28EC20",
- OWEE,-1,0,ReadOneWireMem,{0xA00,2},0,WriteOneWireMem,{0xA00,1},0}, //2560
- {"DS1820",
- OWEE,-1,0,ReadDS1820,{-10},0,0,{0},0}, //digital thermometer
-//-------------UNIO devices---------------------------------------------------------
- {"11010",
- UNIOEE,-1,0,Read11xx,{0x80},0,Write11xx,{0x80,16},0}, //128
- {"11020",
- UNIOEE,-1,0,Read11xx,{0x100},0,Write11xx,{0x100,16},0}, //256
- {"11040",
- UNIOEE,-1,0,Read11xx,{0x200},0,Write11xx,{0x200,16},0}, //512
- {"11080",
- UNIOEE,-1,0,Read11xx,{0x400},0,Write11xx,{0x400,16},0}, //1k
- {"11160",
- UNIOEE,-1,0,Read11xx,{0x800},0,Write11xx,{0x800,16},0} //2k
-};
-
-int NDEVLIST = (sizeof(DEVLIST)/sizeof(struct DEVICES));
-
-//Add all devices to the appropriate structure
-#ifndef _GTKGUI
-void AddDevices(char *list){ //make sure list is long enough
- int i;
- static char last[8]="";
- for(i=0;i<sizeof(devices)/sizeof(char*);i++){
- if(last[0]) strcat(list,", ");
- if(strncmp(devices[i],last,2)){
- strcat(list,"\n");
- last[0]=devices[i][0];
- last[1]=devices[i][1];
- last[2]=0;
- }
- strcat(list,devices[i]);
- }
-}
-#endif
-
-//Make a list of all supported devices (insert \n between types)
-char* ListDevices(){
- int i,len=0,l;
- static char last[8]="";
- char* list=0;
- for(i=0;i<Ndevices;i++){
- l=strlen(devices[i]);
- if(!last[0]){
- list=realloc(list,len+l+1);
- strcpy(list+len,devices[i]);
- len+=l;
- }
- else{
- list=realloc(list,len+l+3);
- if(strncmp(devices[i],last,2)) strcpy(list+len,",\n");
- else strcpy(list+len,", ");
- strcpy(list+len+2,devices[i]);
- len+=l+2;
- }
- last[0]=devices[i][0];
- last[1]=devices[i][1];
- last[2]=0;
- }
- return list;
-}
-
-#ifdef DEBUG
-//Check that all devices in the list have a read/write function
-void CheckDevices(){
- int i;
- for(i=0;i<Ndevices;i++){
- if(GetDevType(devices[i])<0){
- printf("Can't find %s\n",devices[i]);fflush(stdout);
- }
- }
- printf("OK %d devices\n",Ndevices);fflush(stdout);
-}
-#endif
-
-
-void Read(char* dev,int ee,int r)
-{
- int i,j;
- int params[5];
- char *str=0,*tok;
-#ifdef DEBUG
- CheckDevices();
-#endif
- //parse all device names until "dev" is found,
- //then execute the read function with the right number of parameters
- for(i=0;i<sizeof(DEVLIST)/sizeof(DEVLIST[0]);i++){
- if(str) free(str);
- str=malloc(strlen(DEVLIST[i].device)+1);
- strcpy(str,DEVLIST[i].device);
- for(tok=strtok(str,",");tok;tok=strtok(NULL,",")){ //compare every device name
- if(!strcmp(dev,tok)){ //proceed if found
- for(j=0;j<4;j++) params[j]=DEVLIST[i].ReadParam[j];
- if(DEVLIST[i].V33>0){ //3.3V required
- if(!CheckV33Regulator()){
- PrintMessage(strings[S_noV33reg]); //Can't find 3.3V expansion board
- return;
- }
- }
- if(hvreg!=DEVLIST[i].HV) hvreg=StartHVReg(DEVLIST[i].HV)>0?DEVLIST[i].HV:0;
- if(DEVLIST[i].ReadPtr==0){
- PrintMessage(strings[S_nodev_r]); //"Device not supported for reading\r\n");
- return;
- }
- switch(DEVLIST[i].family){ //call read function with the right number of arguments (better ways to do it???)
- case PIC12:
- if(r) params[1]=DEVLIST[i].ResArea; //modify reserved area parameter
- (*DEVLIST[i].ReadPtr)(params[0],params[1]);
- break;
- case PIC16:
- if(r) params[2]=DEVLIST[i].ResArea; //modify reserved area parameter
- if(!ee) params[1]=0; //clear eeprom parameter
- (*DEVLIST[i].ReadPtr)(params[0],params[1],params[2],params[3]);
- break;
- case PIC18:
- if(!ee) params[1]=0; //clear eeprom parameter
- (*DEVLIST[i].ReadPtr)(params[0],params[1],params[2]);
- break;
- case PIC24:
- if(!ee) params[1]=0; //clear eeprom parameter
- (*DEVLIST[i].ReadPtr)(params[0],params[1],params[2],params[3],r?DEVLIST[i].ResArea:0);
- break;
- case PIC32:
-// if(!ee) params[1]=0; //clear eeprom parameter
- (*DEVLIST[i].ReadPtr)(params[0],params[1]);
- break;
- case AVR:
- if(!ee) params[1]=0; //clear eeprom parameter
- (*DEVLIST[i].ReadPtr)(params[0],params[1],params[2]);
- break;
- case I2CEE:
- (*DEVLIST[i].ReadPtr)(params[0],params[1]);
- break;
- case UWEE:
- (*DEVLIST[i].ReadPtr)(params[0],params[1],params[2]);
- break;
- case SPIEE:
- (*DEVLIST[i].ReadPtr)(params[0]);
- break;
- case OWEE:
- if(params[0]==-10) (*DEVLIST[i].ReadPtr)();
- else (*DEVLIST[i].ReadPtr)(params[0],params[1]);
- break;
- case UNIOEE:
- (*DEVLIST[i].ReadPtr)(params[0]);
- break;
- default:
- PrintMessage(strings[S_nodev_r]); //"Device not supported for reading\r\n");
- }
- return;
- }
- }
- }
- PrintMessage(strings[S_nodev_r]); //"Device not supported for reading\r\n");
-}
-
-
-void Write(char* dev,int ee)
-{
- int i,j;
- int params[6];
- char *str=0,*tok;
- //parse all device names until "dev" is found,
- //then execute the write function with the right number of parameters
- for(i=0;i<sizeof(DEVLIST)/sizeof(DEVLIST[0]);i++){
- if(str) free(str);
- str=malloc(strlen(DEVLIST[i].device)+1);
- strcpy(str,DEVLIST[i].device);
- for(tok=strtok(str,",");tok;tok=strtok(NULL,",")){ //compare every device name
- if(!strcmp(dev,tok)){ //proceed if found
- for(j=0;j<6;j++) params[j]=DEVLIST[i].WriteParam[j];
- if(DEVLIST[i].V33>0){ //3.3V required
- if(!CheckV33Regulator()){
- PrintMessage(strings[S_noV33reg]); //Can't find 3.3V expansion board
- return;
- }
- }
- if(hvreg!=DEVLIST[i].HV) hvreg=StartHVReg(DEVLIST[i].HV)>0?DEVLIST[i].HV:0;
- if(DEVLIST[i].WritePtr==0){
- PrintMessage(strings[S_nodev_w]); //"Device not supported for writing\r\n");
- return;
- }
- switch(DEVLIST[i].family){ //call write function with the right number of arguments (better ways to do it???)
- case PIC12:
- (*DEVLIST[i].WritePtr)(params[0],params[1]);
- break;
- case PIC16:
- if(!ee) params[1]=0; //clear eeprom parameter
- if(params[2]==-10) (*DEVLIST[i].WritePtr)(params[0],params[1]);
- else (*DEVLIST[i].WritePtr)(params[0],params[1],params[2]);
- break;
- case PIC18:
- if(!ee) params[1]=0; //clear eeprom parameter
- (*DEVLIST[i].WritePtr)(params[0],params[1],params[2],params[3],params[4],params[5]);
- break;
- case PIC24:
- if(!ee) params[1]=0; //clear eeprom parameter
- (*DEVLIST[i].WritePtr)(params[0],params[1],params[2],params[3],params[4],DEVLIST[i].WriteParamD);
- break;
- case AVR:
- if(!ee) params[1]=0; //clear eeprom parameter
- (*DEVLIST[i].WritePtr)(params[0],params[1],params[2],params[3]);
- break;
- case I2CEE:
- (*DEVLIST[i].WritePtr)(params[0],params[1],params[2]);
- break;
- case UWEE:
- (*DEVLIST[i].WritePtr)(params[0],params[1],params[2]);
- break;
- case SPIEE:
- (*DEVLIST[i].WritePtr)(params[0],params[1]);
- break;
- case OWEE:
- (*DEVLIST[i].WritePtr)(params[0],params[1]);
- break;
- case UNIOEE:
- (*DEVLIST[i].WritePtr)(params[0],params[1]);
- break;
- default:
- PrintMessage(strings[S_nodev_w]); //"Device not supported for writing\r\n");
- }
- return;
- }
- }
- }
- PrintMessage(strings[S_nodev_w]); //"Device not supported for writing\r\n");
-}
-
-///Search the device type
-int GetDevType(const char* dev)
-{
- int i,type=-1;
- char *str=0,*tok;
- //parse all device names until "dev" is found
- for(i=0;i<sizeof(DEVLIST)/sizeof(DEVLIST[0]);i++){
- if(str) free(str);
- str=malloc(strlen(DEVLIST[i].device)+1);
- strcpy(str,DEVLIST[i].device);
- for(tok=strtok(str,",");tok;tok=strtok(NULL,",")){ //compare every device name
- if(!strcmp(dev,tok)){ //proceed if found
- type=DEVLIST[i].family;
- tok=0;
- i=sizeof(DEVLIST)/sizeof(DEVLIST[0]);
- }
- }
- }
- free(str);
- return type;
-}
-
-/// Determine the group of a specific device
-enum group_t nameToGroup(const char *devName) {
- if(!strncmp(devName,"10F",3)||!strncmp(devName,"12F",3)||!strncmp(devName,"12C",3))
- return G_PIC_10_12;
- if(!strncmp(devName,"16F",3)||!strncmp(devName,"16LF",4)||!strncmp(devName,"16C",3))
- return G_PIC_16;
- if(!strncmp(devName,"18F",3))
- return G_PIC_18;
- if(!strncmp(devName,"24F",3)||!strncmp(devName,"24H",3)||!strncmp(devName,"24E",3))
- return G_PIC_24;
- if(!strncmp(devName,"30F",3)||!strncmp(devName,"33F",3)||!strncmp(devName,"33E",3))
- return G_PIC_30_33;
- if(!strncmp(devName,"AT",2))
- return G_ATMEL;
- if(!strncmp(devName,"24",2)||!strncmp(devName,"25",2)||!strncmp(devName,"93",2)|| \
- !strncmp(devName,"95",2)||!strncmp(devName,"11",2)||!strncmp(devName,"DS",2))
- return G_EEPROM;
- PrintMessage1("can't determine group of device '%s'\n",devName);
- return -1;
-}
-
-/// Copies the device info from the passed devlist entry into the passed DevInfo
-/// Does NOT populate fields 'device' and 'group' as these are device-specific
-void populateDevInfo(struct DevInfo *info, const struct DEVICES *devlistEntry) {
- char str2[256],str3[64],strF[32];
- info->family=devlistEntry->family;
- info->HV=devlistEntry->HV;
- info->V33=devlistEntry->V33;
- info->size=devlistEntry->ReadParam[0];
- info->sizeEE=devlistEntry->ReadParam[1];
- str2[0]=0;
- double x=info->size/1024.0;
- if(x-(int)x) sprintf(strF,"%.1f",x);
- else sprintf(strF,"%d",(int)x);
- switch(info->family){
- case -1:
- sprintf(str2,"?? ");
- break;
- case PIC12:
- sprintf(str2,"PIC12, ");
- if(info->size<1024) sprintf(str3,"%dW FLASH",info->size);
- else sprintf(str3,"%sKW FLASH",strF);
- strcat(str2,str3);
- break;
- case PIC16:
- sprintf(str2,"PIC16, ");
- if(info->size<1024) sprintf(str3,"%dW FLASH",info->size);
- else sprintf(str3,"%sKW FLASH",strF);
- strcat(str2,str3);
- if(info->sizeEE){
- int ee=info->sizeEE;
- if(ee<0) ee=-ee;
- sprintf(str3," + %dB EEPROM",ee);
- strcat(str2,str3);
- }
- break;
- case PIC18:
- sprintf(str2,"PIC18, ");
- if(info->size<1024) sprintf(str3,"%dB FLASH ",info->size);
- else sprintf(str3,"%sKB FLASH ",strF);
- strcat(str2,str3);
- if(info->sizeEE){
- sprintf(str3,"+ %dB EEPROM ",info->sizeEE);
- strcat(str2,str3);
- }
- break;
- case PIC24:
- sprintf(str2,"PIC24, ");
- if(info->size<1024) sprintf(str3,"%dW FLASH",info->size);
- else sprintf(str3,"%sKW FLASH",strF);
- strcat(str2,str3);
- if(info->sizeEE){
- sprintf(str3," + %dB EEPROM",info->sizeEE);
- strcat(str2,str3);
- }
- break;
- case PIC32:
- sprintf(str2,"PIC32, ");
- if(info->size<1024) sprintf(str3,"%dW FLASH",info->size);
- else sprintf(str3,"%sKW FLASH",strF);
- strcat(str2,str3);
- if(info->sizeEE){
- sprintf(str3," + %dB EEPROM",info->sizeEE);
- strcat(str2,str3);
- }
- break;
- case AVR:
- sprintf(str2,"AVR, ");
- if(info->size<1024) sprintf(str3,"%dB FLASH",info->size);
- else sprintf(str3,"%sKB FLASH",strF);
- strcat(str2,str3);
- if(info->sizeEE){
- sprintf(str3," + %dB EEPROM",info->sizeEE);
- strcat(str2,str3);
- }
- break;
- case I2CEE:
- if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_I2CMEM],info->size); //I2C Memory
- else sprintf(str2,"%s, %sKB",strings[I_I2CMEM],strF); //I2C Memory
- break;
- case SPIEE:
- if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_SPIMEM],info->size); //SPI Memory
- else sprintf(str2,"%s, %sKB",strings[I_SPIMEM],strF); //SPI Memory
- break;
- case UWEE:
- if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_UWMEM],info->size); //Microwire Memory
- else sprintf(str2,"%s,%sKB",strings[I_UWMEM],strF);
- break;
- case OWEE:
- if(info->size<0) sprintf(str2,strings[I_OWDEV]); //OneWire device
- else if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_OWMEM],info->size); //OneWire Memory
- else sprintf(str2,"%s, %sKB",strings[I_OWMEM],strF);
- break;
- case UNIOEE:
- if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_UNIOMEM],info->size); //UNI/O Memory
- else sprintf(str2,"%s, %sKB",strings[I_UNIOMEM],strF);
- break;
- default:
- sprintf(str2,"!!unknown family!!");
- }
- if(info->HV>0){
- sprintf(str3,", %.1fV",info->HV);
- strcat(str2,str3);
- }
- if(info->V33){
- strcat(str2,", ");
- strcat(str2,strings[I_3V3REQUIRED]); // 3.3V adapter
- }
- info->features=malloc(strlen(str2)+1);
- strcpy(info->features,str2);
-}
-
-
-///Search and return device info
-struct DevInfo GetDevInfo(const char* dev)
-{
- int i;
- char *str=0,*tok;
- struct DevInfo info;
- info.device=0;
- info.family=-1;
- info.HV=-1;
- info.V33=-1;
- info.size=-1;
- info.sizeEE=-1;
- info.features=0;
- //parse all device names until "dev" is found
- for(i=0;i<NDEVLIST;i++){
- str=malloc(strlen(DEVLIST[i].device)+1);
- strcpy(str,DEVLIST[i].device);
- for(tok=strtok(str,",");tok;tok=strtok(NULL,",")){ //compare every device name
- if(!strcmp(dev,tok)){ //proceed if found
- info.device=malloc(strlen(tok)+1);
- strcpy(info.device,tok);
- info.group=nameToGroup(info.device);
- populateDevInfo(&info, &(DEVLIST[i]));
- free(str);
- return info;
- }
- }
- free(str);
- }
- return info;
-}
+/*
+ * deviceRW.c - Read-write calls for various devices
+ * Copyright (C) 2010-2025 Alberto Maccioni
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111 USA
+ * or see <http://www.gnu.org/licenses/>
+ */
+
+//configure for GUI or command-line
+#include "common.h"
+#include "progP12.h"
+#include "progP16.h"
+#include "progP18.h"
+#include "progP24.h"
+#include "progEEPROM.h"
+#include "progAVR.h"
+//#include "progP32.h"
+
+#include "deviceRW.h"
+
+char* devices[]={
+"10F200","10F202","10F204","10F206","10F220","10F222",
+"10F320","10F322",
+"12C508","12C508A","12C509","12C509A","12F508","12F509","12F510","12F519",
+"12F609","12F615","12F617","12F629","12F635","12C671","12C672","12CE673","12CE674","12F675","12F683",
+"12F752",
+"12F529T39","12F529T48",
+"12F1501","12LF1552","12F1571","12F1572","12F1612","12F1822","12F1840",
+"16F505","16F506","16F526","16F527","16F54","16F57","16F570","16F59",
+"16F610","16F616","16F627","16F627A","16F628","16F628A","16F630","16F631",
+"16F636","16F639","16F648A","16F676","16F677","16F684","16F685","16F687",
+"16F688","16F689","16F690",
+"16F707","16F716","16F72","16F720","16F721","16F722","16F722A","16F723","16F723A",
+"16F724","16F726","16F727","16F73","16F737","16F74","16F747","16F753","16F76",
+"16F767","16F77","16F777","16F785",
+"16F818","16F819","16C83","16F83","16F83A","16C84","16F84","16F84A","16F87","16F870","16F871","16F872",
+"16F873","16F873A","16F874","16F874A","16F876","16F876A","16F877","16F877A",
+"16F88","16F882","16F883","16F884","16F886","16F887",
+"16F913","16F914","16F916","16F917","16F946",
+"16F1454","16F1455","16F1459",
+"16F1503","16F1507","16F1508","16F1509","16F1512","16F1513","16F1516","16F1517","16F1518","16F1519",
+"16F1526","16F1527","16LF1554","16LF1559","16LF1566","16LF1567","16F1574","16F1575","16F1578","16F1579",
+"16F1613","16F1614","16F1615","16F1618","16F1619",
+"16F1703","16F1704","16F1705","16F1707","16F1708","16F1709","16F1713","16F1716","16F1717","16F1718","16F1719",
+"16F1764","16F1765","16F1768","16F1769","16F1773","16F1776","16F1777","16F17784","16F1779",
+"16F1782","16F1783","16F1784","16F1786","16F1787","16F1788","16F1789",
+"16F1823","16F1824","16F1825","16F1826","16F1827","16F1828","16F1829","16F1847",
+"16LF1902","16LF1903","16LF1904","16LF1906","16LF1907",
+"16F1933","16F1934","16F1936","16F1937","16F1938","16F1939","16F1946","16F1947",
+"16F13113","16F13114","16F13115","16F13123","16F13124","16F13125","16F13143","16F13144","16F13145",
+"16F15213","16F15214","16F15223","16F15224","16F15225","16F15243","16F15244","16F15245",
+"16F15254","16F15255","16F15256","16F15274","16F15275","16F15276",
+"16F15313","16F15323","16F15324","16F15325","16F15344","16F15345","16F15354","16F15355","16F15356",
+"16F15375","16F15376","16F15385","16F15386",
+"16F17114","16F17115","16F17124","16F17125","16F17126","16F17144","16F17145","16F17146",
+"16F17154","16F17155","16F17156","16F17174","16F17175","16F17176",
+"16F18013","16F18014","16F18015","16F18023","16F18024","16F18025","16F18026","16F18044","16F18045","16F18046",
+"16F18054","16F18055","16F18056","16F18074","16F18075","16F18076",
+"16F18114","16F18115","16F18124","16F18125","16F18126","16F18144","16F18145","16F18146",
+"16F18154","16F18155","16F18156","16F18174","16F18175","16F18176",
+"16F18313","16F18323","16F18324","16F18325","16F18326","16F18344","16F18345","16F18346",
+"16F18424","16F18425","16F18426","16F18444","16F18445","16F18446","16F18455","16F18456",
+"16F18854","16F18855","16F18856","16F18857","16F18875","16F18876","16F18877",
+"16F19155","16F19156","16F19175","16F19176","16F19185","16F19186","16F19195","16F19196","16F19197",
+"18F04Q20","18F04Q40","18F04Q41","18F05Q20","18F05Q40","18F05Q41","18F06Q20","18F06Q40","18F06Q41",
+"18F14Q20","18F14Q40","18F14Q41","18F15Q20","18F15Q40","18F15Q41","18F16Q20","18F16Q40","18F16Q41",
+"18F242","18F248","18F252","18F258","18F442","18F448","18F452","18F458",
+"18F1220","18F1230","18F1320","18F1330","18F13K22","18F13K50","18F14K22","18F14K50",
+"18F2220","18F2221","18F2320","18F23K20","18F23K22","18F2321","18F2331","18F2410",
+"18F24J10","18F24Q10","18F24J11","18F2420","18F24K20","18F24K22","18F2423","18F2431","18F2439","18F24K40","18F24K42",
+"18F2450","18F24J50","18F24K50","18F2455","18F2458","18F24Q71","18F2480",
+"18F2510","18F25J10","18F25Q10","18F25J11","18F2515","18F2520","18F25K20","18F25K22","18F2523",
+"18F2525","18F2539","18F25K40","18F25K42","18F25Q43","18F2550","18F25J50","18F25K50","18F2553",
+"18F25Q71","18F2580","18F25K80","18F25K83","18F2585",
+"18F2610","18F26Q10","18F26J11","18F26J13","18F2620","18F26K20",
+"18F26K22","18F26K40","18F26K42","18F26Q43","18F26J50","18F26K50",
+"18F26J53","18F26Q71","18F2680","18F26K80","18F2682","18F26K83","18F26Q83","18F26Q84","18F2685",
+"18F27Q10","18F27J13","18F27K40","18F27K42","18F27Q43","18F27J53","18F27Q83","18F27Q84",
+"18F4220","18F4221","18F4320","18F43K20","18F43K22","18F4321","18F4331",
+"18F4410","18F44J10","18F44J11","18F4420","18F44K20","18F44K22","18F4423","18F4431",
+"18F4439","18F4450","18F44J50","18F4455","18F4458","18F44Q71","18F4480",
+"18F4510","18F45Q10","18F45J10","18F45J11","18F4515","18F4520","18F45K20","18F45K22","18F4523",
+"18F4525","18F4539","18F45K40","18F45K42","18F45Q43","18F4550","18F45J50","18F45K50","18F4553","18F45Q71","18F4580","18F45K80","18F4585",
+"18F4610","18F46Q10","18F46J11","18F46J13","18F4620","18F46K20","18F46K22","18F46K40","18F46K42","18F46Q43","18F46J50","18F46K50",
+"18F46J53","18F46Q71","18F4680","18F46K80","18F4682","18F46Q83","18F46Q84","18F4685",
+"18F47Q10","18F47J13","18F47K40","18F47K42","18F47Q43","18F47J53","18F47Q83","18F47Q84",
+"18F54Q71","18F55K42","18F55Q43","18F55Q71",
+"18F56K42","18F56Q43","18F56Q71","18F56Q83","18F56Q84","18F57K42","18F57Q43","18F57Q83","18F57Q84",
+"18F63J11","18F63J90","18F64J11","18F64J90",
+"18F65J10","18F65J11","18F65J15","18F65J50","18F65J90","18F65K80",
+"18F66J10","18F66J11","18F66J15","18F66J16","18F66J50","18F66J55","18F66J60","18F66J65","18F66J90","18F66J93",
+"18F67J10","18F67J11","18F67J50","18F67J60","18F66K80","18F67J90","18F67J93",
+"18F83J11","18F83J90","18F84J11","18F84J90","18F85J10","18F85J11","18F85J15","18F85J50","18F85J90",
+"18F8520","18F86J10","18F86J11","18F86J15","18F86J16","18F86J50","18F86J55","18F86J60","18F86J65",
+"18F86J72","18F86J90","18F86J93",
+"18F8722","18F87J10","18F87J11","18F87J50","18F87J60","18F87J72","18F87J90","18F87J93",
+"18F96J60","18F96J65","18F97J60",
+"24F04KA200","24F04KA201",
+"24F08KA101","24F08KA102",
+"24F16KA101","24F16KA102",
+"24FJ16GA002","24FJ16GA004",
+"24FJ32GA002","24FJ32GA004","24FJ32GA102","24FJ32GA104",
+"24FJ32GB002","24FJ32GB004",
+"24FJ48GA002","24FJ48GA004",
+"24FJ64GA002","24FJ64GA004","24FJ64GA006","24FJ64GA008","24FJ64GA010",
+"24FJ64GA102","24FJ64GA104","24FJ64GA306","24FJ64GA308","24FJ64GA310",
+"24FJ64GB002","24FJ64GB004","24FJ64GB106","24FJ64GB108","24FJ64GB110",
+"24FJ64GC006","24FJ64GC008","24FJ64GC010",
+"24FJ96GA006","24FJ96GA008","24FJ96GA010",
+"24FJ128GA006","24FJ128GA008","24FJ128GA010","24FJ128GA106","24FJ128GA108","24FJ128GA110",
+"24FJ128GA306","24FJ128GA308","24FJ128GA310",
+"24FJ128GB106","24FJ128GB108","24FJ128GB110","24FJ128GB206","24FJ128GB210",
+"24FJ128GC006","24FJ128GC008","24FJ128GC010",
+"24FJ128DA106","24FJ128DA110","24FJ128DA206","24FJ128DA210",
+"24FJ192GA106","24FJ192GA108","24FJ192GA110",
+"24FJ192GB106","24FJ192GB108","24FJ192GB110",
+"24FJ256GA106","24FJ256GA108","24FJ256GA110",
+"24FJ256GB106","24FJ256GB108","24FJ256GB110",
+"24FJ256GB206","24FJ256GB210",
+"24FJ256DA106","24FJ256DA110","24FJ256DA206","24FJ256DA210",
+"24EP32GP202","24EP32GP203","24EP32GP204",
+"24EP32MC202","24EP32MC203","24EP32MC204",
+"24EP64GP202","24EP64GP203","24EP64GP204","24EP64GP206",
+"24EP64MC202","24EP64MC203","24EP64MC204","24EP64MC206",
+"24EP128GP202","24EP128GP204","24EP128GP206",
+"24EP128MC202","24EP128MC204","24EP128MC206",
+"24EP256GP202","24EP256GP204","24EP256GP206",
+"24EP256MC202","24EP256MC204","24EP256MC206",
+"24EP512GP202","24EP512GP204","24EP512GP206",
+"24EP512MC202","24EP512MC204","24EP512MC206",
+"24HJ12GP201","24HJ12GP202",
+"24HJ16GP304",
+"24HJ32GP202","24HJ32GP204","24HJ32GP302","24HJ32GP304",
+"24HJ64GP202","24HJ64GP204","24HJ64GP206","24HJ64GP210","24HJ64GP502",
+"24HJ64GP504","24HJ64GP506","24HJ64GP510",
+"24HJ128GP202","24HJ128GP204","24HJ128GP206","24HJ128GP210",
+"24HJ128GP306","24HJ128GP310","24HJ128GP502","24HJ128GP504","24HJ128GP506","24HJ128GP510",
+"24HJ256GP206","24HJ256GP210","24HJ256GP610",
+"30F1010","30F2010","30F2011","30F2012","30F2020","30F2023",
+"30F3010","30F3011","30F3012","30F3013","30F3014",
+"30F4011","30F4012","30F4013",
+"30F5011","30F5013","30F5015","30F5016",
+"30F6010","30F6011","30F6012","30F6013","30F6014","30F6015",
+//"32MX270F256",
+"33FJ06GS101","33FJ06GS102","33FJ06GS202",
+"33FJ12GP201","33FJ12GP202","33FJ12MC201","33FJ12MC202",
+"33FJ16GP304","33FJ16GS402","33FJ16GS404","33FJ16GS502","33FJ16GS504","33FJ16MC304",
+"33FJ32GP202","33FJ32GP204","33FJ32GP302","33FJ32GP304",
+"33FJ32GS406","33FJ32GS606","33FJ32GS608","33FJ32GS610",
+"33FJ32MC202","33FJ32MC204","33FJ32MC302","33FJ32MC304",
+"33FJ64GP202","33FJ64GP204","33FJ64GP206","33FJ64GP306","33FJ64GP310",
+"33FJ64GP706","33FJ64GP708","33FJ64GP710","33FJ64GP802","33FJ64GP804",
+"33FJ64GS406","33FJ64GS606","33FJ64GS608","33FJ64GS610",
+"33FJ64MC202","33FJ64MC204","33FJ64MC506","33FJ64MC508","33FJ64MC510",
+"33FJ64MC706","33FJ64MC710","33FJ64MC802","33FJ64MC804",
+"33FJ128GP202","33FJ128GP204","33FJ128GP206","33FJ128GP306","33FJ128GP310","33FJ128GP706",
+"33FJ128GP708","33FJ128GP710","33FJ128GP802","33FJ128GP804",
+"33FJ128MC202","33FJ128MC204","33FJ128MC506","33FJ128MC510","33FJ128MC706","33FJ128MC708",
+"33FJ128MC710","33FJ128MC802","33FJ128MC804",
+"33FJ256GP506","33FJ256GP510","33FJ256GP710",
+"33FJ256MC510","33FJ256MC710",
+"33EP32GP502","33EP32GP503","33EP32GP504",
+"33EP32MC202","33EP32MC203","33EP32MC204","33EP32MC502","33EP32MC503","33EP32MC504",
+"33EP64GP502","33EP64GP503","33EP64GP504","33EP64GP506",
+"33EP64MC202","33EP64MC203","33EP64MC204","33EP64MC206","33EP64MC502","33EP64MC503","33EP64MC504","33EP64MC506",
+"33EP128GP502","33EP128GP504","33EP128GP506",
+"33EP128MC202","33EP128MC204","33EP128MC206","33EP128MC502","33EP128MC504","33EP128MC506",
+"33EP256GP502","33EP256GP504","33EP256GP506",
+"33EP256MC202","33EP256MC204","33EP256MC206","33EP256MC502","33EP256MC504","33EP256MC506",
+"33EP512GP502","33EP512GP504","33EP512GP506",
+"33EP512MC202","33EP512MC204","33EP512MC206","33EP512MC502","33EP512MC504","33EP512MC506",
+"AT90S1200","AT90S2313",
+"AT90S8515","AT90S8535","ATmega48","ATmega8","ATmega88","ATmega8515",
+"ATmega8535","ATmega16","ATmega164","ATmega168","ATmega32","ATmega324",
+"ATmega328","ATmega64","ATmega644","ATmega1284",
+"ATtiny11","ATtiny12","ATtiny13",
+"ATtiny2313","ATtiny24","ATtiny25","ATtiny26","ATtiny261","ATtiny4313","ATtiny44","ATtiny45",
+"ATtiny461","ATtiny48","ATtiny84","ATtiny85","ATtiny88","ATtiny861",
+"2400","2401","2402","2404","2408","2416","2432","2464","24128","24256","24512","241024","241025",
+"25010","25020","25040","25080","25160","25320","25640","25128","25256","25512","251024",
+"95010","95020","95040","95080","95160","95320","95640","95128","95256","95512","95M01","95M02",
+"251005","252005","254005","258005","251605",
+"25X05","25X10","25X20","25X40","25X80","25X16","25X32","25X64","25X128","25Q40",
+"93S46","93X46","93X46A","93S56","93X56","93X56A","93S66","93X66", "93X66A","93X76","93X76A","93X86","93X86A",
+"DS2430","DS2431","DS2433","DS28EC20","DS1820",
+"11010","11020","11040","11080","11160"
+};
+
+typedef void(*fp)(); //to cast function pointers
+int Ndevices=sizeof(devices)/sizeof(char*);
+/*struct DEVICES {device; family; HV; V33; (*ReadPtr); ReadParam[4]; ResArea; (*WritePtr); WriteParam[6]; WriteParamD;};
+*/
+struct DEVICES DEVLIST[]={
+//-------------PIC10-16---------------------------------------------------------
+ {"10F200,10F204,10F220",
+ PIC12,13.0,0,(fp)Read12F5xx,{0x100,5},0x40,(fp)Write12F5xx,{0x100,0xFF},0}, //256
+ {"10F320",
+ PIC16,9.0,1,(fp)Read16Fxxx,{0x100,0,10,0},0x80,(fp)Write12F6xx,{0x100,0,-10},0}, //256, vpp, 3.3V
+ {"12C508,12C508A",
+ PIC12,13.0,0,(fp)Read12F5xx,{0x200,4},0x40,(fp)Write12C5xx,{0x200,0},0}, //512
+ {"12F508,10F202,10F206,10F222",
+ PIC12,13.0,0,(fp)Read12F5xx,{0x200,5},0x40,(fp)Write12F5xx,{0x200,0x1FF},0}, //512
+ {"16F54",
+ PIC12,13.0,0,(fp)Read12F5xx,{0x200,4},0x40,(fp)Write12F5xx,{0x200,-1},0}, //512, no osccal
+ {"10F322",
+ PIC16,9.0,1,(fp)Read16Fxxx,{0x200,0,10,0},0x80,(fp)Write12F6xx,{0x200,0,-10},0}, //512, vpp, 3.3V
+ {"12C509,12C509A",
+ PIC12,13.0,0,(fp)Read12F5xx,{0x400,4},0x40,(fp)Write12C5xx,{0x400,0},0}, //1K
+ {"12F509,12F510,16F505,16F506",
+ PIC12,13.0,0,(fp)Read12F5xx,{0x400,5},0x40,(fp)Write12F5xx,{0x400,0x3FF},0}, //1K
+ {"12F519,16F526,16F527",
+ PIC12,13.0,0,(fp)Read12F5xx,{0x440,8},0x60,(fp)Write12F5xx,{0x440,0x3FF},0}, //1K + 64
+ {"12F529T39,12F529T48",
+ PIC12,13.0,0,(fp)Read12F5xx,{0x640,8},0x78,(fp)Write12F5xx,{0x640,0x5FF},0}, //1.5K + 64
+ {"16F57,16F59",
+ PIC12,13.0,0,(fp)Read12F5xx,{0x800,4},0x40,(fp)Write12F5xx,{0x800,-1},0}, //2K
+ {"16F570",
+ PIC12,13.0,0,(fp)Read12F5xx,{0x840,8},0x70,(fp)Write12F5xx,{0x840,0x7FF},0}, //2K + 64
+ {"16C83,16F83,16F83A",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x200,0x40,8,1},0x10,(fp)Write16F8x,{0x200,0x40,-10},0}, //512, 64, vdd
+ {"12C671,12CE673",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x400,0,0,0},0x100,0,{},0}, //1K, vpp
+ {"12F1501",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x400,0,11,0},0x100,(fp)Write16F1xxx,{0x400,0,0},0}, //1K, vpp, 3.3V
+ {"12F1571",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x400,0,12,0},0x200,(fp)Write16F1xxx,{0x400,0,0},0}, //1K, vpp, 3.3V
+ {"12F609,12F615,16F610",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x400,0,9,0},0x40,(fp)Write12F61x,{0x400,0,0},0}, //1K, vpp, cal1
+ {"12F752",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x400,0,10,0},0x80,(fp)Write12F61x,{0x400,0,0},0}, //1K, vpp, cal1
+ {"16C84,16F84,16F84A",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x400,0x40,8,1},0x10,(fp)Write16F8x,{0x400,0x40,-10},0}, //1K, 64, vdd
+ {"12F635",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x400,0x80,10,0},0x80,(fp)Write12F6xx,{0x400,0x80,-10},0}, //1K, 128, vpp, cal1 + cal2
+ {"16F631",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x400,0x80,9,0},0x80,(fp)Write12F6xx,{0x400,0x80,-10},0}, //1K, 128, vpp, cal1
+ {"12F629,12F675,16F630,16F676",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x400,0x80,8,0},0x20,(fp)Write12F62x,{0x400,0x80,-10},0}, //1K, 128, vpp
+ {"16F627",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x400,-0x80,8,0},0x10,(fp)Write16F62x,{0x400,0x80,-10},0}, //1K, 128, vpp, ee@0x2200
+ {"16F627A",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x400,0x80,8,0},0x10,(fp)Write12F6xx,{0x400,0x80,-10},0}, //1K, 128, vpp
+ {"16F818",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x400,0x80,8,2},0x10,(fp)Write16F81x,{0x400,0x80,-10},0}, //1K, 128, vdd short delay
+ {"16F72",
+ PIC16,8.5,1,(fp)Read16Fxxx,{0x800,0,8,1},0x20,(fp)Write16F7x,{0x800,0,-10},0}, //2K, vdd, 3.3V
+ {"16F720,16F722,16F722A",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x800,0,11,0},0x100,(fp)Write16F72x,{0x800,0,0},0}, //2K, vpp, config1-2 + cal1-2, 3.3V
+ {"12C672,12CE674",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x800,0,0,0},0x100,0,{},0}, //2K, vpp
+ {"16F716",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x800,0,8,2},8,(fp)Write16F71x,{0x800,1,-10},0}, //2K, vdd
+ {"16F616,12F617",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x800,0,9,0},0x40,(fp)Write12F61x,{0x800,0,0},0}, //2K, vpp, cal1
+ {"16F753",
+ PIC16,12.5,0,(fp)Read16Fxxx,{0x800,0,10,0},0x80,(fp)Write12F61x,{0x800,0,0},0}, //2K, vpp, cal1
+ {"16LF1902,16F1503,16F1507,16F1512,12LF1552",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x800,0,11,0},0x200,(fp)Write16F1xxx,{0x800,0,0},0}, //2K, vpp, 3.3V
+ {"12F1572",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x800,0,12,0},0x200,(fp)Write16F1xxx,{0x800,0,0},0}, //2K, vpp, 3.3V
+ {"16F1703,16F1707",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x800,0,13,0},0x200,(fp)Write16F1xxx,{0x800,0,0},0}, //2K, vpp, 3.3V
+ {"12F1612,16F1613",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x800,0,13,4},0x200,(fp)Write16F1xxx,{0x800,0,4},0}, //2K, vpp, 3.3V
+ {"16F15213,16F15223,16F15243",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x800,0,0,0},0,(fp)Write16F18xxx,{0x800,0,0x40},0}, //2K, vpp, 3.3V, 8b commands, reboot
+ {"16F15313,16F15323",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x800,0,0,0},0,(fp)Write16F18xxx,{0x800,0,0},0}, //2K, vpp, 3.3V, 8b commands
+ {"16F13113,16F13123,16F13143",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x800,0,0,0},0,(fp)Write16F18xxx,{0x800,0,0x20},0}, //2K, vpp, 3.3V, 8b commands, bit field erase
+ {"16F870,16F871,16F872",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x800,0x40,8,1},0x100,(fp)Write16F87x,{0x800,0x40,-10},0}, //2K, 64, vdd
+ {"16F628",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x800,-0x80,8,0},0x10,(fp)Write16F62x,{0x800,0x80,-10},0}, //2K, 128, vpp, ee@0x2200
+ {"16F628A",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x800,0x80,8,0},0x10,(fp)Write12F6xx,{0x800,0x80,-10},0}, //2K, 128, vpp
+ {"16F882",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x800,0x80,10,0},0x80,(fp)Write16F88x,{0x800,0x80,-10},0}, //2K, 128, vpp, config2 + cal1
+ {"16F819",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x800,0x100,8,2},0x10,(fp)Write16F81x,{0x800,0x100,-10},0}, //2K, 256, vdd short delay
+ {"12F683,16F684",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x800,0x100,9,0},0x40,(fp)Write12F6xx,{0x800,0x100,-10},0}, //2K, 256, vpp, cal1
+ {"16F636,16F639,16F785",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x800,0x100,10,0},0x40,(fp)Write12F6xx,{0x800,0x100,-10},0}, //2K, 256, vpp, cal1 + cal2
+ {"16F677,16F687",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x800,0x100,9,0},0x80,(fp)Write12F6xx,{0x800,0x100,-10},0}, //2K, 256, vpp, cal1
+ {"12F1822,16F1823,16F1826",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x800,0x100,11,0},0x200,(fp)Write16F1xxx,{0x800,0x100,0},0}, //2K, 256, vpp, 3.3V
+ {"16F1782",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x800,0x100,19,0},0x200,(fp)Write16F1xxx,{0x800,0x100,0},0}, //2K, 256, vpp, 3.3V
+ {"16F18313,16F18323",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x800,0x100,11,0x1C},0x20,(fp)Write16F1xxx,{0x800,0x100,0x1C},0}, //2K, 256, vpp, 3.3V, new cmd
+ {"16F18013,16F18023",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x800,1,0,0},0,(fp)Write16F18xxx,{0x800,0x100,0x20},0}, //2K, 256, vpp, 3.3V, 8b commands, bit field erase
+ {"16F73,16F74",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x1000,0,8,1},0x20,(fp)Write16F7x,{0x1000,0,-10},0}, //4K, vdd
+ {"16F737,16F747",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x1000,0,9,2},9,(fp)Write16F7x,{0x1000,1,-10},0}, //4K, vdd short/no delay
+ {"16F721,16F723,16F723A,16F724",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x1000,0,11,0},0x100,(fp)Write16F72x,{0x1000,0,0},0}, //4K, vpp, config1-2 + cal1-2, 3.3V
+ {"16LF1903,16LF1904,16F1508,16F1513,16LF1554",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x1000,0,11,0},0x200,(fp)Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
+ {"16F1574,16F1578",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x1000,0,12,0},0x200,(fp)Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
+ {"16F1704,16F1708",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x1000,0,13,0},0x200,(fp)Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
+ {"16F1614,16F1618",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x1000,0,13,4},0x200,(fp)Write16F1xxx,{0x1000,0,4},0}, //4K, vpp, 3.3V
+ {"16F1713",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x1000,0,17,0},0x200,(fp)Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
+ {"16F1783,16F1784",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x1000,0,19,0},0x200,(fp)Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
+ {"16F1764,16F1768",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x1000,0,20,0},0x200,(fp)Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
+ {"16F1773",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x1000,0,24,0},0x200,(fp)Write16F1xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V
+ {"16F15214,16F15224,16F15244,16F15254,16F15274",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x1000,0,0,0},0,(fp)Write16F18xxx,{0x1000,0,0x40},0}, //4K, vpp, 3.3V, 8b commands, reboot
+ {"16F15324,16F15344,16F15354",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x1000,0,0,0},0,(fp)Write16F18xxx,{0x1000,0,0},0}, //4K, vpp, 3.3V, 8b commands
+ {"16F13114,16F13124,16F13144",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x1000,0,0,0},0,(fp)Write16F18xxx,{0x1000,0,0x20},0}, //4K, vpp, 3.3V, 8b commands, bit field erase
+ {"16F873A,16F874A",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x1000,0x80,8,1},0x100,(fp)Write16F87xA,{0x1000,0x80,1},0}, //4K, 128, vdd
+ {"16F873,16F874",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x1000,-0x80,8,1},0x100,(fp)Write16F87x,{0x1000,-0x80,-10},0}, //4K, 128, vdd, ee@0x2200
+ {"16F685,16F689,16F690",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x1000,0x100,9,0},0x80,(fp)Write12F6xx,{0x1000,0x100,-10},0}, //4K, 256, vpp, cal1
+ {"16F688",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x1000,0x100,9,0},0x40,(fp)Write12F6xx,{0x1000,0x100,-10},0}, //4K, 256, vpp, cal1
+ {"16F883,16F884",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x1000,0x100,10,0},0x80,(fp)Write16F88x,{0x1000,0x100,-10},0}, //4K, 256, vpp, config2 + cal1
+ {"16F648A",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x1000,0x100,8,0},0x10,(fp)Write12F6xx,{0x1000,0x100,-10},0}, //4K, 256, vpp
+ {"16F87,16F88",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x1000,0x100,9,2},0x10,(fp)Write16F81x,{0x1000,0x100,-10},0}, //4K, 256, vdd short delay
+ {"16F913,16F914",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x1000,0x100,10,0},0x40,(fp)Write12F6xx,{0x1000,0x100,-10},0}, //4K, 256, vpp, cal1 + cal2
+ {"16F1933,16F1934,16F1824,16F1827,16F1828,12F1840",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x1000,0x100,11,0},0x200,(fp)Write16F1xxx,{0x1000,0x100,0},0}, //4K, 256, vpp, 3.3V
+ {"16F18324,16F18344",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x1000,0x100,11,0x1C},0x20,(fp)Write16F1xxx,{0x1000,0x100,0x1C},0}, //4K, 256, vpp, 3.3V, new cmd
+ {"16F18424,16F18444",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x1000,1,0,0},0,(fp)Write16F18xxx,{0x1000,0x100,0},0}, //4K, 256, vpp, 3.3V, 8b commands
+ {"16F17114,16F17124,16F17144,16F17154,16F17174,16F18014,16F18024,16F18044,16F18054,16F18074,16F18114,16F18124,16F18144,16F18154,16F18174",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x1000,1,0,0},0,(fp)Write16F18xxx,{0x1000,0x100,0x20},0}, //4K, 256, vpp, 3.3V, 8b commands, bit field erase
+ {"16F18854",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x1000,0x100,0,0x10},0,(fp)Write16F18xxx,{0x1000,0x100,0x10},0}, //4K, 256, vpp, 3.3V, 8b commands no DIA
+ {"16F76,16F77",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x2000,0,8,1},0x20,(fp)Write16F7x,{0x2000,0,-10},0}, //8K, vdd
+ {"16F767,16F777",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x2000,0,9,2},0x40,(fp)Write16F7x,{0x2000,1,-10},0}, //8K, vdd short delay
+ {"16F726,16F727,16F707",
+ PIC16,8.5,1,(fp)Read16Fxxx,{0x2000,0,11,0},0x100,(fp)Write16F72x,{0x2000,0,0},0}, //8K, vpp, config1-2 + cal1-2, 3.3V
+ {"16LF1906,16LF1907,16F1509,16F1454,16F1455,16F1459,16F1516,16F1517,16F1526,16LF1559,16LF1566,16LF1567",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x2000,0,11,0},0x200,(fp)Write16F1xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V
+ {"16F1575,16F1579",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x2000,0,12,0},0x200,(fp)Write16F1xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V
+ {"16F1705,16F1709",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x2000,0,13,0},0x200,(fp)Write16F1xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V
+ {"16F1615,16F1619",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x2000,0,13,4},0x200,(fp)Write16F1xxx,{0x2000,0,4},0}, //8K, vpp, 3.3V
+ {"16F1716,16F1717",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x2000,0,17,0},0x200,(fp)Write16F1xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V
+ {"16F1765,16F1769",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x2000,0,20,0},0x200,(fp)Write16F1xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V
+ {"16F1776,16F1777",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x2000,0,24,0},0x200,(fp)Write16F1xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V
+ {"16F15225,16F15245,16F15255,16F15275",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x2000,0,0,0},0,(fp)Write16F18xxx,{0x2000,0,0x40},0}, //8K, vpp, 3.3V, 8b commands, reboot
+ {"16F15325,16F15345,16F15355,16F15375,16F15385",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x2000,0,0,0},0,(fp)Write16F18xxx,{0x2000,0,0},0}, //8K, vpp, 3.3V, 8b commands
+ {"16F13115,16F13125,16F13145",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x2000,0,0,0},0,(fp)Write16F18xxx,{0x2000,0,0x20},0}, //8K, vpp, 3.3V, 8b commands, bit field erase
+ {"16F876A,16F877A",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x2000,0x100,8,1},0x100,(fp)Write16F87xA,{0x2000,0x100,1},0}, //8K, 256, vdd
+ {"16F876,16F877",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x2000,-0x100,8,1},0x100,(fp)Write16F87x,{0x2000,-0x100,-10},0}, //8K, 256, vdd, ee@0x2200
+ {"16F886,16F887",
+ PIC16,11.0,0,(fp)Read16Fxxx,{0x2000,0x100,10,0},0x80,(fp)Write16F88x,{0x2000,0x100,-10},0}, //8K, 256, vpp, config2 + cal1
+ {"16F916,16F917,16F946",
+ PIC16,13.0,0,(fp)Read16Fxxx,{0x2000,0x100,10,0},0x40,(fp)Write12F6xx,{0x2000,0x100,-10},0}, //8K, 256, vpp, cal1 + cal2
+ {"16F1936,16F1937,16F1946,16F1825,16F1829,16F1847",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x2000,0x100,11,0},0x200,(fp)Write16F1xxx,{0x2000,0x100,0},0}, //8K, 256, vpp, 3.3V
+ {"16F1786,16F1787",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x2000,0x100,19,0},0x200,(fp)Write16F1xxx,{0x2000,0x100,0},0}, //8K, 256, vpp, 3.3V
+ {"16F18325,16F18345",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x2000,0x100,11,0x1C},0x20,(fp)Write16F1xxx,{0x2000,0x100,0x1C},0}, //8K, 256, vpp, 3.3V, new cmd
+ {"16F18425,16F18445,16F18455,16F19155,16F19175,16F19185,16F19195",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x2000,1,0,0},0,(fp)Write16F18xxx,{0x2000,0x100,0},0}, //8K, 256, vpp, 3.3V, 8b commands
+ {"16F17115,16F17125,16F17145,16F17155,16F17175,16F18015,16F18025,16F18045,16F18055,16F18075,16F18115,16F18125,16F18145,16F18155,16F18175",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x2000,1,0,0},0,(fp)Write16F18xxx,{0x2000,0x100,0x20},0}, //8K, 256, vpp, 3.3V, 8b commands, bit field erase
+ {"16F18855,16F18875",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x2000,0x100,0,0x10},0,(fp)Write16F18xxx,{0x2000,0x100,0x10},0}, //8K, 256, vpp, 3.3V, 8b commands no DIA
+ {"16F1518,16F1519,16F1527",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x4000,0,11,0},0x200,(fp)Write16F1xxx,{0x4000,0,0},0}, //16K, vpp, 3.3V
+ {"16F1718,16F1719",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x4000,0,17,0},0x200,(fp)Write16F1xxx,{0x4000,0,0},0}, //16K, vpp, 3.3V
+ {"16F1778,16F1779",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x4000,0,24,0},0x200,(fp)Write16F1xxx,{0x4000,0,0},0}, //16K, vpp, 3.3V
+ {"16F15256,16F15276",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x4000,0,0,0},0,(fp)Write16F18xxx,{0x4000,0,0x40},0}, //16K, vpp, 3.3V, 8b commands, reboot
+ {"16F15356,16F15376,16F15386",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x4000,0,0,0},0,(fp)Write16F18xxx,{0x4000,0,0},0}, //16K, vpp, 3.3V, 8b commands
+ {"16F1938,16F1939,16F1947",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x4000,0x100,11,0},0x200,(fp)Write16F1xxx,{0x4000,0x100,0},0}, //16K, 256, vpp, 3.3V
+ {"16F1788,16F1789",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x4000,0x100,19,0},0x200,(fp)Write16F1xxx,{0x4000,0x100,0},0}, //16K, 256, vpp, 3.3V
+ {"16F18326,16F18346",
+ PIC16,8.5,1,(fp)Read16F1xxx,{0x4000,0x100,11,0x1C},0x20,(fp)Write16F1xxx,{0x4000,0x100,0x1C},0}, //16K, 256, vpp, 3.3V, new cmd
+ {"16F18426,16F18446,16F18456,16F19156,16F19176,16F19186,16F19196",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x4000,1,0,0},0,(fp)Write16F18xxx,{0x4000,0x100,0},0}, //16K, 256, vpp, 3.3V, 8b commands
+ {"16F17126,16F17146,16F17156,16F17176,16F18026,16F18046,16F18056,16F18076,16F18126,16F18146,16F18156,16F18176",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x4000,1,0,0},0,(fp)Write16F18xxx,{0x4000,0x100,0x20},0}, //16K, 256, vpp, 3.3V, 8b commands, bit field erase
+ {"16F18856,16F18876",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x4000,0x100,0,0x10},0,(fp)Write16F18xxx,{0x4000,0x100,0x10},0}, //16K, 256, vpp, 3.3V, 8b commands no DIA
+ {"16F19197",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x8000,1,0,0},0,(fp)Write16F18xxx,{0x8000,0x100,0},0}, //32K, 256, vpp, 3.3V, 8b commands
+ {"16F18857,16F18877",
+ PIC16,8.5,1,(fp)Read16F18xxx,{0x8000,0x100,0,0x10},0,(fp)Write16F18xxx,{0x8000,0x100,0x10},0}, //32K, 256, vpp, 3.3V, 8b commands no DIA
+//-------------PIC18---------------------------------------------------------
+// Read18Fx options:
+// bit [3:0]
+// 0 = vdd before vpp (12V)
+// 1 = vdd before vpp (9V)
+// 2 = low voltage entry with 32 bit key
+// bit [7:4]
+// 0 = normal control registers address
+// 1 = new control registers address (18FxxK80)
+//
+// Write18Fx options:
+// bit [3:0]
+// 0 = vdd before vpp (12V)
+// 1 = vdd before vpp (9V)
+// 2 = low voltage entry with 32 bit key
+// bit [7:4]
+// 0 = normal eeprom write algoritm
+// 1 = with unlock sequence 55 AA
+// bit [11:8]
+// 0 = 15ms erase delay, 1ms code write time, 5ms EE write, 5ms config write
+// 1 = 550ms erase delay, 1.2ms code write time, no config or EEPROM
+// 2 = 550ms erase delay, 3.4ms code write time, no config or EEPROM
+// 3 = separate block erase with 5ms delay, 1ms code write, 5ms EE write, 5ms config write
+// + new control registers address (18FxxK80)
+ {"18F1230",
+ PIC18,12,0,(fp)Read18Fx,{0x1000,0x80,0},0,(fp)Write18Fx,{0x1000,0x80,8,0x0F0F,0x8787,0},0}, //4K, 128, 8
+ {"18F2221,18F4221",
+ PIC18,12,0,(fp)Read18Fx,{0x1000,0x100,0},0,(fp)Write18Fx,{0x1000,0x100,8,0x3F3F,0x8F8F,0},0}, //4K, 256, 8
+ {"18F1220,18F2220,18F4220",
+ PIC18,12,0,(fp)Read18Fx,{0x1000,0x100,0},0,(fp)Write18Fx,{0x1000,0x100,8,0x10000,0x80,0x10},0}, //4K, 256, 8, EE with unlock
+ {"18F63J11,18F63J90,18F83J11,18F83J90",
+ PIC18,-1,1,(fp)Read18Fx,{0x2000,0,2},0,(fp)Write18Fx,{0x2000,0,64,0x0101,0x8080,0x202},0}, //8K, 0, 64, LV
+ {"18F1330",
+ PIC18,12,0,(fp)Read18Fx,{0x2000,0x80,0},0,(fp)Write18Fx,{0x2000,0x80,8,0x0F0F,0x8787,0},0}, //8K, 128, 8
+ {"18F2321,18F4321",
+ PIC18,12,0,(fp)Read18Fx,{0x2000,0x100,0},0,(fp)Write18Fx,{0x2000,0x100,8,0x3F3F,0x8F8F,0},0}, //8K, 256, 8
+ {"18F1320,18F2320,18F4320,18F2331,18F4331",
+ PIC18,12,0,(fp)Read18Fx,{0x2000,0x100,0},0,(fp)Write18Fx,{0x2000,0x100,8,0x10000,0x80,0x10},0}, //8K, 256, 8, EE with unlock
+ {"18F13K50,18F13K22",
+ PIC18,8.5,1,(fp)Read18Fx,{0x2000,0x100,1},0,(fp)Write18Fx,{0x2000,0x100,8,0x0F0F,0x8F8F,1},0}, //8K, 256, 8, 9V
+ {"18F23K20,18F43K20",
+ PIC18,8.5,1,(fp)Read18Fx,{0x2000,0x100,1},0,(fp)Write18Fx,{0x2000,0x100,16,0x0F0F,0x8F8F,1},0}, //8K, 256, 16, 9V
+ {"18F23K22,18F43K22",
+ PIC18,8.5,1,(fp)Read18Fx,{0x2000,0x100,1},0,(fp)Write18Fx,{0x2000,0x100,64,0x0F0F,0x8F8F,1},0}, //8K, 256, 64, 9V
+ {"18F2439,18F4439",
+ PIC18,12,0,(fp)Read18Fx,{0x3000,0x100,0},0,(fp)Write18Fx,{0x3000,0x100,8,0x10000,0x80,0x10},0}, //12K, 256, 8, EE with unlock
+ {"18F2410,18F4410",
+ PIC18,12,0,(fp)Read18Fx,{0x4000,0,0},0,(fp)Write18Fx,{0x4000,0,32,0x3F3F,0x8F8F,0},0}, //16K, 0, 32
+ {"18F24J10,18F44J10,18F64J11,18F64J90,18F84J11,18F84J90",
+ PIC18,-1,1,(fp)Read18Fx,{0x4000,0,2},0,(fp)Write18Fx,{0x4000,0,64,0x0101,0x8080,0x202},0}, //16K, 0, 64, LV
+ {"18F24J11,18F24J50,18F44J11,18F44J50",
+ PIC18,-1,1,(fp)Read18Fx,{0x4000,0,2},0,(fp)Write18Fx,{0x4000,0,64,0x0101,0x8080,0x102},0}, //16K, 0, 64, LV
+ {"18F2420,18F2423,18F4420,18F4423,18F2480,18F4480",
+ PIC18,12,0,(fp)Read18Fx,{0x4000,0x100,0},0,(fp)Write18Fx,{0x4000,0x100,32,0x3F3F,0x8F8F,0},0}, //16K, 256, 32
+ {"18F2431,18F4431,18F242,18F248,18F442,18F448",
+ PIC18,12,0,(fp)Read18Fx,{0x4000,0x100,0},0,(fp)Write18Fx,{0x4000,0x100,8,0x10000,0x80,0x10},0}, //16K, 256, 8, EE with unlock
+ {"18F2450,18F4450",
+ PIC18,12,0,(fp)Read18Fx,{0x4000,0,0},0,(fp)Write18Fx,{0x4000,0,16,0x3F3F,0x8F8F,0},0}, //16K, 0, 16
+ {"18F14K50,18F14K22",
+ PIC18,8.5,1,(fp)Read18Fx,{0x4000,0x100,1},0,(fp)Write18Fx,{0x4000,0x100,16,0x0F0F,0x8F8F,1},0}, //16K, 256, 16, 9V
+ {"18F24K20,18F44K20",
+ PIC18,8.5,1,(fp)Read18Fx,{0x4000,0x100,1},0,(fp)Write18Fx,{0x4000,0x100,32,0x0F0F,0x8F8F,1},0}, //16K, 256, 32, 9V
+ {"18F24K22,18F44K22,18F24K50",
+ PIC18,8.5,1,(fp)Read18Fx,{0x4000,0x100,1},0,(fp)Write18Fx,{0x4000,0x100,64,0x0F0F,0x8F8F,1},0}, //16K, 256, 64, 9V
+ {"18F04Q40,18F14Q40,18F04Q41,18F14Q41,18F24Q71,18F44Q71,18F54Q71",
+ PIC18,8.5,1,(fp)Read18FKx,{0x4000,1,0x10},0,(fp)Write18FKx,{0x4000,0x200,0x10,0,0,0},0}, //16K, 512, --, LV
+ {"18F04Q20,18F14Q20",
+ PIC18,8.5,1,(fp)Read18FKx,{0x4000,1,0x50},0,(fp)Write18FKx,{0x4000,0x100,0x50,0,0,0},0}, //16K, 256, --, LV
+ {"18F24K40",
+ PIC18,8.5,1,(fp)Read18FKx,{0x4000,0x100,0x30},0,(fp)Write18FKx,{0x4000,0x100,0x30,0,0,0},0}, //16K, 256, --, LV
+ {"18F24K42",
+ PIC18,8.5,1,(fp)Read18FKx,{0x4000,1,0},0,(fp)Write18FKx,{0x4000,0x100,0,0,0,0},0}, //16K, 256, --, LV
+ {"18F24Q10",
+ PIC18,8.5,1,(fp)Read18FKx,{0x4000,0x100,0x40},0,(fp)Write18FKx,{0x4000,0x100,0x40,0,0,0},0}, //16K, 256, --, LV
+ {"18F2455,18F2458,18F4455,18F4458",
+ PIC18,12,0,(fp)Read18Fx,{0x6000,0x100,0},0,(fp)Write18Fx,{0x6000,0x100,32,0x3F3F,0x8F8F,0},0}, //24K, 256, 32
+ {"18F2539,18F4539",
+ PIC18,12,0,(fp)Read18Fx,{0x6000,0x100,0},0,(fp)Write18Fx,{0x6000,0x100,8,0x10000,0x80,0x10},0}, //24K, 256, 8, EE with unlock
+ {"18F2510,18F4510",
+ PIC18,12,0,(fp)Read18Fx,{0x8000,0,0},0,(fp)Write18Fx,{0x8000,0,32,0x3F3F,0x8F8F,0},0}, //32K, 0, 32
+ {"18F25J10,18F45J10,18F65J10,18F65J11,18F65J50,18F65J90,18F85J10,18F85J11,18F85J50,18F85J90",
+ PIC18,-1,1,(fp)Read18Fx,{0x8000,0,2},0,(fp)Write18Fx,{0x8000,0,64,0x0101,0x8080,0x202},0}, //32K, 0, 64, LV
+ {"18F25J11,18F25J50,18F45J11,18F45J50",
+ PIC18,-1,1,(fp)Read18Fx,{0x8000,0,2},0,(fp)Write18Fx,{0x8000,0,64,0x0101,0x8080,0x102},0}, //32K, 0, 64, LV
+ {"18F252,18F258,18F452,18F458",
+ PIC18,12,0,(fp)Read18Fx,{0x8000,0x100,0},0,(fp)Write18Fx,{0x8000,0x100,8,0x10000,0x80,0x10},0}, //32K, 256, 8, EE with unlock
+ {"18F2550,18F2553,18F4550,18F4553,18F2520,18F2523,18F4520,18F4523,18F2580,18F4580",
+ PIC18,12,0,(fp)Read18Fx,{0x8000,0x100,0},0,(fp)Write18Fx,{0x8000,0x100,32,0x3F3F,0x8F8F,0},0}, //32K, 256, 32
+ {"18F25K20,18F45K20",
+ PIC18,8.5,1,(fp)Read18Fx,{0x8000,0x100,1},0,(fp)Write18Fx,{0x8000,0x100,32,0x0F0F,0x8F8F,1},0}, //32K, 256, 32, 9V
+ {"18F25K22,18F45K22,18F25K50,18F45K50",
+ PIC18,8.5,1,(fp)Read18Fx,{0x8000,0x100,1},0,(fp)Write18Fx,{0x8000,0x100,64,0x0F0F,0x8F8F,1},0}, //32K, 256, 64, 9V
+ {"18F25K42,18F45K42,18F55K42",
+ PIC18,8.5,1,(fp)Read18FKx,{0x8000,1,0},0,(fp)Write18FKx,{0x8000,0x100,0,0,0,0},0}, //32K, 256, --, LV
+ {"18F25K40,18F45K40",
+ PIC18,8.5,1,(fp)Read18FKx,{0x8000,0x100,0x30},0,(fp)Write18FKx,{0x8000,0x100,0x30,0,0,0},0}, //32K, 256, --, LV
+ {"18F25Q10,18F45Q10",
+ PIC18,8.5,1,(fp)Read18FKx,{0x8000,0x100,0x40},0,(fp)Write18FKx,{0x8000,0x100,0x40,0,0,0},0}, //32K, 256, --, LV
+ {"18F05Q40,18F15Q40,18F05Q41,18F15Q41,18F25Q71,18F45Q71,18F55Q71",
+ PIC18,8.5,1,(fp)Read18FKx,{0x8000,1,0x10},0,(fp)Write18FKx,{0x8000,0x200,0x10,0,0,0},0}, //32K, 512, --, LV
+ {"18F05Q20,18F15Q20",
+ PIC18,8.5,1,(fp)Read18FKx,{0x8000,1,0x50},0,(fp)Write18FKx,{0x8000,0x100,0x50,0,0,0},0}, //32K, 256, --, LV
+ {"18F25K80,18F45K80,18F65K80",
+ PIC18,8.5,1,(fp)Read18Fx,{0x8000,0x400,0x13},0,(fp)Write18Fx,{0x8000,0x400,64,0,0,0x303},0}, //32K, 1K, 64, 9V, xxK80
+ {"18F8520",
+ PIC18,12,0,(fp)Read18Fx,{0x8000,0x400,0},0,(fp)Write18Fx,{0x8000,0x400,8,0x10000,0x0080,0x10},0},//32K, 1K, 8, EE with unlock
+ {"18F25Q43,18F45Q43,18F55Q43",
+ PIC18,8.5,1,(fp)Read18FKx,{0x8000,1,0x10},0,(fp)Write18FKx,{0x8000,0x400,0x10,0,0,0},0}, //32K, 1k, --, LV
+ {"18F25K83",
+ PIC18,8.5,1,(fp)Read18FKx,{0x8000,1,0},0,(fp)Write18FKx,{0x8000,0x400,0,0,0,0},0}, //32K, 1k, --, LV
+ {"18F2515,18F4515",
+ PIC18,12,0,(fp)Read18Fx,{0xC000,0,0},0,(fp)Write18Fx,{0xC000,0,64,0x3F3F,0x8F8F,0},0}, //48K, 0, 64
+ {"18F65J15,18F85J15",
+ PIC18,-1,1,(fp)Read18Fx,{0xC000,0,2},0,(fp)Write18Fx,{0xC000,0,64,0x0101,0x8080,0x202},0}, //48K, 0, 64, LV
+ {"18F2525,18F2585,18F4525,18F4585",
+ PIC18,12,0,(fp)Read18Fx,{0xC000,0x400,0},0,(fp)Write18Fx,{0xC000,0x400,64,0x3F3F,0x8F8F,0},0}, //48K, 1K, 64
+ {"18F2610,18F4610",
+ PIC18,12,0,(fp)Read18Fx,{0x10000,0,0},0,(fp)Write18Fx,{0x10000,0,64,0x3F3F,0x8F8F,0},0}, //64K, 0, 64
+ {"18F26J11,18F26J13,18F26J50,18F26J53,18F46J11,18F46J13,18F46J50,18F46J53",
+ PIC18,-1,1,(fp)Read18Fx,{0x10000,0,2},0,(fp)Write18Fx,{0x10000,0,64,0x0101,0x8080,0x102},0}, //64K, 0, 64, LV
+ {"18F66J60,18F86J60,18F96J60,18F66J10,18F66J11,18F66J50,18F66J90,18F66J93,18F86J10,18F86J11,18F86J50,18F86J72,18F86J90,18F86J93",
+ PIC18,-1,1,(fp)Read18Fx,{0x10000,0,2},0,(fp)Write18Fx,{0x10000,0,64,0x0101,0x8080,0x202},0}, //64K, 0, 64, LV
+ {"18F2620,18F2680,18F4620,18F4680",
+ PIC18,12,0,(fp)Read18Fx,{0x10000,0x400,0},0,(fp)Write18Fx,{0x10000,0x400,64,0x3F3F,0x8F8F,0},0},//64K, 1K, 64
+ {"18F26K20,18F46K20,18F26K22,18F46K22,18F26K50,18F46K50",
+ PIC18,12,0,(fp)Read18Fx,{0x10000,0x100,1},0,(fp)Write18Fx,{0x10000,0x100,64,0x0F0F,0x8F8F,1},0},//64K, 256, 64, 9V
+ {"18F06Q40,18F16Q40,18F06Q41,18F16Q41,18F26Q71,18F46Q71,18F56Q71",
+ PIC18,8.5,1,(fp)Read18FKx,{0x10000,1,0x10},0,(fp)Write18FKx,{0x10000,0x200,0x10,0,0,0},0}, //64K, 512, --, LV
+ {"18F06Q20,18F16Q20",
+ PIC18,8.5,1,(fp)Read18FKx,{0x10000,1,0x50},0,(fp)Write18FKx,{0x10000,0x100,0x50,0,0,0},0}, //64K, 256, --, LV
+ {"18F26K80,18F46K80,18F66K80",
+ PIC18,8.5,1,(fp)Read18Fx,{0x10000,0x400,0x13},0,(fp)Write18Fx,{0x10000,0x400,64,0,0,0x303},0}, //64K, 1K, 64, 9V, xxK80
+ {"18F26Q43,18F46Q43,18F56Q43",
+ PIC18,8.5,1,(fp)Read18FKx,{0x10000,1,0x10},0,(fp)Write18FKx,{0x10000,0x400,0x10,0,0,0},0}, //64K, 1k, --, LV
+ {"18F26K40,18F46K40",
+ PIC18,8.5,1,(fp)Read18FKx,{0x10000,0x400,0x30},0,(fp)Write18FKx,{0x10000,0x400,0x30,0,0,0},0}, //64K, 1k, --, LV
+ {"18F26K42,18F46K42,18F56K42,18F26K83",
+ PIC18,8.5,1,(fp)Read18FKx,{0x10000,1,0},0,(fp)Write18FKx,{0x10000,0x400,0,0,0,0},0}, //64K, 1k, --, LV
+ {"18F26Q10,18F46Q10",
+ PIC18,8.5,1,(fp)Read18FKx,{0x10000,0x400,0x40},0,(fp)Write18FKx,{0x10000,0x400,0x40,0,0,0},0}, //64K, 1k, --, LV
+ {"18F26Q83,18F26Q84,18F46Q83,18F46Q84,18F56Q83,18F56Q84",
+ PIC18,8.5,1,(fp)Read18FKx,{0x10000,1,0x20},0,(fp)Write18FKx,{0x10000,0x400,0x20,0,0,0},0}, //64K, 1k, --, LV
+ {"18F2682,18F4682",
+ PIC18,12,0,(fp)Read18Fx,{0x14000,0x400,0},0,(fp)Write18Fx,{0x14000,0x400,64,0x3F3F,0x8F8F,0},0},//80K, 1K, 64
+ {"18F66J65,18F86J65,18F96J65,18F66J15,18F66J16,18F66J55,18F86J15,18F86J16,18F86J55",
+ PIC18,-1,1,(fp)Read18Fx,{0x18000,0,2},0,(fp)Write18Fx,{0x18000,0,64,0x0101,0x8080,0x202},0}, //96K, 0, 64, LV
+ {"18F2685,18F4685",
+ PIC18,12,0,(fp)Read18Fx,{0x18000,0x400,0},0,(fp)Write18Fx,{0x18000,0x400,64,0x3F3F,0x8F8F,0},0},//96K, 1K, 64
+ {"18F27J13,18F27J53,18F47J13,18F47J53,18F67J10,18F87J10",
+ PIC18,-1,1,(fp)Read18Fx,{0x20000,0,2},0,(fp)Write18Fx,{0x20000,0,64,0x0101,0x8080,0x102},0}, //128K, 0, 64, LV
+ {"18F67J60,18F87J60,18F97J60,18F67J11,18F67J50,18F67J90,18F67J93,18F87J11,18F87J50,18F87J72,18F87J90,18F87J93",
+ PIC18,-1,1,(fp)Read18Fx,{0x20000,0,2},0,(fp)Write18Fx,{0x20000,0,64,0x0101,0x8080,0x202},0}, //128K, 0, 64, LV
+ {"18F8722",
+ PIC18,12,0,(fp)Read18Fx,{0x20000,0x400,0},0,(fp)Write18Fx,{0x20000,0x400,64,0xFFFF,0x8787,0},0},//128K, 1K, 64
+ {"18F27Q43,18F47Q43,18F57Q43",
+ PIC18,8.5,1,(fp)Read18FKx,{0x20000,1,0x10},0,(fp)Write18FKx,{0x20000,0x400,0x10,0,0,0},0}, //128K, 1k, --, LV
+ {"18F27K40,18F47K40",
+ PIC18,8.5,1,(fp)Read18FKx,{0x20000,0x400,0x30},0,(fp)Write18FKx,{0x20000,0x400,0x30,0,0,0},0}, //128K, 1k, --, LV
+ {"18F27K42,18F47K42,18F57K42",
+ PIC18,8.5,1,(fp)Read18FKx,{0x20000,1,0},0,(fp)Write18FKx,{0x20000,0x400,0,0,0,0},0}, //128K, 1k, --, LV
+ {"18F27Q10,18F47Q10",
+ PIC18,8.5,1,(fp)Read18FKx,{0x20000,0x400,0x40},0,(fp)Write18FKx,{0x20000,0x400,0x40,0,0,0},0}, //128K, 1k, --, LV
+ {"18F27Q83,18F27Q84,18F47Q83,18F47Q84,18F57Q83,18F57Q84",
+ PIC18,8.5,1,(fp)Read18FKx,{0x20000,1,0x20},0,(fp)Write18FKx,{0x20000,0x400,0x20,0,0,0},0}, //128K, 1k, --, LV
+//-------------PIC24---------------------------------------------------------
+// options:
+// bit [3:0]
+// 0 = low voltage ICSP entry
+// 1 = High voltage ICSP entry (6V)
+// 2 = High voltage ICSP entry (12V) + PIC30F sequence (additional NOPs)
+// 3 = low voltage ICSP entry (5V power supply)
+// bit [7:4]
+// 0 = config area in the last 2 program words
+// 1 = config area in the last 3 program words
+// 2 = config area in the last 4 program words
+// 3 = 0xF80000 to 0xF80010 except 02 (24F)
+// 4 = 0xF80000 to 0xF80016 (24H-33F)
+// 5 = 0xF80000 to 0xF8000C (x16 bit, 30F)
+// 6 = 0xF80000 to 0xF8000E (30FSMPS)
+// bit [11:8]
+// 0 = code erase word is 0x4064, row write is 0x4004
+// 1 = code erase word is 0x404F, row write is 0x4001
+// 2 = code erase word is 0x407F, row write is 0x4001, 55AA unlock and external timing (2 ms)
+// 3 = code erase word is 0x407F, row write is 0x4001, 55AA unlock and external timing (200 ms)
+// bit [15:12]
+// 0 = eeprom erase word is 0x4050, write word is 0x4004
+// 1 = eeprom erased with bulk erase, write word is 0x4004
+// 2 = eeprom erased with special sequence, write word is 0x4004
+// bit [19:16]
+// 0 = config write is 0x4000
+// 1 = config write is 0x4003
+// 2 = config write is 0x4004
+// 3 = config write is 0x4008
+ {"24F04KA200,24F04KA201",
+ PIC24,6,1,(fp)Read24Fx,{0xB00,0,0x31,0x05BE},0x800,(fp)Write24Fx,{0xB00,0,0x20031,0x05BE,32},2.0}, //1.375KW, HV
+ {"24F08KA101,24F08KA102",
+ PIC24,6,1,(fp)Read24Fx,{0x1600,0x200,0x31,0x05BE},0x800,(fp)Write24Fx,{0x1600,0x200,0x20031,0x05BE,32},2.0}, //2.75KW, HV, 512
+ {"24F16KA101,24F16KA102",
+ PIC24,6,1,(fp)Read24Fx,{0x2C00,0x200,0x31,0x05BE},0x800,(fp)Write24Fx,{0x2C00,0x200,0x20031,0x05BE,32},2.0}, //5.5KW, HV, 512
+ {"24FJ16GA002,24FJ16GA004",
+ PIC24,-1,1,(fp)Read24Fx,{0x2C00,0,0,0x05BE},0x800,(fp)Write24Fx,{0x2C00,0,0x10100,0x05BE,64},2.0}, //5.5KW
+ {"24FJ32GA002,24FJ32GA004",
+ PIC24,-1,1,(fp)Read24Fx,{0x5800,0,0,0x05BE},0x800,(fp)Write24Fx,{0x5800,0,0x10100,0x05BE,64},2.0}, //11KW
+ {"24FJ32GA102,24FJ32GA104,24FJ32GB002,24FJ32GB004",
+ PIC24,-1,1,(fp)Read24Fx,{0x5800,0,0x20,0x07F0},0x800,(fp)Write24Fx,{0x5800,0,0x10120,0x07F0,64},2.0}, //11KW 4 Config Word
+ {"24FJ48GA002,24FJ48GA004",
+ PIC24,-1,1,(fp)Read24Fx,{0x8400,0,0,0x05BE},0x800,(fp)Write24Fx,{0x8400,0,0x10100,0x05BE,64},2.0}, //16.5KW
+ {"24FJ64GA002,24FJ64GA004,24FJ64GA006,24FJ64GA008,24FJ64GA010",
+ PIC24,-1,1,(fp)Read24Fx,{0xAC00,0,0,0x05BE},0x800,(fp)Write24Fx,{0xAC00,0,0x10100,0x05BE,64},2.0}, //22KW
+ {"24FJ64GA102,24FJ64GA104,24FJ64GB002,24FJ64GB004",
+ PIC24,-1,1,(fp)Read24Fx,{0xAC00,0,0x20,0x07F0},0x800,(fp)Write24Fx,{0xAC00,0,0x10120,0x07F0,64},2.0}, //22KW 4 Config Word
+ {"24FJ64GA306,24FJ64GA308,24FJ64GA310,24FJ64GC006,24FJ64GC008,24FJ64GC010",
+ PIC24,-1,1,(fp)Read24Fx,{0xAC00,0,0x120,0x07F0},0x800,(fp)Write24Fx,{0xAC00,0,0x110120,0x07F0,64},2.0}, //22KW 4 Config Word new TABLPAG
+ {"24FJ64GB106,24FJ64GB108,24FJ64GB110",
+ PIC24,-1,1,(fp)Read24Fx,{0xAC00,0,0x10,0x07F0},0x800,(fp)Write24Fx,{0xAC00,0,0x10110,0x07F0,64},2.0}, //22KW 3 Config Word
+ {"24FJ96GA006,24FJ96GA008,24FJ96GA010",
+ PIC24,-1,1,(fp)Read24Fx,{0x10000,0,0,0x05BE},0x800,(fp)Write24Fx,{0x10000,0,0x10100,0x05BE,64},2.0}, //32KW
+ {"24FJ128GA006,24FJ128GA008,24FJ128GA010",
+ PIC24,-1,1,(fp)Read24Fx,{0x15800,0,0,0x05BE},0x800,(fp)Write24Fx,{0x15800,0,0x10100,0x05BE,64},2.0}, //44KW
+ {"24FJ128GA106,24FJ128GA108,24FJ128GA110,24FJ128GB106,24FJ128GB108,24FJ128GB110",
+ PIC24,-1,1,(fp)Read24Fx,{0x15800,0,0x10,0x07F0},0x800,(fp)Write24Fx,{0x15800,0,0x10110,0x07F0,64},2.0}, //44KW 3 Config Word
+ {"24FJ128GA306,24FJ128GA308,24FJ128GA310,24FJ128GB206,24FJ128GB210,24FJ128GC006,24FJ128GC008,\
+24FJ128GC010,24FJ128DA106,24FJ128DA110,24FJ128DA206,24FJ128DA210",
+ PIC24,-1,1,(fp)Read24Fx,{0x15800,0,0x120,0x07F0},0x800,(fp)Write24Fx,{0x15800,0,0x110120,0x07F0,64},2.0}, //44KW 4 Config Word new TABLPAG
+ {"24FJ192GA106,24FJ192GA108,24FJ192GA110,24FJ192GB106,24FJ192GB108,24FJ192GB110",
+ PIC24,-1,1,(fp)Read24Fx,{0x20C00,0,0x10,0x07F0},0x800,(fp)Write24Fx,{0x20C00,0,0x10110,0x07F0,64},2.0}, //68KW 3 Config Word
+ {"24FJ256GA106,24FJ256GA108,24FJ256GA110,24FJ256GB106,24FJ256GB108,24FJ256GB110",
+ PIC24,-1,1,(fp)Read24Fx,{0x2AC00,0,0x10,0x07F0},0x800,(fp)Write24Fx,{0x2AC00,0,0x10110,0x07F0,64},2.0}, //88KW 3 Config Word
+ {"24FJ256DA106,24FJ256DA110,24FJ256DA206,24FJ256DA210,24FJ256GB206,24FJ256GB210",
+ PIC24,-1,1,(fp)Read24Fx,{0x2AC00,0,0x120,0x07F0},0x800,(fp)Write24Fx,{0x2AC00,0,0x110120,0x07F0,64},2.0}, //88KW 4 Config Word new TABLPAG
+ {"33FJ06GS101,33FJ06GS102,33FJ06GS202",
+ PIC24,-1,1,(fp)Read24Fx,{0x1000,0,0x40,0x07F0},0x800,(fp)Write24Fx,{0x1000,0,0x00140,0x07F0,64},2.0}, //2KW
+ {"24HJ12GP201,24HJ12GP202,33FJ12GP201,33FJ12GP202,33FJ12MC201,33FJ12MC202",
+ PIC24,-1,1,(fp)Read24Fx,{0x2000,0,0x40,0x07F0},0x800,(fp)Write24Fx,{0x2000,0,0x00140,0x07F0,64},2.0}, //4KW
+ {"24HJ16GP304,33FJ16GP304,33FJ16GS402,33FJ16GS404,33FJ16GS502,33FJ16GS504,33FJ16MC304",
+ PIC24,-1,1,(fp)Read24Fx,{0x2C00,0,0x40,0x07F0},0x800,(fp)Write24Fx,{0x2C00,0,0x00140,0x07F0,64},2.0}, //5.5KW
+ {"24HJ32GP202,24HJ32GP204,24HJ32GP302,24HJ32GP304,33FJ32GP202,33FJ32GP204,33FJ32GP302,\
+33FJ32GP304,33FJ32GS406,33FJ32GS606,33FJ32GS608,33FJ32GS610,33FJ32MC202,33FJ32MC204,33FJ32MC302,33FJ32MC304",
+ PIC24,-1,1,(fp)Read24Fx,{0x5800,0,0x40,0x07F0},0x1000,(fp)Write24Fx,{0x5800,0,0x00140,0x07F0,64},2.0}, //11KW
+ {"24HJ64GP202,24HJ64GP204,24HJ64GP206,24HJ64GP210,24HJ64GP502,24HJ64GP504,24HJ64GP506,24HJ64GP510,\
+33FJ64GP202,33FJ64GP204,33FJ64GP206,33FJ64GP306,33FJ64GP310,33FJ64GP706,33FJ64GP708,33FJ64GP710,33FJ64GP802,\
+33FJ64GP804,33FJ64GS406,33FJ64GS606,33FJ64GS608,33FJ64GS610,33FJ64MC202,33FJ64MC204,33FJ64MC506,33FJ64MC508,33FJ64MC510,\
+33FJ64MC706,33FJ64MC710,33FJ64MC802,33FJ64MC804",
+ PIC24,-1,1,(fp)Read24Fx,{0xAC00,0,0x40,0x07F0},0x1000,(fp)Write24Fx,{0xAC00,0,0x00140,0x07F0,64},2.0}, //22KW
+ {"24HJ128GP202,24HJ128GP204,24HJ128GP206,24HJ128GP210,24HJ128GP306,24HJ128GP310,24HJ128GP502,\
+24HJ128GP504,24HJ128GP506,24HJ128GP510,\
+33FJ128GP202,33FJ128GP204,33FJ128GP206,33FJ128GP306,33FJ128GP310,33FJ128GP706,33FJ128GP708,33FJ128GP710,\
+33FJ128GP802,33FJ128GP804,33FJ128MC202,33FJ128MC204,33FJ128MC506,33FJ128MC510,33FJ128MC706,33FJ128MC708,\
+33FJ128MC710,33FJ128MC802,33FJ128MC804",
+ PIC24,-1,1,(fp)Read24Fx,{0x15800,0,0x40,0x07F0},0x1000,(fp)Write24Fx,{0x15800,0,0x00140,0x07F0,64},2.0}, //44KW
+ {"24HJ256GP206,24HJ256GP210,24HJ256GP610,\
+33FJ256GP506,33FJ256GP510,33FJ256GP710,33FJ256MC510,33FJ256MC710",
+ PIC24,-1,1,(fp)Read24Fx,{0x2AC00,0,0x40,0x07F0},0x1000,(fp)Write24Fx,{0x2AC00,0,0x00140,0x07F0,64},2.0}, //88KW
+ {"24EP32GP202,24EP32GP203,24EP32GP204,33EP32GP502,33EP32GP503,33EP32GP504,\
+24EP32MC202,24EP32MC203,24EP32MC204,33EP32MC202,33EP32MC203,33EP32MC204,33EP32MC502,33EP32MC503,33EP32MC504",
+ PIC24,-1,1,(fp)Read24Ex,{0x5800,0,0,0x0FF0},0x1000,(fp)Write24Ex,{0x5800,0,0,0,0,0},2.0}, //11KW 10 Config Word
+ {"24EP64GP202,24EP64GP203,24EP64GP204,24EP64GP206,33EP64GP502,33EP64GP503,33EP64GP504,33EP64GP506,\
+24EP64MC202,24EP64MC203,24EP64MC204,24EP64MC206,33EP64MC202,33EP64MC203,33EP64MC204,33EP64MC206,\
+33EP64MC502,33EP64MC503,33EP64MC504,33EP64MC506",
+ PIC24,-1,1,(fp)Read24Ex,{0xB000,0,0,0x0FF0},0x1000,(fp)Write24Ex,{0xB000,0,0,0,0,0},2.0}, //22.5KW 10 Config Word
+ {"24EP128GP202,24EP128GP204,24EP128GP206,33EP128GP502,33EP128GP504,33EP128GP506,\
+24EP128MC202,24EP128MC204,24EP128MC206,33EP128MC202,33EP128MC204,33EP128MC206,\
+33EP128MC502,33EP128MC504,33EP128MC506",
+ PIC24,-1,1,(fp)Read24Ex,{0x15800,0,0,0x0FF0},0x1000,(fp)Write24Ex,{0x15800,0,0,0,0,0},2.0}, //44KW 10 Config Word
+ {"24EP256GP202,24EP256GP204,24EP256GP206,33EP256GP502,33EP256GP504,33EP256GP506,\
+24EP256MC202,24EP256MC204,24EP256MC206,33EP256MC202,33EP256MC204,33EP256MC206,\
+33EP256MC502,33EP256MC504,33EP256MC506",
+ PIC24,-1,1,(fp)Read24Ex,{0x2B000,0,0,0x0FF0},0x1000,(fp)Write24Ex,{0x2B000,0,0,0,0,0},2.0}, //88KW 10 Config Word
+ {"24EP512GP202,24EP512GP204,24EP512GP206,33EP512GP502,33EP512GP504,33EP512GP506,\
+24EP512MC202,24EP512MC204,24EP512MC206,33EP512MC202,33EP512MC204,33EP512MC206,\
+33EP512MC502,33EP512MC504,33EP512MC506",
+ PIC24,-1,1,(fp)Read24Ex,{0x56000,0,0,0x0FF0},0x1000,(fp)Write24Ex,{0x56000,0,0,0,0,0},2.0}, //175KW 10 Config Word
+ {"30F1010",
+ PIC24,-1,0,(fp)Read24Fx,{0x1000,0,0x63,0x05BE},0x600,(fp)Write24Fx,{0x1000,0,0x30263,0x05BE,32},2.0}, //1KW, LV5V
+ {"30F2020,30F2023",
+ PIC24,-1,0,(fp)Read24Fx,{0x2000,0,0x63,0x05BE},0x600,(fp)Write24Fx,{0x2000,0,0x30263,0x05BE,32},2.0}, //2KW, LV5V
+ {"30F2010",
+ PIC24,12,0,(fp)Read24Fx,{0x2000,0x400,0x52,0x05BE},0x600,(fp)Write24Fx,{0x2000,0x400,0x31252,0x05BE,32},2.0}, //4KW, 1K, HV12
+ {"30F2011,30F2012",
+ PIC24,12,0,(fp)Read24Fx,{0x2000,0,0x52,0x05BE},0x600,(fp)Write24Fx,{0x2000,0,0x31252,0x05BE,32},2.0}, //4KW, HV12
+ {"30F3010,30F3011,30F3012,30F3013,30F3014",
+ PIC24,12,0,(fp)Read24Fx,{0x4000,0x400,0x52,0x05BE},0x600,(fp)Write24Fx,{0x4000,0x400,0x31252,0x05BE,32},2.0}, //8KW, 1K, HV12
+ {"30F4011,30F4012,30F4013",
+ PIC24,12,0,(fp)Read24Fx,{0x8000,0x400,0x52,0x05BE},0x600,(fp)Write24Fx,{0x8000,0x400,0x31252,0x05BE,32},2.0}, //16KW, 1K, HV12
+ {"30F5011,30F5013,30F5015,30F5016",
+ PIC24,12,0,(fp)Read24Fx,{0xB000,0x400,0x52,0x05BE},0x600,(fp)Write24Fx,{0xB000,0x400,0x31252,0x05BE,32},2.0}, //22KW, 1K, HV12
+ {"30F6011,30F6013",
+ PIC24,12,0,(fp)Read24Fx,{0x16000,0x800,0x52,0x05BE},0x600,(fp)Write24Fx,{0x16000,0x800,0x31252,0x05BE,32},2.0}, //44KW, 2K, HV12
+ {"30F6010,30F6012,30F6014,30F6015",
+ PIC24,12,0,(fp)Read24Fx,{0x18000,0x1000,0x52,0x05BE},0x600,(fp)Write24Fx,{0x18000,0x1000,0x31252,0x05BE,32},2.0}, //49KW, 4K, HV12
+//-------------PIC32---------------------------------------------------------
+// options:
+// {"32MX270F256",
+// PIC32,-1,1,(fp)Read32x,{0x40000,0},0x800,0,{0,0,0,0,0},0.0}, //256K
+//-------------ATMEL---------------------------------------------------------
+ {"AT90S1200",
+ AVR,-1,0,(fp)ReadAT,{0x400,0x40,0},0,(fp)WriteAT,{0x400,0x40,0,0},0}, //1K, 64
+ {"ATtiny11",
+ AVR,12,0,(fp)ReadAT_HV,{0x400,0,LOCK+FUSE+CAL},0,(fp)WriteAT_HV,{0x400,0,0,0},0}, //1K, HV
+ {"ATtiny12",
+ AVR,12,0,(fp)ReadAT_HV,{0x400,0x40,LOCK+FUSE+CAL},0,(fp)WriteAT_HV,{0x400,0x40,0,0},0}, //1K, 64, HV
+ {"ATtiny13",
+ AVR,12,0,(fp)ReadAT_HV,{0x400,0x40,LOCK+FUSE+FUSE_H+CAL},0,(fp)WriteAT_HV,{0x400,0x40,16,0},0}, //1K, 64, HV
+ {"AT90S2313",
+ AVR,-1,0,(fp)ReadAT,{0x800,0x80,0},0,(fp)WriteAT,{0x800,0x80,0,0},0}, //2K, 128
+ {"ATtiny2313",
+ AVR,-1,0,(fp)ReadAT,{0x800,0x80,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteATmega,{0x800,0x80,16,0},0},//2K, 128
+ {"ATtiny24,ATtiny25",
+ AVR,12,0,(fp)ReadAT_HV,{0x800,0x80,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteAT_HV,{0x800,0x80,16,0},0}, //2K, 128, HV
+ {"ATtiny26",
+ AVR,-1,0,(fp)ReadAT,{0x800,0x80,LOCK+FUSE+FUSE_H+CAL},0,(fp)WriteATmega,{0x800,0x80,16,0},0}, //2K, 128
+ {"ATtiny261",
+ AVR,-1,0,(fp)ReadAT,{0x800,0x80,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteATmega,{0x800,0x80,16,0},0}, //2K, 128
+ {"ATtiny44,ATtiny45",
+ AVR,12,0,(fp)ReadAT_HV,{0x1000,0x100,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteAT_HV,{0x1000,0x100,32,0},0}, //4K, 256, HV
+ {"ATtiny461,ATtiny4313,ATmega48",
+ AVR,-1,0,(fp)ReadAT,{0x1000,0x100,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteATmega,{0x1000,0x100,32,0},0}, //4K, 256
+ {"ATtiny48",
+ AVR,-1,0,(fp)ReadAT,{0x1000,0x40,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteATmega,{0x1000,0x40,32,0},0}, //4K, 64
+ {"ATtiny88",
+ AVR,-1,0,(fp)ReadAT,{0x2000,0x40,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteATmega,{0x2000,0x40,32,0},0}, //8K, 64
+ {"AT90S8515,AT90S8535",
+ AVR,-1,0,(fp)ReadAT,{0x2000,0x100,0},0,(fp)WriteAT,{0x2000,0x100,0,0},0}, //8K, 256
+ {"ATmega8,ATmega8515,ATmega8535",
+ AVR,-1,0,(fp)ReadAT,{0x2000,0x200,LOCK+FUSE+FUSE_H+CAL},0,(fp)WriteATmega,{0x2000,0x200,32,0},0}, //8K, 512
+ {"ATmega88,ATtiny861",
+ AVR,-1,0,(fp)ReadAT,{0x2000,0x200,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteATmega,{0x2000,0x200,32,0},0}, //8K, 512
+ {"ATtiny84,ATtiny85",
+ AVR,12,0,(fp)ReadAT_HV,{0x2000,0x200,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteAT_HV,{0x2000,0x200,32,0},0}, //8K, 512, HV
+ {"ATmega16",
+ AVR,-1,0,(fp)ReadAT,{0x4000,0x200,LOCK+FUSE+FUSE_H+CAL},0,(fp)WriteATmega,{0x4000,0x200,64,0},0}, //16K, 512
+ {"ATmega164,ATmega168",
+ AVR,-1,0,(fp)ReadAT,{0x4000,0x200,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteATmega,{0x4000,0x200,64,0},0}, //16K, 512
+ {"ATmega32",
+ AVR,-1,0,(fp)ReadAT,{0x8000,0x400,LOCK+FUSE+FUSE_H+CAL},0,(fp)WriteATmega,{0x8000,0x400,64,0},0}, //32K, 1K
+ {"ATmega324,ATmega328",
+ AVR,-1,0,(fp)ReadAT,{0x8000,0x400,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteATmega,{0x8000,0x400,64,0},0}, //32K, 1K
+ {"ATmega64,ATmega644",
+ AVR,-1,0,(fp)ReadAT,{0x10000,0x800,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteATmega,{0x10000,0x800,128,0},0}, //64K, 2K
+ {"ATmega1284",
+ AVR,-1,0,(fp)ReadAT,{0x20000,0x1000,LOCK+FUSE+FUSE_H+FUSE_X+CAL},0,(fp)WriteATmega,{0x20000,0x1000,128,0},0},//128K, 4K
+//-------------I2C---------------------------------------------------------
+ {"2400",
+ I2CEE,-1,0,(fp)ReadI2C,{0x10,0},0,(fp)WriteI2C,{0x10,0,1},0}, //16, 1B addr.
+ {"2401",
+ I2CEE,-1,0,(fp)ReadI2C,{0x80,0},0,(fp)WriteI2C,{0x80,0,8},0}, //128, 1B addr.
+ {"2402",
+ I2CEE,-1,0,(fp)ReadI2C,{0x100,0},0,(fp)WriteI2C,{0x100,0,8},0}, //256, 1B addr.
+ {"2404",
+ I2CEE,-1,0,(fp)ReadI2C,{0x200,0},0,(fp)WriteI2C,{0x200,0,16},0}, //512, 1B addr.
+ {"2408",
+ I2CEE,-1,0,(fp)ReadI2C,{0x400,0},0,(fp)WriteI2C,{0x400,0,16},0}, //1K, 1B addr.
+ {"2416",
+ I2CEE,-1,0,(fp)ReadI2C,{0x800,0},0,(fp)WriteI2C,{0x800,0,16},0}, //2K, 1B addr.
+ {"2432",
+ I2CEE,-1,0,(fp)ReadI2C,{0x1000,1},0,(fp)WriteI2C,{0x1000,1,32},0}, //4K, 2B addr.
+ {"2464",
+ I2CEE,-1,0,(fp)ReadI2C,{0x2000,1},0,(fp)WriteI2C,{0x2000,1,32},0}, //8K, 2B addr.
+ {"24128",
+ I2CEE,-1,0,(fp)ReadI2C,{0x4000,1},0,(fp)WriteI2C,{0x4000,1,64},0}, //16K, 2B addr.
+ {"24256",
+ I2CEE,-1,0,(fp)ReadI2C,{0x8000,1},0,(fp)WriteI2C,{0x8000,1,64},0}, //32K, 2B addr.
+ {"24512",
+ I2CEE,-1,0,(fp)ReadI2C,{0x10000,1},0,(fp)WriteI2C,{0x10000,1,128},0}, //64K, 2B addr.
+ {"241024",
+ I2CEE,-1,0,(fp)ReadI2C,{0x20000,0x201},0,(fp)WriteI2C,{0x20000,0x201,256},0}, //128K, 2B addr.
+ {"241025",
+ I2CEE,-1,0,(fp)ReadI2C,{0x20000,0x841},0,(fp)WriteI2C,{0x20000,0x841,128},0}, //128K, 2B addr.
+//-------------Microwire EEPROM---------------------------------------------------------
+ {"93S46",
+ UWEE,-1,0,(fp)Read93x,{0x80,6,0},0,(fp)Write93Sx,{0x80,6,8},0}, //128, 6b addr, 4W page
+ {"93X46",
+ UWEE,-1,0,(fp)Read93x,{0x80,6,0},0,(fp)Write93Cx,{0x80,6,0},0}, //128, 6b addr
+ {"93X46A",
+ UWEE,-1,0,(fp)Read93x,{0x80,7,1},0,(fp)Write93Cx,{0x80,7,1},0}, //128, 6b addr x8
+ {"93S56",
+ UWEE,-1,0,(fp)Read93x,{0x100,8,0},0,(fp)Write93Sx,{0x100,8,8},0}, //256, 8b addr, 4W page
+ {"93X56",
+ UWEE,-1,0,(fp)Read93x,{0x100,8,0},0,(fp)Write93Cx,{0x100,8,0},0}, //256, 8b addr
+ {"93X56A",
+ UWEE,-1,0,(fp)Read93x,{0x100,9,1},0,(fp)Write93Cx,{0x100,9,1},0}, //256, 8b addr x8
+ {"93S66",
+ UWEE,-1,0,(fp)Read93x,{0x200,8,0},0,(fp)Write93Sx,{0x200,8,8},0}, //512, 8b addr, 4W page
+ {"93X66",
+ UWEE,-1,0,(fp)Read93x,{0x200,8,0},0,(fp)Write93Cx,{0x200,8,0},0}, //512, 8b addr
+ {"93X66A",
+ UWEE,-1,0,(fp)Read93x,{0x200,9,1},0,(fp)Write93Cx,{0x200,9,1},0}, //512, 8b addr x8
+ {"93X76",
+ UWEE,-1,0,(fp)Read93x,{0x400,10,0},0,(fp)Write93Cx,{0x400,10,0},0}, //1k, 10b addr
+ {"93X76A",
+ UWEE,-1,0,(fp)Read93x,{0x400,11,1},0,(fp)Write93Cx,{0x400,11,1},0}, //1k, 10b addr x8
+ {"93X86",
+ UWEE,-1,0,(fp)Read93x,{0x800,10,0},0,(fp)Write93Cx,{0x800,10,0},0}, //2k, 10b addr
+ {"93X86A",
+ UWEE,-1,0,(fp)Read93x,{0x800,11,1},0,(fp)Write93Cx,{0x800,11,1},0}, //2k, 10b addr x8
+//-------------SPI---------------------------------------------------------
+ {"25010,95010",
+ SPIEE,-1,0,(fp)Read25xx,{0x80},0,(fp)Write25xx,{0x80,16},0}, //128
+ {"25020,95020",
+ SPIEE,-1,0,(fp)Read25xx,{0x100},0,(fp)Write25xx,{0x100,16},0}, //256
+ {"25040,95040",
+ SPIEE,-1,0,(fp)Read25xx,{0x200},0,(fp)Write25xx,{0x200,16},0}, //512
+ {"25080,95080",
+ SPIEE,-1,0,(fp)Read25xx,{0x400},0,(fp)Write25xx,{0x400,16},0}, //1K
+ {"25160,95160",
+ SPIEE,-1,0,(fp)Read25xx,{0x800},0,(fp)Write25xx,{0x800,16},0}, //2K
+ {"25320,95320",
+ SPIEE,-1,0,(fp)Read25xx,{0x1000},0,(fp)Write25xx,{0x1000,32},0}, //4K
+ {"25640,95640",
+ SPIEE,-1,0,(fp)Read25xx,{0x2000},0,(fp)Write25xx,{0x2000,32},0}, //8K
+ {"25128,95128",
+ SPIEE,-1,0,(fp)Read25xx,{0x4000},0,(fp)Write25xx,{0x4000,64},0}, //16K
+ {"25256,95256",
+ SPIEE,-1,0,(fp)Read25xx,{0x8000},0,(fp)Write25xx,{0x8000,64},0}, //32K
+ {"25512,95512",
+ SPIEE,-1,0,(fp)Read25xx,{0x10000},0,(fp)Write25xx,{0x10000,128},0}, //64K
+ {"251024,95M01",
+ SPIEE,-1,0,(fp)Read25xx,{0x20000},0,(fp)Write25xx,{0x20000,256},0}, //128K
+ {"95M02",
+ SPIEE,-1,0,(fp)Read25xx,{0x40000},0,(fp)Write25xx,{0x40000,256},0}, //256K
+ {"25X05",
+ SPIEE,-1,0,(fp)Read25xx,{0x10000},0,(fp)Write25xx,{0x10000,0x1000+256},0}, //64K flash 3.3V
+ {"251005,25X10",
+ SPIEE,-1,0,(fp)Read25xx,{0x20000},0,(fp)Write25xx,{0x20000,0x1000+256},0}, //128K flash 3.3V
+ {"252005,25X20",
+ SPIEE,-1,0,(fp)Read25xx,{0x40000},0,(fp)Write25xx,{0x40000,0x1000+256},0}, //256K flash 3.3V
+ {"254005,25X40",
+ SPIEE,-1,0,(fp)Read25xx,{0x80000},0,(fp)Write25xx,{0x80000,0x1000+256},0}, //512K flash 3.3V
+ {"25Q40",
+ SPIEE,-1,0,(fp)Read25xx,{0x80000},0,(fp)Write25xx,{0x80000,0x3000+256},0}, //512K flash 3.3V STATUS2
+ {"258005,25X80",
+ SPIEE,-1,0,(fp)Read25xx,{0x100000},0,(fp)Write25xx,{0x100000,0x1000+256},0},//1M flash 3.3V
+ {"251605,25X16",
+ SPIEE,-1,0,(fp)Read25xx,{0x200000},0,(fp)Write25xx,{0x200000,0x1000+256},0},//2M flash 3.3V
+ {"25X32",
+ SPIEE,-1,0,(fp)Read25xx,{0x400000},0,(fp)Write25xx,{0x400000,0x1000+256},0},//4M flash 3.3V
+ {"25X64",
+ SPIEE,-1,0,(fp)Read25xx,{0x800000},0,(fp)Write25xx,{0x800000,0x1000+256},0},//8M flash 3.3V
+ {"25X128",
+ SPIEE,-1,0,(fp)Read25xx,{0x1000000},0,(fp)Write25xx,{0x1000000,0x1000+256},0},//16M flash 3.3V
+//-------------One wire devices---------------------------------------------------------
+ {"DS2430",
+ OWEE,-1,0,(fp)ReadOneWireMem,{0x20,1},0,(fp)WriteOneWireMem,{0x20,1},0}, //32
+ {"DS2431",
+ OWEE,-1,0,(fp)ReadOneWireMem,{0x80,2},0,(fp)WriteOneWireMem,{0x80,0},0}, //128
+ {"DS2433",
+ OWEE,-1,0,(fp)ReadOneWireMem,{0x200,0},0,(fp)WriteOneWireMem,{0x200,1},0}, //512
+ {"DS28EC20",
+ OWEE,-1,0,(fp)ReadOneWireMem,{0xA00,2},0,(fp)WriteOneWireMem,{0xA00,1},0}, //2560
+ {"DS1820",
+ OWEE,-1,0,(fp)ReadDS1820,{-10},0,0,{0},0}, //digital thermometer
+//-------------UNIO devices---------------------------------------------------------
+ {"11010",
+ UNIOEE,-1,0,(fp)Read11xx,{0x80},0,(fp)Write11xx,{0x80,16},0}, //128
+ {"11020",
+ UNIOEE,-1,0,(fp)Read11xx,{0x100},0,(fp)Write11xx,{0x100,16},0}, //256
+ {"11040",
+ UNIOEE,-1,0,(fp)Read11xx,{0x200},0,(fp)Write11xx,{0x200,16},0}, //512
+ {"11080",
+ UNIOEE,-1,0,(fp)Read11xx,{0x400},0,(fp)Write11xx,{0x400,16},0}, //1k
+ {"11160",
+ UNIOEE,-1,0,(fp)Read11xx,{0x800},0,(fp)Write11xx,{0x800,16},0} //2k
+};
+
+int NDEVLIST = (sizeof(DEVLIST)/sizeof(struct DEVICES));
+
+//Add all devices to the appropriate structure
+#ifndef OPGUI
+void AddDevices(char *list){ //make sure list is long enough
+ int i;
+ static char last[8]="";
+ for(i=0;i<sizeof(devices)/sizeof(char*);i++){
+ if(last[0]) strcat(list,", ");
+ if(strncmp(devices[i],last,2)){
+ strcat(list,"\n");
+ last[0]=devices[i][0];
+ last[1]=devices[i][1];
+ last[2]=0;
+ }
+ strcat(list,devices[i]);
+ }
+}
+#endif
+
+//Make a list of all supported devices (insert \n between types)
+char* ListDevices(){
+ int i,len=0,l;
+ static char last[8]="";
+ char* list=0;
+ for(i=0;i<Ndevices;i++){
+ l=strlen(devices[i]);
+ if(!last[0]){
+ list=realloc(list,len+l+1);
+ strcpy(list+len,devices[i]);
+ len+=l;
+ }
+ else{
+ list=realloc(list,len+l+3);
+ if(strncmp(devices[i],last,2)) strcpy(list+len,",\n");
+ else strcpy(list+len,", ");
+ strcpy(list+len+2,devices[i]);
+ len+=l+2;
+ }
+ last[0]=devices[i][0];
+ last[1]=devices[i][1];
+ last[2]=0;
+ }
+ return list;
+}
+
+//Check that all devices in the list have a read/write function
+void CheckDevices(){
+ int i;
+ for(i=0;i<Ndevices;i++){
+ if(GetDevType(devices[i])<0){
+ printf("Can't find %s\n",devices[i]);fflush(stdout);
+ }
+ }
+ printf("OK %d devices\n",Ndevices);fflush(stdout);
+}
+
+//Main read function
+//parse all device names until "dev" is found,
+//then execute the read function with the right number of parameters
+void Read(char* dev,int ee,int r)
+{
+ int i,j;
+ int params[5];
+ char *str=0,*tok;
+#ifdef DEBUG
+ CheckDevices();
+#endif
+ for(i=0;i<sizeof(DEVLIST)/sizeof(DEVLIST[0]);i++){
+ if(str) free(str);
+ str=malloc(strlen(DEVLIST[i].device)+1);
+ strcpy(str,DEVLIST[i].device);
+ for(tok=strtok(str,",");tok;tok=strtok(NULL,",")){ //compare every device name
+ if(!strcmp(dev,tok)){ //proceed if found
+ for(j=0;j<4;j++) params[j]=DEVLIST[i].ReadParam[j];
+ if(DEVLIST[i].V33>0){ //3.3V required
+ if(!CheckV33Regulator()){
+ PrintMessage(strings[S_noV33reg]); //Can't find 3.3V expansion board
+ return;
+ }
+ }
+ if(hvreg!=DEVLIST[i].HV) hvreg=StartHVReg(DEVLIST[i].HV)>0?DEVLIST[i].HV:0;
+ if(DEVLIST[i].ReadPtr==0){
+ PrintMessage(strings[S_nodev_r]); //"Device not supported for reading\r\n");
+ return;
+ }
+ //call read function with the right number of arguments (better ways to do it???)
+ //need to cast to a function with the right number of parameters
+ switch(DEVLIST[i].family){
+ case PIC12:
+ if(r) params[1]=DEVLIST[i].ResArea; //modify reserved area parameter
+ ((void (*)(int,int))(DEVLIST[i].ReadPtr))(params[0],params[1]);
+ break;
+ case PIC16:
+ if(r) params[2]=DEVLIST[i].ResArea; //modify reserved area parameter
+ if(!ee) params[1]=0; //clear eeprom parameter
+ ((void (*)(int,int,int,int))(DEVLIST[i].ReadPtr))(params[0],params[1],params[2],params[3]);
+ break;
+ case PIC18:
+ if(!ee) params[1]=0; //clear eeprom parameter
+ ((void (*)(int,int,int))(DEVLIST[i].ReadPtr))(params[0],params[1],params[2]);
+ break;
+ case PIC24:
+ if(!ee) params[1]=0; //clear eeprom parameter
+ ((void (*)(int,int,int,int,int))(DEVLIST[i].ReadPtr))(params[0],params[1],params[2],params[3],r?DEVLIST[i].ResArea:0);
+ break;
+ case PIC32:
+ ((void (*)(int,int))(DEVLIST[i].ReadPtr))(params[0],params[1]);
+ break;
+ case AVR:
+ if(!ee) params[1]=0; //clear eeprom parameter
+ ((void (*)(int,int,int))(DEVLIST[i].ReadPtr))(params[0],params[1],params[2]);
+ break;
+ case I2CEE:
+ ((void (*)(int,int))(DEVLIST[i].ReadPtr))(params[0],params[1]);
+ break;
+ case UWEE:
+ ((void (*)(int,int,int))(DEVLIST[i].ReadPtr))(params[0],params[1],params[2]);
+ break;
+ case SPIEE:
+ ((void (*)(int))(DEVLIST[i].ReadPtr))(params[0]);
+ break;
+ case OWEE:
+ if(params[0]==-10) (*DEVLIST[i].ReadPtr)();
+ else ((void (*)(int,int))(DEVLIST[i].ReadPtr))(params[0],params[1]);
+ break;
+ case UNIOEE:
+ ((void (*)(int))(DEVLIST[i].ReadPtr))(params[0]);
+ break;
+ default:
+ PrintMessage(strings[S_nodev_r]); //"Device not supported for reading\r\n");
+ }
+ return;
+ }
+ }
+ }
+ PrintMessage(strings[S_nodev_r]); //"Device not supported for reading\r\n");
+}
+
+
+//Main write function
+//parse all device names until "dev" is found,
+//then execute the write function with the right number of parameters
+void Write(char* dev,int ee)
+{
+ int i,j;
+ int params[6];
+ char *str=0,*tok;
+ for(i=0;i<sizeof(DEVLIST)/sizeof(DEVLIST[0]);i++){
+ if(str) free(str);
+ str=malloc(strlen(DEVLIST[i].device)+1);
+ strcpy(str,DEVLIST[i].device);
+ for(tok=strtok(str,",");tok;tok=strtok(NULL,",")){ //compare every device name
+ if(!strcmp(dev,tok)){ //proceed if found
+ for(j=0;j<6;j++) params[j]=DEVLIST[i].WriteParam[j];
+ if(DEVLIST[i].V33>0){ //3.3V required
+ if(!CheckV33Regulator()){
+ PrintMessage(strings[S_noV33reg]); //Can't find 3.3V expansion board
+ return;
+ }
+ }
+ if(hvreg!=DEVLIST[i].HV) hvreg=StartHVReg(DEVLIST[i].HV)>0?DEVLIST[i].HV:0;
+ if(DEVLIST[i].WritePtr==0){
+ PrintMessage(strings[S_nodev_w]); //"Device not supported for writing\r\n");
+ return;
+ }
+ //call write function with the right number of arguments (better ways to do it???)
+ //need to cast to a function with the right number of parameters
+ switch(DEVLIST[i].family){
+ case PIC12:
+ ((void (*)(int,int))(DEVLIST[i].WritePtr))(params[0],params[1]);
+ break;
+ case PIC16:
+ if(!ee) params[1]=0; //clear eeprom parameter
+ if(params[2]==-10) ((void (*)(int,int))(DEVLIST[i].WritePtr))(params[0],params[1]);
+ else ((void (*)(int,int,int))(DEVLIST[i].WritePtr))(params[0],params[1],params[2]);
+ break;
+ case PIC18:
+ if(!ee) params[1]=0; //clear eeprom parameter
+ ((void (*)(int,int,int,int,int,int))(DEVLIST[i].WritePtr))(params[0],params[1],params[2],params[3],params[4],params[5]);
+ break;
+ case PIC24:
+ if(!ee) params[1]=0; //clear eeprom parameter
+ ((void (*)(int,int,int,int,int,int))(DEVLIST[i].WritePtr))(params[0],params[1],params[2],params[3],params[4],DEVLIST[i].WriteParamD);
+ break;
+ case AVR:
+ if(!ee) params[1]=0; //clear eeprom parameter
+ ((void (*)(int,int,int,int))(DEVLIST[i].WritePtr))(params[0],params[1],params[2],params[3]);
+ break;
+ case I2CEE:
+ ((void (*)(int,int,int))(DEVLIST[i].WritePtr))(params[0],params[1],params[2]);
+ break;
+ case UWEE:
+ ((void (*)(int,int,int))(DEVLIST[i].WritePtr))(params[0],params[1],params[2]);
+ break;
+ case SPIEE:
+ ((void (*)(int,int))(DEVLIST[i].WritePtr))(params[0],params[1]);
+ break;
+ case OWEE:
+ ((void (*)(int,int))(DEVLIST[i].WritePtr))(params[0],params[1]);
+ break;
+ case UNIOEE:
+ ((void (*)(int,int))(DEVLIST[i].WritePtr))(params[0],params[1]);
+ break;
+ default:
+ PrintMessage(strings[S_nodev_w]); //"Device not supported for writing\r\n");
+ }
+ return;
+ }
+ }
+ }
+ PrintMessage(strings[S_nodev_w]); //"Device not supported for writing\r\n");
+}
+
+///Search the device type
+int GetDevType(const char* dev)
+{
+ int i,type=-1;
+ char *str=0,*tok;
+ //parse all device names until "dev" is found
+ for(i=0;i<sizeof(DEVLIST)/sizeof(DEVLIST[0]);i++){
+ if(str) free(str);
+ str=malloc(strlen(DEVLIST[i].device)+1);
+ strcpy(str,DEVLIST[i].device);
+ for(tok=strtok(str,",");tok;tok=strtok(NULL,",")){ //compare every device name
+ if(!strcmp(dev,tok)){ //proceed if found
+ type=DEVLIST[i].family;
+ tok=0;
+ i=sizeof(DEVLIST)/sizeof(DEVLIST[0]);
+ }
+ }
+ }
+ free(str);
+ return type;
+}
+
+/// Determine the group of a specific device
+enum group_t nameToGroup(const char *devName) {
+ if(!strncmp(devName,"10F",3)||!strncmp(devName,"12F",3)||!strncmp(devName,"12C",3)||!strncmp(devName,"12LF",4))
+ return G_PIC_10_12;
+ if(!strncmp(devName,"16F",3)||!strncmp(devName,"16LF",4)||!strncmp(devName,"16C",3))
+ return G_PIC_16;
+ if(!strncmp(devName,"18F",3))
+ return G_PIC_18;
+ if(!strncmp(devName,"24F",3)||!strncmp(devName,"24H",3)||!strncmp(devName,"24E",3))
+ return G_PIC_24;
+ if(!strncmp(devName,"30F",3)||!strncmp(devName,"33F",3)||!strncmp(devName,"33E",3))
+ return G_PIC_30_33;
+ if(!strncmp(devName,"AT",2))
+ return G_ATMEL;
+ if(!strncmp(devName,"24",2)||!strncmp(devName,"25",2)||!strncmp(devName,"93",2)|| \
+ !strncmp(devName,"95",2)||!strncmp(devName,"11",2)||!strncmp(devName,"DS",2))
+ return G_EEPROM;
+ PrintMessage1("can't determine group of device '%s'\n",devName);
+ return -1;
+}
+
+/// Copies the device info from the passed devlist entry into the passed DevInfo
+/// Does NOT populate fields 'device' and 'group' as these are device-specific
+void populateDevInfo(struct DevInfo *info, const struct DEVICES *devlistEntry) {
+ char str2[256],str3[64],strF[32];
+ info->family=devlistEntry->family;
+ info->HV=devlistEntry->HV;
+ info->V33=devlistEntry->V33;
+ info->size=devlistEntry->ReadParam[0];
+ info->sizeEE=devlistEntry->WriteParam[1]; //some devices implement auto EE size on read, but never on write
+ str2[0]=0;
+ double x=info->size/1024.0;
+ if(x-(int)x) sprintf(strF,"%.1f",x);
+ else sprintf(strF,"%d",(int)x);
+ switch(info->family){
+ case PIC12:
+ sprintf(str2,"PIC12, ");
+ if(info->size<1024) sprintf(str3,"%dW FLASH",info->size);
+ else sprintf(str3,"%sKW FLASH",strF);
+ strcat(str2,str3);
+ break;
+ case PIC16:
+ sprintf(str2,"PIC16, ");
+ if(info->size<1024) sprintf(str3,"%dW FLASH",info->size);
+ else sprintf(str3,"%sKW FLASH",strF);
+ strcat(str2,str3);
+ if(info->sizeEE){
+ int ee=info->sizeEE;
+ if(ee<0) ee=-ee;
+ sprintf(str3," + %dB EEPROM",ee);
+ strcat(str2,str3);
+ }
+ break;
+ case PIC18:
+ sprintf(str2,"PIC18, ");
+ if(info->size<1024) sprintf(str3,"%dB FLASH ",info->size);
+ else sprintf(str3,"%sKB FLASH ",strF);
+ strcat(str2,str3);
+ if(info->sizeEE){
+ sprintf(str3,"+ %dB EEPROM ",info->sizeEE);
+ strcat(str2,str3);
+ }
+ break;
+ case PIC24:
+ sprintf(str2,"PIC24, ");
+ if(info->size<1024) sprintf(str3,"%dW FLASH",info->size);
+ else sprintf(str3,"%sKW FLASH",strF);
+ strcat(str2,str3);
+ if(info->sizeEE){
+ sprintf(str3," + %dB EEPROM",info->sizeEE);
+ strcat(str2,str3);
+ }
+ break;
+ case PIC32:
+ sprintf(str2,"PIC32, ");
+ if(info->size<1024) sprintf(str3,"%dW FLASH",info->size);
+ else sprintf(str3,"%sKW FLASH",strF);
+ strcat(str2,str3);
+ if(info->sizeEE){
+ sprintf(str3," + %dB EEPROM",info->sizeEE);
+ strcat(str2,str3);
+ }
+ break;
+ case AVR:
+ sprintf(str2,"AVR, ");
+ if(info->size<1024) sprintf(str3,"%dB FLASH",info->size);
+ else sprintf(str3,"%sKB FLASH",strF);
+ strcat(str2,str3);
+ if(info->sizeEE){
+ sprintf(str3," + %dB EEPROM",info->sizeEE);
+ strcat(str2,str3);
+ }
+ break;
+ case I2CEE:
+ if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_I2CMEM],info->size); //I2C Memory
+ else sprintf(str2,"%s, %sKB",strings[I_I2CMEM],strF); //I2C Memory
+ break;
+ case SPIEE:
+ if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_SPIMEM],info->size); //SPI Memory
+ else sprintf(str2,"%s, %sKB",strings[I_SPIMEM],strF); //SPI Memory
+ break;
+ case UWEE:
+ if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_UWMEM],info->size); //Microwire Memory
+ else sprintf(str2,"%s,%sKB",strings[I_UWMEM],strF);
+ break;
+ case OWEE:
+ if(info->size<0) sprintf(str2,strings[I_OWDEV]); //OneWire device
+ else if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_OWMEM],info->size); //OneWire Memory
+ else sprintf(str2,"%s, %sKB",strings[I_OWMEM],strF);
+ break;
+ case UNIOEE:
+ if(info->size<1024) sprintf(str2,"%s, %dB",strings[I_UNIOMEM],info->size); //UNI/O Memory
+ else sprintf(str2,"%s, %sKB",strings[I_UNIOMEM],strF);
+ break;
+ default:
+ sprintf(str2,"!!unknown family!!");
+ }
+ if(info->HV>0){
+ sprintf(str3,", %.1fV",info->HV);
+ strcat(str2,str3);
+ }
+ if(info->V33){
+ strcat(str2,", ");
+ strcat(str2,strings[I_3V3REQUIRED]); // 3.3V adapter
+ }
+ info->features=malloc(strlen(str2)+1);
+ strcpy(info->features,str2);
+}
+
+
+///Search and return device info
+struct DevInfo GetDevInfo(const char* dev)
+{
+ int i;
+ char *str=0,*tok;
+ struct DevInfo info;
+ info.device=0;
+ info.family=-1;
+ info.HV=-1;
+ info.V33=-1;
+ info.size=-1;
+ info.sizeEE=-1;
+ info.features=0;
+ //parse all device names until "dev" is found
+ for(i=0;i<NDEVLIST;i++){
+ str=malloc(strlen(DEVLIST[i].device)+1);
+ strcpy(str,DEVLIST[i].device);
+ for(tok=strtok(str,",");tok;tok=strtok(NULL,",")){ //compare every device name
+ if(!strcmp(dev,tok)){ //proceed if found
+ info.device=malloc(strlen(tok)+1);
+ strcpy(info.device,tok);
+ info.group=nameToGroup(info.device);
+ populateDevInfo(&info, &(DEVLIST[i]));
+ free(str);
+ return info;
+ }
+ }
+ free(str);
+ }
+ return info;
+}
diff --git a/fileIO.c b/fileIO.c
index 30da4b0..8ac79ca 100644
--- a/fileIO.c
+++ b/fileIO.c
@@ -1,6 +1,6 @@
/*
* fileIO.c - file read and write
- * Copyright (C) 2010-2021 Alberto Maccioni
+ * Copyright (C) 2010-2025 Alberto Maccioni
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -25,6 +25,7 @@
#include "progP18.h"
#include "progP24.h"
#include "progAVR.h"
+#include "deviceRW.h"
unsigned int htoi(const char *hex, int length)
{
@@ -40,14 +41,14 @@ unsigned int htoi(const char *hex, int length)
return v;
}
-void Save(char* dev,char* savefile)
+void Save(int devType,char* savefile)
{
FILE* f=fopen(savefile,"w");
if(!f) return;
char str[512],str1[512]="";
int i,sum=0,count=0,ext=0,s,base;
//**************** 10-16F *******************************************
- if(!strncmp(dev,"10",2)||!strncmp(dev,"12",2)||!strncmp(dev,"16",2)){
+ if(devType==PIC12||devType==PIC16){
int x=0x3fff,addr;
//if(!strncmp(dev,"16",2)||!strncmp(dev,"12F6",4)) x=0x3fff;
fprintf(f,":020000040000FA\n"); //extended address=0
@@ -102,7 +103,7 @@ void Save(char* dev,char* savefile)
fprintf(f,":00000001FF\n");
}
//**************** 18F *******************************************
- else if(!strncmp(dev,"18F",3)){
+ else if(devType==PIC18){
fprintf(f,":020000040000FA\n"); //extended address=0
for(i=0;i<size&&memCODE[i]==0xff;i++); //remove leading 0xFF
for(;i<size;i++){
@@ -197,7 +198,7 @@ void Save(char* dev,char* savefile)
fprintf(f,":00000001FF\n");
}
//**************** 24F *******************************************
- else if((!strncmp(dev,"24F",3)||!strncmp(dev,"24H",3)||!strncmp(dev,"24E",3)||!strncmp(dev,"30F",3)||!strncmp(dev,"33F",3)||!strncmp(dev,"33E",3))){
+ else if(devType==PIC24){
int valid;
fprintf(f,":020000040000FA\n"); //extended address=0
int sum=0,count=0,s,word;
@@ -269,7 +270,7 @@ void Save(char* dev,char* savefile)
fprintf(f,":00000001FF\n");
}
//**************** ATxxxx *******************************************
- else if(!strncmp(dev,"AT",2)){
+ else if(devType==AVR){
fprintf(f,":020000040000FA\n"); //extended address=0
for(i=0;i<size&&memCODE[i]==0xff;i++); //remove leading 0xFF
for(;i<size;i++){
@@ -299,8 +300,7 @@ void Save(char* dev,char* savefile)
fprintf(f,":00000001FF\n");
}
//**************** 24xxx / 93xxx / 25xxx / 95xxx / DSxxxx *******************************************
- else if(!strncmp(dev,"24",2)||!strncmp(dev,"93",2)||!strncmp(dev,"25",2)||!strncmp(dev,"95",2)||\
- !strncmp(dev,"DS",2)||!strncmp(dev,"11",2)){
+ else if(devType==I2CEE||devType==SPIEE||devType==UWEE||devType==OWEE||devType==UNIOEE){
if(strstr(savefile,".bin")||strstr(savefile,".BIN")){
#ifdef _WIN32
//brain-damaged op. systems need this to avoid messing with some bytes
@@ -340,11 +340,11 @@ void Save(char* dev,char* savefile)
if(f) fclose(f);
}
-void SaveEE(char* dev,char* savefile){
+void SaveEE(int devType,char* savefile){
FILE* f=fopen(savefile,"w");
if(!f) return;
//**************** ATMEL *******************************************
- if(!strncmp(dev,"AT",2)){
+ else if(devType==AVR){
char str[512],str1[512]="";
int i,base;
fprintf(f,":020000040000FA\n"); //extended address=0
@@ -374,14 +374,14 @@ void SaveEE(char* dev,char* savefile){
if(f) fclose(f);
}
-int Load(char*dev,char*loadfile){
+int Load(int devType,char*loadfile){
int i,input_address=0,ext_addr=0,sum,valid;
char line[256];
FILE* f=fopen(loadfile,"r");
if(!f) return -1;
- PrintMessage1("%s :\r\n",loadfile);
+ PrintMessage2("[%d] %s :\r\n",devType,loadfile);
//**************** 10-16F *******************************************
- if(!strncmp(dev,"10",2)||!strncmp(dev,"12",2)||!strncmp(dev,"16",2)){
+ if(devType==PIC12||devType==PIC16){
unsigned char buffer[0x20000],bufferEE[0x1000];
int sizeM=0;
memset(buffer,0xFF,sizeof(buffer));
@@ -451,7 +451,7 @@ int Load(char*dev,char*loadfile){
PrintMessage("\r\n");
}
//**************** 18F *******************************************
- else if(!strncmp(dev,"18F",3)){
+ else if(devType==PIC18){
unsigned char buffer[0x30000],bufferEE[0x1000];
int sizeM;
memset(buffer,0xFF,sizeof(buffer));
@@ -487,7 +487,7 @@ int Load(char*dev,char*loadfile){
memID[input_address+i]=htoi(line+9+i*2,2);
}
}
- else if(ext_addr==0x30&&input_address<14){ //CONFIG: 0x300000
+ else if(ext_addr==0x30&&input_address<32){ //CONFIG: 0x300000
for (i=0;i<hex_count;i++){
memCONFIG[input_address+i]=htoi(line+9+i*2,2);
}
@@ -521,9 +521,11 @@ int Load(char*dev,char*loadfile){
PrintMessage(strings[S_IDMem]); //"ID memory:\r\n"
for(i=0;i<8;i+=2) PrintMessage4("ID%d: 0x%02X ID%d: 0x%02X\r\n",i,memID[i],i+1,memID[i+1]);
PrintMessage(strings[S_ConfigMem]); //"CONFIG memory:\r\n"
- for(i=0;i<7;i++){
- PrintMessage2(strings[S_ConfigWordH],i+1,memCONFIG[i*2+1]); //"CONFIG%dH: 0x%02X\t"
- PrintMessage2(strings[S_ConfigWordL],i+1,memCONFIG[i*2]); //"CONFIG%dL: 0x%02X\r\n"
+ for(i=0;i<12;i++){
+ PrintMessage2("[0x%06X] 0x%02X\r\n",0x300000+i,memCONFIG[i]);
+ }
+ for(;i<32;i++){ //only not empty locations
+ if(memCONFIG[i]!=0xFF) PrintMessage2("[0x%06X] 0x%02X\r\n",0x300000+i,memCONFIG[i]);
}
PrintMessage(strings[S_CodeMem]); //"\r\nCODE memory:\r\n"
DisplayCODE18F(size);
@@ -531,7 +533,7 @@ int Load(char*dev,char*loadfile){
PrintMessage("\r\n");
}
//**************** 24F *******************************************
- else if(!strncmp(dev,"24F",3)||!strncmp(dev,"24H",3)||!strncmp(dev,"24E",3)||!strncmp(dev,"30F",3)||!strncmp(dev,"33F",3)||!strncmp(dev,"33E",3)){
+ else if(devType==PIC24){
unsigned char *buffer,bufferEE[0x2000];
int d;
buffer=(unsigned char*)malloc(0x100000);
@@ -621,7 +623,7 @@ int Load(char*dev,char*loadfile){
PrintMessage("\r\n");
}
//**************** ATxxxx *******************************************
- else if(!strncmp(dev,"AT",2)){
+ else if(devType==AVR){
unsigned char buffer[0x30000];
memset(buffer,0xFF,sizeof(buffer));
for(;fgets(line,256,f);){
@@ -666,8 +668,7 @@ int Load(char*dev,char*loadfile){
PrintMessage("\r\n");
}
//**************** 24xxx / 93xxx / 25xxx / 95xxx / DSxxxx /11xxx *******************************
- else if(!strncmp(dev,"24",2)||!strncmp(dev,"93",2)||!strncmp(dev,"25",2)||!strncmp(dev,"95",2)||\
- !strncmp(dev,"DS",2)||!strncmp(dev,"11",2)){
+ else if(devType==I2CEE||devType==SPIEE||devType==UWEE||devType==OWEE||devType==UNIOEE){
if(strstr(loadfile,".bin")||strstr(loadfile,".BIN")){
#ifdef _WIN32
//brain-damaged op. systems need this to avoid messing with some bytes
@@ -743,12 +744,12 @@ int Load(char*dev,char*loadfile){
return 0;
}
-void LoadEE(char*dev,char*loadfile){
+void LoadEE(int devType,char*loadfile){
FILE* f=fopen(loadfile,"r");
if(!f) return;
int i;
//**************** ATMEL *******************************************
- if(!strncmp(dev,"AT",2)){
+ if(devType==AVR){
char line[256];
int input_address=0,ext_addr=0;
unsigned char bufferEE[0x1000];
diff --git a/fileIO.h b/fileIO.h
index 339d5a9..941d8b7 100644
--- a/fileIO.h
+++ b/fileIO.h
@@ -1,8 +1,8 @@
unsigned int htoi(const char *hex, int length);
-void Save(char* dev,char* savefile);
-int Load(char*dev,char*loadfile);
-void SaveEE(char* dev,char* savefile);
-int LoadEE(char*dev,char*loadfile);
+void Save(int devType,char* savefile);
+int Load(int devType,char*loadfile);
+void SaveEE(int devType,char* savefile);
+int LoadEE(int devType,char*loadfile);
void OpenLogFile(void);
void WriteLogIO();
void CloseLogFile();
diff --git a/instructions.h b/instructions.h
index bb96aa0..487d78e 100644
--- a/instructions.h
+++ b/instructions.h
@@ -66,7 +66,7 @@
#define uWTX 0x3C //+1+NB
#define uWRX 0x3D //+1B ->+1+NB
#define SIX_LONG 0x3E //+3B
-#define SIX_N 0x3F //+1+3NB ->1B
+#define SIX_N 0x3F //+1+3NB
#define OW_RESET 0x40 // ->1B
#define OW_WRITE 0x41 //+1+NB
#define OW_READ 0x42 //+1B ->1+NB
@@ -75,7 +75,7 @@
#define SET_PORT_DIR 0x45 //+2B
#define READ_B 0x46 // ->1B
#define READ_AC 0x47 // ->1B
-#define AT_HV_RTX 0x48 //+1+NB ->1B
+#define AT_HV_RTX 0x48 //+1+2NB ->1B
#define SIX_LONG5 0x49 //+3B
#define LOAD_PC 0x50 //+2B 011101
#define LOAD_DATA_INC 0x51 //+2B 100010
diff --git a/op.c b/op.c
index 032e068..f34bc5a 100644
--- a/op.c
+++ b/op.c
@@ -1,6 +1,6 @@
/*
* op.c - control program for the open programmer
- * Copyright (C) 2009-2020 Alberto Maccioni
+ * Copyright (C) 2009-2025 Alberto Maccioni
* for detailed info see:
* http://openprog.altervista.org/
*
@@ -61,6 +61,7 @@ int DeviceDetected=0;
int skipV33check=0;
char dev[64]="";
int devType=0x10000;
+int useSAFLOCK_flag=0;
int main (int argc, char **argv) {
@@ -140,6 +141,7 @@ int main (int argc, char **argv) {
{"spispeed", required_argument, 0, 'D'},
{"support", no_argument, &support, 1},
{"use_BKosccal", no_argument, &use_BKosccal, 1},
+ {"use_SAFLOCK", no_argument,&useSAFLOCK_flag, 1},
{"version", no_argument, &ver, 1},
{"v", no_argument, &ver, 1},
{"vid", required_argument, 0, 'V'},
@@ -321,7 +323,7 @@ int main (int argc, char **argv) {
if(langfile) GenerateLangFile(langid,"languages.rc");
if (ver){
- printf("OP v%s\nCopyright (C) Alberto Maccioni 2009-2023\
+ printf("OP v%s\nCopyright (C) Alberto Maccioni 2009-2025\
\n For detailed info see http://openprog.altervista.org/\
\nThis program is free software; you can redistribute it and/or modify it under \
the terms of the GNU General Public License as published by the Free Software \
@@ -424,12 +426,12 @@ Foundation; either version 2 of the License, or (at your option) any later versi
}
if(loadfile[0]){ //write
- if(Load(dev,loadfile)==-1){
+ if(Load(devType,loadfile)==-1){
PrintMessage(strings[S_NoCode2]);
PrintMessage("\n");
exit(-1);
}
- if(!strncmp(dev,"AT",2)&&loadfileEE[0]) LoadEE(dev,loadfileEE);
+ if(!strncmp(dev,"AT",2)&&loadfileEE[0]) LoadEE(devType,loadfileEE);
//force config words
if(devType==PIC16){
if((!strncmp(dev,"16F1",4)||!strncmp(dev,"12F1",4))&&sizeW>0x8008){ //16F1xxx
@@ -543,8 +545,8 @@ Foundation; either version 2 of the License, or (at your option) any later versi
}
else Read(dev,ee,r); //choose the right function
- if(savefile[0]) Save(dev,savefile);
- if(!strncmp(dev,"AT",2)&&savefileEE[0]) SaveEE(dev,savefileEE);
+ if(savefile[0]) Save(devType,savefile);
+ if(!strncmp(dev,"AT",2)&&savefileEE[0]) SaveEE(devType,savefileEE);
}
#if !defined _WIN32 && !defined __CYGWIN__ //Linux
diff --git a/opgui.c b/opgui.c
index c93dc86..b935466 100644
--- a/opgui.c
+++ b/opgui.c
@@ -2,7 +2,7 @@
* \file opgui.c
* main control program for the open programmer
*
- * Copyright (C) 2009-2023 Alberto Maccioni
+ * Copyright (C) 2009-2025 Alberto Maccioni
* for detailed info see:
* http://openprog.altervista.org/
*
@@ -50,7 +50,7 @@ int IOTimer=0;
int skipV33check=0;
int waitS1=0,waitingS1=0;
int progress=0;
-
+int useSAFLOCK_flag=0;
#ifdef DEBUG
int addrDebug=0;
unsigned short dataDebug=0;
@@ -79,6 +79,7 @@ GtkWidget * EEPROM_RW;
GtkWidget * ReadReserved;
GtkWidget * Write_ID_BKCal;
GtkWidget * WriteCalib12;
+GtkWidget * UseSaflock;
GtkWidget * UseOSCCAL;
GtkWidget * UseBKOSCCAL;
GtkWidget * UseFileCal;
@@ -214,7 +215,7 @@ void info(GtkWidget *widget,GtkWidget *window)
//"authors","Alberto Maccioni",NULL,
"comments", "A graphical interface for the Open Programmer",
"copyright",
- "Copyright (C) Alberto Maccioni 2009-2023\n\n"
+ "Copyright (C) Alberto Maccioni 2009-2025\n\n"
"This program is free software; you can \n"
"redistribute it and/or modify it under \n"
"the terms of the GNU General Public License \n"
@@ -282,7 +283,10 @@ void getOptions()
programID = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(Write_ID_BKCal));
max_err=atoi(gtk_entry_get_text(GTK_ENTRY(Errors_entry)));
load_calibword= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(WriteCalib12));
- load_osccal= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(UseOSCCAL));
+ useSAFLOCK_flag= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(UseSaflock));
+ //load_osccal means load from file so it is the opposite of "OSCCal" setting
+ //no need to check FileCal
+ load_osccal= !(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(UseOSCCAL)));
load_BKosccal= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(UseBKOSCCAL));
ICDenable= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ICD_check));
readRes= gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(ReadReserved));
@@ -429,9 +433,9 @@ void Fopen(GtkWidget *widget,GtkWidget *window)
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
if(cur_path) free(cur_path);
cur_path = gtk_file_chooser_get_current_folder(dialog);
- Load(dev,filename);
+ Load(devType,filename);
g_free (filename);
- if(!strncmp(dev,"AT",2)){ //load EEPROM from separate file for ATMEL chips
+ if(devType==AVR){ //load EEPROM from separate file for ATMEL chips
GtkFileChooser *dialog2;
dialog2 = (GtkFileChooser*) gtk_file_chooser_dialog_new (strings[S_openEEfile],
GTK_WINDOW(window),
@@ -446,7 +450,7 @@ void Fopen(GtkWidget *widget,GtkWidget *window)
filename2 = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog2));
if(cur_pathEE) free(cur_pathEE);
cur_pathEE = gtk_file_chooser_get_current_folder(dialog2);
- LoadEE(dev,filename2);
+ LoadEE(devType,filename2);
g_free (filename2);
}
gtk_widget_destroy(GTK_WIDGET(dialog2));
@@ -476,10 +480,10 @@ void Fsave(GtkWidget *widget,GtkWidget *window)
filename = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog));
if(cur_path) free(cur_path);
cur_path = gtk_file_chooser_get_current_folder(dialog);
- Save(dev,filename);
+ Save(devType,filename);
PrintMessage1(strings[S_FileSaved],filename);
g_free (filename);
- if(!strncmp(dev,"AT",2)&&sizeEE){ //save EEPROM on separate file for ATMEL chips
+ if(devType==AVR){ //save EEPROM on separate file for ATMEL chips
GtkFileChooser *dialog2;
dialog2 = (GtkFileChooser*) gtk_file_chooser_dialog_new (strings[S_saveEEfile],
GTK_WINDOW(window),
@@ -495,7 +499,7 @@ void Fsave(GtkWidget *widget,GtkWidget *window)
filename2 = gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (dialog2));
if(cur_pathEE) free(cur_pathEE);
cur_pathEE = gtk_file_chooser_get_current_folder(dialog2);
- SaveEE(dev,filename2);
+ SaveEE(devType,filename2);
PrintMessage1(strings[S_FileSaved],filename2);
g_free (filename2);
}
@@ -665,6 +669,7 @@ void onDevSel_Changed(GtkWidget *widget,GtkWidget *window)
gtk_widget_show_all(GTK_WIDGET(devPIC_CW6));
gtk_widget_show_all(GTK_WIDGET(devPIC_CW7));
gtk_widget_show_all(GTK_WIDGET(devPIC_CW8));
+ gtk_widget_show_all(GTK_WIDGET(devPIC_CW8));
}
}
else{
@@ -1462,6 +1467,8 @@ int main( int argc, char *argv[])
gtk_button_set_label(GTK_BUTTON(Write_ID_BKCal),strings[I_ID_BKo_W]); //"Write ID and BKOscCal"
WriteCalib12 = GTK_WIDGET(gtk_builder_get_object(builder,"PROG_CAL12"));
gtk_button_set_label(GTK_BUTTON(WriteCalib12),strings[I_CalW]); //"Write Calib 1 and 2"
+ UseSaflock = GTK_WIDGET(gtk_builder_get_object(builder,"USE_SAFLOCK"));
+ gtk_button_set_label(GTK_BUTTON(UseSaflock),strings[I_Saflock]); //"Use SAFLOCK"
gtk_label_set_text(GTK_LABEL(GTK_WIDGET(gtk_builder_get_object(builder,"OSCCAL_L"))),strings[I_OSCW]); //"Write OscCal"
UseOSCCAL = GTK_WIDGET(gtk_builder_get_object(builder,"OSCCAL"));
gtk_button_set_label(GTK_BUTTON(UseOSCCAL),strings[I_OSC]); //"OSCCal"
@@ -1701,7 +1708,7 @@ int main( int argc, char *argv[])
//------status bar-------------
status_bar = GTK_WIDGET(gtk_builder_get_object(builder,"STATUS_B"));
statusID=gtk_statusbar_get_context_id(GTK_STATUSBAR(status_bar),"ID");
- //printf("load time: %dms\n",GetTickCount()-t0);fflush(stdout);
+ //printf("%dms> show window\n",GetTickCount()-t0);fflush(stdout);
gtk_widget_show_all(window);
//********Init*************
diff --git a/opgui.glade b/opgui.glade
index 194e5ac..12dc576 100644
--- a/opgui.glade
+++ b/opgui.glade
@@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
-<!-- Generated with glade 3.38.2 -->
+<!-- Generated with glade 3.40.0 -->
<interface>
<requires lib="gtk+" version="3.12"/>
<object class="GtkAdjustment" id="I2C_adj">
@@ -202,6 +202,7 @@
<property name="can-focus">True</property>
<property name="margin-start">5</property>
<property name="margin-top">5</property>
+ <property name="editable">False</property>
<style>
<class name="mono"/>
</style>
@@ -439,6 +440,20 @@
</packing>
</child>
<child>
+ <object class="GtkCheckButton" id="USE_SAFLOCK">
+ <property name="label" translatable="yes">_useSaflock</property>
+ <property name="visible">True</property>
+ <property name="can-focus">True</property>
+ <property name="receives-default">False</property>
+ <property name="draw-indicator">True</property>
+ </object>
+ <packing>
+ <property name="expand">False</property>
+ <property name="fill">True</property>
+ <property name="position">3</property>
+ </packing>
+ </child>
+ <child>
<object class="GtkFrame" id="OSC_OPT">
<property name="visible">True</property>
<property name="can-focus">False</property>
@@ -510,7 +525,7 @@
<packing>
<property name="expand">False</property>
<property name="fill">True</property>
- <property name="position">3</property>
+ <property name="position">4</property>
</packing>
</child>
</object>
diff --git a/progP16.c b/progP16.c
index be9f5a0..2f5f5f9 100644
--- a/progP16.c
+++ b/progP16.c
@@ -1,6 +1,6 @@
/**
* \file progP16.c - algorithms to program the PIC16 (14 bit word) family of microcontrollers
- * Copyright (C) 2009-2023 Alberto Maccioni
+ * Copyright (C) 2009-2025 Alberto Maccioni
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -175,6 +175,7 @@ struct ID16{
{0x2AE>>1,"16LF1784 rev%d\r\n",0x1F}, //10 1010 111x xxxx
{0x2B0>>1,"16LF1786 rev%d\r\n",0x1F}, //10 1011 000x xxxx
{0x2B2>>1,"16LF1787 rev%d\r\n",0x1F}, //10 1011 001x xxxx
+ {0x2BC>>1,"12LF1552 rev%d\r\n",0x1F}, //10 1011 110x xxxx
{0x2C0>>1,"16LF1903 rev%d\r\n",0x1F}, //10 1100 000x xxxx
{0x2C2>>1,"16LF1902 rev%d\r\n",0x1F}, //10 1100 001x xxxx
{0x2C4>>1,"16LF1907 rev%d\r\n",0x1F}, //10 1100 010x xxxx
@@ -225,6 +226,8 @@ struct ID16{
{0x3043,"16F1704\r\n",0},
{0x3044,"16LF1708\r\n",0},
{0x3045,"16LF1704\r\n",0},
+ {0x3046,"16LF1566\r\n",0},
+ {0x3047,"16LF1567\r\n",0},
{0x3048,"16F1716\r\n",0},
{0x3049,"16F1713\r\n",0},
{0x304A,"16LF1716\r\n",0},
@@ -417,6 +420,15 @@ struct ID16{
{0x3104,"16F17175\r\n",0},
{0x3105,"16F17156\r\n",0},
{0x3106,"16F17176\r\n",0},
+ {0x3121,"16F13113\r\n",0},
+ {0x3122,"16F13123\r\n",0},
+ {0x3123,"16F13143\r\n",0},
+ {0x3124,"16F13114\r\n",0},
+ {0x3125,"16F13124\r\n",0},
+ {0x3126,"16F13144\r\n",0},
+ {0x3127,"16F13115\r\n",0},
+ {0x3128,"16F13125\r\n",0},
+ {0x3129,"16F13145\r\n",0},
};
static bool PIC16_ID(int id)
@@ -597,6 +609,7 @@ void Read16Fxxx(int dim,int dim2,int dim3,int vdd)
PacketIO(vdd?55:5);
//****************** read code ********************
PrintMessage(strings[S_CodeReading1]); //read code ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_CodeReading1]); //read code ...
PrintStatusSetup();
for(i=0,j=0;i<dim;i++){
@@ -628,6 +641,7 @@ void Read16Fxxx(int dim,int dim2,int dim3,int vdd)
for(i=k;i<0x2000;i++) memCODE_W[i]=0x3fff;
//****************** read config area ********************
PrintMessage(strings[S_Read_CONFIG_A]); //read config ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_Read_CONFIG_A]); //read config ...
bufferU[j++]=LOAD_CONF; //counter at 0x2000
bufferU[j++]=0xFF; //fake config
@@ -661,6 +675,7 @@ void Read16Fxxx(int dim,int dim2,int dim3,int vdd)
//****************** read eeprom ********************
if(dim2){
PrintMessage(strings[S_ReadEE]); //Read EEPROM ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_ReadEE]); //Read EEPROM ...
PrintStatusSetup();
if(ee2200){ //eeprom a 0x2200
@@ -875,6 +890,7 @@ void Read16F1xxx(int dim,int dim2,int dim3,int options)
PacketIO(2);
//****************** read code ********************
PrintMessage(strings[S_CodeReading1]); //read code ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_CodeReading1]); //read code ...
PrintStatusSetup();
for(i=0,j=0;i<dim;i++){
@@ -905,6 +921,7 @@ void Read16F1xxx(int dim,int dim2,int dim3,int options)
else PrintMessage(strings[S_Compl]);
//****************** read config area ********************
PrintMessage(strings[S_Read_CONFIG_A]); //read config ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_Read_CONFIG_A]); //read config ...
bufferU[j++]=LOAD_CONF; //counter at 0x8000
bufferU[j++]=0xFF;
@@ -965,6 +982,7 @@ void Read16F1xxx(int dim,int dim2,int dim3,int options)
//****************** read eeprom ********************
if(dim2&&!F18x){ //16F1xxx
PrintMessage(strings[S_ReadEE]); //Read EEPROM ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_ReadEE]); //Read EEPROM ...
bufferU[j++]=CUST_CMD;
bufferU[j++]=0x16; //Reset address
@@ -998,6 +1016,7 @@ void Read16F1xxx(int dim,int dim2,int dim3,int options)
}
else if(dim2&&F18x){ //16F18xxx
PrintMessage(strings[S_ReadEE]); //Read EEPROM ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_ReadEE]); //Read EEPROM ...
bufferU[j++]=LOAD_PC; //counter at 0xF000
bufferU[j++]=0xF0;
@@ -1215,6 +1234,7 @@ void Read16F18xxx(int dim,int dim2,int dim3,int options)
PacketIO(2);
//****************** read code ********************
PrintMessage(strings[S_CodeReading1]); //read code ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_CodeReading1]); //read code ...
PrintStatusSetup();
for(i=0,j=0;i<dim;i++){
@@ -1245,6 +1265,7 @@ void Read16F18xxx(int dim,int dim2,int dim3,int options)
else PrintMessage(strings[S_Compl]);
//****************** read config area ********************
PrintMessage(strings[S_Read_CONFIG_A]); //read config ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_Read_CONFIG_A]); //read config ...
bufferU[j++]=ICSP8_LOAD; //counter at 0x8000
bufferU[j++]=LOAD_PC_ADDR;
@@ -1278,6 +1299,7 @@ void Read16F18xxx(int dim,int dim2,int dim3,int options)
else PrintMessage(strings[S_Compl]);
//****************** read device info area ********************
if(useDCI){ //if not disabled
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"Read device info area @0x8100\n");
bufferU[j++]=ICSP8_LOAD; //counter at 0x8000
bufferU[j++]=LOAD_PC_ADDR;
@@ -1309,6 +1331,7 @@ void Read16F18xxx(int dim,int dim2,int dim3,int options)
PrintMessage2(strings[S_ConfigErr],0x20,k2); //"Error reading config area, requested %d words, read %d\r\n"
}
//****************** read calibration area (Device Configuration Information) ********************
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"Read Device Configuration Information @0x8200\n");
bufferU[j++]=ICSP8_LOAD; //counter at 0x8200
bufferU[j++]=LOAD_PC_ADDR;
@@ -1352,6 +1375,7 @@ void Read16F18xxx(int dim,int dim2,int dim3,int options)
memEE=(unsigned char*)malloc(sizeEE); //EEPROM
for(i=0;i<sizeEE;i++) memEE[i]=0xFF;
PrintMessage(strings[S_ReadEE]); //Read EEPROM ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_ReadEE]); //Read EEPROM ...
bufferU[j++]=ICSP8_LOAD; //counter at 0xF000
bufferU[j++]=LOAD_PC_ADDR;
@@ -1551,6 +1575,8 @@ void Write12F6xx(int dim,int dim2)
}
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
bufferU[j++]=EN_VPP_VCC; //VPP
bufferU[j++]=0x4;
@@ -1599,6 +1625,8 @@ void Write12F6xx(int dim,int dim2)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
for(w=i=k=0,j=0;i<dim;i++){
if(memCODE_W[i]<0x3fff){
bufferU[j++]=LOAD_DATA_PROG;
@@ -1648,6 +1676,8 @@ void Write12F6xx(int dim,int dim2)
int err_e=0;
PrintMessage(strings[S_EEAreaW]); //"Writing EEPROM ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_EEAreaW]);
j=0;
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
@@ -1709,6 +1739,8 @@ void Write12F6xx(int dim,int dim2)
}
//****************** write ID, CONFIG, CALIB ********************
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
int ICDgoto=0x2800+(ICDaddr&0x7FF); //GOTO ICD routine (0x28xx)
bufferU[j++]=SET_PARAMETER;
@@ -1936,6 +1968,8 @@ void Write16F8x (int dim,int dim2)
PrintMessage1(strings[S_ConfigWord],config); //"Config word: 0x%04X\r\n"
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
@@ -2035,6 +2069,8 @@ void Write16F8x (int dim,int dim2)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
for(w=i=k=0,j=0;i<dim;i++){
if(memCODE_W[i]<0x3fff){
bufferU[j++]=LOAD_DATA_PROG;
@@ -2083,6 +2119,8 @@ void Write16F8x (int dim,int dim2)
if(dim2){
PrintMessage(strings[S_EEAreaW]); //"Writing EEPROM ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_EEAreaW]);
j=0;
bufferU[j++]=LOAD_CONF; //counter at 0x2000
bufferU[j++]=0xFF; //fake config
@@ -2137,6 +2175,8 @@ void Write16F8x (int dim,int dim2)
}
//****************** write ID, CONFIG ********************
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
bufferU[j++]=LOAD_CONF; //counter at 0x2000
bufferU[j++]=0xFF; //fake config
@@ -2300,6 +2340,8 @@ void Write16F62x (int dim,int dim2)
PrintMessage1(strings[S_ConfigWord],config); //"Config word: 0x%04X\r\n"
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
@@ -2363,6 +2405,8 @@ void Write16F62x (int dim,int dim2)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
for(w=i=k=0,j=0;i<dim;i++){
if(memCODE_W[i]<0x3fff){
bufferU[j++]=LOAD_DATA_PROG;
@@ -2411,6 +2455,8 @@ void Write16F62x (int dim,int dim2)
if(dim2){
PrintMessage(strings[S_EEAreaW]); //"Writing EEPROM ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_EEAreaW]);
j=0;
bufferU[j++]=LOAD_CONF; //counter at 0x2000
bufferU[j++]=0xFF; //fake config
@@ -2467,6 +2513,8 @@ void Write16F62x (int dim,int dim2)
}
//****************** write ID, CONFIG ********************
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
bufferU[j++]=LOAD_CONF; //counter at 0x2000
bufferU[j++]=0xFF; //fake config
@@ -2632,6 +2680,8 @@ void Write12F62x(int dim,int dim2)
if (!PIC16_ID(devID)) return;
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
bufferU[j++]=EN_VPP_VCC; //enter program mode
bufferU[j++]=0x0;
@@ -2671,6 +2721,8 @@ void Write12F62x(int dim,int dim2)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
if(!load_osccal) memCODE_W[dim-1]=osccal; //backup osccal
for(w=i=k=0,j=0;i<dim;i++){
if(memCODE_W[i]<0x3fff){
@@ -2720,6 +2772,8 @@ void Write12F62x(int dim,int dim2)
if(dim2){
PrintMessage(strings[S_EEAreaW]); //"Writing EEPROM ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_EEAreaW]);
j=0;
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
@@ -2781,6 +2835,8 @@ void Write12F62x(int dim,int dim2)
}
//****************** write ID, CONFIG, CALIB ********************
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
bufferU[j++]=LOAD_CONF; //counter at 0x2000
bufferU[j++]=0xFF; //fake config
@@ -2946,6 +3002,8 @@ void Write16F87x (int dim,int dim2)
PrintMessage1(strings[S_ConfigWord],config); //"Config word: 0x%04X\r\n"
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
@@ -3039,6 +3097,8 @@ void Write16F87x (int dim,int dim2)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
for(w=i=k=0,j=0;i<dim;i++){
if(memCODE_W[i]<0x3fff){
bufferU[j++]=LOAD_DATA_PROG;
@@ -3088,6 +3148,8 @@ void Write16F87x (int dim,int dim2)
int err_e=0;
PrintMessage(strings[S_EEAreaW]); //"Writing EEPROM ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_EEAreaW]);
j=0;
bufferU[j++]=LOAD_CONF; //counter at 0x2000
bufferU[j++]=0xFF; //fake config
@@ -3149,6 +3211,8 @@ void Write16F87x (int dim,int dim2)
}
//****************** write ID, CONFIG, CALIB ********************
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
int ICDgoto=0x2800+(ICDaddr&0x7FF); //GOTO ICD routine (0x28xx)
bufferU[j++]=SET_PARAMETER;
@@ -3330,6 +3394,8 @@ void Write16F87xA (int dim,int dim2,int seq)
PrintMessage1(strings[S_ConfigWord],config); //"Config word: 0x%04X\r\n"
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
@@ -3363,6 +3429,8 @@ void Write16F87xA (int dim,int dim2,int seq)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
for(w=i=k=0,j=0;i<dim;i++){
if(memCODE_W[i]<0x3fff){
bufferU[j++]=LOAD_DATA_PROG;
@@ -3414,6 +3482,8 @@ void Write16F87xA (int dim,int dim2,int seq)
int err_e=0;
PrintMessage(strings[S_EEAreaW]); //"Writing EEPROM ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_EEAreaW]);
j=0;
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
@@ -3473,6 +3543,8 @@ void Write16F87xA (int dim,int dim2,int seq)
}
//****************** write ID, CONFIG, CALIB ********************
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
int ICDgoto=0x2800+(ICDaddr&0x7FF); //GOTO ICD routine (0x28xx)
bufferU[j++]=SET_PARAMETER;
@@ -3672,6 +3744,8 @@ void Write16F81x (int dim,int dim2)
PrintMessage1(strings[S_ConfigWord],config); //"Config word: 0x%04X\r\n"
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
@@ -3717,6 +3791,8 @@ void Write16F81x (int dim,int dim2)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
for(w=i=k=0,j=0;i<dim;i++){
if(memCODE_W[i]<0x3fff){
bufferU[j++]=LOAD_DATA_PROG;
@@ -3768,6 +3844,8 @@ void Write16F81x (int dim,int dim2)
int err_e=0;
PrintMessage(strings[S_EEAreaW]); //"Writing EEPROM ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_EEAreaW]);
j=0;
bufferU[j++]=EN_VPP_VCC;
bufferU[j++]=0x1;
@@ -3840,6 +3918,8 @@ void Write16F81x (int dim,int dim2)
}
//****************** write ID, CONFIG, CALIB ********************
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
int ICDgoto=0x2800+(ICDaddr&0x7FF); //GOTO ICD routine (0x28xx)
bufferU[j++]=LOAD_CONF; //counter at 0x2000
@@ -4046,6 +4126,8 @@ void Write12F61x(int dim, int d, int d2)
if(calib2<0x3fff) PrintMessage1(strings[S_CalibWord2],calib2); //"Calib2: 0x%04X\r\n"
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
bufferU[j++]=EN_VPP_VCC; //enter program mode
bufferU[j++]=0x0;
@@ -4089,6 +4171,8 @@ void Write12F61x(int dim, int d, int d2)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
for(w=i=k=0,j=0;i<dim;i++){
if(memCODE_W[i]<0x3fff){
bufferU[j++]=LOAD_DATA_PROG;
@@ -4137,6 +4221,8 @@ void Write12F61x(int dim, int d, int d2)
PrintMessage1(strings[S_ComplErr],err); //"completed, %d errors\r\n"
//****************** write ID, CONFIG, CALIB ********************
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
bufferU[j++]=LOAD_CONF; //counter at 0x2000
bufferU[j++]=0xFF; //fake config
@@ -4329,6 +4415,8 @@ void Write16F88x(int dim,int dim2)
}
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
bufferU[j++]=EN_VPP_VCC; //enter program mode
bufferU[j++]=0x0;
@@ -4370,6 +4458,8 @@ void Write16F88x(int dim,int dim2)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
for(w=i=k=0,j=0;i<dim;i++){
if(memCODE_W[i]<0x3fff){
bufferU[j++]=LOAD_DATA_PROG;
@@ -4418,6 +4508,8 @@ void Write16F88x(int dim,int dim2)
if(dim2){
PrintMessage(strings[S_EEAreaW]); //"Writing EEPROM ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_EEAreaW]);
j=0;
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
@@ -4478,6 +4570,8 @@ void Write16F88x(int dim,int dim2)
}
//****************** write ID, CONFIG, CALIB ********************
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
int ICDgoto=0x2800+(ICDaddr&0x7FF); //GOTO ICD routine (0x28xx)
bufferU[j++]=SET_PARAMETER;
@@ -4675,6 +4769,8 @@ void Write16F7x(int dim,int vdd)
if (!PIC16_ID(devID)) return;
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
//enter program mode
bufferU[j++]=EN_VPP_VCC; //VDD
@@ -4722,6 +4818,8 @@ void Write16F7x(int dim,int vdd)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
for(w=i=k=0,j=0;i<dim;i++){
if(memCODE_W[i]<0x3fff){
bufferU[j++]=LOAD_DATA_PROG;
@@ -4769,6 +4867,8 @@ void Write16F7x(int dim,int vdd)
PrintMessage1(strings[S_ComplErr],err); //"completed, %d errors\r\n"
//****************** write ID, CONFIG, CALIB ********************
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
bufferU[j++]=LOAD_CONF; //counter at 0x2000
bufferU[j++]=0xFF; //fake config
@@ -4939,6 +5039,8 @@ void Write16F71x(int dim,int vdd)
if (!PIC16_ID(devID)) return;
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
//enter program mode
bufferU[j++]=EN_VPP_VCC; //VDD
@@ -4989,6 +5091,8 @@ void Write16F71x(int dim,int vdd)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
for(w=i=k=0,j=0;i<dim;i++){
if(memCODE_W[i]<0x3fff){
bufferU[j++]=LOAD_DATA_PROG;
@@ -5037,6 +5141,8 @@ void Write16F71x(int dim,int vdd)
PrintMessage1(strings[S_ComplErr],err); //"completed, %d errors\r\n"
//****************** write ID, CONFIG, CALIB ********************
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
bufferU[j++]=LOAD_CONF; //counter at 0x2000
bufferU[j++]=0xFF; //fake config
@@ -5206,6 +5312,8 @@ void Write16F72x(int dim, int d, int d2)
if (!PIC16_ID(devID)) return;
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
if(programID||ICDenable){
bufferU[j++]=LOAD_CONF; //counter at 0x2000
@@ -5229,6 +5337,8 @@ void Write16F72x(int dim, int d, int d2)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
for(w=i=k=0,j=0;i<dim;i++){
if(memCODE_W[i]<0x3fff){
bufferU[j++]=LOAD_DATA_PROG;
@@ -5275,6 +5385,8 @@ void Write16F72x(int dim, int d, int d2)
PrintMessage1(strings[S_ComplErr],err); //"completed, %d errors\r\n"
//****************** write ID, CONFIG, CALIB ********************
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
int ICDgoto=0x2800+(ICDaddr&0x7FF); //GOTO ICD routine (0x28xx)
bufferU[j++]=SET_PARAMETER;
@@ -5568,6 +5680,7 @@ void Write16F1xxx(int dim,int dim2,int options)
}
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erasing ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
int dly=8;
j=0;
@@ -5613,6 +5726,7 @@ void Write16F1xxx(int dim,int dim2,int options)
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
fflush(logfile);
int valid,inc;
@@ -5705,6 +5819,7 @@ void Write16F1xxx(int dim,int dim2,int options)
//****************** verify code ********************
PrintMessage(strings[S_CodeV]); //"Verifying code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_CodeV]);
j=0;
if(!F18x){
@@ -5775,6 +5890,7 @@ void Write16F1xxx(int dim,int dim2,int options)
int errEE=0;
PrintMessage(strings[S_EEAreaW]); //"Writing EEPROM ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_EEAreaW]);
j=0;
bufferU[j++]=SET_PARAMETER;
@@ -5838,6 +5954,7 @@ void Write16F1xxx(int dim,int dim2,int options)
int errEE=0;
PrintMessage(strings[S_EEAreaW]); //"Writing EEPROM ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_EEAreaW]);
j=0;
bufferU[j++]=SET_PARAMETER;
@@ -5904,6 +6021,7 @@ void Write16F1xxx(int dim,int dim2,int options)
//****************** write ID, CONFIG, CALIB ********************
if(max_err&&err<max_err){
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
bufferU[j++]=SET_PARAMETER;
@@ -5968,7 +6086,7 @@ void Write16F1xxx(int dim,int dim2,int options)
PacketIO(18+j);
for(i=0,z=0;programID&&i<4;i++){
for(;z<DIMBUF-2&&bufferI[z]!=READ_DATA_PROG;z++);
- if (memCODE_W[0x8000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
+ if(memCODE_W[0x8000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
PrintMessage("\r\n");
PrintMessage3(strings[S_IDErr],i,memCODE_W[0x8000+i],(bufferI[z+1]<<8)+bufferI[z+2]); //"Error writing ID%d: written %04X, read %04X\r\n"
err_c++;
@@ -6046,13 +6164,15 @@ void Write16F18xxx(int dim,int dim2,int options)
// bit0=1 -> vdd before vpp
// bit1=1 -> LVP programming
// bit4=1 -> do not use DIA&DCI
+// bit5=1 -> Bulk erase with bit field payload
+// bit6=1 -> workaround for 16F152XX: turn-off/on after bulk erase
// DevREV@0x8005 DevID@0x8006
// Config@0x8007-800B
// Device info area @0x8100
// Device configuration info area @0x8200
-// erase: BULK_ERASE_PROGRAM_MEM (0x18) +14ms
+// erase: BULK_ERASE_PROGRAM_MEM (0x18) +14ms or 20ms
// EEPROM erase: idem
-// write flash: LOAD_NVM (0x0/2) + BEGIN_INT_PROG (0xE0) + 2.8ms (32 word algorithm)
+// write flash: LOAD_NVM (0x0/2) + BEGIN_INT_PROG (0xE0) + 2.8ms/7ms (32 word algorithm)
// EEPROM write: one word, 6ms
// config write: one word, 10ms
// verify after write
@@ -6061,6 +6181,8 @@ void Write16F18xxx(int dim,int dim2,int options)
WORD devID=0x3fff,devREV=0x3fff;
int k=0,k2=0,z=0,i,j,w;
int useDCI=(options&0x10)==0?1:0;
+ int bulkEraseField=(options&0x20)?1:0;
+ int reboot=(options&0x40)?1:0;
int rowN=32; //32 word algorithm
if(FWVersion<0xB00){
PrintMessage1(strings[S_FWver2old],"0.11.0"); //"This firmware is too old. Version %s is required\r\n"
@@ -6141,8 +6263,14 @@ void Write16F18xxx(int dim,int dim2,int options)
bufferU[j++]=READ_NVM_INC; //DevID
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
- bufferU[j++]=2800>>8;
- bufferU[j++]=2800&0xff;
+ if(!bulkEraseField){
+ bufferU[j++]=2800>>8;
+ bufferU[j++]=2800&0xff;
+ }
+ else{ //max delay for devices with bulk erase bit field (only 131xx require 7ms)
+ bufferU[j++]=7000>>8;
+ bufferU[j++]=7000&0xff;
+ }
bufferU[j++]=FLUSH;
for(;j<DIMBUF;j++) bufferU[j]=0x0;
PacketIO(5);
@@ -6157,6 +6285,7 @@ void Write16F18xxx(int dim,int dim2,int options)
if(memCODE_W[0x8006]<0x3FFF&&devID!=memCODE_W[0x8006]) PrintMessage(strings[S_DevMismatch]); //"Warning: the device is different from what specified in source data"
//****************** DIA-DCI ********************
if(useDCI){ //if not disabled
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"Device Information Area @0x8100\n");
WORD DIA[0x20];
bufferU[j++]=ICSP8_LOAD; //counter at 0x8100
@@ -6240,44 +6369,78 @@ void Write16F18xxx(int dim,int dim2,int options)
}
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erasing ... "
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_StartErase]);
j=0;
- bufferU[j++]=ICSP8_LOAD;
- bufferU[j++]=LOAD_PC_ADDR;
- if(programID){ //0x8000 to erase UserID
- bufferU[j++]=0x80;
- bufferU[j++]=0x00;
+ if(!bulkEraseField){ //bulk erase various regions depending on memory address
+ bufferU[j++]=ICSP8_LOAD;
+ bufferU[j++]=LOAD_PC_ADDR;
+ if(programID){ //0x8000 to erase UserID
+ bufferU[j++]=0x80;
+ bufferU[j++]=0x00;
+ }
+ else{ //only flash and config
+ bufferU[j++]=0x00;
+ bufferU[j++]=0x00;
+ }
+ bufferU[j++]=ICSP8_SHORT;
+ bufferU[j++]=BULK_ERASE_PROGRAM_MEM;
+ bufferU[j++]=WAIT_T3; // wait ~14ms
+ bufferU[j++]=WAIT_T3;
+ bufferU[j++]=WAIT_T3;
+ bufferU[j++]=WAIT_T3;
+ bufferU[j++]=WAIT_T3;
+ if(dim2){ //separate EEPROM erase (undocumented on 16F184xx devices)
+ bufferU[j++]=ICSP8_LOAD;
+ bufferU[j++]=LOAD_PC_ADDR;
+ bufferU[j++]=0xF0;
+ bufferU[j++]=0x00;
+ bufferU[j++]=ICSP8_SHORT;
+ bufferU[j++]=BULK_ERASE_PROGRAM_MEM;
+ bufferU[j++]=WAIT_T3; // wait ~14ms
+ bufferU[j++]=WAIT_T3;
+ bufferU[j++]=WAIT_T3;
+ bufferU[j++]=WAIT_T3;
+ bufferU[j++]=WAIT_T3;
+ }
}
- else{
+ else{ //bulk erase with bit field
+ bufferU[j++]=ICSP8_LOAD;
+ bufferU[j++]=LOAD_PC_ADDR;
+ bufferU[j++]=0x00;
bufferU[j++]=0x00;
+ bufferU[j++]=ICSP8_LOAD;
+ bufferU[j++]=BULK_ERASE_PROGRAM_MEM;
bufferU[j++]=0x00;
+ bufferU[j++]=programID?0x0F:0x0B;
+ bufferU[j++]=WAIT_T3; //3x7ms
+ bufferU[j++]=WAIT_T3;
+ bufferU[j++]=WAIT_T3;
}
- bufferU[j++]=ICSP8_SHORT;
- bufferU[j++]=BULK_ERASE_PROGRAM_MEM;
- bufferU[j++]=WAIT_T3; // wait ~14ms
- bufferU[j++]=WAIT_T3;
- bufferU[j++]=WAIT_T3;
- bufferU[j++]=WAIT_T3;
- bufferU[j++]=WAIT_T3;
- //separate EEPROM erase (undocumented on 16F184xx devices)
- bufferU[j++]=ICSP8_LOAD;
- bufferU[j++]=LOAD_PC_ADDR;
- bufferU[j++]=0xF0;
- bufferU[j++]=0x00;
- bufferU[j++]=ICSP8_SHORT;
- bufferU[j++]=BULK_ERASE_PROGRAM_MEM;
- bufferU[j++]=WAIT_T3; // wait ~14ms
- bufferU[j++]=WAIT_T3;
- bufferU[j++]=WAIT_T3;
- bufferU[j++]=WAIT_T3;
- bufferU[j++]=WAIT_T3;
bufferU[j++]=FLUSH;
for(;j<DIMBUF;j++) bufferU[j]=0x0;
PacketIO(30);
PrintMessage(strings[S_Compl]); //"completed\r\n"
+//**************** Workaround for 152xx: apparently it does not return from bulk erase
+ if(reboot){
+ j=0;
+ bufferU[j++]=EN_VPP_VCC; //enter program mode
+ bufferU[j++]=0x0;
+ bufferU[j++]=SET_CK_D;
+ bufferU[j++]=0x0;
+ bufferU[j++]=WAIT_T3;
+ bufferU[j++]=EN_VPP_VCC;
+ bufferU[j++]=4; //VPP
+ bufferU[j++]=EN_VPP_VCC;
+ bufferU[j++]=0x5; //VDD+VPP
+ bufferU[j++]=FLUSH;
+ for(;j<DIMBUF;j++) bufferU[j]=0x0;
+ PacketIO(2);
+ }
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"Write code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_StartCodeProg]);
fflush(logfile);
int valid;
@@ -6306,7 +6469,7 @@ void Write16F18xxx(int dim,int dim2,int options)
}
if(i<dim){
bufferU[j++]=ICSP8_SHORT;
- bufferU[j++]=BEGIN_INT_PROG; //internally timed, T=2.8ms
+ bufferU[j++]=BEGIN_INT_PROG; //internally timed, T=2.8ms or 7ms
bufferU[j++]=WAIT_T3;
bufferU[j++]=FLUSH;
for(;j<DIMBUF;j++) bufferU[j]=0x0;
@@ -6323,6 +6486,7 @@ void Write16F18xxx(int dim,int dim2,int options)
//****************** verify code ********************
PrintMessage(strings[S_CodeV]); //"Verifying code ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_CodeV]);
j=0;
bufferU[j++]=ICSP8_LOAD;
@@ -6379,6 +6543,7 @@ void Write16F18xxx(int dim,int dim2,int options)
int errEE=0;
PrintMessage(strings[S_EEAreaW]); //"Writing EEPROM ... "
PrintStatusSetup();
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_EEAreaW]);
j=0;
bufferU[j++]=SET_PARAMETER;
@@ -6449,12 +6614,14 @@ void Write16F18xxx(int dim,int dim2,int options)
char t[256];
PrintMessage(strings[S_ConfigAreaW]); //"Writing CONFIG area ... "
PrintMessage("\r\n");
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_ConfigAreaW]);
int err_c=0;
+ j=0;
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
- bufferU[j++]=10000>>8; //5.6ms in datasheet, but requires more in practice
- bufferU[j++]=10000&0xff;
+ bufferU[j++]=12000>>8; //some require 5.6ms, others up to 12ms
+ bufferU[j++]=12000&0xff;
if(programID){
bufferU[j++]=ICSP8_LOAD;
bufferU[j++]=LOAD_PC_ADDR; //load address
@@ -6467,13 +6634,13 @@ void Write16F18xxx(int dim,int dim2,int options)
bufferU[j++]=memCODE_W[i]&0xff; //LSB
bufferU[j++]=ICSP8_SHORT;
bufferU[j++]=BEGIN_INT_PROG; //internally timed
- bufferU[j++]=WAIT_T3; //Tprogram 10ms
+ bufferU[j++]=WAIT_T3; //Tprogram 12ms
bufferU[j++]=ICSP8_READ;
bufferU[j++]=READ_NVM_INC;
}
bufferU[j++]=FLUSH;
for(;j<DIMBUF;j++) bufferU[j]=0x0;
- PacketIO(45);
+ PacketIO(50);
for(i=0,z=0;i<4;i++){
for(;z<DIMBUF-2&&bufferI[z]!=ICSP8_READ;z++);
if (memCODE_W[0x8000+i]!=(bufferI[z+1]<<8)+bufferI[z+2]){
@@ -6495,13 +6662,13 @@ void Write16F18xxx(int dim,int dim2,int options)
bufferU[j++]=memCODE_W[i]&0xff; //LSB
bufferU[j++]=ICSP8_SHORT;
bufferU[j++]=BEGIN_INT_PROG; //internally timed
- bufferU[j++]=WAIT_T3; //Tprogram 10ms
+ bufferU[j++]=WAIT_T3; //Tprogram 12ms
bufferU[j++]=ICSP8_READ;
bufferU[j++]=READ_NVM_INC;
}
bufferU[j++]=FLUSH;
for(;j<DIMBUF;j++) bufferU[j]=0x0;
- PacketIO(55);
+ PacketIO(60);
for(i=0,z=0;i<5;i++){
for(;z<DIMBUF-2&&bufferI[z]!=ICSP8_READ;z++);
if (~memCODE_W[0x8007+i]&((bufferI[z+1]<<8)+bufferI[z+2])){ //error if written 0 and read 1 (~W&R)
diff --git a/progP18.c b/progP18.c
index de77e99..90d2d62 100644
--- a/progP18.c
+++ b/progP18.c
@@ -1,6 +1,6 @@
/**
* \file progP18F.c - algorithms to program the PIC18 family of microcontrollers
- * Copyright (C) 2009-2023 Alberto Maccioni
+ * Copyright (C) 2009-2025 Alberto Maccioni
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@@ -260,6 +260,20 @@ struct ID18{
{0x6220,"18LF65K80 rev%d\r\n",0x1F},
{0x6240,"18LF45K80 rev%d\r\n",0x1F},
{0x6260,"18LF25K80 rev%d\r\n",0x1F},
+ {0x6900,"18F47K40 rev%c%d\r\n",0xFFFF},
+ {0x6920,"18F46K40 rev%c%d\r\n",0xFFFF},
+ {0x6940,"18F45K40 rev%c%d\r\n",0xFFFF},
+ {0x6960,"18F27K40 rev%c%d\r\n",0xFFFF},
+ {0x6980,"18F26K40 rev%c%d\r\n",0xFFFF},
+ {0x69A0,"18F25K40 rev%c%d\r\n",0xFFFF},
+ {0x69C0,"18F24K40 rev%c%d\r\n",0xFFFF},
+ {0x69E0,"18LF47K40 rev%c%d\r\n",0xFFFF},
+ {0x6A00,"18LF46K40 rev%c%d\r\n",0xFFFF},
+ {0x6A20,"18LF45K40 rev%c%d\r\n",0xFFFF},
+ {0x6A40,"18LF27K40 rev%c%d\r\n",0xFFFF},
+ {0x6A60,"18LF26K40 rev%c%d\r\n",0xFFFF},
+ {0x6A80,"18LF25K40 rev%c%d\r\n",0xFFFF},
+ {0x6AA0,"18LF24K40 rev%c%d\r\n",0xFFFF},
{0x6B80,"18F57K42 rev%c%d\r\n",0xFFFF},
{0x6BA0,"18F56K42 rev%c%d\r\n",0xFFFF},
{0x6BC0,"18F55K42 rev%c%d\r\n",0xFFFF},
@@ -268,6 +282,8 @@ struct ID18{
{0x6C20,"18F45K42 rev%c%d\r\n",0xFFFF},
{0x6C40,"18F27K42 rev%c%d\r\n",0xFFFF},
{0x6C60,"18F26K42 rev%c%d\r\n",0xFFFF},
+ {0x6C80,"18F25K42 rev%c%d\r\n",0xFFFF},
+ {0x6CA0,"18F24K42 rev%c%d\r\n",0xFFFF},
{0x6CC0,"18LF57K42 rev%c%d\r\n",0xFFFF},
{0x6CE0,"18LF56K42 rev%c%d\r\n",0xFFFF},
{0x6D00,"18LF55K42 rev%c%d\r\n",0xFFFF},
@@ -276,10 +292,19 @@ struct ID18{
{0x6D60,"18LF45K42 rev%c%d\r\n",0xFFFF},
{0x6D80,"18LF27K42 rev%c%d\r\n",0xFFFF},
{0x6DA0,"18LF26K42 rev%c%d\r\n",0xFFFF},
+ {0x6DC0,"18LF25K42 rev%c%d\r\n",0xFFFF},
+ {0x6DE0,"18LF24K42 rev%c%d\r\n",0xFFFF},
{0x6EC0,"18F26K83 rev%c%d\r\n",0xFFFF},
{0x6EE0,"18F25K83 rev%c%d\r\n",0xFFFF},
{0x6F00,"18LF26K83 rev%c%d\r\n",0xFFFF},
{0x6F20,"18LF25K83 rev%c%d\r\n",0xFFFF},
+ {0x70E0,"18F47Q10 rev%c%d\r\n",0xFFFF},
+ {0x7100,"18F27Q10 rev%c%d\r\n",0xFFFF},
+ {0x7120,"18F46Q10 rev%c%d\r\n",0xFFFF},
+ {0x7140,"18F45Q10 rev%c%d\r\n",0xFFFF},
+ {0x7180,"18F26Q10 rev%c%d\r\n",0xFFFF},
+ {0x71A0,"18F25Q10 rev%c%d\r\n",0xFFFF},
+ {0x71C0,"18F24Q10 rev%c%d\r\n",0xFFFF},
{0x73C0,"18F25Q43 rev%c%d\r\n",0xFFFF},
{0x73E0,"18F45Q43 rev%c%d\r\n",0xFFFF},
{0x7400,"18F55Q43 rev%c%d\r\n",0xFFFF},
@@ -310,6 +335,12 @@ struct ID18{
{0x77E0,"18F45Q71 rev%c%d\r\n",0xFFFF},
{0x7820,"18F54Q71 rev%c%d\r\n",0xFFFF},
{0x7860,"18F55Q71 rev%c%d\r\n",0xFFFF},
+ {0x7A40,"18F16Q20 rev%c%d\r\n",0xFFFF},
+ {0x7A60,"18F06Q20 rev%c%d\r\n",0xFFFF},
+ {0x7A80,"18F15Q20 rev%c%d\r\n",0xFFFF},
+ {0x7AA0,"18F05Q20 rev%c%d\r\n",0xFFFF},
+ {0x7AC0,"18F14Q20 rev%c%d\r\n",0xFFFF},
+ {0x7AE0,"18F04Q20 rev%c%d\r\n",0xFFFF},
{0x9900,"18F26Q84 rev%c%d\r\n",0xFFFF},
{0x9901,"18F46Q84 rev%c%d\r\n",0xFFFF},
{0x9902,"18F56Q84 rev%c%d\r\n",0xFFFF},
@@ -1620,24 +1651,30 @@ void Write18Fx(int dim,int dim2,int wbuf,int eraseW1,int eraseW2,int options)
#define PROGRAM_DATA 0xC0
#define PROGRAM_DATA_INC 0xE0
#define END_EXT_PROG 0x82
+#define PROGRAM_ACCESS_EN 0x4C
void Read18FKx(int dim,int dim2,int options)
-// read 16 bit PIC 18FxxKx3 with new 8b commands
+// read 16 bit PIC 18FxxKx with new 8b commands
// dim=program size (bytes)
-// dim2=if>0 use eeprom, size is automatic when reading DCI
+// dim2=if>0 use eeprom, size is automatic when reading DCI; otherwise dim2=ee size (bytes)
// options:
// bit [3:0]
// 0 = vpp before vdd (8.5V)
// bit [7:4] memory layout
-// code config EE DCI DIA model
-// 0 5 0x310000 0x3FFF00 0x3F0000 K42 K83
-// 1 10 0x380000 0x3C0000 0x2C0000 Q40-43
-// 2 35 0x380000 0x3C0000 0x2C0000 Q83-84
+// code config EE DCI DIA model
+// 0 5 (W) 0x310000 0x3FFF00 0x3F0000 K42 K83
+// 1 10 (B) 0x380000 0x3C0000 0x2C0000 Q40-43
+// 2 35 (B) 0x380000 0x3C0000 0x2C0000 Q83-84
+// 3 6 (W) 0x310000 no no K40
+// 4 6 (W) 0x310000 no no Q10
+// 5 14 (B) 0x380000 0x3C0000 0x2C0000 Q20
+//config length refers to number of read commands required; some types
+//respond with 1 byte, some with 2 bytes.
{
int k=0,k2=0,z=0,i,j;
int devID=0,devREV=0;
int MemAddr;
- int EEaddr=0,DCIaddr=0,DIAaddr=0,DIAlen=0,UIDlen=0,CONFIGlen=0;
+ int EEaddr=0,DCIaddr=0,DIAaddr=0,DIAlen=0,UIDlen=0,CONFIGlen=0,CONFIGorg=0;
int type=(options>>4)&0xF;
if(type==0){ //K42 K83
EEaddr=0x310000;
@@ -1646,6 +1683,7 @@ void Read18FKx(int dim,int dim2,int options)
DIAlen=0x40;
UIDlen=0x10;
CONFIGlen=5;
+ CONFIGorg=0; //word organization
}
else if(type==1){ //Q43
EEaddr=0x380000;
@@ -1654,6 +1692,7 @@ void Read18FKx(int dim,int dim2,int options)
DIAlen=0x100;
UIDlen=0x40;
CONFIGlen=10;
+ CONFIGorg=1; //byte organization
}
else if(type==2){ //Q83-84
EEaddr=0x380000;
@@ -1662,6 +1701,34 @@ void Read18FKx(int dim,int dim2,int options)
DIAlen=0x100;
UIDlen=0x40;
CONFIGlen=35;
+ CONFIGorg=1; //byte organization
+ }
+ else if(type==3){ //K40
+ EEaddr=0x310000;
+ DCIaddr=0;
+ DIAaddr=0;
+ DIAlen=0;
+ UIDlen=8;
+ CONFIGlen=6;
+ CONFIGorg=0; //word organization
+ }
+ else if(type==4){ //Q10
+ EEaddr=0x310000;
+ DCIaddr=0;
+ DIAaddr=0;
+ DIAlen=0;
+ UIDlen=0x100;
+ CONFIGlen=6;
+ CONFIGorg=0; //word organization ***only for read! write is different from K40
+ }
+ else if(type==5){ //Q20
+ EEaddr=0x380000;
+ DCIaddr=0x3C0000;
+ DIAaddr=0x2C0000;
+ DIAlen=0x100;
+ UIDlen=0x40;
+ CONFIGlen=26; // 0xB to 0x17 are reserved
+ CONFIGorg=1; //byte organization
}
else PrintMessage("unexpected parameter");
if(dim>0x1FFFFF||dim<0){
@@ -1689,8 +1756,8 @@ void Read18FKx(int dim,int dim2,int options)
if(memCODE) free(memCODE);
memCODE=(unsigned char*)malloc(size); //CODE
unsigned char* memDIA=(unsigned char*)malloc(DIAlen); //DIA
- for(j=0;j<64;j++) memID[j]=0xFF;
- for(j=0;j<14;j++) memCONFIG[j]=0xFF;
+ for(j=0;j<sizeof(memID);j++) memID[j]=0xFF;
+ for(j=0;j<48;j++) memCONFIG[j]=0xFF;
for(j=0;j<DIAlen;j++) memDIA[j]=0xFF;
unsigned int start=GetTickCount();
j=0;
@@ -1722,23 +1789,25 @@ void Read18FKx(int dim,int dim2,int options)
bufferU[j++]=READ_NVM_INC;
bufferU[j++]=ICSP8_READ;
bufferU[j++]=READ_NVM_INC;
- MemAddr=DCIaddr<<1; //DCI
- bufferU[j++]=TX16;
- bufferU[j++]=2;
- bufferU[j++]=0x80;
- bufferU[j++]=MemAddr>>16;
- bufferU[j++]=(MemAddr>>8)&0xFF;
- bufferU[j++]=MemAddr&0xFF;
- bufferU[j++]=ICSP8_READ;
- bufferU[j++]=READ_NVM_INC;
- bufferU[j++]=ICSP8_READ;
- bufferU[j++]=READ_NVM_INC;
- bufferU[j++]=ICSP8_READ;
- bufferU[j++]=READ_NVM_INC;
- bufferU[j++]=ICSP8_READ;
- bufferU[j++]=READ_NVM_INC;
- bufferU[j++]=ICSP8_READ;
- bufferU[j++]=READ_NVM_INC;
+ if(DCIaddr>0){
+ MemAddr=DCIaddr<<1; //DCI
+ bufferU[j++]=TX16;
+ bufferU[j++]=2;
+ bufferU[j++]=0x80;
+ bufferU[j++]=MemAddr>>16;
+ bufferU[j++]=(MemAddr>>8)&0xFF;
+ bufferU[j++]=MemAddr&0xFF;
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ }
bufferU[j++]=TX16;
bufferU[j++]=2;
bufferU[j++]=0x80;
@@ -1759,30 +1828,34 @@ void Read18FKx(int dim,int dim2,int options)
PrintMessage1("DevID: 0x%04X\r\n",devID);
PrintMessage1("RevID: 0x%04X\r\n",devREV);
if(!PIC18_ID(devID+(devREV<<16))) return;
- PrintMessage("Device Configuration Information:\r\n");
- for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
- if(z<DIMBUF-2){
- PrintMessage1("Erase row size: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
- }
- for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
- if(z<DIMBUF-2){
- PrintMessage1("Write latches per row: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
- }
- for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
- if(z<DIMBUF-2){
- PrintMessage1("User rows: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
- }
- for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
- if(z<DIMBUF-2){
- PrintMessage1("EEPROM size: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
- sizeEE=(bufferI[z+1]<<8)+bufferI[z+2];
- }
- for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
- if(z<DIMBUF-3){
- PrintMessage1("Pin count: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+ if(DCIaddr>0){
+ PrintMessage("Device Configuration Information:\r\n");
+ for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+ if(z<DIMBUF-2){
+ PrintMessage1("Erase row size: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+ }
+ for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+ if(z<DIMBUF-2){
+ PrintMessage1("Write latches per row: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+ }
+ for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+ if(z<DIMBUF-2){
+ PrintMessage1("User rows: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+ }
+ for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+ if(z<DIMBUF-2){
+ PrintMessage1("EEPROM size: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+ sizeEE=(bufferI[z+1]<<8)+bufferI[z+2];
+ }
+ for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+ if(z<DIMBUF-3){
+ PrintMessage1("Pin count: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+ }
}
+ else sizeEE=dim2;
//****************** read code ********************
PrintMessage(strings[S_CodeReading1]); //read code ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_CodeReading1]); //read code ...
PrintStatusSetup();
for(i=0,j=0;i<dim;i+=2){ //2 bytes per read
@@ -1814,6 +1887,7 @@ void Read18FKx(int dim,int dim2,int options)
else PrintMessage(strings[S_Compl]);
//****************** read config area ********************
PrintMessage(strings[S_Read_CONFIG_A]); //read config ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_Read_CONFIG_A]); //read config ...
MemAddr=0x300000<<1; //config area
bufferU[j++]=TX16;
@@ -1833,7 +1907,7 @@ void Read18FKx(int dim,int dim2,int options)
for(z=0;z<DIMBUF-2;z++){
if(bufferI[z]==ICSP8_READ){
memCONFIG[k2++]=bufferI[z+2]; //LSB
- if(type==0) memCONFIG[k2++]=bufferI[z+1]; //MSB
+ if(CONFIGorg==0) memCONFIG[k2++]=bufferI[z+1]; //MSB if organized as words
z+=2;
}
}
@@ -1844,12 +1918,14 @@ void Read18FKx(int dim,int dim2,int options)
}
}
}
- if(k2!=10){
+ if(CONFIGorg==0) CONFIGlen*=2; //adjust expected size
+ if(k2!=CONFIGlen){
PrintMessage("\r\n");
- PrintMessage2(strings[S_ReadConfigErr],10,k2); //"Error reading config area, requested %d bytes, read %d\r\n"
+ PrintMessage2(strings[S_ReadConfigErr],CONFIGlen,k2); //"Error reading config area, requested %d bytes, read %d\r\n"
}
else PrintMessage(strings[S_Compl]);
//****************** read user ID ********************
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"Read user ID\n");
MemAddr=0x200000<<1; //user ID
bufferU[j++]=TX16;
@@ -1885,39 +1961,42 @@ void Read18FKx(int dim,int dim2,int options)
PrintMessage2(strings[S_ReadConfigErr],UIDlen,k2); //"Error reading config area, requested %d bytes, read %d\r\n"
}
//****************** read device info area (DIA) ********************
- if(saveLog) fprintf(logfile,"Read device info area\n");
- MemAddr=DIAaddr<<1; //DIA
- bufferU[j++]=TX16;
- bufferU[j++]=2;
- bufferU[j++]=0x80;
- bufferU[j++]=MemAddr>>16;
- bufferU[j++]=(MemAddr>>8)&0xFF;
- bufferU[j++]=MemAddr&0xFF;
- k2=0;
- for(i=0;i<DIAlen;i+=2){ //DIA
- bufferU[j++]=ICSP8_READ;
- bufferU[j++]=READ_NVM_INC;
- if((j+1)/2*3+3>DIMBUF||i==DIAlen-2){ //2B cmd -> 3B data
- bufferU[j++]=FLUSH;
- for(;j<DIMBUF;j++) bufferU[j]=0x0;
- PacketIO(5);
- for(z=0;z<DIMBUF-2;z++){
- if(bufferI[z]==ICSP8_READ){
- memDIA[k2++]=bufferI[z+2];
- memDIA[k2++]=bufferI[z+1];
- z+=2;
+ if(DIAaddr>0){
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
+ if(saveLog) fprintf(logfile,"Read device info area\n");
+ MemAddr=DIAaddr<<1; //DIA
+ bufferU[j++]=TX16;
+ bufferU[j++]=2;
+ bufferU[j++]=0x80;
+ bufferU[j++]=MemAddr>>16;
+ bufferU[j++]=(MemAddr>>8)&0xFF;
+ bufferU[j++]=MemAddr&0xFF;
+ k2=0;
+ for(i=0;i<DIAlen;i+=2){ //DIA
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ if((j+1)/2*3+3>DIMBUF||i==DIAlen-2){ //2B cmd -> 3B data
+ bufferU[j++]=FLUSH;
+ for(;j<DIMBUF;j++) bufferU[j]=0x0;
+ PacketIO(5);
+ for(z=0;z<DIMBUF-2;z++){
+ if(bufferI[z]==ICSP8_READ){
+ memDIA[k2++]=bufferI[z+2];
+ memDIA[k2++]=bufferI[z+1];
+ z+=2;
+ }
+ }
+ PrintStatus(strings[S_CodeReading],(dim+sizeEE+10+UIDlen+i)*100/(dim+sizeEE+10+UIDlen+DIAlen),i); //"Read: %d%%, addr. %03X"
+ j=0;
+ if(saveLog){
+ fprintf(logfile,strings[S_Log7],i,i,k2,k2); //"i=%d(0x%X), k=%d(0x%X)\n"
}
- }
- PrintStatus(strings[S_CodeReading],(dim+sizeEE+10+UIDlen+i)*100/(dim+sizeEE+10+UIDlen+DIAlen),i); //"Read: %d%%, addr. %03X"
- j=0;
- if(saveLog){
- fprintf(logfile,strings[S_Log7],i,i,k2,k2); //"i=%d(0x%X), k=%d(0x%X)\n"
}
}
- }
- if(k2!=DIAlen){
- PrintMessage("\r\n");
- PrintMessage2(strings[S_ReadConfigErr],DIAlen,k2); //"Error reading config area, requested %d bytes, read %d\r\n"
+ if(k2!=DIAlen){
+ PrintMessage("\r\n");
+ PrintMessage2(strings[S_ReadConfigErr],DIAlen,k2); //"Error reading config area, requested %d bytes, read %d\r\n"
+ }
}
//****************** read eeprom ********************
if(dim2){ //EEPROM
@@ -1929,6 +2008,7 @@ void Read18FKx(int dim,int dim2,int options)
memEE=(unsigned char*)malloc(sizeEE); //EEPROM
for(i=0;i<sizeEE;i++) memEE[i]=0xFF;
PrintMessage(strings[S_ReadEE]); //Read EEPROM ...
+ if(saveLog) fprintf(logfile,strings[S_sepLine]);
if(saveLog) fprintf(logfile,"%s\n",strings[S_ReadEE]); //Read EEPROM ...
MemAddr=EEaddr<<1; //EE base address
bufferU[j++]=TX16;
@@ -1981,14 +2061,17 @@ void Read18FKx(int dim,int dim2,int options)
for(i=0;i<UIDlen;i+=2){
if(memID[i]<0xFF||memID[i+1]<0xFF) PrintMessage4(strings[S_ChipID2],i,memID[i],i+1,memID[i+1]); //"ID%d: 0x%02X ID%d: 0x%02X\r\n"
}
- if(type==0){ //K42 K83 etc.
- for(i=0;i<5;i++){
+ if(CONFIGorg==0){ //word organization K42 K83 etc.
+ for(i=0;i<CONFIGlen;i++){
PrintMessage2(strings[S_ConfigWordH],i+1,memCONFIG[i*2+1]); //"CONFIG%dH: 0x%02X\t"
PrintMessage2(strings[S_ConfigWordL],i+1,memCONFIG[i*2]); //"CONFIG%dL: 0x%02X\r\n"
}
}
- else if(type==1){ //Q43 etc.
- for(i=0;i<10;i++) PrintMessage2("CONFIG%d: 0x%02X\r\n",i+1,memCONFIG[i]);
+ else{ //byte organization Q43 Q8X etc.
+ for(i=0;i<CONFIGlen;i++){
+ if(type==5&&(i>=0xB&&i<=0x17)); //reserved area for Q20
+ else PrintMessage2("CONFIG%d: 0x%02X\r\n",i+1,memCONFIG[i]); //Naming is not the same as datasheet
+ }
}
PrintMessage(strings[S_CodeMem]); //"\r\nCode memory:\r\n"
DisplayCODE18F(dim);
@@ -2004,22 +2087,26 @@ void Read18FKx(int dim,int dim2,int options)
}
void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
-// write 16 bit PIC 18FxxKx3 with new 8b commands
+// write 16 bit PIC 18FxxKx with new 8b commands
// dim=program size (bytes) dim2=eeprom size (bytes)
// options:
// bit [3:0]
// 0 = vpp before vdd (8.5V)
// bit [7:4] memory layout
-// code config EE DCI DIA model program cycle delays ms (E,W,EE)
-// 0 5 0x310000 0x3FFF00 0x3F0000 K42 K83 multiple-word 25.5 2.8 5.6
-// 1 10 0x380000 0x3C0000 0x2C0000 Q40-43 one-word 11 0.075 11
-// 2 35 0x380000 0x3C0000 0x2C0000 Q83-84 one-word 11 0.075 11
+// code config EE DCI DIA model program cycle delays ms (E,W,EE)
+// 0 5 (W) 0x310000 0x3FFF00 0x3F0000 K42 K83 multiple-word 25.5 2.8 5.6
+// 1 10 (B) 0x380000 0x3C0000 0x2C0000 Q40-43 one-word 11 0.075 11
+// 2 35 (B) 0x380000 0x3C0000 0x2C0000 Q83-84 one-word 11 0.075 11
+// 3 6 (W) 0x310000 no no K40 multiple-word 25.5 2.8 5.6
+// 4 6 (W) 0x310000 no no Q10 one-word 75 0.065 11
+// 5 11+2 (B) 0x380000 0x3C0000 0x2C0000 Q20 one-word 11 0.075 11 SAFLOCK bit
{
int k=0,z=0,i,j,x=0,w=0;
int err=0;
int devID=0,devREV=0;
int MemAddr,rowN=0;
- int EEaddr=0,DCIaddr=0,DIAaddr=0,DIAlen=0,UIDlen=0,CONFIGlen=0;
+ int EEaddr=0,DCIaddr=0,DIAaddr=0,DIAlen=0,UIDlen=0,CONFIGlen=0,CONFIGorg=0;
+ int delayErase=0,delayWrite=0,delayWriteConfig=0;
int type=(options>>4)&0xF;
if(type==0){ //K42 K83
EEaddr=0x310000;
@@ -2028,6 +2115,10 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
DIAlen=0x40;
UIDlen=0x10;
CONFIGlen=5;
+ CONFIGorg=0; //word organization
+ delayErase=25500; //in us
+ delayWrite=2800; //in us
+ delayWriteConfig=5600; //in us
}
else if(type==1){ //Q43
EEaddr=0x380000;
@@ -2036,6 +2127,9 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
DIAlen=0x100;
UIDlen=0x40;
CONFIGlen=10;
+ CONFIGorg=1; //byte organization
+ delayErase=11500; //in us
+ delayWriteConfig=11000; //in us
}
else if(type==2){ //Q83-84
EEaddr=0x380000;
@@ -2044,6 +2138,45 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
DIAlen=0x100;
UIDlen=0x40;
CONFIGlen=35;
+ CONFIGorg=1; //byte organization
+ delayErase=11500; //in us
+ delayWriteConfig=11000; //in us
+ }
+ else if(type==3){ //K40
+ EEaddr=0x310000;
+ DCIaddr=0;
+ DIAaddr=0;
+ DIAlen=0;
+ UIDlen=8;
+ CONFIGlen=6;
+ CONFIGorg=0; //word organization
+ rowN=32; //max 64 in 27K40 but can be 32
+ delayErase=25500; //in us
+ delayWrite=2800; //in us
+ delayWriteConfig=5600; //in us
+ }
+ else if(type==4){ //Q10
+ EEaddr=0x310000;
+ DCIaddr=0;
+ DIAaddr=0;
+ DIAlen=0;
+ UIDlen=0x100;
+ CONFIGlen=6;
+ CONFIGorg=2; //word organization
+ delayErase=75500; //in us
+ delayWrite=11000; //in us (because it is used for SET_T3 during erase like Kxx devices)
+ delayWriteConfig=11000; //in us
+ }
+ else if(type==5){ //Q20 (SAFLOCK)
+ EEaddr=0x380000;
+ DCIaddr=0x3C0000;
+ DIAaddr=0x2C0000;
+ DIAlen=0x100;
+ UIDlen=0x40;
+ CONFIGlen=11; // 0xB to 0x17 are reserved, then 0x19 and 0x18 (SAFLOCK)
+ CONFIGorg=1; //byte organization
+ delayErase=11500; //in us
+ delayWriteConfig=11000; //in us
}
else PrintMessage("unexpected parameter");
if(dim>0x1FFFFF||dim<0){
@@ -2095,18 +2228,7 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
MemAddr=0x3FFFFc<<1; //devREV
bufferU[j++]=TX16;
bufferU[j++]=2;
- bufferU[j++]=0x80;
- bufferU[j++]=MemAddr>>16;
- bufferU[j++]=(MemAddr>>8)&0xFF;
- bufferU[j++]=MemAddr&0xFF;
- bufferU[j++]=ICSP8_READ;
- bufferU[j++]=READ_NVM_INC;
- bufferU[j++]=ICSP8_READ;
- bufferU[j++]=READ_NVM_INC;
- MemAddr=DCIaddr<<1; //DCI
- bufferU[j++]=TX16;
- bufferU[j++]=2;
- bufferU[j++]=0x80;
+ bufferU[j++]=LOAD_PC_ADDR;
bufferU[j++]=MemAddr>>16;
bufferU[j++]=(MemAddr>>8)&0xFF;
bufferU[j++]=MemAddr&0xFF;
@@ -2114,15 +2236,28 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
bufferU[j++]=READ_NVM_INC;
bufferU[j++]=ICSP8_READ;
bufferU[j++]=READ_NVM_INC;
- bufferU[j++]=ICSP8_READ;
- bufferU[j++]=READ_NVM_INC;
- bufferU[j++]=ICSP8_READ;
- bufferU[j++]=READ_NVM_INC;
- bufferU[j++]=ICSP8_READ;
- bufferU[j++]=READ_NVM_INC;
+ if(DCIaddr>0){
+ MemAddr=DCIaddr<<1; //DCI
+ bufferU[j++]=TX16;
+ bufferU[j++]=2;
+ bufferU[j++]=LOAD_PC_ADDR;
+ bufferU[j++]=MemAddr>>16;
+ bufferU[j++]=(MemAddr>>8)&0xFF;
+ bufferU[j++]=MemAddr&0xFF;
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ }
bufferU[j++]=TX16;
bufferU[j++]=2;
- bufferU[j++]=0x80;
+ bufferU[j++]=LOAD_PC_ADDR;
bufferU[j++]=0x0;
bufferU[j++]=0x0;
bufferU[j++]=0x0;
@@ -2140,41 +2275,48 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
PrintMessage1("DevID: 0x%04X\r\n",devID);
PrintMessage1("RevID: 0x%04X\r\n",devREV);
if(!PIC18_ID(devID+(devREV<<16))) return;
- PrintMessage("Device Configuration Information:\r\n");
- for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
- if(z<DIMBUF-2){
- PrintMessage1("Erase row size: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
- }
- for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
- if(z<DIMBUF-2){
- rowN=(bufferI[z+1]<<8)+bufferI[z+2];
- PrintMessage1("Write latches per row: %d\r\n",rowN);
- }
- for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
- if(z<DIMBUF-2){
- PrintMessage1("User rows: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
- }
- for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
- if(z<DIMBUF-2){
- PrintMessage1("EEPROM size: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
- sizeEE=(bufferI[z+1]<<8)+bufferI[z+2];
- }
- for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
- if(z<DIMBUF-3){
- PrintMessage1("Pin count: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+ if(DCIaddr>0){
+ PrintMessage("Device Configuration Information:\r\n");
+ for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+ if(z<DIMBUF-2){
+ PrintMessage1("Erase row size: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+ }
+ for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+ if(z<DIMBUF-2){
+ rowN=(bufferI[z+1]<<8)+bufferI[z+2];
+ PrintMessage1("Write latches per row: %d\r\n",rowN);
+ }
+ for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+ if(z<DIMBUF-2){
+ PrintMessage1("User rows: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+ }
+ for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+ if(z<DIMBUF-2){
+ PrintMessage1("EEPROM size: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+ //sizeEE=(bufferI[z+1]<<8)+bufferI[z+2];
+ }
+ for(z+=3;bufferI[z]!=ICSP8_READ&&z<DIMBUF;z++);
+ if(z<DIMBUF-3){
+ PrintMessage1("Pin count: %d\r\n",(bufferI[z+1]<<8)+bufferI[z+2]);
+ }
}
j=0;
//****************** erase memory ********************
PrintMessage(strings[S_StartErase]); //"Erase ... "
- if(type==0){ //K42 K83
+ if(saveLog){
+ fprintf(logfile,strings[S_sepLine]);
+ fprintf(logfile,strings[S_StartErase]);
+ fprintf(logfile,strings[S_NL]);
+ }
+ if(type==0||type==3||type==4){ //K42 K83 K40 Q10
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
- bufferU[j++]=25500>>8;
- bufferU[j++]=25500&0xff;
+ bufferU[j++]=delayErase>>8;
+ bufferU[j++]=delayErase&0xff;
MemAddr=0x300000<<1; //address to erase Flash+User+Config
bufferU[j++]=TX16;
bufferU[j++]=2;
- bufferU[j++]=0x80;
+ bufferU[j++]=LOAD_PC_ADDR;
bufferU[j++]=MemAddr>>16;
bufferU[j++]=(MemAddr>>8)&0xFF;
bufferU[j++]=MemAddr&0xFF;
@@ -2184,7 +2326,7 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
MemAddr=0x310000<<1; //address to erase EEPROM
bufferU[j++]=TX16;
bufferU[j++]=2;
- bufferU[j++]=0x80;
+ bufferU[j++]=LOAD_PC_ADDR;
bufferU[j++]=MemAddr>>16;
bufferU[j++]=(MemAddr>>8)&0xFF;
bufferU[j++]=MemAddr&0xFF;
@@ -2193,34 +2335,39 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
bufferU[j++]=WAIT_T3; //TERAB
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
- bufferU[j++]=2800>>8;
- bufferU[j++]=2800&0xff;
+ bufferU[j++]=delayWrite>>8;
+ bufferU[j++]=delayWrite&0xff;
bufferU[j++]=FLUSH;
for(;j<DIMBUF;j++) bufferU[j]=0x0;
- PacketIO(52);
+ PacketIO(delayErase/1000*2);
}
- else if(type==1){ //Q43
+ else if(type==1||type==2||type==5){ //Q4x-Q8x-Q20
bufferU[j++]=ICSP8_LOAD;
bufferU[j++]=BULK_ERASE;
bufferU[j++]=0;
bufferU[j++]=0xF;
+ bufferU[j++]=SET_PARAMETER;
+ bufferU[j++]=SET_T3;
+ bufferU[j++]=delayWriteConfig>>8;
+ bufferU[j++]=delayWriteConfig&0xff;
bufferU[j++]=FLUSH;
for(;j<DIMBUF;j++) bufferU[j]=0x0;
PacketIO(1);
- msDelay(12); //bulk erase delay
+ msDelay(delayErase/1000); //bulk erase delay
}
PrintMessage(strings[S_Compl]); //"completed\r\n"
//****************** write code ********************
PrintMessage(strings[S_StartCodeProg]); //"code write ... "
PrintStatusSetup();
if(saveLog){
+ fprintf(logfile,strings[S_sepLine]);
fprintf(logfile,"WRITE CODE\ndim=%d(0x%X)\n",dim,dim); //
}
- if(type==1){ //Q43
+ if(type==1||type==2||type==4||type==5){ //Q4x-Q8x Q43 Q10 Q20 one word algorithm
j=0;
bufferU[j++]=TX16;
bufferU[j++]=2;
- bufferU[j++]=0x80;
+ bufferU[j++]=LOAD_PC_ADDR;
bufferU[j++]=0x0;
bufferU[j++]=0x0;
bufferU[j++]=0x0;
@@ -2245,7 +2392,7 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
MemAddr=i<<1;
bufferU[j++]=TX16;
bufferU[j++]=2;
- bufferU[j++]=0x80;
+ bufferU[j++]=LOAD_PC_ADDR;
bufferU[j++]=MemAddr>>16;
bufferU[j++]=(MemAddr>>8)&0xFF;
bufferU[j++]=MemAddr&0xFF;
@@ -2289,7 +2436,7 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
}
err+=i-k;
}
- else if(type==0){ //K42 K83
+ else if(type==0||type==3){ //K42 K83 K40 multiple word algorithm
int valid;
for(;dim>0&&memCODE[dim-1]==0xff&&memCODE[dim-2]==0xff;dim-=2); //skip empty space at end
if(dim%rowN) dim+=rowN-dim%rowN; //grow to N byte multiple
@@ -2310,7 +2457,7 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
MemAddr=i<<1;
bufferU[j++]=TX16; //load new address
bufferU[j++]=2;
- bufferU[j++]=0x80;
+ bufferU[j++]=LOAD_PC_ADDR;
bufferU[j++]=MemAddr>>16;
bufferU[j++]=(MemAddr>>8)&0xFF;
bufferU[j++]=MemAddr&0xFF;
@@ -2345,11 +2492,14 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
//****************** verify code ********************
PrintMessage(strings[S_CodeV]); //"Verifying code ... "
PrintStatusSetup();
- if(saveLog) fprintf(logfile,"%s\n",strings[S_CodeV]);
+ if(saveLog){
+ fprintf(logfile,strings[S_sepLine]);
+ fprintf(logfile,"%s\n",strings[S_CodeV]);
+ }
j=0;
bufferU[j++]=TX16;
bufferU[j++]=2;
- bufferU[j++]=0x80;
+ bufferU[j++]=LOAD_PC_ADDR;
bufferU[j++]=0x0;
bufferU[j++]=0x0;
bufferU[j++]=0x0;
@@ -2366,7 +2516,7 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
MemAddr=i<<1;
bufferU[j++]=TX16;
bufferU[j++]=2;
- bufferU[j++]=0x80;
+ bufferU[j++]=LOAD_PC_ADDR;
bufferU[j++]=MemAddr>>16;
bufferU[j++]=(MemAddr>>8)&0xFF;
bufferU[j++]=MemAddr&0xFF;
@@ -2401,8 +2551,8 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
}
bufferU[j++]=SET_PARAMETER;
bufferU[j++]=SET_T3;
- bufferU[j++]=5600>>8;
- bufferU[j++]=5600&0xff;
+ bufferU[j++]=delayWriteConfig>>8;
+ bufferU[j++]=delayWriteConfig&0xff;
bufferU[j++]=FLUSH;
for(;j<DIMBUF;j++) bufferU[j]=0x0;
PacketIO(1);
@@ -2414,25 +2564,28 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
if(dim2){
PrintMessage(strings[S_EEAreaW]); //"Write EEPROM ... "
PrintStatusSetup();
- if(saveLog) fprintf(logfile,"WRITE EEPROM\ndim2=%d(0x%X)\n",dim2,dim2);
+ if(saveLog){
+ fprintf(logfile,strings[S_sepLine]);
+ fprintf(logfile,"WRITE EEPROM\ndim2=%d(0x%X)\n",dim2,dim2);
+ }
int errEE=0;
j=0;
MemAddr=EEaddr<<1;
bufferU[j++]=TX16;
bufferU[j++]=2;
- bufferU[j++]=0x80;
+ bufferU[j++]=LOAD_PC_ADDR;
bufferU[j++]=MemAddr>>16;
bufferU[j++]=(MemAddr>>8)&0xFF;
bufferU[j++]=MemAddr&0xFF;
for(i=k=0;i<dim2;i++){
if(memEE[i]<0xFF){
- if(type==1){ //Q43
+ if(type==1||type==2||type==4||type==5){ //Q4x-Q8x Q10 Q20
bufferU[j++]=ICSP8_LOAD;
bufferU[j++]=PROGRAM_DATA;
bufferU[j++]=0;
bufferU[j++]=memEE[i];
}
- else if(type==0){ //K42 K83
+ else if(type==0||type==3){ //K42 K83 K40
bufferU[j++]=ICSP8_LOAD;
bufferU[j++]=LOAD_NVM;
bufferU[j++]=0; //High byte
@@ -2453,12 +2606,12 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
PrintStatus(strings[S_CodeWriting],(i+dim)*100/(dim+dim2),i+EEaddr); //"Writing: %d%%, addr. %03X"
bufferU[j++]=FLUSH;
for(;j<DIMBUF;j++) bufferU[j]=0x0;
- w*=type==1?11:5.6; //total write time
+ w=(float)w*(delayWriteConfig/1000.0);//(type==1||type==2)?11:5.6; //total write time
PacketIO(w+10);
for(z=0;z<DIMBUF-4;z++){
if(bufferI[z]==ICSP8_SHORT&&memEE[k]==0xff) k++;
else if(bufferI[z]==ICSP8_LOAD){
- w=type==1?bufferI[z+4]:bufferI[z+5];
+ w=(type==1||type==2||type==4||type==5)?bufferI[z+4]:bufferI[z+5];
if(memEE[k]!=w){
PrintMessage("\r\n");
PrintMessage3(strings[S_CodeWError2],k,memEE[k],w); //"Error writing address %3X: written %04X, read %04X\r\n"
@@ -2471,7 +2624,7 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
}
}
k++;
- z+=type==1?4:5;
+ z+=(type==1||type==2||type==4||type==5)?4:5;
}
}
j=0;
@@ -2490,25 +2643,28 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
#define IDaddr 0x200000
if(programID){
PrintMessage(strings[S_IDW]); //"Write ID ... "
- if(saveLog) fprintf(logfile,"Write ID\n");
+ if(saveLog){
+ fprintf(logfile,strings[S_sepLine]);
+ fprintf(logfile,"Write ID\n");
+ }
int errID=0;
j=0;
MemAddr=IDaddr<<1;
bufferU[j++]=TX16;
bufferU[j++]=2;
- bufferU[j++]=0x80;
+ bufferU[j++]=LOAD_PC_ADDR;
bufferU[j++]=MemAddr>>16;
bufferU[j++]=(MemAddr>>8)&0xFF;
bufferU[j++]=MemAddr&0xFF;
for(i=k=0;i<UIDlen;i+=2){
if(memID[i]<0xFF||memID[i+1]<0xFF){
- if(type==1){ //Q43
+ if(type==1||type==2||type==4||type==5){ //Q4x-Q8x Q10 Q20
bufferU[j++]=ICSP8_LOAD;
bufferU[j++]=PROGRAM_DATA;
bufferU[j++]=memID[i+1];
bufferU[j++]=memID[i];
}
- else if(type==0){ //K42 K83
+ else if(type==0||type==3){ //K42 K83 K40
bufferU[j++]=ICSP8_LOAD;
bufferU[j++]=LOAD_NVM;
bufferU[j++]=memID[i+1];
@@ -2528,12 +2684,12 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
PrintStatus(strings[S_CodeWriting],99,IDaddr+i); //"Writing: %d%%, add. %03X"
bufferU[j++]=FLUSH;
for(;j<DIMBUF;j++) bufferU[j]=0x0;
- PacketIO(80);
+ PacketIO(9*delayWriteConfig/1000+2); //at most 9 writes per IO packet
for(z=0;z<DIMBUF-4;z++){
if(bufferI[z]==ICSP8_SHORT&&memID[k]==0xff&&memID[k+1]==0xff) k+=2;
else if(bufferI[z]==ICSP8_LOAD){
- if(type==1) w=(bufferI[z+3]<<8)+bufferI[z+4];
- else if(type==0) w=(bufferI[z+4]<<8)+bufferI[z+5];
+ if(type==1||type==2||type==4||type==5) w=(bufferI[z+3]<<8)+bufferI[z+4]; //Q4x-Q8x Q10 Q20
+ else if(type==0||type==3) w=(bufferI[z+4]<<8)+bufferI[z+5]; //K42 K83 K40
x=(memID[k+1]<<8)+memID[k];
if(x!=w){
PrintMessage("\r\n");
@@ -2547,7 +2703,7 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
}
}
k+=2;
- z+=type==1?4:5;
+ z+=(type==1||type==2||type==4||type==5)?4:5;
}
}
j=0;
@@ -2565,24 +2721,21 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
#define CONFIGaddr 0x300000
if(err<max_err){
PrintMessage(strings[S_ConfigW]); //"Write CONFIG ..."
- if(saveLog) fprintf(logfile,"Write CONFIG\n");
+ if(saveLog){
+ fprintf(logfile,strings[S_sepLine]);
+ fprintf(logfile,"Write CONFIG\n");
+ }
int errC=0;
j=0;
MemAddr=CONFIGaddr<<1;
bufferU[j++]=TX16;
bufferU[j++]=2;
- bufferU[j++]=0x80;
+ bufferU[j++]=LOAD_PC_ADDR;
bufferU[j++]=MemAddr>>16;
bufferU[j++]=(MemAddr>>8)&0xFF;
bufferU[j++]=MemAddr&0xFF;
for(i=k=0;i<CONFIGlen;i++){
- if(type==1){ //Q43
- bufferU[j++]=ICSP8_LOAD;
- bufferU[j++]=PROGRAM_DATA;
- bufferU[j++]=0;
- bufferU[j++]=memCONFIG[i];
- }
- else if(type==0){ //K42 K83
+ if(CONFIGorg==0){ // word organization K42 K83 K40 etc
bufferU[j++]=ICSP8_LOAD;
bufferU[j++]=LOAD_NVM;
bufferU[j++]=memCONFIG[i*2+1]; //High byte
@@ -2590,6 +2743,18 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
bufferU[j++]=ICSP8_SHORT;
bufferU[j++]=BEGIN_INT_PROG; //internally timed
}
+ else if(CONFIGorg==1){ //byte organization Q4x-Q8x Q43 etc
+ bufferU[j++]=ICSP8_LOAD;
+ bufferU[j++]=PROGRAM_DATA;
+ bufferU[j++]=0; //High byte=0
+ bufferU[j++]=memCONFIG[i]; //Low byte
+ }
+ else if(CONFIGorg==2){ //word organization Q10 etc
+ bufferU[j++]=ICSP8_LOAD;
+ bufferU[j++]=PROGRAM_DATA;
+ bufferU[j++]=memCONFIG[i*2+1]; //High byte
+ bufferU[j++]=memCONFIG[i*2]; //Low byte
+ }
bufferU[j++]=WAIT_T3; //Tprogram 11ms or 5.6ms
bufferU[j++]=ICSP8_READ;
bufferU[j++]=READ_NVM_INC;
@@ -2597,14 +2762,18 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
PrintStatus(strings[S_CodeWriting],99,i+CONFIGaddr); //"Writing: %d%%, addr. %03X"
bufferU[j++]=FLUSH;
for(;j<DIMBUF;j++) bufferU[j]=0x0;
- PacketIO(80);
+ PacketIO(9*delayWriteConfig/1000.0+2); //at most 9 writes per IO packet
for(z=0;z<DIMBUF-4;z++){
if(bufferI[z]==ICSP8_LOAD){
- if(type==1){ //Q43 single byte
+ if(CONFIGorg==1){ //Q4x-Q8x Q43 single byte
w=bufferI[z+4];
x=memCONFIG[k];
}
- else if(type==0){ //K42 K83 2 bytes
+ else if(CONFIGorg==2){ //Q10 2 bytes
+ w=(bufferI[z+3]<<8)+bufferI[z+4];
+ x=(memCONFIG[k+1]<<8)+memCONFIG[k];
+ }
+ else if(CONFIGorg==0){ //K42 K83 K40 2 bytes
w=(bufferI[z+4]<<8)+bufferI[z+5];
x=(memCONFIG[k+1]<<8)+memCONFIG[k];
}
@@ -2619,11 +2788,15 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
z=DIMBUF;
}
}
- if(type==1){ //Q43 single byte
+ if(CONFIGorg==1){ //Q4x-Q8x single byte
k++;
z+=4;
}
- else if(type==0){ //K42 K83 2 bytes
+ else if(CONFIGorg==2){ //Q10 2 bytes
+ k+=2;
+ z+=4;
+ }
+ else if(CONFIGorg==0){ //K42 K83 2 bytes
k+=2;
z+=5;
}
@@ -2635,8 +2808,97 @@ void Write18FKx(int dim,int dim2,int options,int nu1,int nu2, int nu3)
}
}
}
- errC+=10-k;
+ if(CONFIGorg==1) errC+=CONFIGlen-k; //byte
+ else errC+=CONFIGlen*2-k; //word
err+=errC;
+ if(useSAFLOCK_flag&&type==5&&memCONFIG[0x18]!=0xFF&&err>0) PrintMessage(strings[S_SkipSaflock]); //"skip SAFLOCK"
+ if(useSAFLOCK_flag&&type==5&&memCONFIG[0x18]!=0xFF&&err==0){ //Q20 with SAFLOCK
+ PrintMessage("\r\nWrite SAFLOCK");
+ if(saveLog){
+ fprintf(logfile,strings[S_sepLine]);
+ fprintf(logfile,"Write SAFLOCK\n");
+ }
+ errC=0;
+ if(memCONFIG[0x19]!=0xFF){ //SAFZ@0x300019
+ errC=1;
+ j=0;
+ MemAddr=0x300019<<1;
+ bufferU[j++]=TX16;
+ bufferU[j++]=2;
+ bufferU[j++]=LOAD_PC_ADDR;
+ bufferU[j++]=MemAddr>>16;
+ bufferU[j++]=(MemAddr>>8)&0xFF;
+ bufferU[j++]=MemAddr&0xFF;
+ bufferU[j++]=ICSP8_LOAD;
+ bufferU[j++]=PROGRAM_DATA;
+ bufferU[j++]=0; //High byte=0
+ bufferU[j++]=memCONFIG[0x19]; //Low byte
+ bufferU[j++]=WAIT_T3; //Tprogram 11ms or 5.6ms
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ bufferU[j++]=FLUSH;
+ for(;j<DIMBUF;j++) bufferU[j]=0x0;
+ PacketIO(delayWriteConfig/1000.0+2);
+ for(z=0;z<DIMBUF-4;z++){
+ if(bufferI[z]==ICSP8_LOAD){
+ w=bufferI[z+4];
+ x=memCONFIG[0x19];
+ if(~x&w){ //error if written 0 and read 1 (~Written&Read)
+ PrintMessage("\r\n");
+ PrintMessage3(strings[S_CodeWError2],0x300019,x,w); //"Error writing address %3X: written %04X, read %04X\r\n"
+ //stop even if SAFZ is not written correctly
+ PrintMessage(strings[S_IntW]); //"Write interrupted"
+ }
+ else errC=0;
+ z=DIMBUF*2; //only one to check
+ }
+ }
+ err+=errC;
+ }
+ if(errC>0) PrintMessage(strings[S_SkipSaflock]); //"skip SAFLOCK"
+ else{ //only if SAFZ was written and verified correctly
+ errC=1;
+ j=0;
+ MemAddr=0x300018<<1;
+ bufferU[j++]=TX16;
+ bufferU[j++]=2;
+ bufferU[j++]=LOAD_PC_ADDR;
+ bufferU[j++]=MemAddr>>16;
+ bufferU[j++]=(MemAddr>>8)&0xFF;
+ bufferU[j++]=MemAddr&0xFF;
+ //Program Access Enable
+ bufferU[j++]=TX16; //0100 1100 0 10 0111 1010 0001 1010 0101 1 = 4C + 0 + 27A1A5 + 1
+ bufferU[j++]=2; //2x16bit
+ bufferU[j++]=0x4C;
+ bufferU[j++]=0x4F;
+ bufferU[j++]=0x43;
+ bufferU[j++]=0x4B;
+ bufferU[j++]=ICSP8_LOAD;
+ bufferU[j++]=PROGRAM_DATA;
+ bufferU[j++]=0; //High byte=0
+ bufferU[j++]=memCONFIG[0x18]; //Low byte
+ bufferU[j++]=WAIT_T3; //Tprogram 11ms or 5.6ms
+ bufferU[j++]=ICSP8_READ;
+ bufferU[j++]=READ_NVM_INC;
+ bufferU[j++]=FLUSH;
+ for(;j<DIMBUF;j++) bufferU[j]=0x0;
+ PacketIO(delayWriteConfig/1000.0+2);
+ for(z=0;z<DIMBUF-4;z++){
+ if(bufferI[z]==ICSP8_READ){
+ w=bufferI[z+2];
+ x=memCONFIG[0x18];
+ if(~x&w){ //error if written 0 and read 1 (~Written&Read)
+ PrintMessage("\r\n");
+ PrintMessage3(strings[S_CodeWError2],0x300018,x,w); //"Error writing address %3X: written %04X, read %04X\r\n"
+ PrintMessage(strings[S_IntW]); //"Write interrupted"
+ }
+ else errC=0;
+ z=DIMBUF*2; //only one to check
+ }
+ }
+ err+=errC;
+ }
+ }
PrintStatusEnd();
PrintMessage1(strings[S_ComplErr],errC); //"completed, %d errors\r\n"
}
diff --git a/readme b/readme
index 499e757..092d701 100644
--- a/readme
+++ b/readme
@@ -5,6 +5,15 @@ Website: http://openprog.altervista.org
These sources are given free of charge under the GNU General Public License version 2
Changelog (to use new features the corresponding firmware is required):
+V 0.12.4 may 2025: added 18F04-05-06-14-15-16Q20;
+ fixed config write on 18FXXQ10;
+ fixed erase and write on 16F131XX,16F152XX,16F171XX,16F18XXX
+
+V 0.12.3 february 2025: fixed load OSCCal for 12F629-675,16F630-76;
+ fixed write on 18FXXQ8X devices;
+ added 12LF1552,16LF1566-67,16F13113-14-15-23-24-25-43-44-45,
+ 18F24K42,18F24-25-26-27-45-46-47K40,18F24-25-26-27-45-46-47Q10
+
V 0.12.2 december 2023: fixed config write on 16F18456; support all-in-one board
V 0.12.1 february 2023: fixed crash when selecting "*" filter;
diff --git a/strings.c b/strings.c
index 254e837..82d94d9 100644
--- a/strings.c
+++ b/strings.c
@@ -1,4 +1,4 @@
-// Strings.c v0.12.2
+// Strings.c v0.12.4
#include "common.h"
#define NL "\n"
@@ -73,6 +73,7 @@ void GenerateLangFile(const char* langid,const char* langfile){
void strinit()
{
STR_ID[S_NL]=(char*) "S_NL";
+ STR_ID[S_sepLine]=(char*) "S_sepLine";
STR_ID[S_noprog]=(char*) "S_noprog";
STR_ID[S_prog]="S_prog";
STR_ID[S_progDev]="S_progDev";
@@ -251,6 +252,7 @@ void strinit()
STR_ID[S_ForceConfigW]="S_ForceConfigW";
STR_ID[S_ForceConfigWx]="S_ForceConfigWx";
STR_ID[S_WarnFlashSize]="S_WarnFlashSize";
+ STR_ID[S_SkipSaflock]="S_SkipSaflock";
STR_ID[I_Fopen]="I_Fopen";
STR_ID[I_Fsave]="I_Fsave";
STR_ID[I_DevR]="I_DevR";
@@ -267,6 +269,7 @@ void strinit()
STR_ID[I_ID_BKo_W]="I_ID_BKo_W";
STR_ID[I_EE]="I_EE";
STR_ID[I_CalW]="I_CalW";
+ STR_ID[I_Saflock]="I_Saflock";
STR_ID[I_OSCW]="I_OSCW";
STR_ID[I_OSC]="I_OSC";
STR_ID[I_BKOSC]="I_BKOSC";
@@ -342,6 +345,7 @@ void strinit()
STR_ID[L_DEV_RW]="L_DEV_RW";
strings_it[S_NL]=NL;
+ strings_it[S_sepLine]="********************************" NL;
strings_it[S_noprog]="Programmatore non rilevato" NL;
strings_it[S_prog]="Programmatore rilevato" NL;
strings_it[S_progDev]="Programmatore rilevato su %s" NL;
@@ -527,6 +531,7 @@ void strinit()
strings_it[S_NextIns]="Prossima istruzione";
strings_it[S_ForceConfigW]="Forzo config word" NL;
strings_it[S_ForceConfigWx]="Forzo config word%d [0x%04X]=0x%04X" NL;
+ strings_it[S_SkipSaflock]="Ci sono stati errori; salto scrittura SAFLOCK" NL;
//
strings_it[I_CANCEL]="A_nnulla";
strings_it[I_OPEN]="_Apri";
@@ -547,6 +552,7 @@ void strinit()
strings_it[I_ID_BKo_W]="Programma ID e BKosccal";
strings_it[I_EE]="Leggi e programma EEPROM";
strings_it[I_CalW]="Programma Calib1 e 2";
+ strings_it[I_Saflock]="Usa SAFLOCK";
strings_it[I_OSCW]="Scrivi OSCCal";
strings_it[I_OSC]="OSCCal";
strings_it[I_BKOSC]="Backup OSCCal";
@@ -693,6 +699,7 @@ void strinit()
"-spispeed <s> cambia velocità SPI: 0=100k,1=200k,2=300k,3=500k" NL
"-support dispositivi supportati" NL
"-use_BKosccal copia BKosccal su osccal" NL
+ "-use_SAFLOCK usa SAFLOCK (dal file Hex)" NL
"-v, version versione" NL
"-vid <vid> vid programmatore [0x4D8]" NL
"-w, write <file> scrivi file Ihex" NL
@@ -709,6 +716,7 @@ void strinit()
// ENGLISH strings
strings_en[S_NL]=NL;
+ strings_en[S_sepLine]="********************************" NL;
strings_en[S_noprog]="Programmer not detected" NL;
strings_en[S_prog]="Programmer detected" NL;
strings_en[S_progDev]="Programmer detected on %s" NL;
@@ -896,6 +904,7 @@ void strinit()
strings_en[S_ForceConfigW]="Forcing config words" NL;
strings_en[S_ForceConfigWx]="Forcing config word%d [0x%04X]=0x%04X" NL;
strings_en[S_WarnFlashSize]="Warning, flash size is different from the expected value" NL;
+ strings_en[S_SkipSaflock]="There were write errors: skipping SAFLOCK write" NL;
//
strings_en[I_CANCEL]="_Cancel";
strings_en[I_OPEN]="_Open";
@@ -916,6 +925,7 @@ void strinit()
strings_en[I_ID_BKo_W]="Write ID and BKosccal";
strings_en[I_EE]="Read and write EEPROM";
strings_en[I_CalW]="Write Calib1 e 2";
+ strings_en[I_Saflock]="Use SAFLOCK";
strings_en[I_OSCW]="Write OSCCal";
strings_en[I_OSC]="OSCCal";
strings_en[I_BKOSC]="Backup OSCCal";
@@ -1060,6 +1070,7 @@ void strinit()
"-spispeed <s> set SPI speed: 0=100k,1=200k,2=500k,3=800k" NL
"-support supported devices" NL
"-use_BKosccal copy BKosccal to osccal" NL
+ "-use_SAFLOCK use SAFLOCK (from Hex file)" NL
"-v, version version" NL
"-vid <vid> programmer vid [0x4D8]" NL
"-w, write <file> write Ihex file" NL
diff --git a/strings.h b/strings.h
index f6eec68..e8c72fd 100644
--- a/strings.h
+++ b/strings.h
@@ -1,7 +1,8 @@
-// Strings.h v0.12.2
+// Strings.h v0.12.4
enum S {
S_NL,
+ S_sepLine,
S_noprog,
S_prog,
S_progDev,
@@ -182,6 +183,7 @@ enum S {
S_WaitS1W,
S_WaitS1R,
S_WarnFlashSize,
+ S_SkipSaflock,
// GUI strings
I_CANCEL,
I_OPEN,
@@ -202,6 +204,7 @@ enum S {
I_ID_BKo_W,
I_EE,
I_CalW,
+ I_Saflock,
I_OSCW,
I_OSC,
I_BKOSC,