Disabled external gits

cs473-es/lab3/sw/nios/.project

@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>lab3_lcd</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>com.altera.sbtgui.project.makefileBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>com.altera.sbtgui.project.makefileBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.cdt.managedbuilder.core.genmakebuilder</name>
+			<triggers>clean,full,incremental,</triggers>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.cdt.managedbuilder.core.ScannerConfigBuilder</name>
+			<triggers>full,incremental,</triggers>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.cdt.core.cnature</nature>
+		<nature>org.eclipse.cdt.managedbuilder.core.managedBuildNature</nature>
+		<nature>org.eclipse.cdt.managedbuilder.core.ScannerConfigNature</nature>
+		<nature>org.eclipse.cdt.core.ccnature</nature>
+		<nature>com.altera.sbtgui.project.SBTGUINature</nature>
+		<nature>com.altera.sbtgui.project.SBTGUIAppNature</nature>
+		<nature>com.altera.sbtgui.project.SBTGUIManagedNature</nature>
+	</natures>
+</projectDescription>

cs473-es/lab3/sw/nios/application/image_test.c

@@ -0,0 +1,152 @@
+#ifdef ENABLE_IMAGE_TEST
+
+#include "stdint.h"
+#include "math.h"
+#include "stdio.h"
+
+#include "lt24.h"
+
+#include "system.h"
+#include "sys/alt_irq.h"
+
+
+#define W (320)
+#define H (240)
+
+
+typedef struct {
+     unsigned char red,green,blue;
+} PPMPixel;
+
+typedef struct {
+     int x, y;
+     PPMPixel *data;
+} PPMImage;
+
+#define RGB_COMPONENT_COLOR 255
+
+// Source: https://stackoverflow.com/questions/2693631/read-ppm-file-and-store-it-in-an-array-coded-with-c
+static PPMImage *readPPM(const char *filename)
+{
+         char buff[16];
+         PPMImage *img;
+         FILE *fp;
+         int c, rgb_comp_color;
+         //open PPM file for reading
+         fp = fopen(filename, "rb");
+         if (!fp) {
+              fprintf(stderr, "Unable to open file '%s'\n", filename);
+              return NULL;
+         }
+
+         //read image format
+         if (!fgets(buff, sizeof(buff), fp)) {
+              perror(filename);
+              return NULL;
+         }
+
+    //check the image format
+    if (buff[0] != 'P' || buff[1] != '6') {
+         fprintf(stderr, "Invalid image format (must be 'P6')\n");
+         return NULL;
+    }
+
+    //alloc memory form image
+    img = HPS_0_BRIDGES_BASE;//(PPMImage *)malloc(sizeof(PPMImage));
+    if (!img) {
+         fprintf(stderr, "Unable to allocate memory\n");
+         return NULL;
+    }
+
+    //check for comments
+    c = getc(fp);
+    while (c == '#') {
+    while (getc(fp) != '\n') ;
+         c = getc(fp);
+    }
+
+    ungetc(c, fp);
+    //read image size information
+    if (fscanf(fp, "%d %d", &img->x, &img->y) != 2) {
+         fprintf(stderr, "Invalid image size (error loading '%s')\n", filename);
+         return NULL;
+    }
+
+    //read rgb component
+    if (fscanf(fp, "%d", &rgb_comp_color) != 1) {
+         fprintf(stderr, "Invalid rgb component (error loading '%s')\n", filename);
+         return NULL;
+    }
+
+    //check rgb component depth
+    if (rgb_comp_color!= RGB_COMPONENT_COLOR) {
+         fprintf(stderr, "'%s' does not have 8-bits components\n", filename);
+         return NULL;
+    }
+
+    while (fgetc(fp) != '\n') ;
+    //memory allocation for pixel data
+    img->data = HPS_0_BRIDGES_BASE + sizeof(PPMImage);
+
+    if (!img) {
+         fprintf(stderr, "Unable to allocate memory\n");
+         return NULL;
+    }
+
+    //read pixel data from file
+    if (fread(img->data, 3 * img->x, img->y, fp) != img->y) {
+         fprintf(stderr, "Error loading image '%s'\n", filename);
+         return NULL;
+    }
+
+    fclose(fp);
+    return img;
+}
+
+
+void ppmToLCD(uint16_t* lcdbuf, PPMImage* ppm) {
+	pixel_t p;
+	for(int y = 0; y < ppm->y; y++) {
+		for(int x = 0; x < ppm->x; x++) {
+			const PPMPixel* ppmPixel = &ppm->data[y*W + x];
+			p.r = ppmPixel->red >> 3;
+			p.g = ppmPixel->green >> 2;
+			p.b = ppmPixel->blue >> 3;
+			IOWR_16DIRECT(lcdbuf,y*W + x, encPixel(&p));
+		}
+	}
+}
+
+int main()
+{
+	struct LT24 *lcd = LCDCONTROLLER_0_BASE;
+	uint16_t *buffer = HPS_0_BRIDGES_BASE;
+
+    LT24_initialize(lcd);
+    LT24_setWidth(lcd, W);
+    LT24_setHeight(lcd, H);
+
+    LT24_writeBase(lcd, (uint32_t)buffer);
+
+    // Read PPM from file
+    PPMImage* img = readPPM("/mnt/host/application/testimage.ppm");
+    if (img == NULL){
+    	return 1;
+    }
+
+    // Ensure equal to LCD display
+    if(img->x != W || img->y != H) {
+        fprintf(stderr, "Invalid image size (must be 320x240 but was %d x %d)\n", img->x, img->y);
+        return 1;
+    }
+
+    // Write (and translate) to LCD buffer
+    ppmToLCD(buffer, img);
+
+    LT24_refresh(lcd);
+
+    while (1){}
+
+    return 0;
+}
+#endif

