ASCS PART 1: A simple computing system

Hi!

Computers are one of the most important parts of our every day life.
Not only that we actively use them to do things like communicate, entertain,
educate or blog, as I am currently doing, they also control the transport of goods,
they help emergency teams to rescue people in danger and do a lot more.

But what would happen, if, someday in the future, our economy will break?
No more cheap parts from China, no more cheap microprocessors, no more cheap computers.
We would definitely have a really big problem.

But not only the possible breakdown of the economic system is a reason for me to do this project.
I also want to learn, how a processor REALLY works.
Yes, it uses logic gates, it uses a synchronous design and so on.
But how would I build a computer, if I were to do so my self?

This is, what this series of blogs will be about.
It is definitely planned as a long-time project,
so I will interrupt the series for updates on other projects.

So, what will this first blog be about?
Well, we need to define, what the computer will be able to do.
I will restrict this on only the instructions and the main build.

So, what will our system look like?
Mostly like this:

Simple and easy.

So, now we just need the mentioned 16 instructions mentioned in the ALU.
Guess what the next blog will be about.

A simple 3x5 binary font generator

Hi!

In my LED-matrix-project, I needed some kind of possibility to display text.
Since the flash memory of an AVR, especially from the ATTiny series, is somewhat limited,
I had to find a good way to store the characters without using up to much of the space.
After a small discussion on www.mikrocontroller.net, I had everything I needed to make it.
 Well, everything but the font.
As recommended, I'm using a 16-bit mono-color font, which means, I'm storing all the information needed in just two bytes. This makes it a bit hard to understand by just looking at the binary, so I wrote a small program
to generate the chars for me.

Using this and a routine from the forum-user "Peter Dannegger", I can now display the characters on the matrix. Here is the function, which is meant to be used together with the code I posted earlier:

void writeSign(uint8_t px, uint8_t py, uint16_t pattern, uint8_t color){
   for (int x = 0; x < 3; x++) {
      for (int y = 0; y < 5; y++) {
         if (pattern & 1) // LSB first
            ht1632_plot(px +x, py +y, color);
         else
            ht1632_plot(px +x, py +y, BLACK);  
         pattern >>= 1; // next bit
      }
   }
}


You can download the program to generate the 16-bit fonts here:
http://sourceforge.net/projects/binaryfontmaker/

Apexys

DE-DP14211 LED-matrix

Hi!
I've been looking quite a while for cheap LED matrices now and I finally found some.
SureElectronics has some really good ones, in all variants you could want.
Finally, I bought two DE-DP14211 matrices.
Featuring a 32x16 tricolor LED matrix, 4-bit PWM dimming and a SPI-like interface, they only cost about 25€ per item.

Well, I bought them without reading the datasheet, because what was named SPI-like was different enough from normal SPI, that you couldn't use the AVRs hardware SPI to control these devices.

After googling the misery, I found an Arduino library that could control the matrix.
Now, since I'm not using the Arduino bootloader, I had to change a few things.

First of all, you need to pick the functions, you need.
In my case, I only wanted the parts to be able to set or delete a pixel.
So what did I need?

First of all, go through the compiler definitions.
We won't use the DEBUGPRINT function, so don't copy it.
Here is what you need:


/*
* commands written to the chip consist of a 3 bit "ID", followed by
* either 9 bits of "Command code" or 7 bits of address + 4 bits of data.
*/
#define HT1632_ID_CMD 4 /* ID = 100 - Commands */
#define HT1632_ID_RD 6 /* ID = 110 - Read RAM */
#define HT1632_ID_WR 5 /* ID = 101 - Write RAM */


