uiimage to nsdata to nsstring to nsdata to uiimage

Why would you want to make these conversions?

nsstring is a format that can be sent to any system.  In my case I want to send it to an SQLite database.  However, SQLite does not support images.  the closest thing to it is a blob type.  A blog type accepts a bunch of bytes.  While this is good, it might not always suit your purposes.

If you do not want to use a blob type, you can use the text type.  In the following blog post I will detail how to convert an uiimage to nsdata to nsstring.  Then how to turn that nsstring back to data then back to uiimage.


UIImage *originalImage = ...; //get image from somewhere.  a path or an iphoto library.

NSData *originalData = UIImagePNGRepresentation(originalImage);

NSString *originalString = [originalData base64EncodedStringWithOptions:NSDataBase64Encoding64CharacterLineLength];

//Now that you have the data in a string format you can pass it around.  In my case I stored it in my SQLite database.  Now if I want to retrieve it I need to convert it back.

NSData *decodedData = [[NSData alloc] initWithBase64EncodedString:originalString options:NSDataBase64DecodingIgnoreUnknownCharacters];

UIImage *decodedImage = [UIImage imageWithData:decodedData];

-------------------
There is only one decoder option: "NSDataBase64DecodingIgnoreUnknownCharacters"
But there are four encoder options.  In the example above I used "NSDataBase64Encoding64CharacterLineLength"

but there are 3 others.  What are the differences and why would you use them?

• NSDataBase64Encoding64CharacterLineLength
• Sets the maximum line length to 64 characters, after which a line ending is inserted.
• NSDataBase64Encoding76CharacterLineLength
• Sets the maximum line Length to 76 characters, after which a line ending is inserted.
• NSDataBase64EncodingEndLineWithCarriageReturn
• When a maximum line length is set, specify that the line ending to insert should include a carriage return
• NSDataBase64EncodingEndLineWithLineFeed
• When a maximum line length is set, specify that the line ending to insert should include a line feed.

Xvolve programming assignment

You are given two lines.
the first line tells you how many numbers (N) are in the array, the second tells you the difference(K) that you must find.
The second line give you a string of numbers.
Your goal is to count the number of numbers that have a difference (K).

input
5 2
1 5 3 4 2

output
3

in the above input N is 5 and K is 2.  I must find all numbers that have a difference of 2.
There are two ways to do this.  The brute fore way and the better way.  The brute force way does it the way that you would expect.  Create an array of numbers and for each number compare it to every other number until you get to the end.  then you increment to the next number lined up and compare that to every other number until you reach the end.  The running time of this algorithm is O(n^2).  It gets the job done but it does too many comparisons.

the brute force method is called match1.
The better method is called match2.

First it sorts the array of numbers.  We start at the left most index i and compare it to index j.  We will compare it until the values of j are greater than the expected diff.  If it is less than K we increment j to the next.  if it is the same as K then we increment numberOfMatches and then increment J.

This actuall results in much less comparisons.

look at my test cases:

$ 

(10)

3

(9)

3

$ 

(31996000)

0

(7999)

0

$

(7998000)

0

(3999)

0

$ 

(45)

0

(9)

0

After the dollar sign we the I show the number of comparisons, the number of matchs for brute force, the next two are the better method.  Observe the difference.

I think the better method is O(nlogn)

Code is below

#include <stdio.h>
#include <stdlib.h>

int compare(const void *a, const void *b) {
return *(int*)a - *(int*)b;
}

int match1(int *arrOfNum, int len, int diff) {
int i,j;
int numMatches=0;
int numComparisons = 0;
    for(i = 0; i < len-1; ++i) {
    for(j = i + 1; j < len; ++j) {
    //printf("%d - %d\n", arrOfNum[i], arrOfNum[j]);
    numComparisons++;
    if(abs(arrOfNum[i] - arrOfNum[j]) == diff) {
    numMatches++;
    }
    }
    }
    printf("(%d)\n", numComparisons);
    return numMatches;
}

