ＰＩＣマイコンは面白い

# GreenPAK writer Ver 0.01 2024/05/26 by skyriver
#  Grenwriter written with picle language

use LibGreen;

# serial reset
proc SeriReset() {
    var dmy;
    if (I2CAdr(Padr,I2C_WR) = 0) {
        if (I2CSnd($c8) = 0) {
            dmy = I2CSnd( 2 );  # reset
        }
        I2CStop();
    }
}


# erase NVM
proc EraNvm() {
    PrnStr_( "Erase NVM :" );
    EraRom(0,14);
}


# erase EEPROM
proc EraEep() {
    PrnStr_( "Erase EEP :" );
    EraRom(16,31);
}


# write NVM
func WriteNvm() {
    PrnStr_( "¥nWrite NVM :" );
    return = WritePages( 2, 14 );
    PrnStr_( "¥n" );
}


# write EEPROM
func WriteEep() {
    PrnStr_( "¥nWrite EEP :" );
    return = WritePages( 3, 15 );
    PrnStr_( "¥n" );
}


# input I2C adr
func InpAdr( now ) {
    PrnStr_( "¥ninput I2C adr(0..F) " );
    if ( now >= 0 ) {
        PrnHexB_( now / 8 );
    } else {
        PrnStr_( "xx" );
    }
    PrnStr_( " -> " );
    return = GetHex();
}


# patch buffer data
proc Patch() {
    var adr,dat,c;
    PrnStr_( "¥n input adr:" );
    adr = GetHexByte();
    if ( (adr>=0) & (adr<=$FF) ) {
        PrnHexB_( adr );
        PrnStr_( "   data " );
        PrnHexB_( _Buf[ adr ] );
        PrnStr_( " -> " );
        dat = GetHexByte();
        PrnHexB_( dat );
        PrnStr_( "  sure?(Y/N) : " );
        c = InpChar_();
        PrnChar_( c );
        if ( ToUpper(c) = 'Y' ) {
            _Buf[ adr ] = dat;
        }
        PrnStr_( "¥n" );
    }
}


proc PrnErr() {
    PrnStr_( " .. Error !!¥n" );
}


proc Help() {
    PrnStr_("¥n<<<< Grenwriter for Green PAK SLG46826 >>>>¥n");
    PrnStr_("   S:scan I2C      A:set I2C current adr¥n");
    PrnStr_("   L:load HexFile  B:set I2C adr(NVM)¥n");
    PrnStr_("   W:write NVM     E:write EEP¥n");
    PrnStr_("   D:dump NVM      F:dump EEP¥n");
    PrnStr_("   R:dump REG      P:patch buffer data¥n");
    PrnStr_("   Q:quit¥n");
    PrnStr_("           V0.01 2024/05/26 by skyriver¥n¥n");
}

proc main() {
    var c,adr,nadr,flg;
    Init();
    Padr = $08;     # I2C addr
    nadr = -1;
    while (1) {
        Help();
        PrnChar_( ']' );
        c = ToUpper(InpChar_());
        PrnChar_( c );
        if ( c = 'S' ) {
            PrnStr_( "¥nscan I2C adr" );
            adr = Scan();
            PrnStr_( "¥n now adr:" );
            PrnHexB_( Padr / 8 );
            if ( adr >= 0 ) {
                PrnStr_( "  estimate adr:" );
                PrnHexB_( adr / 8 );
            }
            PrnStr_( "¥n" );
        }
        else if ( c = 'A' ) {
            adr = InpAdr( Padr );
            if ( (adr>=0)&(adr<16) ) {
                PrnHexB_( adr );
                Padr = adr * 8;
            }
            PrnStr_( "¥n" );
        }
        else if ( c = 'L' ) {
            PrnStr_( "¥nDrag HexFile" );
            if ( LoadHex() = 0 ) {
                DumpBuf();
            }
        }
        else if ( c = 'B' ) {
            adr = InpAdr( nadr );
            if ( (adr >=0)&(adr<16) ) {
                PrnHexB_( adr );
                nadr = adr * 8;
            }
            PrnStr_( "¥n" );
        }
        else if ( c = 'W' ) {
            if ( nadr >= 0 ) {
                _Buf[ $CA ] = nadr / 8;
            }
            PrnStr_( "¥nErase NVM :" );
            flg = 1;
            EraRom( 0, 14  );
            if ( WriteNvm() = 0 ) {
                DumpBuf();
                flg = 0;
            }
            SeriReset();
            Padr = _Buf[ $CA ] * 8;
            WaitAck();
            if ( flg ) {
                PrnErr();
            }
        }
        else if ( c = 'E' ) {
            PrnStr_( "¥nErase EEP :" );
            flg = 1;
            EraRom( 16, 31  );
            if ( WriteEep() = ) {
                DumpBuf();
                flg = 0;
            }
            if ( flg ) {
                PrnErr();
            }
        }
        else if ( c = 'D' ) {
            PrnStr_( "¥n dump NVM" );
            if ( ReadMem( 2 ) = 0 ) {
                DumpBuf();
            }
        }
        else if ( c = 'F' ) {
            PrnStr_( "¥n dump EEP" );
            if ( ReadMem( 3 ) = 0 ) {
                DumpBuf();
            }
        }
        else if ( c = 'R' ) {
            PrnStr_( "¥n dump REG" );
            if ( ReadMem( 0 ) = 0 ) {
                DumpBuf();
            }
        }
        else if ( c = 'P' ) {
            Patch();
        }
        else if ( c = 'Q' ) {
            break;
        }
    }
    PrnStr_( "¥nSee you again!" );
}