#define HT1632_CMD_SYSDIS 0x00 /* CMD= 0000-0000-x Turn off oscil */
#define HT1632_CMD_SYSON 0x01 /* CMD= 0000-0001-x Enable system oscil */
#define HT1632_CMD_LEDOFF 0x02 /* CMD= 0000-0010-x LED duty cycle gen off */
#define HT1632_CMD_LEDON 0x03 /* CMD= 0000-0011-x LEDs ON */
#define HT1632_CMD_BLOFF 0x08 /* CMD= 0000-1000-x Blink ON */
#define HT1632_CMD_BLON 0x09 /* CMD= 0000-1001-x Blink Off */
#define HT1632_CMD_SLVMD 0x10 /* CMD= 0001-0xxx-x Slave Mode */
#define HT1632_CMD_MSTMD 0x18 /* CMD= 0001-10xx-x Use on-chip clock */
#define HT1632_CMD_EXTCLK 0x1C /* CMD= 0001-11xx-x Use external clock */
#define HT1632_CMD_COMS00 0x20 /* CMD= 0010-ABxx-x commons options */
#define HT1632_CMD_COMS01 0x24 /* CMD= 0010-ABxx-x commons options */
#define HT1632_CMD_COMS10 0x28 /* CMD= 0010-ABxx-x commons options */
#define HT1632_CMD_COMS11 0x2C /* CMD= 0010-ABxx-x commons options */
#define HT1632_CMD_PWM 0xA0 /* CMD= 101x-PPPP-x PWM duty cycle */


// Dual 3216 LED Matrix
// If you have only one set these to:
// X_MAX=31
// Y_MAX=15
// CHIP_MAX=4
#define X_MAX 63 // 0 based X
#define Y_MAX 15 // 0 based Y
#define CHIP_MAX 4*2 // Number of HT1632C Chips
// 4 each board * 2 boards

// possible values for a pixel;
#define BLACK 0
#define GREEN 1
#define RED 2
#define ORANGE 3 


#define calcBit(y) (8>>(y&3)) 






 Next is the variable definition:
  /*
* Set these constants to the values of the pins connected to the SureElectronics Module
*/
static const byte ht1632_data = 53; // Data pin (pin 7)
static const byte ht1632_clk = 52; // Data pin (pin 2)
static const byte ht1632_wrclk = 51; // Write clock pin (pin 5)
static const byte ht1632_cs = 50; // Chip Select (pin 1)
// The should be a common GND.
// The module with all LEDs like draws about 200mA,
// which makes it PROBABLY powerable via Arduino +5V
//(Apexys comment: The module will draw up to 1.5 Amps with all LEDs on,
// so forget about powering it with an Arduino and get it a good 
// switching PSU!) 

/*
* we keep a copy of the display controller contents so that we can
* know which bits are on without having to (slowly) read the device.
* Note that we only use the low four bits of the shadow ram, since
* we're shadowing 4-bit memory. This makes things faster, but we
* COULD do something with the other half of our bytes !
*/
byte ht1632_shadowram[63][CHIP_MAX] = {0};

Followed by the functions

 void OutputCLK_Pulse(void) //Output a clock pulse
void ht1632_chipselect(int select) //Select a chip
void ht1632_writebits (byte bits, byte firstbit) //Write bits on SPI
static void ht1632_sendcmd (byte chipNo, byte command) Send Command
static void ht1632_senddata (byte chipNo, byte address, byte data) //Data
void ht1632_clear() //Clear Display 
byte xyToIndex(byte x, byte y) //Get RAM position for a pixel
 int get_pixel(byte x, byte y) //Get a pixel's color at a position 
 void ht1632_plot (byte x, byte y, byte color) //Set a pixel
static void ht1632_initialize() //Init the display 


Now, simply replace byte with uint8_t.
Two last things are to do: You need to define four pins of any port as output and you need  a function to replace the digitalWrite function of the Arduino library. Here it is:

//Replace the Arduinos digitalWrite() function
void digitalWrite(uint8_t port, uint8_t value){
switch(port){
case 0:{
if(value){
PORTC |= (1<<PC0);
}
else{
PORTC &= ~(1<<PC0);
}
}
break;
case 1:{
if(value){
PORTC |= (1<<PC1);
}
else{
PORTC &= ~(1<<PC1);
}
}
break;
case 2:{
if(value){
PORTC |= (1<<PC2);
}
else{
PORTC &= ~(1<<PC2);
}
}
break;
case 3:{
if(value){
PORTC |= (1<<PC3);
}
else{
PORTC &= ~(1<<PC3);
}
}
break;
}
}

Now simply change the static const byte for the port values to something like

#define ht1632_cs 0
#define ht1632_clk 1
#define ht1632_wrclk 2
#define ht1632_data 3

And add a statement like

#define LOW 0
#define HIGH 1 

And your done!

Now you can set a pixel with ht1632_plot(x,y,color) and you can clear the matrix by calling
ht1632_clear().

Now, back to development!

Apexys 