cs473-es/lab3/sw/nios/application/lcdcam_system_test.c

@@ -0,0 +1,99 @@
+#ifdef ENABLE_LCDCAM_TEST
+
+#include "lt24.h"
+#include "stdint.h"
+#include "stddef.h"
+
+#include "system.h"
+
+#define WIDTH   320
+#define HEIGHT  240
+#define NPIXELS WIDTH*HEIGHT
+#define PIXELSIZE 2 // 16 bits
+#define BUFFER_SIZE NPIXELS / PIXELSIZE // in words
+#define BUFFER1 0x10000000
+#define BUFFER2 BUFFER1 + BUFFER_SIZE
+#define BUFFER3 BUFFER2 + BUFFER_SIZE
+#define N_BUFFERS 3
+
+struct BufferManager {
+    uint32_t* buffers[N_BUFFERS];
+
+    // Buffer assignment semantics:
+    //    if null
+    //        => device currently has no assigne buffer
+    //        => device is currently now showing/capturing
+    uint32_t* lcd_buffer;
+    uint32_t* cam_buffer;
+};
+
+struct BufferManager bman;
+struct LT24 *lcd = LCDCONTROLLER_0_BASE;
+// struct Camera cam = CAMERA_ADDRESS;
+
+void setupBuffers(struct BufferManager* bman, uint32_t* b1, uint32_t* b2, uint32_t* b3) {
+    bman->buffers[0] = b1;
+    bman->buffers[1] = b2;
+    bman->buffers[2] = b3;
+    bman->lcd_buffer = 0;
+    bman->cam_buffer = 0;
+}
+
+int main_changeme() {
+    setupBuffers(&bman, BUFFER1, BUFFER2, BUFFER3);
+
+    LT24_initialize(lcd);
+    // startCamera(&cam);
+    while(1) {
+    	// TODO: put to sleep...
+    }
+}
+
+void tryLCDShow() {
+    char gotBuffer = 0;
+    for (int i = 0; i < N_BUFFERS; i++) {
+        if (bman.buffers[i] != 0 && bman.buffers[i] != bman.cam_buffer) {
+            bman.lcd_buffer = bman.buffers[i];
+            gotBuffer = 1;
+            break;
+        }
+    }
+    if (gotBuffer) {
+        LT24_refresh(lcd);
+    } else {
+        bman.lcd_buffer = 0;
+    }
+}
+
+void tryCamCapture() {
+    char gotBuffer = 0;
+    for (int i = 0; i < N_BUFFERS; i++) {
+        if (bman.buffers[i] != bman.lcd_buffer && bman.buffers[i] != bman.cam_buffer) {
+            bman.cam_buffer = bman.buffers[i];
+            gotBuffer = 1;
+            break;
+        }
+    }
+    if (gotBuffer) {
+    	// captureImage(bman.lcd_buffer);
+    } else {
+        bman.cam_buffer = 0;
+    }
+}
+
+void IRQ_lcd() {
+    bman.lcd_buffer = 0;            // Yield buffer
+    tryLCDShow();                   // Locate any ready buffer
+    if (bman.cam_buffer == 0) {     // If camera currently inactive, re-try capture (we just yielded a buffer)
+        tryCamCapture();
+    }
+}
+
+void IRQ_camera() {
+    tryCamCapture();
+    if (bman.lcd_buffer == 0) {
+        tryLCDShow();
+    }
+}
+
+#endif

