Wednesday, December 4, 2013

Offernation.com payment proof screenshot

This is my paypal screenshot showing the payment I get from OfferNation.com


















Sign up now: www.offernation.com


Friday, September 27, 2013

ALU Bit Slice Verilog code







Bit slicing is a method of combining processor modules to multiply the word length. In a bit-sliced processor, each module contains an ALU (arithmetic-logic unit) usually capable of handling a 4-bit field. By combining two or more identical modules, it is possible to build a processor that can handle any multiple of this value, such as 8 bits, 12 bits, 16 bits, 20 bits, and so on. Each module is called a slice. The control lines for all the slices are connected effectively in parallel to share the processing "work" equally.

VERILOG CODE:




`timescale 1ns / 1ps

//////////////////////////////////////////////////////////////////////////////////
module ALUbitSlice(a,b,cin,out,cout,control );

input a,b,cin;
input [2:0]control;
output out,cout;
reg out, cout;

always @(control)
                begin    
                                case (control)
                                0: begin
                                                out = a^b^cin;
                                                cout = (b&&cin)||(a&&cin)||(a&&b);
                                                end
                                1: begin
                                                out = a^(~b)^cin;
                                                cout = ((~b)&&cin)||(a&&cin)||(a&&(~b));
                                                end
                                2: begin out = a&b;
                                                cout = 0;
                                                end
                                3: begin
                                                out = a&(~b);
                                                cout =0;
                                                end
                                4: begin
                                   out = a||b;
                                                cout =0;
                                                end
                                5: begin
                                                out = a||(~b);
                                                cout =0;
                                                end
                                6: begin
                                                out = b;
                                                cout =0;
                                                end
                                7:            begin
                                                out = a;
                                                cout =0;
                                                end
                                default: out=0;
                                endcase
                end
endmodule









Verilog Test Fixture




`timescale 1ns / 1ps

////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////

module ALUbitSliceVTF;
                reg [5:0] ctr;
                reg out_tc;
                reg cout_tc;
                reg error;
                reg clk;

                wire out;
                wire cout;

                // Instantiate the Unit Under Test (UUT)
                ALUbitSlice uut (
                                .a(ctr[5]),
                                .b(ctr[4]),
                                .cin(ctr[3]),
                                .out(out),
                                .cout(cout),
                                .control(ctr[2:0])
                );

                initial begin
                                // Initialize Inputs
                                ctr = 0;
                                clk =0;
                                error =0;
               
                                // Wait 100 ns for global reset to finish
                                #100;    
    end 
                 
                                 always begin
                                 #10 clk= ~clk;
                                 end
                                 
                                 always @ (posedge clk)
                                 begin
                                 ctr = ctr +1;
                                 end
                                 
always
                begin    
                                case (ctr[2:0])
                                0: begin
                                                out_tc = ctr[5]^ctr[4]^ctr[3];
                                                cout_tc = (ctr[4]&&ctr[3])||(ctr[5]&&ctr[3])||(ctr[5]&&ctr[4]);
                                                end
                                1: begin
                                                out_tc = ctr[5]^(~ctr[4])^ctr[3];
                                                cout_tc = ((~ctr[4])&&ctr[3])||(ctr[5]&&ctr[3])||(ctr[5]&&(~ctr[4]));
                                                end
                                2: begin out_tc = ctr[5]&ctr[4];
                                                cout_tc = 0;
                                                end
                                3: begin
                                                out_tc = ctr[5]&(~ctr[4]);
                                                cout_tc =0;
                                                end
                                4: begin
                                   out_tc = ctr[5]||ctr[4];
                                                cout_tc =0;
                                                end
                                5: begin
                                                out_tc = ctr[5]||(~ctr[4]);
                                                cout_tc =0;
                                                end
                                6: begin
                                                out_tc = ctr[4];
                                                cout_tc =0;
                                                end
                                7:            begin
                                                out_tc = ctr[5];
                                                cout_tc =0;
                                                end
                                default: out_tc=0;
                                endcase
                               

                #1 if (out== out_tc && cout==cout_tc) error=0;
                else error=1;
                end
     
endmodule








Tuesday, June 18, 2013

