static DUMP_INFO* dumpStruct( // DUMP A STRUCTURE
TYPE type, // - structure type
DUMP_INFO* di, // - dump information
char* title, // - title for dump
ds_control control ) // - control word
{
CLASSINFO* info; // - class information
NAME *parent; // - where parent ptr is stored
control = control;
type = StructType( type );
info = type->u.c.info;
parent = VstkPush( &di->stack );
*parent = info->name;
di = dumpTitle( di, title, NameStr( info->name ) );
if( type != di->original ) {
di = bufferInit( di );
di = bufferStr( di, "embedded size: " );
di = bufferNmb( di, info->vsize );
di = bufferWrite( di );
di = dumpOffset( di );
di = dumpParentage( di );
} else {
di = bufferInit( di );
di = bufferStr( di, "size: " );
di = bufferNmb( di, info->size );
di = bufferWrite( di );
}
if( info->has_vbptr ) {
di = dumpDataMemb( di
, "[virtual"
, "base pointer]"
, info->vb_offset + di->offset
, CgMemorySize( TypePtrToVoid() ) );
}
if( info->has_vfptr ) {
di = dumpDataMemb( di
, "[virtual"
, "functions pointer]"
, info->vf_offset + di->offset
, CgMemorySize( TypePtrToVoid() ) );
}
ScopeWalkDataMembers( type->u.c.scope, dumpMember, di );
if( type == di->original ) {
ScopeWalkVirtualBases( type->u.c.scope, dumpVirtual, di );
}
ScopeWalkDirectBases( type->u.c.scope, dumpDirect, di );
VstkPop( &di->stack );
return di;
}
void OWLENTRY OWLBufferWrite( owl_buffer *buffer, const char *src, owl_offset len ) {
//***********************************************************************************
if( buffer->location > buffer->size ) {
bufferPad( buffer, buffer->location );
}
bufferWrite( buffer, src, len );
}
/**
* Buffers output sent to a peer. May be called multiple times until the entire
* buffer is filled. Returns true when the buffer is empty.
*/
static bool peerProxyWriteFromBuffer(PeerProxy* peerProxy, Buffer* outgoing) {
ssize_t size = bufferWrite(outgoing, peerProxy->fd->fd);
if (size < 0) {
peerProxyHandleError(peerProxy, "write");
return false;
} else {
return bufferWriteComplete(outgoing);
}
}
static DUMP_INFO* dumpOffset( // DUMP OFFSET LINE
DUMP_INFO* di ) // - dump information
{
di = bufferInit( di );
di = bufferStr( di, "offset of class: " );
di = bufferNmb( di, di->offset );
di = bufferWrite( di );
return di;
}
void Framebuffer::drawVerticalLine(int16_t x, int16_t y, int16_t h, uint16_t color) {
int16_t w = 1;
if (!clipToScreen(x, y, w, h)) {
return;
}
for (int y1 = y; y1 < y + h; y1++) {
uint8_t pcol = color & 0xFF;
uint32_t pos = y1 * _width + x;
bufferWrite(pos, pcol);
}
}
void Framebuffer::drawHorizontalLine(int16_t x, int16_t y, int16_t w, uint16_t color) {
int16_t h = 1;
if (!clipToScreen(x, y, w, h)) {
return;
}
for (int x1 = x; x1 < x + w; x1++) {
uint8_t pcol = color & 0xFF;
uint32_t pos = y * _width + x1;
bufferWrite(pos, pcol);
}
}
static void bufferPad( owl_buffer *buffer, size_t to )
//****************************************************
{
size_t old_location;
if( to > buffer->size ) {
old_location = buffer->location;
buffer->location = buffer->size;
bufferWrite( buffer, NULL, to - buffer->size );
buffer->location = old_location;
}
}
static void bufferPad( owl_buffer *buffer, owl_offset to ) {
//**********************************************************
owl_offset old_location;
if( to > buffer->size ) {
old_location = buffer->location;
buffer->location = buffer->size;
bufferWrite( buffer, NULL, to - buffer->size );
buffer->location = old_location;
}
}
void generateData(Buffer* buffer) {
char i = 1;
printf("[%s] Starting to produce data.\n", getTime());
while(1) {
bufferWrite(buffer, i);
printf("[%s][%d/%d] Wrote '%d' to buffer.\n", getTime(), buffer->size, buffer->maxSize, i);
i++;
usleep(getRandom(SPEEDMIN, SPEEDMAX));
}
}
static DUMP_INFO* dumpTitle( // DUMP A TITLE LINE
DUMP_INFO *di, // - dump information
const char *title, // - title line
const char *class_name ) // - name of class
{
di = bufferRewind( di );
di = bufferChr( di, '\n' );
di = bufferStr( di, title );
di = bufferChr( di, ' ' );
di = bufferStr( di, class_name );
di = bufferWrite( di );
return di;
}
static DUMP_INFO* dumpParentage( // DUMP PARENTAGE
DUMP_INFO* di ) // - dump information
{
char**daughter; // - daughter class
for( daughter = VstkTop( &di->stack ); ; ) {
daughter = VstkNext( &di->stack, daughter );
if( daughter == NULL ) break;
di = bufferInit( di );
di = bufferStr( di, "base of: " );
di = bufferStr( di, *daughter );
di = bufferWrite( di );
}
return di;
}
void Framebuffer::setPixel(int16_t x, int16_t y, uint16_t color) {
translateCoordinates(&x, &y);
if (x < 0 || x >= _width || y < 0 || y >= _height) {
return;
}
uint8_t pcol = color & 0xFF;
uint32_t pos = y * _width + x;
bufferWrite(pos, pcol);
if (x < _minX) _minX = x;
if (x > _maxX) _maxX = x;
if (y < _minY) _minY = y;
if (y > _maxY) _maxY = y;
}
/**
* @function buffer.write64
*
* ### Synopsis
*
* buffer.write64(buf, base64String)
*
* Write a base64 encoded string to buffer, decoding the base64 to binary. This function writes binary data to the buffer.
*
* @param {object} buf - buffer to write to.
* @param {string} base64Str - base64 encoded binary data to add to buffer as binary.
*/
static JSVAL buffer_write64 (JSARGS args) {
HandleScope scope;
Local<External>wrap = Local<External>::Cast(args[0]);
Buffer *buf = (Buffer *) wrap->Value();
String::Utf8Value data(args[1]);
#ifdef BUFFER_STRING
buf->s += Base64Decode(*data);
#else
//char decodeBuf[len];
char* decodeBuf = new char[data.length()];
long decodeLen = decode_base64((unsigned char *) decodeBuf, *data);
bufferWrite(buf, decodeBuf, decodeLen);
delete decodeBuf;
#endif
return Undefined();
}
static DUMP_INFO* dumpDataMemb( // DUMP A DATA MEMBER
DUMP_INFO *di, // - dump information
const char *kind, // - kind of field
const char *name, // - field name
target_offset_t offset, // - field offset
target_size_t size ) // - field size
{
di = bufferInit( di );
di = bufferStr( di, kind );
di = bufferChr( di, ' ' );
di = bufferStr( di, name );
di = bufferStr( di, ", offset = " );
di = bufferNmb( di, offset );
di = bufferStr( di, ", size = " );
di = bufferNmb( di, size );
di = bufferWrite( di );
return di;
}
/**
* @function buffer.write
*
* ### Synopsis
* buffer.write(buf, str);
*
* Write a string into the specified buffer.
*
* @param {object} buf - buffer to write string to.
* @param {string{ str - string to add to buffer.
*/
static JSVAL buffer_write (JSARGS args) {
HandleScope scope;
Local<External>wrap = Local<External>::Cast(args[0]);
Buffer *buf = (Buffer *) wrap->Value();
String::Utf8Value data(args[1]);
bufferWrite(buf, *data, data.length());
//#ifdef BUFFER_STRING
// buf->s += *data;
//#else
// long len = args[2]->IntegerValue();
// if (buf->pos + len >= buf->size) {
// while (buf->pos + len >= buf->size) {
// buf->size *= 2;
// }
// buf->mem = (unsigned char *)realloc(buf->mem, buf->size);
// }
// memcpy(&buf->mem[buf->pos], *data, len);
// buf->pos += len;
// buf->mem[buf->pos] = '\0';
//#endif
return Undefined();
}
void Framebuffer::copyRect(int16_t dx, int16_t dy, int16_t sx, int16_t sy, uint16_t w, uint16_t h) {
uint32_t dpos;
uint32_t spos;
translateCoordinates(&dx, &dy);
for (int y = 0; y < w; y++) {
for (int x = 0; x < h; x++) {
if (sx > dx && sy > dy) {
dpos = (y + dy) * _width + (x + dx);
spos = (y + sy) * _width + (x + sx);
} else if(sx <= dx && sy > dy) {
dpos = (y + dy) * _width + ((w - x) + dx);
spos = (y + sy) * _width + ((w - x) + sx);
} else if(sx > dx && sy <= dy) {
dpos = ((h - y) + dy) * _width + (x + dx);
spos = ((h - y) + sy) * _width + (x + sx);
} else if(sx <= dx && sy <= dy) {
dpos = ((h - y) + dy) * _width + ((w - x) + dx);
spos = ((h - y) + sy) * _width + ((w - x) + sx);
}
bufferWrite(dpos, bufferRead(spos));
}
}
}
int main(void) {
initUSART();
_delay_ms(200);
uint8_t i;
uint8_t tempCharStorage;
while (1) {
dumpBuffer();
printString(" Demo: adding characters to buffer\n");
uint8_t coolString[] = "Howdy";
i = 0;
while(i < sizeof(coolString) - 1){
bufferWrite(coolString[i]);
++i;
dumpBuffer();
}
printString(" Demo: reading out the first three characters\n");
for (i = 0; i<3 ; i++){
bufferRead(&tempCharStorage);
transmitByte(tempCharStorage);
printString("\n");
dumpBuffer();
}
printString(" Demo: adding more characters to buffer\n");
uint8_t anotherString[] = "Hello";
i = 0;
while(i < sizeof(anotherString) - 1){
bufferWrite(anotherString[i]);
++i;
dumpBuffer();
}
// And read it back out using return code
printString(" Demo: reading everything back out\n");
while (bufferRead(&tempCharStorage) == BUFFER_OK){
transmitByte(tempCharStorage);
}
printString("\n");
dumpBuffer();
printString(" Demo: empty! (newest = oldest)\n");
// Fill up buffer, using return code
i = 0;
while(bufferWrite('A'+i) == BUFFER_OK){
++i;
dumpBuffer();
}
printString(" Note: never fills up whole buffer\n");
printString(" it's full when first index equals last\n");
return 0;
} /* End event loop */
return 0; /* This line is never reached */
}
int main(void) {
PORTE.DIRSET |= 0xFF;
PORTD.DIRSET = 0x00;
PORTD.PIN1CTRL = 0b00011010;
PORTC.DIRSET |= 0x01;
while(1)
{
/* Read the next incoming event. Usually this is a blocking function. */
// EVENTS event = readEventFromMessageQueue();
if((flag.HARDWARE_ERROR_FLAG == 1 || flag.OVERTEMP_FLAG == 1) && flag.DISCHARGED_FLAG == 0)
{
state = DISCHARGE;
}
/* Finite State Machine */
switch(state)
{
case INIT:
init_clock();
init();
interrupt_init();
UART_init();
AC_init();
init_DAC();
init_GPIO_interrupt();
// init_counter();
// Start by using capbank 1
flag.CAPBANK_FLAG = 0;
PORTE.OUT = 0x00;
//_delay_ms(4000);
// comparator reference voltages
// Desired voltage reference level expressed in Capacitor voltage
// TODO: high_trigger_cap is based on user_settings.voltage_amplitude which is in percent but should be converted to absolute.
double low_trigger_cap = 0.3;
// Voltage divided, digital version of capacitor voltage
uint16_t high_trigger_b;
uint16_t low_trigger_b;
// high_trigger_b = voltage_to_DAC(voltage_to_vdac(high_trigger_cap));
low_trigger_b = voltage_to_DAC(low_trigger_cap);
state = STANDBY;
break;
case STANDBY:
PORTE.OUT = 0x01;
if (flag.PRECHARGE_FLAG)
{
state = PRECHARGE;
// PORTE.OUT = 0x04;
// _delay_ms(3000);
break;
}
else if(flag.WRITE_FLAG)
{
state = WRITE;
//delay_ms(3000);
break;
}
else if(flag.READ_FLAG)
{
state = READ;
// PORTE.OUT = 0x05;
//_delay_ms(3000);
break;
}
else if(!(PORTD.IN & (1 << 1)))
{
PORTE.OUT = 0x06;
//_delay_ms(3000);
if(user_settings.mode == 0)
{
state = SINGLE_PULSE;
break;
}
else if(user_settings.mode == 1)
{
state = PAIRED_PULSE;
break;
}
}
else
{
state = STANDBY;
break;
}
break;
case PRECHARGE:
// Clear precharge flag
flag.PRECHARGE_FLAG = 0;
flag.DISCHARGED_FLAG = 0;
PORTE.OUT = 0x03;
//_delay_ms(3000);
// Set AC trigger high
// write_DAC(high_trigger_b);
write_DAC(voltage_to_DAC(voltage_to_vdac(user_settings.voltage_amplitude * V_MAX)));
// Go to pulse state, single or paired depending on user settings
if (user_settings.mode == 0) // single pulse mode
{
// Capbank 1
if (flag.CAPBANK_FLAG == 0)
{
// Close precharge switch Capbank 1
PRECHARGE1_ON;
PORTC.OUT |= (1 << 0);
// check if precharge reference triggered
if(ACA.STATUS & (1 << 4) )
{
// TODO: Open precharge switch
PRECHARGE1_OFF;
PORTC.OUT &= ~(1 << 0);
PORTE.OUT = 0x04;
//_delay_ms(3000);
// Send precharge ready ACK
USARTF0.DATA = 0x06;
state = STANDBY;
break;
}
}
// Capbank 2
else if (flag.CAPBANK_FLAG == 1)
{
// Close precharge switch Capbank 2
PRECHARGE2_ON;
//PORTC.OUT |= (1 << 0);
// check if precharge reference triggered
// if(ACA.STATUS & (1 << 5) )
if(ACA.STATUS & (1 << 4) )
{
// TODO: Open precharge switch
PRECHARGE2_OFF;
//PORTC.OUT &= ~(1 << 0);
PORTE.OUT = 0x04;
//_delay_ms(3000);
// Send precharge ready ACK
USARTF0.DATA = 0x06;
state = STANDBY;
}
}
}
else if (user_settings.mode == 1) // paired pulse mode
{
PRECHARGE1_ON;
//PORTC.OUT |= (1 << 0);
// check if precharge reference capbank 1 triggered
if (ACA.STATUS & (1 << 4) )
{
// Open precharge switch capbank 1
PRECHARGE1_OFF;
//PORTC.OUT &= ~(1 << 0);
PORTE.OUT = 0x04;
//_delay_ms(1500);
PRECHARGE2_ON;
//PORTC.OUT |= (1 << 0);
// check if precharge reference capbank 2 triggered
// if (ACA.STATUS & (1 << 5) )
if (ACA.STATUS & (1 << 4) )
{
// Open precharge switch capbank 2
PRECHARGE2_OFF;
//PORTC.OUT &= ~(1 << 0);
PORTE.OUT = 0x05;
//_delay_ms(1500);
// Send precharge ready ACK
USARTF0.DATA = 0x06;
state = STANDBY;
}
}
}
else
{
PORTE.OUT = 0x07;
//_delay_ms(1500);
// stay in precharge if trigger level not reached
state = PRECHARGE;
}
break;
case READ:
//_delay_ms(3000);
PORTE.OUT = 0x03;
// read stuff here
// TODO: read not possible yet
state = STANDBY;
break;
case WRITE:
PORTE.OUT = 0x02;
// write stuff here
bufferWrite(&UART_buffer_write, USARTF0.DATA);
// Get char from RX buffer
flag.WRITE_FLAG = 0;
//_delay_ms(1500);
state = STANDBY;
break;
case SINGLE_PULSE:
// set reference for AC with DAC
write_DAC(low_trigger_b);
// single pulse here
PORTE.OUT = 0x05;
//_delay_ms(3000);
if (flag.CAPBANK_FLAG == 0)
{
// Pulse using capbank 1
single_pulse(CAPBANK1);
// TODO: Wait for pulse to damp out
_delay_ms(1);
}
else
{
// Pulse using capbank 2
single_pulse(CAPBANK2);
// TODO: Wait for pulse to damp out
_delay_ms(1);
}
// Toggle capbank used
flag.CAPBANK_FLAG ^= (1 << 0);
break;
case PAIRED_PULSE:
// paired pulse here
PORTE.OUT = 0x05;
//_delay_ms(3000);
// set reference for AC with DAC
write_DAC(low_trigger_b);
state = STANDBY;
// Pulse using capbank 1
single_pulse(CAPBANK1);
// _delay_us(50);
delay_in_ms(user_settings.interstimulus_interval);
// Pulse using capbank 2
single_pulse(CAPBANK2);
_delay_us(50);
// TODO: Wait for pulse to damp out
//_delay_ms(1);
// When finished, go to precharge state again to wait for new pulse
state = STANDBY;
break;
case DISCHARGE:
PORTE.OUT = 0x08;
//_delay_ms(3000);
// set reference for AC with DAC
write_DAC(low_trigger_b);
DISCHARGE1_ON;
DISCHARGE2_ON;
// Discharge complete when both capbank voltages below AC reference
// if ( (ACA.STATUS & (1 << 4)) && (ACA.STATUS & (1 << 5)) )
if ( !(ACA.STATUS & (1 << 4)))
{
DISCHARGE1_OFF;
DISCHARGE2_OFF;
flag.DISCHARGED_FLAG = 1;
flag.HARDWARE_ERROR_FLAG = 0;
flag.OVERTEMP_FLAG = 0;
// _delay_ms(5000);
state = STANDBY;
}
else
{
// Keep discharging
state = DISCHARGE;
}
break;
}
}
}
