Appendix
A: Permissions
The group approves this report for inclusion on the course website.
The group approves the video for inclusion on the course youtube channel.
B: Commented Code Listing
Downsampled Display
// ===== Draws a down-sampled "Pixel" ===================
void draw_ds_pixel(int x, int y, unsigned short color){
int idx;
// Fills in the "pixel"
tft_fillRect((short) xds_to_x(x), (short) yds_to_y(y),
(short) (XMAX+1)/X_ds, (short) (YMAX+1)/Y_ds, color);
// Do the DDS incr conversion
idx = xy2d(HILBERT_ORDER, NPixels, x, y);
DDS_incr[idx] = (color == 0) ? 0 : freq_to_DDS_incr(f_LUT[idx]);
}
// ===== Draws a rectangle in downsampled coordinates ===================
void fillRect_ds(int x, int y, int w, int h, unsigned short color){
// Fills in the "pixel"
tft_fillRect((short) xds_to_x(x), (short) yds_to_y(y),
(short) w*(XMAX+1)/X_ds, (short) h*(YMAX+1)/Y_ds, color);
// Update pixel info lookup tables
int i, j, idx;
for (i = x; i < x+w; i++){
for (j = y; j < y+h; j++){
idx = xy2d(HILBERT_ORDER, NPixels, i, j);
DDS_incr[idx] = (color == 0) ? 0 : freq_to_DDS_incr(f_LUT[idx]);
}
}
}
Hilbert Library
//Converts hilbert coordinate to Cartesian coordinates
void d2xy(int o, int n, int d, int* x, int* y) {
*x = *y = 0;
int rx, ry, s;
int t = d;
int temp;
for(s = 1; s < n; s = s*2){
rx = 1 & ( t / 2 );
ry = 1 & ( t ^ rx );
rot ( s, x, y, rx, ry );
*x = *x + s * rx;
*y = *y + s * ry;
t = t / 4;
}
// Swap x and y coordinates at certain orders to preserve start and end points
if (o % 2){
temp = *x;
*x = *y;
*y = temp;
}
return;
}
//Converts Cartesian coordinates to Hilbert coordinate
int xy2d(int o, int n, int x, int y){
int rx, ry, s, temp;
int d = 0;
// Flip first if necessary so it is oriented properly
if (o % 2){
temp = x;
x = y;
y = temp;
}
for (s = n/2; s > 0; s = s/2){
rx = ( x & s ) > 0;
ry = ( y & s ) > 0;
d = d + s * s * ( ( 3 * rx ) ^ ry );
rot ( s, &x, &y, rx, ry );
}
return d;
}
//Rotates the coordinates
void rot(int n, int *x, int *y, int rx, int ry){
int t;
if ( ry == 0 ){
//Reflect.
if ( rx == 1 ){
*x = n - 1 - *x;
*y = n - 1 - *y;
}
//Flip.
t = *x;
*x = *y;
*y = t;
}
return;
}
Direct Digital Synthesis
void __ISR(_TIMER_2_VECTOR, ipl2) Timer2Handler(void)
{
// you MUST clear the ISR flag
mT2ClearIntFlag();
int i;
DAC_data = 0;
// Use all the DDS units to index into wavetable and sum all frequency components
for(i = 0; i < NPixels; i++){
DDS_accum[i] += DDS_incr[i];
DAC_data += sin_table[DDS_accum[i]>>24];
}
// Normalize the DAC data to its range
DAC_data = DAC_data >> SHIFT_AMT;
// Just as additional protection, prevent from exceeding DAC range
if(DAC_data > 2047){
DAC_data = 2047;
}
if(DAC_data < -2047){
DAC_data = -2047;
}
// === DAC Channel A =============
// wait for possible port expander transactions to complete
// CS low to start transaction
mPORTBClearBits(BIT_4); // start transaction
// write to spi2
WriteSPI2( DAC_config_chan_A | ((DAC_data + 2048) & 0xfff));
while (SPI2STATbits.SPIBUSY) WAIT; // wait for end of transaction
// CS high
mPORTBSetBits(BIT_4) ; // end transaction
//
// Read Timer 2 to check ISR cycle count
t2 = ReadTimer2();
}
Continuous Drawing Thread
// === Continuous Drawing Thread =============================================
// Handles any demo routines that need to erase and redraw autonomously
static PT_THREAD (protothread_draw(struct pt *pt))
{
PT_BEGIN(pt);
// Hilbert variables
static int d;
int xds, yds;
// to store previous and current coordinates
static int xprev, yprev, x, y;
// Sweep variables
static int sweepdir;
// Captures interactive box parameters
static int w, h;
while(1){
PT_YIELD_UNTIL(pt, draw_signal > NONE);
// HORIZONTAL SWEEP DEMO
if (draw_signal == HILBERT){
// Traverse in hilbert index order
for(d = 0; d < NPixels; d++){
// go from hilbert index to cartesian
xds = 0;
yds = 0;
d2xy(HILBERT_ORDER, NPixels, d, &xds, &yds);
// Erase previous pixel if in blink mode
if(hil_blink){
draw_ds_pixel(xprev, yprev, ILI9340_BLACK);
}
// Fill in pixel at calculated index
draw_ds_pixel(xds, yds, ILI9340_WHITE);
xprev = xds;
yprev = yds;
PT_YIELD_TIME_msec(250);
} // for each pixel
draw_signal = 0;
}// IF HILBERT
// HORIZONTAL SWEEP DEMO
else if (draw_signal == HORIZ_SWEEP){
// Reset variables
xprev = yprev = x = y = 0;
sweepdir = 1;
while(draw_signal == HORIZ_SWEEP){
// clear previous pixel
draw_ds_pixel(xprev, yprev, ILI9340_BLACK);
// find and draw next pixel
x += sweepdir;
draw_ds_pixel(x, hsweep_y, ILI9340_WHITE);
xprev = x;
yprev = hsweep_y;
// switch directions at the end
sweepdir = (x == 0 || x == 7) ? -sweepdir : sweepdir;
PT_YIELD_TIME_msec(200);
}
}// HORIZ SWEEP
// VERICAL SWEEP
else if (draw_signal == VERT_SWEEP){
// Reset variables
xprev = yprev = x = y = 0;
sweepdir = 1;
// works exactly like horizontal sweep
while(draw_signal == VERT_SWEEP){
draw_ds_pixel(xprev, yprev, ILI9340_BLACK);
y += sweepdir;
draw_ds_pixel(vsweep_x, y, ILI9340_WHITE);
xprev = vsweep_x;
yprev = y;
sweepdir = (y == 0 || y == 7) ? -sweepdir : sweepdir;
PT_YIELD_TIME_msec(200);
}
}// VERT SWEEP
// INTERACTIVE MODE
else if (draw_signal == INTERACTIVE){
// Capture the box parameters
x = int_pos_x;
y = int_pos_y;
w = int_w;
h = int_h;
while(draw_signal == INTERACTIVE){
PT_YIELD_UNTIL(pt, shape_move > NONE || draw_signal != INTERACTIVE);
// Choose what edge to erase and draw opposite side
if(shape_move == UP){
fillRect_ds(x, y + h-1, w, 1, ILI9340_BLACK);
y -= 1;
fillRect_ds(x, y, w, 1, ILI9340_WHITE);
}
if(shape_move == DOWN){
fillRect_ds(x, y, w, 1, ILI9340_BLACK);
y += 1;
fillRect_ds(x, y + h-1, w, 1, ILI9340_WHITE);
}
if (shape_move == LEFT){
fillRect_ds(x + w-1, y, 1, h, ILI9340_BLACK);
x -= 1;
fillRect_ds(x, y, 1, h, ILI9340_WHITE);
}
if (shape_move == RIGHT){
fillRect_ds(x, y, 1, h, ILI9340_BLACK);
x += 1;
fillRect_ds(x + w-1, y, 1, h, ILI9340_WHITE);
}
shape_move = NONE;
}
} // INTERACTIVE
} // END WHILE(1)
PT_END(pt);
}
Main: Lookup Table Generation
// === build the sine lookup table =======
// scaled to produce values between 0 and 4096
int ii;
for (ii = 0; ii < sine_table_size; ii++){
sin_table[ii] = (int)(2047*sin((float)ii*6.283/(float)sine_table_size));
}
// === build the frequency lookup table =======
f_LUT[0] = base_freq;
// Calculate the ratio between adjacent frequencies, exponential like a piano
freq_step = pow((max_freq / base_freq), (float)1/(float)(NPixels - 1));
// Populate frequency lookup table
for (ii = 1; ii < NPixels; ii++){
f_LUT[ii] = (int)( (_Accum)(f_LUT[ii-1]) * freq_step );
}
C: References
3Blue1Brown - "Hilbert's Curve: Is
infinite math useful?"
vOICe on
sciencemag
Hilbert
Library from FSU
Python
implementation from 3Blue1Brown Reddit