One Hot Counter Structural VERILOG CODE and TEST FIXTURE

Counter One-Hot Verilog code:


`timescale 1ns / 1ps
//////////////////////////////////////////////////////////////////////////////////
module cont_one_hot_struct( start, I, RC, OC, S, V, clr, set, clk, cp);
input start, I, RC, S, V, clr, set, clk;
input [1:0] OC;
output [3:0]cp;
wire d0,d1,d2,d3,d4,d5,d6,d7,d8,d9,d10;
wire q0,q1,q2,q3,q4,q5,q6,q7,q8,q9,q10;
wire w0,w1,w2,w3,w4,w5,w6,w7,w8,w9,w10;
wire Vcmp,RCcmp,Icmp,OC0,Scmp;

dff_syn_low_clr_set FF0 ( clk,d0,set,clr,q0,q_cmp0);
dff_syn_low_clr_set FF1 ( clk,d1,set,clr,q1,q_cmp1);
dff_syn_low_clr_set FF2 ( clk,d2,set,clr,q2,q_cmp2);
dff_syn_low_clr_set FF3 ( clk,d3,set,clr,q3,q_cmp3);
dff_syn_low_clr_set FF4 ( clk,d4,set,clr,q4,q_cmp4);
dff_syn_low_clr_set FF5 ( clk,d5,set,clr,q5,q_cmp5);
dff_syn_low_clr_set FF6 ( clk,d6,set,clr,q6,q_cmp6);
dff_syn_low_clr_set FF7 ( clk,d7,set,clr,q7,q_cmp7);
dff_syn_low_clr_set FF8 ( clk,d8,set,clr,q8,q_cmp8);
dff_syn_low_clr_set FF9 ( clk,d9,set,clr,q9,q_cmp9);
dff_syn_low_clr_set FF10 ( clk,d10,set,clr,q10,q_cmp10);

or O0(d0, start, q5, w0);
not N0(Vcmp, V);
and A0(w0, Vcmp, q10);

and A1(d1, I, q0);

or O2(d2, w2, q1);
not N1(RCcmp, RC);
and A2(w2, RCcmp, q3);

not N2(Icmp,I);
and A3(d3, Icmp, q0);

or O4(d4, w4, q2);
and A4(w4, RC, q3);

not N3(OC0, OC[0]);
and A5(d5, OC0, q4);

and A6(d6, q4, OC[0]);

or O7(d7, w7, w10);
and A7(w7, q4, OC[1]);
and A8(w10, V, q10);

and A9(d8, q6, Scmp);
not N4(Scmp,S);

or O9(d9, q7, w9);
and N5(w9, S, q6);

or O10(d10, q8, q9);

or CP0 (cp[0], q0,q3,q6,q7,q10);
or CP1 (cp[1], q2,q3,q5,q7,q8);
or CP2 (cp[2], q3,q5,q9,q10);
or CP3 (cp[3], q1,q6,q8);
endmodule


D flip flop code

dff_syn_low_clr_set


 `timescale 1ns / 1ps