cs473-es/lab3/sw/nios/application/lcdtest.c

@@ -0,0 +1,67 @@
+#define LCD_TEST
+#ifdef LCD_TEST
+#include <stdint.h>
+#include <math.h>
+#include <stdio.h>
+
+#include "lt24.h"
+
+#include "system.h"
+#include "sys/alt_irq.h"
+
+#define MAX_RED (2 << 5)
+#define MAX_GREEN (2 << 6)
+#define MAX_BLUE (2 << 5)
+
+#define MAX_RED_V 0b11111
+#define MAX_GREEN_V 0b111111
+#define MAX_BLUE_V 0b11111
+
+// Compute an image that is h + MAX_GREEN in height
+void drawTestImage(uint16_t *buffer, const unsigned h, const unsigned w, const unsigned offset)
+{
+    pixel_t p0 = {0};
+    int idx = 0;
+    float rh = 1.*MAX_RED_V;
+    float rw = 1.*MAX_BLUE_V;
+    for (int y = 0; y < h; y++) {
+        for (int x = 0; x < w; x++) {
+            p0.r = (unsigned)(y*rh / h);
+            p0.b = (unsigned)(x*rw / w);
+
+            IOWR_16DIRECT(buffer, idx,  encPixel(&p0));
+            idx+=2;
+        }
+    }
+}
+
+#define W (320)
+#define H (240)
+uint16_t *buffer = HPS_0_BRIDGES_BASE;
+struct LT24 *lcd = LCDCONTROLLER_0_BASE;
+
+void lcd_ISR()
+{
+    LT24_clearIRQ(lcd, LT24_IRQ_CTRL_IRQ0_ACTIVE);
+    LT24_refresh(lcd);
+}
+
+int main()
+{
+    LT24_initialize(lcd);
+    LT24_writeIRQ(lcd, LT24_IRQ_CTRL_ENABLE);
+    LT24_setWidth(lcd, W);
+    LT24_setHeight(lcd, H);
+
+    LT24_writeBase(lcd, (uint32_t)buffer);
+    // Register LCD refresh finished interrupt
+    alt_ic_isr_register(LCDCONTROLLER_0_IRQ_INTERRUPT_CONTROLLER_ID,
+                        LCDCONTROLLER_0_IRQ, lcd_ISR, 0, 0);
+
+    drawTestImage(buffer,H,W,0);
+    // Initiate continuous refreshing through an initial call to the ISR
+    lcd_ISR();
+    while (1){}
+    return 0;
+}
+#endif

cs473-es/lab3/sw/nios/application/lt24.h