#LibGreen GreenPAK writer libraly Ver 0.01 2024/05/26 by skyriver
#  written with picle language

use LibPic;
use LibI2C;
use LibGreen1;


# load Hex into buffer
#  return -> 0:ok
func LoadHex() {
    var i,c,cnt,adr,type,dmy;
    for ( i = 0; i < 256; i=i+1 ) {
        _Buf[ i ] = 0;
    }
    do {
        do {
            c = InpChar_();
            if ( c = $1B ) {    # ESC
                return = -1;
                break;      # $__$
            }
        } while ( c <> ':' );
        Sum = 0;
        cnt = GetHexByte();
        if ( (cnt>$20) | (cnt<0) ) {
            return = 1;
        } else {
            adr = GetHexByte() * 256 + GetHexByte();
            if ( adr >$F0 ) {
                return = -2;
            } else {
                type = GetHexByte();
                for ( i = 0; i < cnt; i=i+1 ) {
                    _Buf[ adr + i ] = GetHexByte();
                }
                dmy = GetHexByte();
                if ( Sum & $FF ) {
                    return = 3;     # SUM err
                }
            }
        }
    } while ( (return=0) & (type=0) );
}


# write ROM 1 page
#  badr <- block adr 00:RAM,02:NVM,03:EEP
#  page <- write page num
#  return -> 0:ok
func WrRom( badr, page ) {
    var i,cbyte,tmp;
    cbyte = Padr | badr;
    page = page * 16;
    return =  I2CAdr( cbyte, I2C_WR );
    if ( return = 0 ) {
        return = I2CSnd( page );
        if ( return = 0 ) {
            for ( i = 0; (i < 16) & (return = 0); i=i+1 ) {
                return = I2CSnd( _Buf[ page + i ] );
            }
            I2CStop();
            WaitAck();
            if ( return = 0 ) {
                return = 1;
                if ( I2CAdr( cbyte, I2C_WR ) = 0 ) {
                    if ( I2CSnd( page ) = 0 ) {
                        if ( I2CAdr( cbyte, I2C_RD ) = 0 ) {
                            for ( i = 0; i < 16; i=i+1 ) {
                                return = I2CRcv(1);
                                if ( return = 0 ) {
                                    if ( I2CRcv <> _Buf[ page + i ] ) {
                                        PrnStr_( " missmatch at " );
                                        PrnHex_( page + i );
                                        PrnChar_( ' ' );
                                        PrnHexB_( _Buf[ page + i ] );
                                        PrnStr_( "->" );
                                        PrnHexB_( I2CRcv );
                                        return = 2;     # miss match
                                        break;          # $__$
                                    }
                                }
                            }
                            tmp = I2CRcv(0);
                        }
                    }
                }
                I2CStop();
            }
        }
    }
}


# write pages in ROM
#  basr <- block adr 00:RAM,02:NVM,03:EEP
#  until <- last page num
func WritePages( badr, until ) {
    var i;
    for ( i = 0; (i<=until) & (return=0); i=i+1 ) {
        PrnChar_( ' ' );
        PrnHexB_( i );
        return = WrRom( badr, i );
    }
}