int match2(int *arrOfNum, int len, int diff) {
qsort(arrOfNum, len, sizeof(int), compare);
    int i = 0, j = i + 1;
    int *a = arrOfNum;
    int numMatches = 0;
    int numComparisons = 0;
    for(; i < len-1;++i) {
    for(j = i + 1; j < len;++j) {
    //printf("%d - %d\n", arrOfNum[i], arrOfNum[j]);
    numComparisons++;
    if(a[i] + diff > a[j]) {continue;}
    else if(a[i] + diff == a[j]){
    numMatches++;
    } else {
    break;
    }
    }
    }
    printf("(%d)\n", numComparisons);
    return numMatches;
}



int main(int argc, char **argv) {
    char cN[10];
    char cK[10];
    char number[20];
    FILE *f = fopen(argv[1], "r");
    if (!f){ //error
        return -1;
    }
    fscanf(f, "%s %s", cN, cK);
    int N = (int)strtol(cN, NULL, 10);
    int K = (int)strtol(cK, NULL, 10);

    int numMatches = 0;
    int arrOfNum[100000];
    int i = 0;
    while(1 == fscanf(f, "%s", number)) {
    arrOfNum[i] = (int)strtol(number, NULL, 10);
    ++i;
    }


    numMatches = match1(arrOfNum, N, K);
    printf("%d\n", numMatches);
     numMatches = match2(arrOfNum, N, K);

    printf("%d\n", numMatches);
    return 0;
}

Reverse a singly linked list

static void _inPlaceRev( Node *cursor, Node *prev) {

  if(!cursor) { 

    return;

  }

  _inPlaceRev(head, tail, cursor->next, cursor);

  cursor->next = prev;

}

static void inPlaceRev(LinkedList * _my) {

  _inPlaceRev(_my->head, NULL);

  //swap the head and tail
  _my->head ^= _my->tail;
  _my->tail ^= _my->head;
  _my->head ^= _my->tail;

}

Object Oriented C

Since C is the mother of all the object oriented languages such as Objective c, c++, java, c#, and everything else, then C should have had SOME ability to be object oriented.

Object orientation is really, a pattern that helps reduce low level problems, such as memory management and encapsulation.  So, before Object oriented patterns became native, people in C would make the pattern.  I have made something that resembles that pattern.

The pattern includes:
1) data encapsulation
2) public member functions.

Object Oriented Linked List

Send STDERR to terminal output. STDOUT to file

How to send STDERR to the terminal output and the STDOUT to a file.

Normally the STDOUT and STDERR are both sent to the terminal output.

To split them up we can use ">" and "2>" for STDOUT and STDERR respectively.

generic example
( cool_prog > cool_file ) 2>&1

**note, the parentheses are required or else it will not work**

The Explanation:

cool_prog will attempt to send thing into STDOUT.  The ">" will send it into cool_file.
cool_prog will attempt to send thing into STDERR.  The "2>&1" will send it to terminal output.

">&" should achieve the same effect as "2>&1"

To find more look at these links

http://www.macobserver.com/tips/macosxcl101/2002/20020607.shtml

http://www.tldp.org/LDP/abs/html/io-redirection.html

How to use cellular ram from micron M45W8MW16

Purpose/Goal/Desire:
To use the micron cellular ram as if it was a block ram.
A cpu is useless without ram.  My original approach was to use
block ram to create a ROM to store the main program files. and then
to use block ram for general purpose ram to store the stack and heap stuff.
When it came down to synthesis, I found that I only had enough block ram
for the rom.  I had two options, buy a bigger machine, or use micron's block ram.
It took a large sum of time to figure out how to use it, but in the end it paid off.

Remember that this is a guide in using asynchronous mode.  Its slower, but it makes everything
more homogenous.  And since I'm using it as a ram, I have no idea where the cpu is going to set/get the data.

Stuff that you need to make it work:

1.  spec sheet
1. They added an extra T to the name, making it harder to find
2. Spartan 6 on nexus 3
1. it has enough bram for a 32kx16 rom.  If you have a bigger board then you probably don't need to use the micron cellular ram.
3. A guide for asynchronous mode
1. pay attention to only slides 13,14, 21, and 22
4. xilinx (i used version 14, but other versions should still work)

Gotchas

1. You gotta let the device power on before you can use it. see init state in the FSM
2. The specs say that you can do async read and write in 70 ns.  True, but once you add the commands to start the device up you get closer to 100 ns.
3. using tristate buffers on the bidirectional dq bus is a must.
4. The specs brag about the memory running at 80mhz, but that is for burst/page mode which are much harder to use.  Async mode will get you 10mhz.

my FSM

T : timer 10 ns

//These pins are used to talk to the celular ram  (memory_interface <--> cellular_ram);
addr_o : out std_logic_vector( addr_width-1 downto 0);
clk_o : out  std_logic;
addr_valid_o :out std_logic;
cntl_reg_enable_o : out std_logic;
chip_enable_o : out std_logic;
output_enable_o : out std_logic;
write_en_o : out std_logic;
lower_byte_en_o : out std_logic;
upper_byte_en_o : out std_logic;
data_io : inout std_logic_vector( data_width-1 downto 0);
wait_i : in std_logic;
//These are the pins used to help interface the memory as if it were a block ram ( some module <--> memory_interface);
addr_i : in std_logic_vector (addr_width-1 downto 0);
we_i : in std_logic ;
data_i : in std_logic_vector (data_width-1 downto 0);
data_o : out std_logic_vector (data_width-1 downto 0);
clk_i : in std_logic;
go_i : in std_logic //top module should set this to 0.  when ready to use, set to 1 for one cycle (max 90 ns) then bring down.  when go_i is high it will read or write otherwise it will be idle.;

View this high level pic to see where everything falls in place

Code: the stuff you probably just wanna take and play with right out of the box and probably the only thing you care about

memory interface

component used to interact with the memory interface

The two links above are synthesis able.  I linked them together in a wrapper file, loaded them on to the FPGA and crossed my fingers.  The first link goes to the source code for the memory interface.  It lets you use the memory as if it was a block ram.  But be warned....you may only read/write every 100ns.  Any slower will cause unexpected data.  Going slower is pretty much acceptable.  Oh yeah, remember to toggle the go_i input when you want to read/write.

the second link takes you to what looks like a massively long entity.  In actuality it has several architectures.  Each architecture has a different test.  One of them writes to 16k memory arrays one after the other, then reads them one after another.  Another test jumps really far to write and then jumps to read each of them.

vhdl random number generator for test benches

 LIBRARY ieee;

  USE ieee.std_logic_1164.ALL;

  USE ieee.math_real.ALL;   -- for UNIFORM, TRUNC functions

  USE ieee.numeric_std.ALL;

tb: process

VARIABLE seed1, seed2: positive;               -- Seed values for random generator

VARIABLE rand: real;                           -- Random real-number value in range 0 to 1.0

VARIABLE int_rand: integer;                    -- Random integer value in range 0..4095

variable time_var1, time_var2: time ;

begin

uniform(seed1, seed2,rand); -- generate random number

int_rand := INTEGER(trunc(rand*4096.0)); -- rescale to 0..4069, find integer part

int_rand := to_integer((to_unsigned(int_rand, 14)) );

time_var2 := (10 ms + (int_rand*1 us)); --save random time n a variable

rand_clock2 <= time_var2; --Save time to a signal so I can see it in waveform

wait for time_var2; --wait for duration random time

end process;

some explaination.....

the uniform function generates a psudo random number.  It is a "real" number so once it is generated the value must be truncated and then converted into an integer.

In this example I chose to turn that integer into a value that would vary the time delays.

References

http://www.markharvey.info/vhdl/rnd/rnd.html