@@ -0,0 +1,248 @@
+#include "stdint.h"
+#include "stddef.h"
+#include "unistd.h"
+
+
+#include "io.h"
+
+// LT24 LCD Controller pixel format
+typedef struct Pixel
+{
+    unsigned r : 5;
+    unsigned g : 6;
+    unsigned b : 5;
+} pixel_t;
+
+static inline uint16_t encPixel(const struct Pixel *p)
+{
+    return (p->r << (5 + 6)) | (p->g << 5) | (p->b);
+}
+
+// LT24 LCD Controller hardware address register layout
+struct LT24
+{
+    uint32_t writeReg;
+    uint32_t writeData;
+    uint32_t writeBase;
+    uint32_t refresh;
+    uint32_t ctrlReg;
+    uint32_t setHeight;
+    uint32_t setWidth;
+    uint32_t writeIRQ;
+    uint32_t setIRQ;
+    uint32_t clearIRQ;
+    uint32_t isBusy;
+} __attribute__((__packed__));
+
+
+static inline void SleepMS(int someTime)
+{
+    usleep(1000*someTime);
+}
+
+#define LT24_WIDTH 320
+#define LT24_HEIGHT 240
+
+
+// LT24 Interrupt control register
+#define LT24_IRQ_CTRL_ENABLE_OFFSET 0
+#define LT24_IRQ_CTRL_ENABLE (1 << LT24_IRQ_CTRL_ENABLE_OFFSET)
+#define LT24_IRQ_CTRL_CLEAR_ON_REFRESH_OFFSET 1
+#define LT24_IRQ_CTRL_CLEAR_ON_REFRESH (1 << LT24_IRQ_CTRL_CLEAR_ON_REFRESH_OFFSET)
+#define LT24_IRQ_CTRL_IRQ0_ACTIVE_OFFSET 2
+#define LT24_IRQ_CTRL_IRQ0_ACTIVE (1 << LT24_IRQ_CTRL_IRQ0_ACTIVE_OFFSET)
+
+// LT24 Control register
+#define LT24_CTRL_LCD_ON_OFFSET 0
+#define LT24_CTRL_LCD_ON (1 << LT24_CTRL_LCD_ON_OFFSET)
+#define LT24_CTRL_RST_OFFSET 1
+#define LT24_CTRL_RST (1 << LT24_CTRL_RST_OFFSET)
+
+// LT24 Read convenience functions
+#define LT24_DEFINE_32_RDFUNC(funcname, fieldName)                   \
+    static inline uint32_t LT24_##funcname(struct LT24 *lcd)    \
+    {                                                                \
+        return IORD_32DIRECT(lcd, offsetof(struct LT24, fieldName)); \
+    }
+
+LT24_DEFINE_32_RDFUNC(isBusy, isBusy);
+
+// LT24 write convenience functions
+#define LT24_DEFINE_16_WRFUNC(funcname, fieldName)                		    \
+    static inline void LT24_##funcname(struct LT24 *lcd, uint16_t value)    \
+    {																		\
+        IOWR_32DIRECT(lcd, offsetof(struct LT24, fieldName), value);		\
+    }
+
+LT24_DEFINE_16_WRFUNC(writeReg, writeReg)
+LT24_DEFINE_16_WRFUNC(writeData, writeData)
+LT24_DEFINE_16_WRFUNC(writeBase, writeBase)
+LT24_DEFINE_16_WRFUNC(writeCtrlReg, ctrlReg)
+LT24_DEFINE_16_WRFUNC(setHeight, setHeight)
+LT24_DEFINE_16_WRFUNC(setWidth, setWidth)
+LT24_DEFINE_16_WRFUNC(writeIRQ, writeIRQ)
+LT24_DEFINE_16_WRFUNC(setIRQ, setIRQ)
+LT24_DEFINE_16_WRFUNC(clearIRQ, clearIRQ)
+
+static inline void LT24_setCursor(struct LT24 *lcd, alt_u16 x, alt_u16 y)
+{
+	 LT24_writeReg(lcd, 0x002A);
+		 LT24_writeData(lcd, x>>8);
+		 LT24_writeData(lcd, x&0XFF);
+	 LT24_writeReg(lcd, 0x002B);
+		 LT24_writeData(lcd, y>>8);
+		 LT24_writeData(lcd, y&0XFF);
+}
+
+static inline void LT24_refresh(struct LT24 *lcd)
+{
+    LT24_setCursor(lcd, 0, 0); // Initialize draw position to (0,0)
+    LT24_writeReg(lcd, 0x2C); //Memory Write
+    IOWR_32DIRECT(lcd, offsetof(struct LT24, refresh), 0);
+}
+
+static inline void LT24_manualRefresh(struct LT24 *lcd, uint16_t* buffer, unsigned width, unsigned height)
+{
+    LT24_setCursor(lcd, 0, 0); // Initialize draw position to (0,0)
+    LT24_writeReg(lcd, 0x2C); //Memory Write
+    for(int i = 0; i < width*height; i++) {
+        LT24_writeData(lcd, *(buffer + i));
+    }
+}
+
+static inline void LT24_reset(struct LT24 *lcd) {
+
+    LT24_writeCtrlReg(lcd, LT24_CTRL_LCD_ON);
+    SleepMS(500);
+    LT24_writeCtrlReg(lcd, LT24_CTRL_LCD_ON | LT24_CTRL_RST);
+    SleepMS(10);
+    LT24_writeCtrlReg(lcd, LT24_CTRL_LCD_ON);
+    SleepMS(120);
+    LT24_writeReg(lcd, 0x11); //Sleep Out
+    SleepMS(10); // Docs: It will be necessary to wait 5msec before sending next to command, this is to allow time for the supply voltages and clock circuits to stabilize
+}
+
+static inline void LT24_initialize(struct LT24 *lcd)
+{
+	LT24_reset(lcd);
+
+    LT24_writeReg(lcd, 0xCF);  //Power Control B
+    LT24_writeData(lcd, 0x00); //Always0x00
+    LT24_writeData(lcd, 0x81);
+    LT24_writeData(lcd, 0xC0);
+
+    LT24_writeReg(lcd, 0xED);  //Power on sequence control
+    LT24_writeData(lcd, 0x64); //Soft Start Keep1 frame
+    LT24_writeData(lcd, 0x03);
+    LT24_writeData(lcd, 0X12);
+    LT24_writeData(lcd, 0X81);
+
+    LT24_writeReg(lcd, 0xE8); //Driver timing control A
+    LT24_writeData(lcd, 0x85);
+    LT24_writeData(lcd, 0x01);
+    LT24_writeData(lcd, 0x0798); // 0x00798 ???
+
+    LT24_writeReg(lcd, 0xCB); // Power control A
+    LT24_writeData(lcd, 0x39);
+    LT24_writeData(lcd, 0x2C);
+    LT24_writeData(lcd, 0x00);
+    LT24_writeData(lcd, 0x34);
+    LT24_writeData(lcd, 0x02);
+
+    LT24_writeReg(lcd, 0xF7); // Pumpratio control
+    LT24_writeData(lcd, 0x20);
+
+    LT24_writeReg(lcd, 0xEA); // Driver timing control B
+    LT24_writeData(lcd, 0x00);
+    LT24_writeData(lcd, 0x00);
+
+    LT24_writeReg(lcd, 0xB1); // Frame Control (In Normal Mode)
+    LT24_writeData(lcd, 0x00);
+    LT24_writeData(lcd, 0x1b);
+
+    LT24_writeReg(lcd, 0xB6); // Display FunctionControl 
+    LT24_writeData(lcd, 0x0A);
+    LT24_writeData(lcd, 0xA2);
+
+    LT24_writeReg(lcd, 0xC0);    //Power control 1
+    LT24_writeData(lcd, 0x05);   //VRH[5:0]
+
+    LT24_writeReg(lcd, 0xC1);    //Power control 2
+    LT24_writeData(lcd, 0x11);   //SAP[2:0];BT[3:0]
+    
+    LT24_writeReg(lcd, 0xC5);    //VCM control 1
+    LT24_writeData(lcd, 0x45);       //3F
+    LT24_writeData(lcd, 0x45);       //3C
+
+    LT24_writeReg(lcd, 0xC7); //VCM control 2
+    LT24_writeData(lcd, 0xA2);
+
+    LT24_writeReg(lcd, 0x36); //Memory Access Control
+    LT24_writeData(lcd, 0x68);
+
+    LT24_writeReg(lcd, 0x2A);  // Column Addr
+    LT24_writeData(lcd, 0x00);
+    LT24_writeData(lcd, 0x00);
+    LT24_writeData(lcd, 0x01);
+    LT24_writeData(lcd, 0x3F);
+
+    LT24_writeReg(lcd, 0x2B); // Page Addr
+    LT24_writeData(lcd, 0x00);
+    LT24_writeData(lcd, 0x00);
+    LT24_writeData(lcd, 0x00);
+    LT24_writeData(lcd, 0xF0);
+
+    LT24_writeReg(lcd, 0xF2); //Disable 3Gamma
+    LT24_writeData(lcd, 0x00);
+
+    LT24_writeReg(lcd, 0x26); //Gamma Curve Selected
+    LT24_writeData(lcd, 0x01);
+
+    LT24_writeReg(lcd, 0xE0); //Positive Gamma Correction, Set Gamma
+    LT24_writeData(lcd, 0x0F);
+    LT24_writeData(lcd, 0x26);
+    LT24_writeData(lcd, 0x24);
+    LT24_writeData(lcd, 0x0B);
+    LT24_writeData(lcd, 0x0E);
+    LT24_writeData(lcd, 0x08);
+    LT24_writeData(lcd, 0x4B);
+    LT24_writeData(lcd, 0XA8);
+    LT24_writeData(lcd, 0x3B);
+    LT24_writeData(lcd, 0x0A);
+    LT24_writeData(lcd, 0x14);
+    LT24_writeData(lcd, 0x06);
+    LT24_writeData(lcd, 0x10);
+    LT24_writeData(lcd, 0x09);
+    LT24_writeData(lcd, 0x00);
+
+    LT24_writeReg(lcd, 0XE1); //NegativeGamma Correction, Set Gamma
+    LT24_writeData(lcd, 0x00);
+    LT24_writeData(lcd, 0x1C);
+    LT24_writeData(lcd, 0x20);
+    LT24_writeData(lcd, 0x04);
+    LT24_writeData(lcd, 0x10);
+    LT24_writeData(lcd, 0x08);
+    LT24_writeData(lcd, 0x34);
+    LT24_writeData(lcd, 0x47);
+    LT24_writeData(lcd, 0x44);
+    LT24_writeData(lcd, 0x05);
+    LT24_writeData(lcd, 0x0B);
+    LT24_writeData(lcd, 0x09);
+    LT24_writeData(lcd, 0x2F);
+    LT24_writeData(lcd, 0x36);
+    LT24_writeData(lcd, 0x0F);
+
+    LT24_writeReg(lcd, 0x3A); //COLMOD: Pixel Format Set
+    LT24_writeData(lcd, 0x55);
+
+    LT24_writeReg(lcd, 0xF6); //Interface Control
+    LT24_writeData(lcd, 0x01);
+    LT24_writeData(lcd, 0x30);
+    LT24_writeData(lcd, 0x00);
+
+    LT24_writeReg(lcd, 0x29); //Display on
+
+    LT24_setCursor(lcd, 0, 0); // Initialize draw position to (0,0)
+
+    LT24_writeReg(lcd, 0x2C); //Memory Write
+}

cs473-es/lab3/sw/nios/readme.txt

@@ -0,0 +1,26 @@
+Readme - Hello World Software Example
+
+DESCRIPTION:
+Simple program that prints "Hello from Nios II"
+
+The memory footprint of this hosted application is intended to be small (under 100 kbytes) by default
+using a standard reference deisgn.
+
+For an even smaller, reduced footprint version of this template, and an explanation of how
+to reduce the memory footprint for a given application, see the
+"small_hello_world" template.
+
+
+PERIPHERALS USED:
+This example exercises the following peripherals:
+- STDOUT device (UART or JTAG UART)
+
+SOFTWARE SOURCE FILES:
+This example includes the following software source files:
+- hello_world.c: Everyone needs a Hello World program, right?
+
+BOARD/HOST REQUIREMENTS:
+This example requires only a JTAG connection with a Nios Development board. If
+the host communication settings are changed from JTAG UART (default) to use a
+conventional UART, a serial cable between board DB-9 connector  and the host is
+required.

cs473-es/lab3/sw/nios/system/template.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<template_settings>
+	<template
+		default_build_configuration="Release">
+	</template>
+</template_settings>