static void
DecodeDM24Time (uint8_t * ptr, G2DM24Time * t)
{
G2GTime gt;
t->time.sec = bcd(ptr[2]);
t->time.min = bcd(ptr[3]);
t->time.hour = bcd(ptr[4]);
t->time.mday = bcd(ptr[5]);
t->time.month = bcd(ptr[6]);
t->time.year = (bcd(ptr[8])*100)+bcd(ptr[9]);
if (t->time.year<1983) {
t->time.year=0;
t->time.wday=-1;
} else {
gt=G2UTC2GTime(t->time);
t->time=G2GTime2UTC(gt);
}
t->status = bcd(ptr[0]);
t->hundredths = bcd(ptr[1]);
t->timer = bcd(ptr[7]);
}
void
add_timer(tymer_t *db, timer_data_t *data)
{
int i;
timer_rec_t *rec, *r;
/* use zalloc() to initialize reserved bits */
rec = (timer_rec_t *)zalloc(sizeof(timer_rec_t));
for(i = 0; i < 9 && data->msg[i]; i++)
rec->msg[i] = rdmi(data->msg[i]);
for(; i < 9; i++)
rec->msg[i] = rdmi(' ');
rec->hours = bcd(data->hours);
rec->minutes = bcd(data->minutes);
rec->seconds = bcd(data->seconds);
if(is_countdn)
rec->at_end = data->at_end;
rec->halfway_reminder = data->halfway_reminder;
if(!data->hours && !data->minutes && !data->seconds)
rec->data_is_0 = 1;
if(!data->hours && !data->minutes && data->seconds < 15)
rec->data_less_than_15sec = 1;
if(!data->hours && !data->minutes && data->seconds < 60 )
rec->data_less_than_1min = 1;
db->hdr.db_size += 13;
/* sort */
for(r = db->head; r; r = r->next){
if(memcmp(rec->msg, r->msg, 9) < 0)
break;
}
if(r){
rec->prev = r->prev;
if(rec->prev)
rec->prev->next = rec;
else
db->head = rec;
rec->next = r;
rec->next->prev = rec;
}else{
rec->prev = db->tail;
if(rec->prev)
rec->prev->next = rec;
else
db->head = rec;
rec->next = NULL;
db->tail = rec;
}
db->hdr.num_recs++;
db->hdr.alloc_size = ((db->hdr.db_size-1) / PAGE_SIZE + 1) * PAGE_SIZE;
return;
}
void dvb_desc_cable_delivery_init(struct dvb_v5_fe_parms *parms, const uint8_t *buf, struct dvb_desc *desc)
{
struct dvb_desc_cable_delivery *cable = (struct dvb_desc_cable_delivery *) desc;
/* copy only the data - length already initialize */
memcpy(((uint8_t *) cable ) + sizeof(cable->type) + sizeof(cable->next) + sizeof(cable->length),
buf,
cable->length);
bswap32(cable->frequency);
bswap16(cable->bitfield1);
bswap32(cable->bitfield2);
cable->frequency = bcd(cable->frequency) * 100;
cable->symbol_rate = bcd(cable->symbol_rate) * 100;
}
void dvb_desc_sat_init(struct dvb_v5_fe_parms *parms, const uint8_t *buf, struct dvb_desc *desc)
{
struct dvb_desc_sat *sat = (struct dvb_desc_sat *) desc;
/* copy from .length */
memcpy(((uint8_t *) sat ) + sizeof(sat->type) + sizeof(sat->next) + sizeof(sat->length),
buf,
sat->length);
bswap16(sat->orbit);
bswap32(sat->bitfield);
bswap32(sat->frequency);
sat->orbit = bcd(sat->orbit);
sat->frequency = bcd(sat->frequency) * 10;
sat->symbol_rate = bcd(sat->symbol_rate) * 100;
}
DCEL3D::DCEL3D(sPoint i_PtA, sPoint i_PtB, sPoint i_PtC, sPoint i_PtD) :
m_PtInside(new Point((*i_PtA + *i_PtB + *i_PtC + *i_PtD) * 0.25)),
m_Facets()
{
// Create first four facets
sptr<Facet> abc(addFacet(i_PtA, i_PtB, i_PtC));
sptr<Facet> bcd(addFacet(i_PtB, i_PtC, i_PtD));
sptr<Facet> acd(addFacet(i_PtA, i_PtC, i_PtD));
sptr<Facet> abd(addFacet(i_PtA, i_PtB, i_PtD));
// Connect them via twins
// TODO: make this part suck less
abc->connectTo(bcd, i_PtB, i_PtC);
abc->connectTo(acd, i_PtA, i_PtC);
abc->connectTo(abd, i_PtA, i_PtB);
bcd->connectTo(abc, i_PtB, i_PtC);
bcd->connectTo(acd, i_PtC, i_PtD);
bcd->connectTo(abd, i_PtB, i_PtD);
acd->connectTo(abc, i_PtA, i_PtC);
acd->connectTo(bcd, i_PtC, i_PtD);
acd->connectTo(abd, i_PtA, i_PtD);
abd->connectTo(abc, i_PtA, i_PtB);
abd->connectTo(bcd, i_PtB, i_PtD);
abd->connectTo(acd, i_PtA, i_PtD);
}
int main() {
bc1( &x );
bc2( &x );
bc3( &x );
bcd( &x );
_PASS;
}
void decTo7seg(uint32_t var01,uint8_t digit)
{
uint8_t i=1;
for(i=1; i<digit; i++)
{
sevenSegBuffer[i]=seg7[bcd(var01,i)];
}
sevenSegBuffer[0]=seg7[var01%10];
}
static void pgm_calendar_w(unsigned short data)
{
time_t nLocalTime = time(NULL);
tm* tmLocalTime = localtime(&nLocalTime);
CalCom <<= 1;
CalCom |= data & 1;
++CalCnt;
if(CalCnt==4)
{
CalMask = 1;
CalVal = 1;
CalCnt = 0;
switch(CalCom & 0xf)
{
case 0x1: case 0x3: case 0x5: case 0x7: case 0x9: case 0xb: case 0xd:
CalVal++;
break;
case 0x0: // Day
CalVal=bcd(tmLocalTime->tm_wday);
break;
case 0x2: // Hours
CalVal=bcd(tmLocalTime->tm_hour);
break;
case 0x4: // Seconds
CalVal=bcd(tmLocalTime->tm_sec);
break;
case 0x6: // Month
CalVal=bcd(tmLocalTime->tm_mon + 1); // not bcd in MVS
break;
case 0x8: // Milliseconds?
CalVal=0;
break;
case 0xa: // Day
CalVal=bcd(tmLocalTime->tm_mday);
break;
case 0xc: // Minute
CalVal=bcd(tmLocalTime->tm_min);
break;
case 0xe: // Year
CalVal=bcd(tmLocalTime->tm_year % 100);
break;
case 0xf: // Load Date
tmLocalTime = localtime(&nLocalTime);
break;
}
}
}
static void vulgar_fraction(char *buf, int x)
{
int d;
d=bcd(x, 1000);
x/=d;
d=1000/d;
if (d>1)
sprintf(buf, "%d/%d", x, d);
else
sprintf(buf, "%d", x);
}
void main(){
TRISA = 255; // Puerto A como entrada
ANSELA = 3; // RA0 y RA1 como analogas
TRISB = 0; // Puerto B salida
ANSELB = 0; // Puerto B Digital
PORTB = 0; // Limpio el puerto B
// Configuración LCD
// Antes de enviar datos al LCD debemos configurarle ciertos parametros
inicio_lcd(); // Llamamos la función para inicializar el LCD
inicio_AD(); // Llamamos la función para inicializar el conversor AD
// Establecemos los mensajes que estaran estaticos en el LCD
irapos_lcd(0); // Nos ubicamos en la primera linea posición 0
cadena_lcd("Volt: . V"); // Envio el mensaje a la primera linea
// En los espacios antes y despues del punto se ubicaran los valores
irapos_lcd(64); // Nos ubicamos en la primera linea posición 0
cadena_lcd("Temp: C"); // Envio el mensaje a la segunda linea
// En los espacion antes de °C aparacera la temperatura
while(1){ // Inicio del código a ejecutar constantemente
convertir_AD(Volt); // Hacemos la conversión en el canal 0
voltaje = (conversion * 49) / 1000; // Calculo para que se muestre el voltaje con un decimal
bcd(voltaje); // Llamamos la funcion bcd para que separe voltaje en digitos
irapos_lcd(6); // Vamos a la posición 6 de la primera linea
caracter_lcd(decenas + 48); // Escribimos el valor del voltaje (se le suma 48 por estar en ascii)
irapos_lcd(8); // Vamos a la posición 8 de la primera linea
caracter_lcd(unidades + 48); // Escribimos el valor decimal del voltaje
convertir_AD(Temp); // Hacemos la conversión en el canal 1
temperatura = conversion / 2; // Calculo para la temperatura
bcd(temperatura); // Llamamos la funcion bcd para que separe temperatura en digitos
irapos_lcd(70); // Vamos a la posición 70 de la segunda linea
caracter_lcd(centenas + 48); // Escribimos centenas
irapos_lcd(71); // Vamos a la posición 71 de la segunda linea
caracter_lcd(decenas + 48); // Escribimos decenas
irapos_lcd(72); // Vamos a la posición 72 de la segunda linea
caracter_lcd(unidades + 48); // Escribimos unidades
}
}
/*
delete all sessionfiles from the watch
*/
void S625Xcomm::deleteAllFiles(void){
unsigned char query[7];
query[0] = 0x0c;
query[1] = 0xff; // delete all files
query[2] = bcd(00); // second
query[3] = bcd(00); // minute
query[4] = bcd(00); // hour
query[5] = bcd(02); // day
query[6] = bcd(00); // year last 2 digits
query[7] = bcd(00); // month
std::cout<< "delete command: ";
for (int i=0; i<=7; i++) {
std::cout<< hex <<(int) query[i]<<" ";
}
std::cout<<"\n";
this->driver->sendbytes(query, sizeof(query));
}
int sc_main(int argc, char *argv[]){
sc_signal<bool> clock, reset;
sc_signal<unsigned short int> count_val;
sc_signal<char> v_hi, v_lo;
sc_set_time_resolution(1, SC_US);
stimul stim("stimuli_mod");
stim.clk(clock);
stim.res(reset);
counter count("counter");
count.clk(clock);
count.res(reset);
count.cnt(count_val);
bcd_decoder bcd("bcd_decode");
bcd.val(count_val);
bcd.hi(v_hi);
bcd.lo(v_lo);
sc_trace_file *tf = sc_create_vcd_trace_file("traces");
sc_trace(tf, reset, "reset");
sc_trace(tf, clock, "clock");
sc_trace(tf, count_val, "counter_value");
sc_trace(tf, v_hi, "BCD_High");
sc_trace(tf, v_lo, "BCD_low");
int n_cycles;
if(argc != 2){
cout << "default n_cycles = 200\n";
n_cycles = 200;
}
else
n_cycles = atoi(argv[1]);
sc_start(n_cycles, SC_US);
sc_close_vcd_trace_file(tf);
return 0;
}
/*-------------------------------------------------------------------------+
| Function: rtc_read
| Description: Read present time from RTC and return it.
| Global Variables: None.
| Arguments: tod - to return present time in 'rtems_time_of_day' format.
| Returns: number of seconds from 1970/01/01 corresponding to 'tod'.
+--------------------------------------------------------------------------*/
long int
rtc_read(rtems_time_of_day *tod)
{
uint8_t sa;
uint32_t sec = 0;
memset(tod, 0, sizeof *tod); /* zero tod structure */
/* do we have a realtime clock present? (otherwise we loop below) */
sa = rtcin(RTC_STATUSA);
if (sa == 0xff || sa == 0)
return -1;
/* ready for a read? */
while ((sa&RTCSA_TUP) == RTCSA_TUP)
sa = rtcin(RTC_STATUSA);
tod->year = bcd(rtcin(RTC_YEAR)) + 1900; /* year */
if (tod->year < 1970) tod->year += 100;
tod->month = bcd(rtcin(RTC_MONTH)); /* month */
tod->day = bcd(rtcin(RTC_DAY)); /* day */
(void) bcd(rtcin(RTC_WDAY)); /* weekday */
tod->hour = bcd(rtcin(RTC_HRS)); /* hour */
tod->minute = bcd(rtcin(RTC_MIN)); /* minutes */
tod->second = bcd(rtcin(RTC_SEC)); /* seconds */
tod->ticks = 0;
#ifndef QUICK_READ /* Quick read of the RTC: don't return number of seconds. */
sec = ytos(tod->year);
sec += mtos(tod->month, (tod->year % 4) == 0);
sec += tod->day * SECS_PER_DAY;
sec += tod->hour * 60 * 60; /* hour */
sec += tod->minute * 60; /* minutes */
sec += tod->second; /* seconds */
#endif /* QUICK_READ */
return (long int)sec;
} /* rtc_read */
int am335x_rtc_gettime(int minor,rtems_time_of_day *t)
{
uint32_t a = 0x0;
if(minor != 0)
return RTEMS_INVALID_NUMBER;
a = mmio_read(AM335X_RTC_BASE+AM335X_RTC_SECS);
t->second = bcd(a);
a = mmio_read(AM335X_RTC_BASE+AM335X_RTC_MINS);
t->minute = bcd(a);
a = mmio_read(AM335X_RTC_BASE+AM335X_RTC_HOURS);
t->hour = bcd(a);
a = mmio_read(AM335X_RTC_BASE+AM335X_RTC_DAYS);
t->day = bcd(a);
a = mmio_read(AM335X_RTC_BASE+AM335X_RTC_MONTHS);
t->month = bcd(a);
a = mmio_read(AM335X_RTC_BASE+AM335X_RTC_YEARS);
t->year = bcd(a)+2000;
t->ticks=0;
return RTEMS_SUCCESSFUL;
}
int main(void)
{
struct tm *newtime;
time_t ltime;
time(<ime); /* Get the time in seconds */
newtime = localtime(<ime); /* Convert it to the structure tm */
char * st; // gen purpose string for bcd's
st = new char[35]; // 32 digits + sign + decimal pt + '\0'
ofstream dout("bcdrun.log");
bcd numa("1234567890987654.123"); // fraction will be dropped
bcd numb(4321.6789); // ditto - we are using integer rules
bcd numc(-24681357L);
bcd numd = numa + numb;
bcd e(0.0);
bcd f(0L);
bcd g(-0.0);
bcd h(-0L);
bcd w(1L);
bcd x(-1.0);
bcd y("-2.0");
bcd z("300.");
bcd aa("99999999999999999999999999999999");
bcd bb("1");
bcd cc("10000000000000000");
bcd dd(".00000000000000001");
bcd m1(12L);
bcd m2(2L);
bcd m3(123456789L);
bcd m4(4096L);
bcd m5(748345987654321.0);
bcd m6(288834570200345.0);
bcd m7("8599238847786248452455563809");
bcd d1("8765432109876");
bcd d2(24687L);
bcd d3(75237L);
bcd d4(45263L);
bcd d5 ("92732081006447");
bcd s1("1234567890987654");
dout << " Regression Log for " << asctime(newtime) << endl;
dout << "significant digits test: 1 = " << w.sigD() << ", 3 = " << z.sigD()
<< ", 32 = " << aa.sigD() << ", 0 = " << dd.sigD() << "\n" << endl;
int rc = numa.bcdToString(st); // convert numa to string no decimal point
dout << "bcd to string test = " << st << "\n"
<< " expected: +1234567890987654" << endl;
rc = numa.bcdToString(st,1); // numa to str with 1 psn to right of dec pt
dout << "bcd to string test = " << st << "\n"
<< " expected: +123456789098765.4" << endl;
rc = numa.bcdToString(st,6); // numa to str with 6 psns to rt of decimal pt
dout << "bcd to string test = " << st << "\n"
<< " expected: +1234567890.987654" << "\n" << endl;
rc = m3.bcdToString(st); // convert m3 to string no decimal point
dout << "bcd to string test = " << st << "\n"
<< " expected: +123456789" << endl;
rc = m3.bcdToString(st,1); // m3 to str with 1 psn to right of dec pt
dout << "bcd to string test = " << st << "\n"
<< " expected: +12345678.9" << endl;
rc = m3.bcdToString(st,6); // m3 to str with 6 psns to rt of decimal pt
dout << "bcd to string test = " << st << "\n"
<< " expected: +123.456789" << "\n" << endl;
rc = h.bcdToString(st); // convert h to string no decimal point
dout << "bcd to string test = " << st << "\n"
<< " expected: +0" << endl;
rc = h.bcdToString(st,1); // convert h to str with 1 psn to right of dec pt
dout << "bcd to string test = " << st << "\n"
<< " expected: +0.0" << endl;
rc = h.bcdToString(st,6); // h to str with 6 psns to rt of decimal pt
dout << "bcd to string test = " << st << "\n"
<< " expected: +0.0" << "\n" << endl;
rc = m2.bcdToString(st); // convert m2 to string no decimal point
dout << "bcd to string test = " << st << "\n"
<< " expected: +2" << endl;
rc = m2.bcdToString(st,1); // m2 to str with 1 psn to right of dec pt
dout << "bcd to string test = " << st << "\n"
<< " expected: +0.2" << endl;
rc = m2.bcdToString(st,6); // m2 to str with 6 psns to rt of decimal pt
dout << "bcd to string test = " << st << "\n"
<< " expected: +0.000002" << "\n" << endl;
s1.shl(1);
dout << "shift test 1234567890987654 shifted left 1 = " << s1
<< " expected = +00000000000000012345678909876540 cc: 0\n" << endl;
s1.shl(2);
dout << "shift test 1234567890987654 shifted left 2 = " << s1
<< " expected = +00000000000001234567890987654000 cc: 0\n" << endl;
s1.shl(3);
dout << "shift test 1234567890987654 shifted left 3 = " << s1
<< " expected = +00000000001234567890987654000000 cc: 0\n" << endl;
s1.shl(13);
dout << "shift test 1234567890987654 shfted left 13 = " << s1
<< " expected = +00000000001234567890987654000000 cc: 16\n" << endl;
s1.shr(1);
dout << "shift test 1234567890987654 shifted rt 1 = " << s1
<< " expected = +00000000000123456789098765400000 cc: 0\n" << endl;
s1.shr(2);
dout << "shift test 1234567890987654 shifted rt 2 = " << s1
<< " expected = +00000000000001234567890987654000 cc: 0\n" << endl;
s1.shr(5);
dout << "shift test 1234567890987654 shifted rt 5 = " << s1
<< " expected = +00000000000000000012345678909876 cc: 0\n" << endl;
s1.shrRnd(4);
dout << "shift test 12345678909876 sh rt 4 & rnd = " << s1
<< " expected = +00000000000000000000001234567891 cc: 0\n" << endl;
s1.shrRnd(4);
dout << "shift test 12345678909876 sh rt 4 & rnd = " << s1
<< " expected = +00000000000000000000000000123457 cc: 0\n" << endl;
s1.shrRnd(5);
dout << "shift test 12345678909876 sh rt 5 & rnd = " << s1
<< " expected = +00000000000000000000000000000001 cc: 0\n" << endl;
s1.shl(31);
dout << "shift test 12345678909876 sh lt 31 = " << s1
<< " expected = +10000000000000000000000000000000 cc: 0\n" << endl;
bcd s2("1234567890987654321");
s2.shrCpld(s1,6); // odd shift even
dout << "coupled shift s2 > s1, s1 = " << s1
<< " expected s1 = +00000000000000000000000000654321 cc: 0\n"
<< " s2 = " << s2
<< " expected s2 = +00000000000000000001234567890987 cc: 0\n" << endl;
s2.shrCpld(s1,5); // odd shift odd
dout << "coupled shift s2 > s1, s1 = " << s1
<< " expected s1 = +00000000000000000000000000090987 cc: 0\n"
<< " s2 = " << s2
<< " expected s2 = +00000000000000000000000012345678 cc: 0\n" << endl;
s2.shrCpld(s1,4); // even shift even
dout << "coupled shift s2 > s1, s1 = " << s1
<< " expected s1 = +00000000000000000000000000005678 cc: 0\n"
<< " s2 = " << s2
<< " expected s2 = +00000000000000000000000000001234 cc: 0\n" << endl;
s2.shrCpld(s1,3); // odd shift odd
dout << "coupled shift s2 > s1, s1 = " << s1
<< " expected s1 = +00000000000000000000000000000234 cc: 0\n"
<< " s2 = " << s2
<< " expected s2 = +00000000000000000000000000000001 cc: 0\n" << endl;
dout << "logical test 1 < 2 = " << int(bb<m2) << "\n"
<< "expected = 1 \n" << endl;
dout << "logical test 1 > 2 = " << int(bb>m2) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test 1 = 2 = " << int(bb==m2) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test 2 < 1 = " << int(m2<bb) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test 2 > 1 = " << int(m2>bb) << "\n"
<< "expected = 1 \n" << endl;
dout << "logical test 2 = 1 = " << int(m2==bb) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test 1 < 12 = " << int(bb<m1) << "\n"
<< "expected = 1 \n" << endl;
dout << "logical test 1 > 12 = " << int(bb>m1) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test 1 = 12 = " << int(bb==m1) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test 12 < 1 = " << int(m1<bb) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test 12 > 1 = " << int(m1>bb) << "\n"
<< "expected = 1 \n" << endl;
dout << "logical test 12 = 1 = " << int(m1==bb) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test -1 < 2 = " << int(x<m2) << "\n"
<< "expected = 1 \n" << endl;
dout << "logical test -1 > 2 = " << int(x>m2) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test -1 = 2 = " << int(x==m2) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test 2 < -1 = " << int(m2<x) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test -1 != 2 = " << int(x!=m2) << "\n"
<< "expected = 1 \n" << endl;
dout << "logical test 2 != -1 = " << int(m2!=x) << "\n"
<< "expected = 1 \n" << endl;
dout << "logical test 2 != 2 = " << int(m2!=m2) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test 2 > -1 = " << int(m2>x) << "\n"
<< "expected = 1 \n" << endl;
dout << "logical test 2 = -1 = " << int(m2==x) << "\n"
<< "expected = 0 \n" << endl;
dout << "logical test d1 = d1 = " << int(d1==d1) << "\n"
<< "expected = 1 \n" << endl;
dout << "logical test 0 = -0 = " << int(f==h) << "\n"
<< "expected = 1 \n" << endl;
dout << "logical test -0 = 0 = " << int(h==f) << "\n"
<< "expected = 1 \n" << endl;
dout << "logical test 0 = 0 = " << int(f==f) << "\n"
<< "expected = 1 \n" << endl;
dout << "logical test -0 = -0 = " << int(h==h) << "\n"
<< "expected = 1 \n" << endl;
dout << "divide test 8765432109876/24687 = " << d1/d2
<< "expected = +00000000000000000000000355062669 cc: 0\n" << endl;
dout << "divide tst 92732081006447/45263 = " << d5/d4
<< "expected = +00000000000000000000002048739169 cc: 0\n" << endl;
dout << "divide test 8765432109876/75237 = " << d1/d3
<< "expected = +00000000000000000000000116504274 cc: 0\n" << endl;
dout << "divide test 1/24687 = " << bb/d2
<< "expected = +00000000000000000000000000000000 cc: 0\n" << endl;
dout << " test 10000000000000000/24687 = " << cc/d2
<< "expected = +00000000000000000000405071495118 cc: 0\n" << endl;
dout << " test 10000000000000000/3 = " << cc/3L
<< "expected = +00000000000000003333333333333333 cc: 0\n" << endl;
dout << " test 10000000000000000/6 = " << cc/6L
<< "expected = +00000000000000001666666666666666 cc: 0\n" << endl;
dout << " test 10000000000000000/7 = " << cc/7L
<< "expected = +00000000000000001428571428571428 cc: 0\n" << endl;
dout << " div test 22000000000000000/7 = " << (cc*22L)/7L
<< "expected = +00000000000000031428571428571428 cc: 0\n" << endl;
dout << "modulus test 24687%1000 = " << d2%1000L
<< "expected = +00000000000000000000000000000687 cc: 0\n" << endl;
dout << "divide by zero test 75237/0 = " << d3/0L
<< "expected = +00000000000000000000000000075237 cc: 16\n" << endl;
dout << "divide d1/d1 test = " << d1/d1
<< "expected = +00000000000000000000000000000001 cc: 0\n" << endl;
dout << "re-subtract test: 12345 - 12346 = " << bcd(12345L) - 12346L
<< "expected = -00000000000000000000000000000001 cc: 0\n"
<< " reverse opnds: 12346 - 12345 = " << bcd(12346L) - 12345L
<< "expected = +00000000000000000000000000000001 cc: 0\n" << endl;
dout << "8599238847786248452455563809*45263 = " << m7 * d4
<< " expected: +00008599238847786248452455563809 cc: 15\n" << endl;
dout << "748345987654321 x 288834570200345 = " << m5 * m6
<< " expected: +00216148191705288491573574940745 cc: 0\n" << endl;
dout << "748345987654321 x 288834570200345 x 10 = " << m5 * m6 * 10.0
<< " expected: +02161481917052884915735749407450 cc: 0\n" << endl;
dout << "748345987654321 x 288834570200345 x 100 = " << m5 * m6 * 100.0
<< " expected: +21614819170528849157357494074500 cc: 0\n" << endl;
dout << "748345987654321 x 288834570200345 x 1000 = " << m5 * m6 * 1000.0
<< " expected: +00216148191705288491573574940745 cc: 16\n" << endl;
dout << "123456789 x 123456789 x 123456789 = " << m3 * m3 * m3
<< " expected: +00000001881676371789154860897069 cc: 0\n" << endl;
dout << "123456789 x 123456789 x 123456789 x 123456789 = " << m3 * m3 * m3 * m3
<< " expected: +00000001881676371789154860897069 cc: 16\n" << endl;
dout << " 2 x 2 = " << m2*m2
<< " expected: +00000000000000000000000000000004 cc: 0\n" << endl;
dout << " 2 x 12 = " << m2*m1
<< " expected: +00000000000000000000000000000024 cc: 0\n" << endl;
dout << " 2 x 123456789 = " << m2 * m3
<< " expected: +00000000000000000000000246913578 cc: 0\n" << endl;
dout << " 123456789 x 2 = " << m3 * m2
<< " expected: +00000000000000000000000246913578 cc: 0\n" << endl;
dout << " 4096 x 2 = " << m4 * m2
<< "expected: +00000000000000000000000000008192 cc: 0\n" << endl;
dout << " 2 x 4096 = " << m2 * m4
<< "expected: +00000000000000000000000000008192 cc: 0\n" << endl;
dout << " 2 x 12 x 4096 = " << m2 * m1 * m4
<< "expected: +00000000000000000000000000098304 cc: 0\n" << endl;
dout << " aa = " << aa
<< " bb = " << bb
<< " aa-bb = " << aa-bb
<< "expected:+99999999999999999999999999999998 cc: 0\n"
<< " aa+bb = " << aa+bb
<< "expected:+00000000000000000000000000000000 cc: 1\n" << endl;
dout << " e = " << e
<< " f = " << f
<< " e + f = " << e+f
<< "expected:+00000000000000000000000000000000 cc: 0\n"
<< " e - f = " << e-f
<< "expected:+00000000000000000000000000000000 cc: 0\n" << endl;
dout << " g = " << g
<< " h = " << h
<< " g + h = " << g+h
<< "expected:+00000000000000000000000000000000 cc: 0\n"
<< " g - h = " << g-h
<< "expected:+00000000000000000000000000000000 cc: 0\n" << endl;
dout << " w = " << w
<< " x = " << x
<< " w + x = " << w+x
<< "expected:+00000000000000000000000000000000 cc: 0\n"
<< " w - x = " << w-x
<< "expected:+00000000000000000000000000000002 cc: 0\n" << endl;
dout << " y = " << y
<< " z = " << z
<< " y + z = " << y+z
<< "expected:+00000000000000000000000000000298 cc: 0\n"
<< " y - z = " << y-z
<< "expected:-00000000000000000000000000000302 cc: 0\n" << endl;
dout << "numa = " << numa
<< "numb = " << numb
<< "numa+numb = " << numd
<< "expected: +00000000000000001234567890991975 cc: 0\n"
<< "numb+numa = " << numb+numa
<< "expected: +00000000000000001234567890991975 cc: 0\n" << endl;
dout << "numa = " << numa
<< "numc = " << numc
<< "numa+numc = " << numa+numc
<< "expected: +00000000000000001234567866306297 cc: 0\n"
<< "numc+numa = " << numc+numa
<< "expected: +00000000000000001234567866306297 cc: 0\n" << endl;
dout << "numb = " << numb
<< "numc = " << numc
<< "numb+numc = " << numb+numc
<< "expected: -00000000000000000000000024677036 cc: 0\n"
<< "numc+numb = " << numc+numb
<< "expected: -00000000000000000000000024677036 cc: 0\n" << endl;
dout << "numa = " << numa
<< "numb = " << numb
<< "numa-numb = " << numa-numb
<< "expected: +00000000000000001234567890983333 cc: 0\n"
<< "numb-numa = " << numb-numa
<< "expected: -00000000000000001234567890983333 cc: 0\n" << endl;
dout << "numa = " << numa
<< "numc = " << numc
<< "numa-numc = " << numa-numc
<< "expected: +00000000000000001234567915669011 cc: 0\n"
<< "numc-numa = " << numc-numa
<< "expected: -00000000000000001234567915669011 cc: 0\n" << endl;
dout << "numb = " << numb
<< "numc = " << numc
<< "numb-numc = " << numb-numc
<< "expected: +00000000000000000000000024685678 cc: 0\n"
<< "numc-numb = " << numc-numb
<< "expected: -00000000000000000000000024685678 cc: 0\n" << endl;
dout.close();
delete st;
return 0;
}
void DS1302_CLK(UINT8 val)
{
if(val!=LastClk)
{
if(val) //Rising, shift in command
{
ICount++;
if(ICount==8) //Command start
{
mame_system_time systime;
mame_get_base_datetime(Machine, &systime);
switch(ShiftIn)
{
case 0x81: //Sec
ShiftOut=bcd(systime.local_time.second);
break;
case 0x83: //Min
ShiftOut=bcd(systime.local_time.minute);
break;
case 0x85: //Hour
ShiftOut=bcd(systime.local_time.hour);
break;
case 0x87: //Day
ShiftOut=bcd(systime.local_time.mday);
break;
case 0x89: //Month
ShiftOut=bcd(systime.local_time.month+1);
break;
case 0x8b: //weekday
ShiftOut=bcd(systime.local_time.weekday);
break;
case 0x8d: //Year
ShiftOut=bcd(systime.local_time.year%100);
break;
default:
ShiftOut=0x0;
}
if(ShiftIn>0xc0)
ShiftOut=SRAM[(ShiftIn>>1)&0x1f];
LastCmd=ShiftIn&0xff;
ICount++;
}
if(ICount==17 && !(LastCmd&1))
{
UINT8 val=(ShiftIn>>9)&0xff;
switch(LastCmd)
{
case 0x80: //Sec
break;
case 0x82: //Min
break;
case 0x84: //Hour
break;
case 0x86: //Day
break;
case 0x88: //Month
break;
case 0x8a: //weekday
break;
case 0x8c: //Year
break;
default:
ShiftOut=0x0;
}
if(LastCmd>0xc0)
{
SRAM[(LastCmd>>1)&0x1f]=val;
}
}
int
find_schedule(schedule_t *db, schedule_data_t *data)
{
int i, l;
u8 *m, dow, year, month, day, hour, minute;
schedule_grp_t *grp;
schedule_rec_t *rec = NULL;
l = strlen(data->grp);
l = (l > MAX_MSG_LEN ? MAX_MSG_LEN : l);
m = (u8 *)malloc(l+1);
for(i = 0; i < l; i++)
m[i] = rdmi(data->grp[i]);
m[i] = DM_SENTINEL;
for(i = 0, grp = db->head; grp && memcmp(grp->hdr.msg, m, l+1);
i += grp->hdr.num_recs, grp = grp->next);
free(m);
if(!grp)
return -1;
l = strlen(data->msg);
l = (l > MAX_MSG_LEN ? MAX_MSG_LEN : l);
m = (u8 *)malloc(l+1);
for(i = 0; i < l; i++)
m[i] = rdmi(data->msg[i]);
m[i] = DM_SENTINEL;
switch(grp_type){
case date:
year = bcd(data->year % 100);
month = bcd(data->month);
day = bcd(data->day);
for(i = 0, rec = grp->head; rec; i++, rec = rec->next){
if(rec->year == year && rec->month == month &&
rec->day == day &&
!memcmp(rec->msg, m, l+1))
break;
}
break;
case dow_time:
dow = data->dow;
hour = bcd(data->hour);
minute = bcd(data->minute);
for(i = 0, rec = grp->head; rec; i++, rec = rec->next){
if(rec->dow == dow && rec->hour == hour &&
rec->minute == minute &&
!memcmp(rec->msg, m, l+1))
break;
}
break;
case date_time:
year = bcd(data->year % 100);
month = bcd(data->month);
day = bcd(data->day);
hour = bcd(data->hour);
minute = bcd(data->minute);
for(i = 0, rec = grp->head; rec; i++, rec = rec->next){
if(rec->year == year && rec->month == month &&
rec->day == day && rec->hour == hour &&
rec->minute == minute &&
!memcmp(rec->msg, m, l+1))
break;
}
break;
}
free(m);
return (rec ? i : -1);
}
void ChartWidget::on_tbHelp_clicked()
{
ByteColorsDialog bcd(this);
bcd.exec();
}
void v3021Write(UINT16 data)
{
#if defined FBA_DEBUG
if (!DebugDev_V3021Initted) bprintf(PRINT_ERROR, _T("v3021Write called without init\n"));
#endif
time_t nLocalTime = time(NULL);
tm* tmLocalTime = localtime(&nLocalTime);
CalCom <<= 1;
CalCom |= data & 1;
++CalCnt;
if(CalCnt==4)
{
CalMask = 1;
CalVal = 1;
CalCnt = 0;
switch(CalCom & 0xf)
{
case 0x1: case 0x3: case 0x5: case 0x7: case 0x9: case 0xb: case 0xd:
CalVal++;
break;
case 0x0: // Day
CalVal=bcd(tmLocalTime->tm_wday);
break;
case 0x2: // Hours
CalVal=bcd(tmLocalTime->tm_hour);
break;
case 0x4: // Seconds
CalVal=bcd(tmLocalTime->tm_sec);
break;
case 0x6: // Month
CalVal=bcd(tmLocalTime->tm_mon + 1); // not bcd in MVS
break;
case 0x8: // Milliseconds?
CalVal=0;
break;
case 0xa: // Day
CalVal=bcd(tmLocalTime->tm_mday);
break;
case 0xc: // Minute
CalVal=bcd(tmLocalTime->tm_min);
break;
case 0xe: // Year
CalVal=bcd(tmLocalTime->tm_year % 100);
break;
case 0xf: // Load Date
tmLocalTime = localtime(&nLocalTime);
break;
}
}
}
void
add_schedule(schedule_t *db, schedule_data_t *data)
{
int i, c, l, alloc_size;
u8 *m, buf1[6], buf2[6];
schedule_grp_t *grp, *g;
schedule_rec_t *rec, *r;
l = strlen(data->grp);
l = (l > MAX_MSG_LEN ? MAX_MSG_LEN : l);
m = (u8 *)malloc(l+1);
for(i = 0; i < l; i++)
m[i] = rdmi(data->grp[i]);
m[i] = DM_SENTINEL;
for(grp = db->head; grp && memcmp(grp->hdr.msg, m, l+1);
grp = grp->next);
if(grp)
free(m);
else{
grp = (schedule_grp_t *)malloc(sizeof(schedule_grp_t));
grp->head = grp->tail = NULL;
grp->prev = grp->next = NULL;
grp->hdr.db_size = 8 + l + 1;
grp->hdr.hdr_size = 3 + l + 1;
grp->hdr.num_recs = 0;
grp->hdr.msg_len = l + 1;
grp->hdr.msg = m;
grp->hdr.alloc_size = ((grp->hdr.db_size-1) / PAGE_SIZE + 1) *
PAGE_SIZE;
/* sort */
for(g = db->head; g; g = g->next){
/* DM_SENTINEL is ignored when comparing strings */
l = (grp->hdr.msg_len < g->hdr.msg_len ?
grp->hdr.msg_len : g->hdr.msg_len) - 1;
c = memcmp(grp->hdr.msg, g->hdr.msg, l);
if((!c && grp->hdr.msg_len < g->hdr.msg_len) || c < 0)
break;
}
if(g){
grp->prev = g->prev;
if(grp->prev)
grp->prev->next = grp;
else
db->head = grp;
grp->next = g;
grp->next->prev = grp;
}else{
grp->prev = db->tail;
if(grp->prev)
grp->prev->next = grp;
else
db->head = grp;
grp->next = NULL;
db->tail = grp;
}
db->hdr.num_grps++;
db->hdr.db_size += 2 + grp->hdr.alloc_size;
}
/* 2: record offset, 7: record header */
grp->hdr.db_size += 2 + 7;
rec = (schedule_rec_t *)malloc(sizeof(schedule_rec_t));
l = strlen(data->msg);
l = (l > MAX_MSG_LEN ? MAX_MSG_LEN : l);
rec->msg_len = l + 1;
rec->msg = (u8 *)malloc(rec->msg_len);
for(i = 0; i < l; i++)
rec->msg[i] = rdmi(data->msg[i]);
rec->msg[i] = DM_SENTINEL;
switch(grp_type){
case date:
rec->dow = rec->hour = rec->minute = 0;
rec->year = bcd(data->year % 100);
rec->month = bcd(data->month);
rec->day = bcd(data->day);
break;
case dow_time:
rec->year = rec->month = rec->day = 0;
rec->dow = data->dow;
rec->hour = bcd(data->hour);
rec->minute = bcd(data->minute);
break;
case date_time:
rec->dow = 0;
rec->year = bcd(data->year % 100);
rec->month = bcd(data->month);
rec->day = bcd(data->day);
rec->hour = bcd(data->hour);
rec->minute = bcd(data->minute);
break;
}
grp->hdr.db_size += rec->msg_len;
/* sort */
buf1[0] = rec->year;
buf1[1] = rec->month;
buf1[2] = rec->day;
buf1[3] = rec->dow;
buf1[4] = rec->hour;
buf1[5] = rec->minute;
/* TODO: order by time? */
for(r = grp->head; r; r = r->next){
buf2[0] = r->year;
buf2[1] = r->month;
buf2[2] = r->day;
buf2[3] = r->dow;
buf2[4] = r->hour;
buf2[5] = r->minute;
c = memcmp(buf1, buf2, 6);
if(c < 0)
break;
if(c > 0)
continue;
/* DM_SENTINEL is ignored when comparing strings */
l = (rec->msg_len < r->msg_len ? rec->msg_len : r->msg_len) - 1;
c = memcmp(rec->msg, r->msg, l);
if((!c && rec->msg_len < r->msg_len) || c < 0)
break;
}
if(r){
rec->prev = r->prev;
if(rec->prev)
rec->prev->next = rec;
else
grp->head = rec;
rec->next = r;
rec->next->prev = rec;
}else{
rec->prev = grp->tail;
if(rec->prev)
rec->prev->next = rec;
else
grp->head = rec;
rec->next = NULL;
grp->tail = rec;
}
grp->hdr.num_recs++;
alloc_size = grp->hdr.alloc_size;
grp->hdr.alloc_size = ((grp->hdr.db_size-1) / PAGE_SIZE + 1)*PAGE_SIZE;
db->hdr.db_size += grp->hdr.alloc_size - alloc_size;
db->hdr.alloc_size = ((db->hdr.db_size-1) / PAGE_SIZE + 1) * PAGE_SIZE;
return;
}