The iron sulfide thermite

Hi!
This is the second one of my promised series of blog post!
It's about a little experiment I did some weeks ago.
I wanted to cover iron stick with liquid iron sulfide,
so I could bring a nice layer of sulfur on some copper in an electrolysis.
To have some fun, I added the thermite process to the sulfurisation.
Here is how it looked like:


Well, quite impressive.
I didn't use the iron sulfide, but gave it to my friend C3H5N3O9 so he could make his copper-sulfur-plate.
I hope you liked this non-electronics-related experiment.

Apexys

The 555 inductance meter enhanced edition

I know it's been a long time since my last blog post, but I had to decrease the level of entropy on my lab desk.
Anyway, I managed to get some projects done, so I can blog them in the next weeks!
Here is the first one: An improved version of my 555 inductance meter!
At virtually no cost (at least if you have some basic parts on stock), you can improve the performance under different serial resistances of the measured inductors.
You just have to add a second NE555 and a few resistors.
The mayor problem of the old version is the rather big output change when the serial resistance changes.
If you have a too big serial resistance, the amplitude of the LC-oscillators flattens out and you aren't measuring the frequency any more. You'll get readings like this:

I simulated these waveforms by stepping the serial resistance from 0.1 ohm (green line on the bottom) to 10 ohm (pink line on the top). The steps are 1 ohm each.

If you now amplify the sine wave to a rail-to-rail rectangle by using a comparator or a schmitt-trigger, you can use this signal as a basis for the low-passed output.
Here is the new schematic:

The output of this version looks like this:

In reality, my inductors had serial resistance from 0.01 to about 3 ohm.
The new version is really better at differing between resistance and inductance,
so at a cost of about 2€ for the basic design and additional 1€ for the improvement,
it might be the cheapest inductance meter out there!
Build yourself one I you don't have one, you won't regret it!

Apexys

Two important C# code snippets

Hi everyone!
And this time especially the AX-team of our little contest!

Here are the two last APXD-snippets in C# :

Converting from a String like '10001000' to an int (this would be 136):

int getint(String bin) {
  int result = 0;
  for(int i = 0; i< 8; i++){
   if(bin[i] == '1'){
    result +=(int) Math.Pow (2,7-i);
   }
  }
  return result;
}


Converting from an int like 136 to the binary-String:

String getbin(int input) {
   String result = "";
   int ax;
   for (int i = 0; i < 8; i++) {
    ax = (int)Math.Pow(2, 7 - i);
    if (input >= ax) {
     result += "1";
     input -=ax;
    }
    else {
     result += "0";
    } 
   }
  return result;
}


That's all for the moment!
Have a good weekend!

apexys

Overdrive and distortion

Hi!

Whilst doing audio stuff, at some point I got to the point, where I wanted to modify the sound of my instrument.
There are two mayor types of distorting an instrument: overdrive and distortion.

Overdrive is the older sound.
Back when there were people building amplifiers out of glass valves and operating with high voltages,
the amplifiers couldn't handle all the voltages over the input range.
This meant, starting at a certain point, the signal would start to clip.
Add some harmonic signals and some white noise,
which both are characteristic for tube amplifiers, and you get overdrive.
Personally, I don't really like overdrive.
It sounds too dirty and noisy,
but in some settings and genres like hard rock, it sounds really great.
The easiest way to get a mean overdrive this days is to use opamps.
Simply configure one as a non-inverting-amplifier with rather high amplification factor and use high input voltages.
For best retro-sound, use a JFET one (as the TL072). But even the LM324 will work.
Here is a schematic for an overdrive with an opamp per channel:

And this is, how the signal looks like:

Now to the other possibility of generating a sound effect by simply clipping it: distortion.
Distortion means that you generate the clipping effect in a much more controllable way, means by diodes.
Diodes have a U/I curve with a kink at normally around 0.8V. This means, they start leading when signals higher than this kink are applied.
An easy way to use this kink for distortion is the following schematic:

And again an example of the waveform.

In this example, I wanted very strong distortion.
With the distortion-type distortion (not the overdrive one), there is an easier approach to this.
Just use the opamp as an schmitt-trigger:

Notice the small difference in the waveform, compared to the solution with the diode:

This was my small walkthrough through these kinds of distortion systems.
Thank you for reading and until next time!

apexys