proc Init() {
    var i;
    InitReg();
    InitI2C( $0210 );        # I2C 2ch:$0210

    LATA[0] = 0;
    LATB[0] = 0;
    LATA[-2] = $0000;
    LATB[-2] = $0b0c;

    I2C_RD = 1;
    I2C_WR = 0;

    _Buf = Alloc( 256 );
    for ( i = 0; i < 256; i=i+1 ) {
        _Buf[ i ] = 0;
    }
}


proc main() {
    var est;
    Init();
    Padr = $08;     # I2C addr
    PrnStr_( "¥nread RAM" );
    if ( ReadMem( 0 ) = 0 ) {
        DumpBuf();
    }
    PrnStr_( "¥nread NVM" );
    if ( ReadMem( 2 ) = 0 ) {
        DumpBuf();
    }
    PrnStr_( "¥nread EEP" );
    if ( ReadMem( 3 ) = 0 ) {
        DumpBuf();
    }
    est = Scan();
    if ( est >= 0 ) {
        PrnStr_( "¥n estimate:" );
        PrnHexB_( est );
    }
    PrnStr_( "¥nDrag Hex file" );
    if ( LoadHex() = 0 ) {
        DumpBuf();
    }
}

#LibGreen1 GreenPAK writer libraly Ver 0.01 2024/05/26 by skyriver
#  written with picle language


var I2C_RD, I2C_WR, Padr, _Buf, Sum;

func ToUpper( c ) {
    if ( (c >= 'a') & (c <='z' ) ) {
        c = c - ('a' - 'A');
    }
    return = c;
}

# scan I2C
#  return -> estimate adr
func Scan() {
    var i,j,adr,cnt,est;
    cnt = 0;
    return = -1;
    est = -1;
    adr = 0;
    for ( i = 0; i < 8; i=i+1 ) {
        PrnStr_( "¥n  " );
        PrnHexB_( adr );
        PrnStr_( " :" );
        for ( j = 0; j < 16; j=j+1 ) {
            PrnChar_( ' ' );
            if ( I2CAdr(adr,I2C_WR) ) {
                PrnStr_( "--" );
                if ( cnt = 4 ) {
                    return = est;
                }
                cnt = 0;
            } else {
                PrnHexB_( adr );
                cnt = cnt + 1;
                if ( cnt = 1 ) {
                    est = adr;
                }
            }
            I2CStop();
            adr = adr + 1;
        }
    }
    PrnStr_( "¥n" );
}


# wait until ack
proc WaitAck() {
    var dat;
    do {
        dat = I2CAdr(Padr,I2C_WR);
        I2CStop();
    } while (dat);
}


# erase ROM
#  st <- start block
#  en <- end block
proc EraRom( st, en ) {
    var i,dmy;
    if ( st <= en ) {
        for ( i=st; i<=en; i=i+1 ) {
            PrnChar_(' ');
            if (I2CAdr(Padr,I2C_WR) = 0) {
                if (I2CSnd($E3) = 0) {  # ERSR
                    dmy = I2CSnd(i | $80);
                }
            }
            I2CStop();
            WaitAck();
            PrnHexB_(i);
        }
    }
}


# dump buffer
proc DumpBuf() {
    var adr,i,j;
    adr = 0;
    for ( j=0; j<16; j=j+1 ) {
        PrnStr_( "¥n  " );
        PrnHexB_( adr );
        PrnStr_( " :" );
        for ( i=0; i< 16; i=i+1 ) {
            PrnChar_( ' ' );
            if ( i = 8 ) {
                PrnStr_( "- " );
            }
            PrnHexB_( _Buf[adr] );
            adr = adr +1 ;
        }
    }
    PrnStr_( "¥n" );
}


# read memory
#  badr <- block adr 00:RAM,02:NVM,03:EEP
#  return -> 0:no error
func ReadMem( badr ){
    var i, cbyte;
    cbyte = Padr | badr;
    return =  I2CAdr( cbyte, I2C_WR );
    if ( return = 0 ) {
        return = I2CSnd( 0 );
        if ( return = 0 ) {
            return =  I2CAdr( cbyte, I2C_RD );
            if ( return = 0 ) {
                for ( i = 0; i < 256; i=i+1 ) {
                    return = I2CRcv( 1 );
                    if ( return ) {
                        break;      # $__$
                    }
                    _Buf[ i ] = I2CRcv;
                }
                cbyte = I2CRcv( 0 );    # dummy read(nack)
                I2CStop();
            }
        }
    }
}