//
//////////////////////////////////////////////////////////////////////////////////
module dff_syn_low_clr_set( clk,d,set,clr,q,q_cmp);
input clr, set, d, clk;
output q, q_cmp;
reg q;
always @(posedge (clk))
begin
if (clr==1'b0) begin q=1'b0; end
else if (set==1'b0) begin q=1'b1; end
else
begin
q=d;
end
end
assign q_cmp=~q;

endmodule










Verilog Test Fixture Code for One hot Counter


`timescale 1ns / 1ps
module cont_one_hot_struct_VTF;

                // Inputs
                reg start;
                reg I;
                reg RC;
                reg [1:0] OC;
                reg S;
                reg V;
                reg clr;
                reg set;
                reg clk;
                // Outputs
                wire [3:0] cp;
reg [10:0]yp,Y;
reg [3:0]cp_tc;
reg error;

parameter t0=11'b10000000000;
parameter t1=11'b01000000000;
parameter t2=11'b00100000000;
parameter t3=11'b00010000000;
parameter t4=11'b00001000000;
parameter t5=11'b00000100000;
parameter t6=11'b00000010000;
parameter t7=11'b00000001000;
parameter t8=11'b00000000100;
parameter t9=11'b00000000010;
parameter t10=11'b10000000001;
                cont_one_hot_struct uut ( .start(start),                .I(I),       .RC(RC), .OC(OC), .S(S),                 .V(V),    .clr(clr), .set(set),
                                .clk(clk), .cp(cp));
                initial begin
                                // Initialize Inputs
                                start = 0;
                                I = 0;
                                RC = 0;
                                OC = 0;
                                S = 0;
                                V = 0;
                                clr = 0;
                                set = 1;
                                clk = 0;
                                Y=11'b00000000000;

                                // Wait 100 ns for global reset to finish
                                #100;
                                start = 1;
                                clr=1;
      #10;
                                start = 0;
                                #100;
                                // Add stimulus here
                end
     
                                always
                                begin
                                #20 clk =~clk;
                                end
               

                               
                                always
                                begin
                                #200 I =~I;
                                end
                               
                                always
                                begin
                                #300 RC =~RC;
                                end
                               
                                always
                                begin
                                #400 OC =OC+1;
                                end
                               
                                always
                                begin
                                #600 S =~S;
                                end
                               
                                always
                                begin
                                #800 V =~V;
                                end
                               
                                always
                                begin
                                #2000  clr=~clr;
                                end
                               
                                always @(yp,I,S,RC,OC,V)
                                begin
                               
                                case (yp)
                                t0: if (I==1'b1) Y=t1;
                                                else Y=t3;
                                t1: Y=t2;
                                t3: if (RC==1'b1) Y=t4;
                                                else Y=t2;
                                t2: Y=t4;
                                t4: if(OC==2'b00) Y=t5;
                                else if(OC==2'b01) Y=t6;
                                else if(OC==2'b10) Y=t7;
                                t5: Y=t0;
                                t6: if(S==1'b1) Y=t9;
                                                else Y=t8;
                               
                                t7: Y=t9;
                                t8: Y=t10;
                                t9: Y=t10;
                                t10: if(V==1'b1) Y=t7;
                                                else Y=t0;
                                               
                                default: Y=0;
                                endcase
                               
                                end
                               
                               
                                always@(posedge clk)
                                begin
                                                if(clr==1'b0) yp=11'b00000000000;
                                else if (start==1'b1) yp=t0;
                                else yp=Y;
                               
                                end
always @(yp)
                                begin
                                case(yp)
                               
                                t0 : cp_tc=4'b0001;
                                t1 : cp_tc=4'b1000;
                                t2 : cp_tc=4'b0010;
                                t3 : cp_tc=4'b0111;
                                t4 : cp_tc=4'b0000;
                                t5 : cp_tc=4'b0110;
                                t6 : cp_tc=4'b1001;
                                t7 : cp_tc=4'b0011;
                                t8 : cp_tc=4'b1010;
                                t9 : cp_tc=4'b0100;
                                t10 : cp_tc=4'b0101;
                                default: cp_tc =4'b0000;
                                endcase                              
                                end
                               
                                always
                                begin
                                #1 if (cp==cp_tc) error=0;
                                else error=1;
                                end
                               
endmodule

ความแตกต่างระหว่างพิธีกร กับ พิธีการ The Different between Spoke person and Organizer


ความแตกต่างระหว่างพิธีกร กับพิธีการ
The Different between Spoke person and Organizer
             ปัจจุบันมีความเข้าใจผิดกันบ่อยมาก ในเรื่องของคำสองคำ คือ พิธีกร (Spoke person) กับ พิธีการ (Organizer) ซึ่งความเข้าใจผิดได้นำไปสู่ผลเสียหายบ่อยครั้ง เช่น การหาบุคคลมารับผิดชอบเป็นพิธีกร ในการจัดงาน แต่กลับไม่มีฝ่ายพิธีการ หรือ Organizer งานนั้นเลยตกไปอยู่กับผู้ที่ทำหน้าที่เป็นพิธีกร ที่จะต้องไปยืนอยู่หน้าเวทีถือไมค์
ปัญหาเกิดขึ้นไม่มีใครวิ่งแก้ไขอันเกิดจาก ไม่มีคนทำหน้าที่เป็น Back end ให้ซึ่งก็คือ ฝ่ายพิธีการ หรือ Organizer นั่นเอง นี่หละ จึงเป็นที่มาของบทความ ฉบับนี้ ที่ต้องการสร้างความเข้าใจคำสองคำนี้ ให้กระจ่าง เพื่อเราจะได้ไม่ผิดพลาดเวลาจะจัดงานหรือ ทำงานอะไรที่ต้องเกี่ยวข้องกับ คนสองคนนี้
           พิธีกร คือใคร พิธีกร ทำหน้าที่อะไร พิธีกร ต้องมีคุณสมบัติอย่างไร เรามาดูกัน เพื่อจะได้มองเห็นภาพ ซึ่งพิธีกร เป็นบุคคลที่ทุกคนรู้จัก เพราะไปงานไหนๆ ก็มักจะ รู้ว่าใครเป็นพิธีกร ส่วน พิธีการนั้น มักจะไม่รู้ตัวว่าเป็นใคร อาจจะเห็นวิ่งไป วิ่งมาบ้าง แต่ก็ไม่รู้ว่าเขาทำอะไรบ้างเหมือนกัน เรามาดูกันก่อนว่า พิธีกร คือใคร
พิธีกร (Spokeperson)
หน้าที่ของพิธีกร
       1. พูดกับผู้มาร่วมงาน สื่อสารกับผู้มาร่วมงาน ด้วยการแนะข้อกำหนดการ ภาษาอังกฤษใช้คำว่า Agenda เพื่อให้ทุกคนทราบว่าจะเกิดอะไรขึ้นบ้าง
       2. พิธีกรทำหน้าที่ในการแก้ปัญหาเฉพาะหน้าบนเวที เช่น กรณีแสง หรือเสียงมีปัญหา พิธีกรจะรีบตันสินใจว่าจะเอาอย่างไร จากนั้นพิธีการ จะรีบดำเนินการแก้ไข ปัญหาทางด้านล่างเวที โดยประสานกับพิธีกร ตลอดเวลา
       3. พิธีกรทำหน้าที่ในการสร้างบรรยากาศการประชุมหรือ การชุมนุม หรือทำให้งานบรรลุตามวัตถุประสงค์
       4. พิธีกร ทำหน้าที่ทำหน้าที่สร้างสรรค์งานคุณภาพ ภาพลักษณ์ของงานจะเป็นอย่างไร พิธีกร สำคัญอย่างยิ่ง
พิธีกรควรจะมีทักษะอะไรเป็นพิเศษ
       1. พิธีกรควรจะเป็นคนพูดเป็น ทักษะการพูดต้องดี
       2. พิธีกร ต้องบุคลิกดี
       3. พิธีกรต้องสื่อสารแล้วคนฟังเข้าใจ
       4. พิธีกรต้องไม่พูดมาก เกินไป
       5. มีทักษะในการใช้เคื่องมือในการหากิน โดยเฉพาะไมโครโฟน ต้องใช้ให้เก่งๆ
พิธีกรมีค่าตัวไหม
       1. พิธีกร ต้องแต่งตัว แต่งหน้า
       2. บางครั้งพิธีกร ต้องเช่าชุดเพื่อมาทำงานให้เข้ากับ Concept ของงาน
       3. พิธีกร ต้องเดินทางไปงาน  ต้องกินข้าว
โดยสรุป
       โดยสรุปแล้ว คนทำหน้าที่เป็นพิธีกร ในงานประชุม สัมมนา หรืองานรื่นเริงต่างๆ จะต้องทำงานหนัก เพราะต้องใช้ทักษะ หลายด้าน ต้องตัดสินใจเก่งด้วย มีท่าทีสง่างาม เพราะต้องอยู่ต่อหน้าสาธารณะชนจำนวนมาก สิ่งหนึ่งที่หลายๆ คนไม่เข้าใจการทำหน้าที่พิธีกร ก็คือ เข้าใจว่า เขามาทำหน้าที่ในการพูดเพียงอย่างเดียว จ่ายเงินค่าเหนื่อยให้สัก 500 สัก 1000 ก็พอ ทำงานแค่สองสามชั่วโมงเอง นี่คือความเข้าใจผิดเป็นอย่างมาก  แท้จริงพิธีกร ต้องแต่งตัว ต้องเดินทาง ต้องกิน ต้องอยู่ ค่าใช้จ่ายในการจ้าง คนให้มาทำงาน ให้ประสบความสำเร็จ จึงควรจะเริ่มต้นที่ ประมาณ 3000 บาทขึ้นไป และให้เข้าใจใหม่ว่า การเป็นพิธีกร หากงานสำเร็จ ผู้จัดได้รับการชื่นชม พิธีกร ได้ มีคำชมนิดๆ หน่อยๆ แต่หากงานนั้น เกิดข้อผิดพลาดขึ้น ระหว่างงานคนที่จะถูกอัดก็คือพิธีกร ดังนั้นตามมารยาทของพิธีกร เราจึงไม่เคยเสนอตัวเอง ไปเป็นพิธีกรกันเท่าไหร่ จะเป็นเจ้าภาพ สนใจ แล้วติดต่อมา มากกว่า การที่เจ้าภาพติดต่อมา แสดงว่า เขาสนใจ เลือกความเป็นตัวเราไปเป็นพิธีกร ไปทำงานให้เขา
พิธีการ (Organizer)
หน้าที่ของพิธีการ
       1. ประสานงานการจัดงาน ตลอดจนกระบวนการ
       2. จัดทำกำหนดการร่วมกันเจ้าภาพงานและประสานพิธีกร
       3. ประสานงานข้อมูลกับพิธีกรตลอดเวลาการจัดงาน
       4. อำนวยความสะดวกในการดำเนินงาน
       5. ตัดสินใจแก้ไขปัญหาในแบบ Back End ในการจัดงาน
พิธีการเป็นใคร
       1. ฝ่ายพิธีการหรือผู้ทำหน้าที่พิธีการ อาจจะเป็นคนของเจ้าภาพจัดงาน หรืออาจจะ ว่าจ้างคนนอก ที่มีความเป็นมืออาชีพ เข้ามาจัดการ
       2. พิธีการต้องทำงานได้กับทุกฝ่าย ไม่ว่าจะเป็นเจ้าภาพ สถานที่ อาหาร พิธีกร วิทยากร การแสดง หรือแม้แต่ คนดูแลกุญแจห้องน้ำ
       3. พิธีกร จะต้องทำงานเป็นทีม เพื่อให้การประสานงานเป็นไปอย่างราบรื่น
       4. พิธีการ อาจจะเรียกว่า เป็นกลุ่มปิดทองหลังพระ
พิธีการต้องจ้างไหม
       1. ไม่ว่าจะใช้คนในองค์กรหรือนอกองค์กร ก็มีค่าใช้จ่าย อย่างน้อยก็ค่าโทรศัพท์
       2. บางครั้งต้องใช้ทีมงานหลายคน เช่น คนประสานการแสดง คนประสานแขกเข้าโต๊ะ งานแต่งงาน ก็ต้องมีค่าใช้จ่าย
สรุป
       ในการจัดงานอะไรสักอย่างหนึ่ง ตั้งแต่งานวันเกิด จนถึงงานศพ สิ่งที่ขาดไม่ได้คือ ควรจะมีฝ่ายพิธีการ หรือ Organizer จะช่วยให้งานดำเนินไปได้อย่างดี ไม่ติดขัด ไม่มีปัญหา โดยหากฝ่ายพิธีการ กับทีมงานพิธีกร ได้สื่อสารกันแต่เนิ่นๆ ก็จะยิ่งเป็นการดี และหากทีมพิธีกร กับ พิธีการ มาด้วยกันก็ยิ่งจะดี เพราะการทำงานของเขาจะเป็นทีม นี่คือ ความแตกต่างระหว่าง พิธีกร กับ พิธีการ
โดย เภสัชกรประชาสรรณ์ แสนภักดี M.P.H. ม.เชียงใหม่ ผู้จัดการศูนย์ฝึกอบรมภูมิปัญญาสู่สากล ขอนแก่น, ประเทศไทยGlocalization Training Center, Khon Kaen, THAILAND
         http://www.prachasan.com/ideaandido/speaker.htm