Of course, one of the main advantages of smartphones is that they’re convenient. With a huge variety of makes, models and contracts available from providers such as O2 and AT&T, it’s little wonder that, these days, a huge number of people own a smartphone, and tend to have it with them wherever they go. For those who may not be professional photographers, but simply want to capture their favourite memories whilst on the go, the smartphone offers the advantage of always being close at hand. Using apps to link with sites such as Facebook can also mean that it’s much easier to upload photos quickly and easily – something which some may feel is more valuable that having pictures which are of a exceptionally high quality.

However, another factor which may influence those thinking about buying a camera is the price. The price of a smartphone can be far higher than that of a basic digital camera – especially if the phone camera is not particularly advanced. If the cost is a deciding factor, then then some people looking to take great photos may decide that they’re rather simple pay less and have a separate camera and phone.

Finally, it is worth remembering that despite the fact the the quality of smartphone cameras has greatly improved over recent years, they are still generally unable to match up to that of advanced digital camera alternatives. To those for whom picture quality is a priority, digital cameras are likely to remain the most popular choice.

Below details a simple solution to debounce and enforce a minimum reset hold time in your code.

——

I use Generics in my entity so I can set the sys clk rate and the minimum width for the reset pulse easily:

entity rst_detect is

generic(

clk_rate_mhz : integer := 20000000;

min_width_us : integer := 10000

);

port(

clk     : in std_logic;

rst_in  : in std_logic;

rst_out : out std_logic

);

end entity

architecture rtl of por_detect is

– to get the minimum ticks for a valid por,

– find the ticks per 1MHz (or 1us) and then

– multiply by the min us value

constant MIN_TICKS : integer := integer(ceil(real((clk_rate_mhz/1000000)*min_width_us)));

– min bit width of the counter for to count to min_ticks

constant COUNTER_WID : integer := integer(ceil(log2(real(MIN_TICKS))));

constant MAX_COUNT : integer := integer((2**COUNTER_WID) – 1);

signal count : std_logic_vector(COUNTER_WID – 1 downto 0) := (others => ’0′);

–start and stop counter vals

signal s_count : std_logic_vector(COUNTER_WID – 1 downto 0);

type   por_state_t is (POR_IDLE, POR_WAIT, POR_OUTPUT);

signal por_state : por_state_t := POR_IDLE;

begin

counter : process(clk) begin

if(rising_edge(clk)) then

count <= count + 1;

end if;

end process;

por_det : process(clk) begin

if(rising_edge(clk)) then

case por_state is

when POR_IDLE =>

por_out <= ’0′;

if(por_in = ’1′) then

s_count   <= count;

por_state <= POR_WAIT;

else

por_state <= POR_IDLE;

end if;

when POR_WAIT =>

if(por_in = ’0′) then

por_state <= POR_IDLE;

else

if(count > s_count) then

if(count – s_count >= MIN_TICKS) then

por_out   <= ’1′;

por_state <= POR_OUTPUT;

else

por_state <= POR_WAIT;

end if;

else

if((MAX_COUNT – s_count) + count >= MIN_TICKS) then

por_out   <= ’1′;

por_state <= POR_OUTPUT;

else

por_state <= POR_WAIT;

end if;

end if;

end if;

when POR_OUTPUT =>

if(por_in = ’0′) then

por_out <= ’0′;

por_state <= POR_IDLE;

else

por_state <= POR_OUTPUT;

end if;

when others =>

por_out   <= ’0′;

por_state <= POR_IDLE;

end case;

end if;
end process;

end architecture rtl

This code came about when I needed to talk to an embeded CPU in a Xilinx FPGA. I have ethernet on the card as well, and the CPU is setup to handle it. I wanted to send control commands to the CPU from my Linux workstation to verify some functionality. To do this, I have two pieces of code: (1) a “server” that spins on the FPGA and receives the incoming messages, and a “client” app that can send a command to the “server”. This is a trvial example and the code is basic, but you can see how easy it would be to expand as needed.

The Client:

#include 
#include 
#include 
#include 
#include 

void die(char* msg) { perror(msg); exit(1); }

int main(int argc, char *argv[]) {
	int sock;
	struct sockaddr_in server;
	unsigned short int serverPort = 9999;

	sock= socket(AF_INET, SOCK_DGRAM, 0);
	if(sock < 0 ) die("failed to create socket");

	server.sin_family = AF_INET;
	server.sin_addr.s_addr = inet_addr("127.0.0.1");
	server.sin_port = serverPort; .

	char msg[] = "Hello World. ";
	printf("We will send the message: \"%s\" to the server. \n", msg);

	if (sendto(socketDescriptor, msg, strlen(msg), 0, (struct sockaddr *) &server, sizeof(server)) < 0) {
                   die("failed to send message");
	}

	return 0;
}

And now the Server:

#include 
#include 
#include 
#include 
#include 
#include 

#define BUFFSIZE 255
void Die(char* msg) { perror(msg); exit(1); }

int main(int argc, char* argv[]){
	int sock;
	struct sockaddr_in echoserver;
	struct sockaddr_in echoclient;

	char buffer[BUFFSIZE];
	unsigned int echolen, serverlen, clientlen;
	int rec = 0;

	if(argc != 2){
		fprintf(stderr, "USAGE: %s
\n", argv[0]);
		exit(1);
	}

	/* create UDP socket */
	if((sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP)) < 0){
		Die("failed to create socket");
	}

	memset(&echoserver, 0, sizeof(echoserver));
	echoserver.sin_family = AF_INET;
	echoserver.sin_addr.s_addr = htonl(INADDR_ANY);
	echoserver.sin_port = htons(atoi(argv[1]));

	serverlen = sizeof(echoserver);
	if(bind(sock, (struct sockaddr *) &echoserver, serverlen) < 0) {
		Die("failed to bind.");
	}

	while(1){

		clientlen = sizeof(echoclient);
		if((rec = recvfrom(sock, buffer, BUFFSIZE, 0, (struct sockaddr*)&echoclient, &clientlen)) < 0){
			Die("failed to rec mesg");
		}
		printf("client connected: %s\nData: %s\n\n", inet_ntoa(echoclient.sin_addr),buffer);

	}
}