# get hex data from input
# GetHex() {
func GetHex() {
    var c;
    c = InpChar_();
    c = ToUpper( c );
    if ( (c >= '0') & (c <= '9') ) {
        return = c - '0';
    }
    else if ( (c >= 'A') & (c <= 'F') ) {
        return = c + ( 10 - 'A' );
    } else {
        return = -1;
    }
}


# get hex byte data
func GetHexByte() {
    return = GetHex();
    if ( return >= 0 ) {
        return = return * 16 + GetHex();
        Sum = Sum + return;
    }
}

#LibI2C I2C libraly v0.02 2024/05/25
#  written with picle language by skyriver

var RegRcv,RegTrn,RegBrg;
var RegCon,RegStat;
var I2CRcv;

# send data to slave
#  data <- send data
#  return -> 0:no error
func I2CSnd( data ) {
    while ( RegCon[0] & $1f ) {}
    RegTrn[0] = data;
    while ( RegStat[0] & $4000 ) {}
    return = RegStat[0] & $8000;     # check nack
}

# receive data form slave
#  ack <- 0:nak, else:ack
#  I2CRcv -> receive data
#  return -> 0:no error
func I2CRcv( ack ) {
    while ( RegCon[0] & $1f ) {}
    RegCon[0] = RegCon[0] | $0008;  # enable receive
    while ( RegCon[0] & $0008 ) {}
    if ( ack ) {
        RegCon[0] = RegCon[0] & ~$0020; # set ack
    } else {
        RegCon[0] = RegCon[0] | $0020;  # set nack
    }
    RegCon[0] = RegCon[0] | $0010;  # send ack/nack
    while ( RegCon[0] & $0010 ) {}
    I2CRcv = RegRcv[0];
    return = RegStat[0] & $0040;     # check overflow
}

# start seqence and send salave adrs
#  adr <- slave_adrs
#  rd  <- 1:rd,0:wr
#  return -> 0:no error
func I2CAdr( adr, rd ) {
    RegCon[0] = RegCon[0] | 3;  # repeated start
    return = I2CSnd( (adr+adr)|rd );
}


# stop I2C sequence
proc I2CStop() {
    RegCon[0] = RegCon[0] | $0004;  # set PEN(stop)
    while ( RegCon[0] & $0004 ) {}
}


proc InitI2C( base ) {
    RegRcv = base;
    RegTrn = base + 2;
    RegBrg = base + 4;
    RegCon = base + 6;
    RegStat = base + 8;
    RegBrg[0] = 37; # Fcy:16MHz -> 157:100kHz 37:400kHz
    RegCon[0] = $8000;  # enable I2C
}


proc main() {
    var adr,err,i,j;
    InitI2C( $0210 );        # I2C 2ch:$0210
    adr = 0;

    for ( j = 0; j < 8; j=j+1 ) {
        PrnHexB_( adr );
        PrnStr_( " :" );
        for ( i = 0; i < 16; i=i+1 ) {
            PrnChar_( ' ' );
            if ( I2CAdr( adr, 0 ) ) {
                PrnStr_( "--" );
            } else {
                PrnHexB_( adr );
            }
            I2CStop();
            adr = adr + 1;
        }
        PrnStr_( "¥n" );
    }
}

#LibPic major registance v0.01 2018/08/20

var _REG,LATA,LATB,LATC;
var ArIdx,Word,_Byte;

func Alloc( size ) {
    return = Array_(ArIdx);
    ArIdx=ArIdx+size;
}


proc InitReg() {
    var Ad1pcfg;
    Ad1pcfg = $032c;
    Ad1pcfg[0] = $ffff; # set digital mode

    LATA=$02c4;
    LATB=$02cc;
    LATC=$02d4;

    Word = Alloc(1);
    _Byte = Word;
}


func GetHigh( dat ) {
    Word[0] = dat;
    return = _Byte[1];
}


func GetLow( dat ) {
    return = dat & $ff;
}