thachdt

HOT

Post Top Ad

Thứ Hai, 2 tháng 9, 2019

Lò vi sóng có gây ung thư không ?

tháng 9 02, 2019 0

Lò vi sóng và ung thư – chuyện không có tranh cãi


Lò vi sóng là một thiết bị gia dụng dễ bị hiểu lầm là có hại, nhất là với những người không hiểu về cách hoạt động của nó. Một số nguồn tin cho rằng lò vi sóng sinh ra phóng xạ và biến thực phẩm thành nguồn gây ung thư. Hiểu đúng về lò vi sóng sẽ giúp bạn phân biệt được thông tin nào là đúng, và có thể hoàn toàn an tâm khi sử dụng sản phẩm này.

1. Cách hoạt động của lò vi sóng

1.1.      Vi sóng là sóng điện từ

Lò vi sóng đun nóng thức ăn bằng năng lượng của sóng điện từ.
Sóng điện từ là loại sóng có cùng bản chất với ánh sáng mà chúng ta thấy bằng mắt thường hằng ngày, hay nói chính xác hơn là ánh sáng thấy được (ánh sáng khả kiến) chính là một loại sóng điện từ.
Khoa học chia sóng điện từ ra thành nhiều loại, dựa trên bước sóng của chúng, hay nói một cách dễ hiểu là dựa trên năng lượng mà chúng mang theo.
Theo đó, năng lượng của các loại sóng điện từ theo chiều tăng dần là:
sóng radio < vi sóng (vi ba) < hồng ngoại < khả kiến < cực tím < tia X < tia gamma
Trong đó:

  • Sóng radio thường được dùng để truyền tín hiệu vô tuyến, như radio, TV.
  • Vi ba (vi sóng) thường được dùng trong lò vi sóng (lò vi ba), truyền tín hiệu vô tuyến như điện thoại, sóng wifi. Có một số nguồn phân loại vi ba thuộc sóng radio.
  • Sóng hồng ngoại thường được dùng để truyền tín hiệu của điều kiển TV, cũng là một cách phát nhiệt của vật nóng.
  • Sóng khả kiến là cái mà mắt chúng ta đang dùng để nhìn thấy mọi vật xung quanh. Cầu vồng chính là hiện tượng cho thấy đầy đủ tất cả các sóng khả kiến.
  • Tia cực tím thường được dùng để soi tiền giả, hay nói cách khác là kích hoạt phát huỳnh quang. Tia cực tím cũng chính là tác nhân gây ung thư da có trong ánh nắng mặt trời.
  • Tia X thường được dùng để chụp ảnh X quang.
  • Tia gamma thường được dùng để điều trị ung thư.

1.2.      Vi sóng không phải là tia phóng xạ

Một số nguồn tin không chính thống cho rằng vi sóng là một loại tia phóng xạ. Điều này hoàn toàn sai về bản chất.
Phóng xạ, một cách gần đúng, là loại năng lượng phát ra do sự phân rã hạt nhân nguyên tử. Có nhiều loại tia phóng xạ, trong đó có tia X và tia gamma.
Các tia phóng xạ thường có năng lượng rất cao. Thực nghiệm cho thấy sự phân rã hạt nhân không phóng ra tia vi sóng, loại sóng có năng lượng còn thấp hơn tia hồng ngoại mà mỗi người chúng ta đều đang phát ra. Hơn nữa, vi sóng cũng không đủ mạnh để kích thích sự phân rã của hạt nhân đồng vị không bền (nếu có) trong không khí trong lòng lò lúc hoạt động. Do đó, nói lò vi sóng là lò phóng xạ là không có cơ sở khoa học.
Cần phải làm rõ rằng, vấn đề vi sóng có phải là tia phóng xạ hay không, cũng như lò vi sóng có tạo ra tia phóng xạ hay không, câu trả lời đã rõ ràng trong giới khoa học từ lâu rằng: Không. Hiện đã không còn tranh luận nào về việc này nữa.

1.3.      Vi sóng làm nóng nước, đường và chất béo, qua đó làm nóng thực phẩm

Cách hoạt động của lò vi sóng, nói một cách đơn giản, là tác động lên phân tử nước (và một số phân tử không đối xứng về mặt điện tích, trong đó có chất béo và đường), làm “rung” các phân tử này, từ đó tạo ra nhiệt, giống như cách mà bạn chà xát 2 vật gì đó với nhau ở tần số rất cao.
Bạn có thể dễ dàng kiểm chứng điều này bằng cách bỏ vào lò vi sóng 1 tờ giấy khô và 1 tờ giấy thấm nước, quay cùng một khoảng thời gian, và bạn sẽ thấy là tờ giấy ướt nóng hơn tờ giấy khô rất nhiều; đơn giản là vì vi sóng chỉ là nóng nhanh ở đâu có nước.
Vi sóng không đủ năng lượng để bẻ gãy liên kết hoá học nào trong phân tử nước, cũng như bất kì phân tử nào. Ngay cả tia hồng ngoại, loại sóng điện từ có năng lượng cao hơn vi sóng, cũng không đủ năng lượng để làm việc đó.

2.    Lợi ích của lò vi sóng

Lợi ích lớn nhất của lò vi sóng chính là khả năng bảo quản giá trị dinh dưỡng của thực phẩm.
Có 3 yếu tố cơ bản để đánh giá mức độ bảo quản giá trị dinh dưỡng của thực phẩm qua một phương pháp chế biến, đó là:
  • Thời gian nấu càng ngắn.
  • Càng ít chất lỏng (chủ yếu là nước) trong quá trình chế biến.
  • Nhiệt độ chế biến càng thấp.
Một cách tổng quát, lò vi sóng hội đủ 3 yếu tố trên, so với các phương pháp chế biến thông thường.
Hơn nữa, vì vi sóng làm nóng những nơi có nước, nên có thể coi đây là một cách “hấp” thực phẩm từ cả bên trong, chứ không đơn thuần là từ ngoài vào trong như các phương pháp thông thường.
Rất nhiều những nghiên cứu đã cho thấy việc sử dụng lò vi sóng bảo quản được tương đương, hoặc nhiều chất dinh dưỡng hơn các phương pháp cổ điển như hấp, luộc, chiên, xào, nướng. Tác dụng này thể hiện rõ ràng nhất với những chất tan trong nước mà dễ bị phá huỷ bởi nhiệt như vitamin C, vitamin B, một số hợp chất chống oxy hoá và chất chứa sulfur có khả năng chống ung thư.

3.    Bí ẩn về tác hại của lò vi sóng: đúng và sai

3.1.      Lò vi sóng có thể gây phỏng

Đúng.
Vì vi sóng làm nóng nước rất nhanh, trong khi cơ thể chúng ta ở đâu cũng có nước, nên hiển nhiên, nếu bị chiếu vi sóng trực tiếp một thời gian đủ lâu, chúng ta sẽ bị phỏng.
Nhưng, lò vi sóng đã được thiết kế để đảm bảo rằng lượng vi sóng thoát ra là hầu như bằng không, không đủ để gây tác hại đáng kể cho người.
Lưu ý rằng, mặc dù mỗi lần lò vi sóng hoạt động, bạn thấy có ánh sáng từ lò phát ra, nhưng đó thật sự không phải là vi sóng, mà chỉ là ánh sáng khả kiến để bạn nhận biết là lò có hoạt động hay không, vì bạn không thể nhìn thấy vi sóng. Việc ánh sáng khả kiến này lọt ra ngoài cửa lò không thể hiện được lò có rò rỉ vi sóng hay không.
Và thực tế là, gần như tất cả các ca ghi nhận phỏng do lò vi sóng, thật ra là phỏng trong lúc lấy đồ ăn nóng trong lò ra mà không để ý nhiệt độ của thức ăn, hoàn toàn không liên quan đến nguyên tắc làm việc của lò vi sóng.

3.2.      Khó điều chỉnh/kiểm soát nhiệt độ

Đúng.
Đây là một trong những hạn chế lớn nhất của lò vi sóng. Do lò vi sóng chỉ làm nóng nhanh nơi có độ ẩm cao, do đó dễ tạo các cùng nóng cục bộ trong khi những nơi khô thì chưa kịp nóng.
Một điều cần lưu ý nữa là mặc dù chất béo và đường hấp thu vi sóng rất kém, nhưng do chúng dễ tăng nhiệt, nên cũng có thể bị đun nóng bởi vi sóng. Các thực phẩm chứa nhiều béo hoặc nhiều đường cũng cần kiểm tra nhiệt độ thường xuyên, tránh để quá lâu trong lò, dễ bị mất nước, than hoá.

3.3.      Lò vi sóng biến đổi protein trong thực phẩm thành những chất khó tiêu hoá

Một nửa là sự thật
Sự biến đổi protein trong thực phẩm thành những dạng khác do nấu với vi sóng là hiển nhiên, và điều này đúng không chỉ với lò vi sóng mà với tất cả các phương pháp chế biến khác. Thậm chí, protein trong thực phẩm cũng sẽ biến đổi từ từ ngay cả khi bạn không làm gì cả, do hoạt động của vi khuẩn trong môi trường.
Nhưng điều đó không có nghĩa là các dạng biến đổi của protein sẽ gây khó tiêu. Chưa có bằng chứng khoa học nào đến nay cho thấy việc biến đổi protein do lò vi sóng sẽ gây khó tiêu hơn so với các phương pháp chế biến khác.
Mặc khác, sự biến đổi của protein bởi nhiệt, về bản chất, đôi khi còn giúp cơ thể dễ tiêu hoá các protein này hơn. Ví dụ điển hình là collagen trong các mô liên kết, đặc biệt là gân ở thịt động vật, một loại protein rất dài và bền về mặt vật lí, nhờ nhiệt độ để phân cắt mà các món như gân bò hầm sẽ dễ tiêu hoá hơn là gân bò sống.

3.4.      Lò vi sóng biến đổi thực phẩm thành chất gây ung thư

Đúng, nhưng chưa đủ
Việc sử dụng nhiệt để chế biến thực phẩm lúc nào cũng để lại nguy cơ sinh chất gây ung thư. Heterocyclic amines (HCAs) và các polycyclic aromatic hydrocarbons (PAHs) là những chất phổ biến sinh ra từ thịt cơ của động vật trong suốt quá trình chế biến nhiệt, và không loại trừ lò vi sóng.
Nhưng một điều quan trọng cần nhớ rằng, các chất này sẽ sinh ra càng nhiều khi thực phẩm bị nấu càng lâu và với nhiệt độ càng cao. Điều này hoàn toàn là lợi thế của lò vi sóng, khi mà phương pháp này làm giảm thời gian nấu cũng như nhiệt độ nấu. Một nghiên cứu năm 2005 đã xác nhận điều này

3.5.      Lò vi sóng để lại phóng xạ trong thực phẩm và trong lò

Hoàn toàn sai
Chưa có một báo cáo khoa học nào chứng minh được điều này. Và đơn giản rằng, như đã nói ở trên, điều này là không thể, nếu hiểu được nguyên tắt làm việc của lò. Tổ chức y tế thế giới (WHO) cũng đã xác nhận điều này[13]. Và việc này từ lâu cũng đã không còn là tranh cãi giữa các nhà khoa học nữa.

4.    Cách hạn chế/loại trừ tác hại của lò vi sóng

4.1.      Đọc kỹ hướng dẫn sử dụng

Mỗi loại lò có những điều kiện an toàn khác nhau. Do đó, việc đọc kỹ hướng dẫn sử dụng để bảo đảm các biện pháp bảo vệ cần thiết là điều nên làm.
Quan trọng nhất: KHÔNG ĐỂ VẬT CHỨA KIM LOẠI TRONG LÒ.
Read More
Đọc thêm »
vào lúc Không có nhận xét nào:
Nhãn:

Thứ Tư, 7 tháng 8, 2019

Tại sao hầu hết bảng mạch in lại có màu xanh lá cây trong khi của Apple lại màu đen

tháng 8 07, 2019 1
Tại sao hầu hết bảng mạch in lại có màu xanh lá cây trong khi của Apple lại màu đen?

Dù các bảng mạch màu xanh lá cây giúp việc kiểm tra bản mạch hiệu quả hơn, nhưng khi quá trình này được tự động hóa cao hơn, màu sắc của nó trở nên không còn quá quan trọng nữa.

Các sản phẩm của Apple không chỉ làm nên ấn tượng bởi ngoại hình bên ngoài mà còn cả bằng nội thất bên trong. Những kỹ sư lành nghề khi mổ xẻ nội thất bên trong mỗi chiếc MacBook của Apple đều ấn tượng với bảng mạch màu đen sạch sẽ với các linh kiện được sắp xếp một cách gọn gàng bên trong.
Khác với Apple, đại đa số các hãng điện tử khác lại thường chọn màu xanh lá cây cho bảng mạch của mình. Đối với nhiều người, màu xanh lá cây này trông thật nhàm chán nhưng tại sao đến giờ nó vẫn được sử dụng trong hầu hết thiết bị điện tử như vậy?
Tại sao hầu hết bảng mạch in lại có màu xanh lá cây trong khi của Apple lại màu đen? - Ảnh 1.
Trên thực tế, màu xanh lá cây đó không phải của bản thân bảng mạch, mà là của lớp chất dẻo phủ lên trên bảng mạch. Mục đích của lớp chất dẻo này là nhằm bảo vệ các đường dẫn điện bằng đồng trên bề mặt bảng mạch khỏi bị oxi hóa, cũng như ngăn không cho hình thành các cầu nối điện giữa mối hàn với những đường dẫn điện xung quanh. Và trong những ngày đầu của kỹ thuật hàn sóng (wave soldering), nó giúp ngăn chất hàn vô tình tràn vào bảng mạch trong quá trình hàn.
Điều này cho thấy vai trò của lớp chất dẻo phủ quanh bảng mạch không liên quan mấy đến màu sắc của nó, tại sao hầu hết các bảng mạch in lại có màu xanh?
Trên thực tế, màu sắc phủ lên các bảng mạch in này có nhiều màu khác nhau, ví dụ như xanh lá cây, đỏ, vàng, xanh dương và đen.
Nhưng nhiều năm trước đây, khi sản xuất nên các bảng mạch in, các công ty sử dụng loại nhựa epoxy sợi thủy tinh, có màu xanh lá cây tự nhiên. Vì vậy, các bảng mạch in ban đầu thường có màu xanh lá cây. Dần dần màu xanh này trở thành yếu tố mặc định cho các bảng mạch điện vì tác dụng của nó trong quá trình kiểm tra các mối hàn.
Tại sao hầu hết bảng mạch in lại có màu xanh lá cây trong khi của Apple lại màu đen? - Ảnh 2.
Màu xanh lá cây được chọn để phủ lên hầu hết bảng mạch in vì đó là màu sắc làm mắt ít phải điều tiết nhất khi nhìn vào. Khi việc kiểm tra các mối hàn vẫn được làm thủ công, điều này sẽ giúp ích rất nhiều cho công việc kiểm tra bảng mạch. Hiện nay, ngay cả khi việc kiểm tra đã được tự động hóa, vẫn cần có người kiểm tra nhiều lần trước khi hoàn thiện. Do vậy, màu xanh vẫn có tác dụng trong việc tăng hiệu suất trong quá trình sản xuất.
Khi màu xanh lá cây trở thành lựa chọn mặc định cho các nhà sản xuất bảng mạch in, loại màu này trở nên rất dễ kiếm và có giá thành rẻ hơn hầu hết các loại màu sắc khác. Điều này càng thúc đẩy các nhà sản xuất tiếp tục sản xuất trên các bảng mạch in có màu xanh lá cây, duy trì ngôi vị thống trị của nó trên các bảng mạch.
Tuy nhiên, cùng với việc tự động hóa trong quá trình kiểm tra bảng mạch ngày càng hoàn thiện hơn, việc sử dụng màu xanh lá cây trên các bảng mạch in dần trở nên không còn cần thiết nữa.
Cùng với đó, đến đầu những năm 2000, các nhà sản xuất bắt đầu chú ý hơn đến màu sắc của các bảng mạch in PCB, một phần vì nhu cầu muốn phân biệt phẩm cấp giữa các sản phẩm của mình. Do đó các nhà sản xuất thường sử dụng hai màu sắc khác nhau để phân biệt giữa dòng sản phẩm cao cấp và dòng sản phẩm cấp thấp hơn của mình.
Ví dụ Asus thường sử dụng màu vàng cho các bảng mạch chủ thông thường của mình và màu đen cho các bảng mạch chủ cao cấp hơn. Nhiều công ty sản xuất bảng mạch khác cũng chọn màu đen để đại diện cho dòng sản phẩm cao cấp hơn của mình.
Tại sao hầu hết bảng mạch in lại có màu xanh lá cây trong khi của Apple lại màu đen? - Ảnh 3.
Bản mạch của Apple TV sử dụng chip Apple A5.
Không chỉ vì màu sắc, một phần lý do của việc bảng mạch màu đen được xem như cao cấp hơn nằm ở việc đục lỗ trên các bảng mạch in thường khó hơn, vì vậy, chúng có năng suất thấp hơn, cũng như có giá thành cao hơn so với bảng mạch với các màu khác.
Tuy nhiên, việc bảng mạch đen bắt đầu trở thành biểu tượng cho các sản phẩm cao cấp từ khi chúng được Apple sử dụng trong các bảng mạch cho máy tính MacBook cũng như các thiết bị khác của mình. Dưới tác động của Apple, các bảng mạch màu đen cũng ngày càng được sử dụng phổ biến bởi các nhà sản xuất khác.
Read More
vào lúc 1 nhận xét:
Nhãn:

Thứ Sáu, 12 tháng 7, 2019

Mạch điều khiển nhiệt độ dùng 555

tháng 7 12, 2019 0
Bạn có thể xây dựng một mạch điều khiển nhiệt độ với 555 IC cùng với một bộ chia điện trở nhiệt điện trở. Lợi thế là một nguồn cung cấp năng lượng điều chỉnh tốt là không cần thiết.Mạng phân chia bao gồm điện trở điều chỉnh R3, điện trở nhiệt R4 và R5.

Mạch điều khiển nhiệt độ Schematic


NGUY HIỂM: Cẩn thận điện giật vì mạch này có kết nối trực tiếp với áp 220V
Nguyên lí hoạt động của mạch điều khiển nhiệt độ :
Khi nhiệt độ thấp hơn giá trị nhiệt độ đã cà đặt thì điện áp tại chân 2 của ic timer 555 giảm xuống dưới 1/3 Vcc. Điều này sẽ bật bộ điều khiển bằng bộ điều khiển tam giác và cũng bắt đầu chu kỳ thời gian.
Nếu nhiệt độ nhiệt độ tăng lên trên điểm đặt trước khi kết thúc chu trình thời gian, bộ phận làm nóng sẽ tắt khi kết thúc khoảng thời gian. Nếu không thì lò sưởi vẫn tiếp tục.
Nhiệt độ ngưỡng tác động được cài đặt bằng cách chỉnh biến trở R3
Read More
vào lúc Không có nhận xét nào:
Nhãn:

Thứ Sáu, 5 tháng 7, 2019

Mạch điều khiển relay giao tiếp qua USB

tháng 7 05, 2019 0
Mạch này thachdt chia sẻ toàn bộ file layout pcb vẽ trên proteus và phần mềm được viết trên C#
Chức năng :
  + Điều khiển bật tắt 10 kênh relay bằng phần mềm 
  + Giao tiếp USB
  + Tự động nhận driver
  + Hổ trợ trên hệ điều hành WINDOWN 7 trở lên , 32bit hoặc 64bit

Giao diện phần mềm như sau :


 Phần mềm có thể thay đổi được tên các nút nhấn cho dễ nhớ hơn bằng cách vào menu cài đặt chọn mục đổi tên nút , một cửa sổ đổi tên nút sẽ hiện ra như hình sau, sau đó đổi tên và nhấn lưu cài đặt
Read More
vào lúc Không có nhận xét nào:
Nhãn:

Thứ Sáu, 19 tháng 4, 2019

Điều khiển góc quay 10 động cơ servo từ xa bằng biến trở dùng NRF24L01 - 2.4GHz

tháng 4 19, 2019 0
Chào các bạn !
thachdt tiếp tục chia sẽ toàn bộ project điều khiển góc quay 10 động cơ servo từ xa bằng 10 biến trở dùng module NRF24L01 và IC vi điều khiển PIC16F886
Facebook : https://www.facebook.com/thachdt.co
Khoảng cách khi dùng module này là 10m trở lại , nếu dùng module có PA công xuất cao hơn thì khoản cách thu phát lên đến 1km
Ảnh chụp mạch thực tế :





 Sơ đồ mạch thu và phát :
 
sơ đồ mạch thu


sơ đồ mạch phát

Video test mạch :



Code C của mạch phát : 
////////////////////////////////////////////////
Blog : thachdt.com
Email : machdienhay@gmail.com
///////////////////////////////////////////////
#include <16F886.h>
#device adc=8

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOMCLR                   //Master Clear pin used for I/O
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOCPD                    //No EE protection
#FUSES NOBROWNOUT               //No brownout reset
#FUSES IESO                     //Internal External Switch Over mode enabled
#FUSES FCMEN                    //Fail-safe clock monitor enabled
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOWRT                    //Program memory not write protected
#FUSES BORV40                   //Brownout reset at 4.0V
#FUSES RESERVED                 //Used to set the reserved FUSE bits

#use delay(clock=16000000)

extern unsigned char TxBuf[32];
//*********************************************NRF24L01*************************************
#define TX_ADR_WIDTH    5      // 5 uints TX address width
#define RX_ADR_WIDTH    5      // 5 uints RX address width
#define TX_PLOAD_WIDTH  10     // 32 uints TX payload
#define RX_PLOAD_WIDTH  10     // 32 uints TX payload

//***************************************NRF24L01*******************************************************
#define READ_REG        0x00     //
#define WRITE_REG       0x20    //
#define RD_RX_PLOAD     0x61     //
#define WR_TX_PLOAD     0xA0     //
#define FLUSH_TX        0xE1    //
#define FLUSH_RX        0xE2     //
#define REUSE_TX_PL     0xE3     //
#define NOP             0xFF     //
//*************************************SPI(nRF24L01)·****************************************************
#define CONFIG          0x00  //
#define EN_AA           0x01  //
#define EN_RXADDR       0x02  //
#define SETUP_AW        0x03  //
#define SETUP_RETR      0x04  //
#define RF_CH           0x05  //
#define RF_SETUP        0x06  //
#define STATUS          0x07  //
#define OBSERVE_TX      0x08  // ·
#define CD              0x09  //
#define RX_ADDR_P0      0x0A  //
#define RX_ADDR_P1      0x0B  //
#define RX_ADDR_P2      0x0C  //
#define RX_ADDR_P3      0x0D  //
#define RX_ADDR_P4      0x0E  //
#define RX_ADDR_P5      0x0F  //
#define TX_ADDR         0x10  //
#define RX_PW_P0        0x11  //
#define RX_PW_P1        0x12  //
#define RX_PW_P2        0x13  //
#define RX_PW_P3        0x14  //
#define RX_PW_P4        0x15  //
#define RX_PW_P5        0x16  //
#define FIFO_STATUS     0x17  //
//**************************************************************************************
#define CE PIN_C7
#define CSN PIN_C3
#define SCK PIN_C6
#define MOSI PIN_C2
#define MISO PIN_C5
#define LED PIN_C1
//**************************************************************************************
unsigned char TxBuf[10]=
{
   0x01,0x02,0x03,0x4,0x05,0x06,0x07,0x08,
   0x09,0x10,
};
unsigned char  TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};   //
unsigned char  RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};   //
//****************************************************************************************
void init_NRF24L01(void);
unsigned char SPI_RW(unsigned char Buff);
unsigned char SPI_Read_reg(unsigned char reg);
unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value);
unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char uchars);
unsigned char SPI_Write_Buf(unsigned char reg, unsigned char *pBuf, unsigned uchars);
void SetRX_Mode(void);
void SetTX_Mode(void);
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);
void nRF24L01_TxPacket(unsigned char * tx_buf);

// -------------------------------------------------------
void main()
{
 set_tris_c(0b00100000);
 output_c(0x00);
 char RxBuf[10];
 setup_adc_ports(sAN0|sAN1|sAN2|sAN3|sAN4|sAN8|sAN9|sAN10|sAN11|sAN12|VSS_VDD);
 setup_adc(ADC_CLOCK_DIV_2);
 delay_ms(1000);
 init_NRF24L01(); 
 SetTX_Mode();
 char sv1,sv2,sv3,sv4,sv5;
 char sv6,sv7,sv8,sv9,sv10;
 while(true)
  {
           set_adc_channel(0);
           delay_us(10);
           sv1 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[0] = sv1;
           delay_us(10);
          
           set_adc_channel(1);
           delay_us(10);
           sv2 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[1] = sv2;
           delay_us(10);       

           set_adc_channel(2);
           delay_us(10);
           sv3 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[2] = sv3;
           delay_us(10);
          
           set_adc_channel(3);
           delay_us(10);
           sv4 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[3] = sv4;
           delay_us(10);        
          
           set_adc_channel(4);
           delay_us(10);
           sv5 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[4] = sv5;
           delay_us(10);          
/////////////////////////////////////////
           set_adc_channel(11);
           delay_us(10);
           sv6 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[5] = sv6;
           delay_us(10);
          
           set_adc_channel(9);
           delay_us(10);
           sv7 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[6] = sv7;
           delay_us(10);

           set_adc_channel(8);
           delay_us(10);
           sv8 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[7] = sv8;
           delay_us(10);          
          
           set_adc_channel(10);
           delay_us(10);
           sv9 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[8] = sv9;
           delay_us(10);
          
           set_adc_channel(12);
           delay_us(10);
           sv10 = 6 + read_adc()/13;
           delay_us(10);
           RxBuf[9] = sv10;
           delay_us(10);         
/////////////////////////////////////////////////////////////          
          //  SetTX_Mode();              
          //  delay_ms(10);
            nRF24L01_TxPacket(RxBuf); // Transmit Tx buffer data
            SPI_RW_Reg(WRITE_REG+STATUS,0XFF); // Clear Bit Send
            output_toggle(LED);
            delay_ms(1);
  }
}
//*NRF24L01
//***************************************************************************************/

void init_NRF24L01(void)
{
     delay_us(100);
   output_low(CE);    // chip enable
   output_high(CSN);   // Spi disable
   output_low(SCK);   // Spi clock line init high
   SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    //
   SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); //
   SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      // EN P0, 2-->P1
   SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  //Enable data P0
   SPI_RW_Reg(WRITE_REG + RF_CH, 0);        // Chanel 0 RF = 2400 + RF_CH* (1or 2 M)
   SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); // Do rong data truyen 32 byte
   SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);         // 1M, 0dbm
   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);          // Enable CRC, 2 byte CRC, Send

}
/****************************************************************************************************/
//unsigned char SPI_RW(unsigned char Buff)
//NRF24L01
/****************************************************************************************************/
unsigned char SPI_RW(unsigned char Buff)
{
      unsigned char bit_ctr;
      for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
      {
         if(Buff & 0x80) output_high(MOSI) ;   // output 'uchar', MSB to MOSI 
         else output_low(MOSI);
         delay_us(5);
         Buff = (Buff << 1);           // shift next bit into MSB..
         output_high(SCK);                      // Set SCK high..         
         delay_us(5);
         if((input(MISO))==1)Buff |= 0x01;             // capture current MISO bit
         output_low(SCK);                    // ..then set SCK low again
      }
      return(Buff);                   // return read uchar
}
/****************************************************************************************************/
//unsigned char SPI_Read(unsigned char reg)
//NRF24L01
/****************************************************************************************************/
unsigned char SPI_Read_reg(unsigned char reg)
{
   unsigned char reg_val=0;
   output_low(CSN);                // CSN low, initialize SPI communication...
   SPI_RW(reg);            // Select register to read from..
   reg_val = SPI_RW(0);    // ..then read registervalue
   output_high(CSN);                // CSN high, terminate SPI communication
   return (reg_val);        // return register value
}
/****************************************************************************************************/
//unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value)
/****************************************************************************************************/
unsigned char SPI_RW_Reg(unsigned char reg,unsigned char value)
{
   unsigned char status1;
   output_low(CSN);                   // CSN low, init SPI transaction
   status1 = SPI_RW(reg);      // select register
   SPI_RW(value);             // ..and write value to it..
   output_high(CSN);     // CSN high again
   return(status1);            // return nRF24L01 status uchar
}
/****************************************************************************************************/
//unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char uchars)
//
/****************************************************************************************************/
unsigned char SPI_Read_Buf(unsigned char reg,unsigned char *pBuf,unsigned char uchars)
{
   unsigned char status1,uchar_ctr;

   output_low(CSN);                           // Set CSN low, init SPI tranaction
   status1 = SPI_RW(reg);             // Select register to write to and read status uchar
   for(uchar_ctr=0;uchar_ctr<uchars;uchar_ctr++) pBuf[uchar_ctr] = SPI_RW(0);    //
   output_high(CSN);
   return(status1);                    // return nRF24L01 status uchar
}
/*********************************************************************************************************/
//uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
/*****************************************************************************************************/
unsigned char SPI_Write_Buf(unsigned char reg,unsigned char *pBuf,unsigned char uchars)
{
   unsigned char status1,uchar_ctr;
   output_low(CSN);           //SPI
   status1 = SPI_RW(reg);
   for(uchar_ctr=0; uchar_ctr<uchars; uchar_ctr++) //
   SPI_RW(*pBuf++);
   output_high(CSN);           //SPI
   return(status1);    //
}
/****************************************************************************************************/
//void SetRX_Mode(void)
//
/****************************************************************************************************/
void SetRX_Mode(void)
{
   output_low(CE);
   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);         // Enable CRC, 2 byte CRC, Recive
   output_high(CE);
   delay_us(130);    //
}
/****************************************************************************************************/
//void SetTX_Mode(void)
//
/****************************************************************************************************/
void SetTX_Mode(void)
{
   output_low(CE);
   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);         // Enable CRC, 2 byte CRC, Send
   output_high(CE);
   delay_us(130);    //
}

/******************************************************************************************************/
//unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
/******************************************************************************************************/
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
{
    unsigned char revale=0;
    unsigned char sta;
   //if(RX_DR)            // Data in RX FIFO
   sta=SPI_Read_reg(STATUS);   // Read Status 
   if(sta&0x40)      // Data in RX FIFO
   {
      output_low(CE);          //SPI
      SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
      revale =1;  
   }
   SPI_RW_Reg(WRITE_REG+STATUS,sta);
   return(revale);
}
/***********************************************************************************************************/
//void nRF24L01_TxPacket(unsigned char * tx_buf)
//
/**********************************************************************************************************/
void nRF24L01_TxPacket(unsigned char * tx_buf)
{
   output_low(CE);     
   SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // Send Address
   SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH);           //send data
   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);          // Send Out
   output_high(CE);      
}

// --------------------END OF FILE------------------------
// -------------------------------------------------------


Code C mạch thu :

////////////////////////////////////////////////
Blog : thachdt.com
Email : machdienhay@gmail.com
///////////////////////////////////////////////
#include <16F886.h>
#device adc=8

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES HS                       //High speed Osc (> 4mhz for PCM/PCH) (>10mhz for PCD)
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOMCLR                   //Master Clear pin used for I/O
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NOCPD                    //No EE protection
#FUSES NOBROWNOUT               //No brownout reset
#FUSES IESO                     //Internal External Switch Over mode enabled
#FUSES FCMEN                    //Fail-safe clock monitor enabled
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOWRT                    //Program memory not write protected
#FUSES BORV40                   //Brownout reset at 4.0V
#FUSES RESERVED                 //Used to set the reserved FUSE bits

#use delay(clock=16000000)

//************************************************************************************************8

extern unsigned char TxBuf[32];
//*********************************************NRF24L01*************************************
#define TX_ADR_WIDTH    5      // 5 uints TX address width
#define RX_ADR_WIDTH    5      // 5 uints RX address width
#define TX_PLOAD_WIDTH  10     // 32 uints TX payload
#define RX_PLOAD_WIDTH  10     // 32 uints TX payload

//***************************************NRF24L01*******************************************************
#define READ_REG        0x00     //
#define WRITE_REG       0x20    //
#define RD_RX_PLOAD     0x61     //
#define WR_TX_PLOAD     0xA0     //
#define FLUSH_TX        0xE1    //
#define FLUSH_RX        0xE2     //
#define REUSE_TX_PL     0xE3     //
#define NOP             0xFF     //
//*************************************SPI(nRF24L01)·****************************************************
#define CONFIG          0x00  //
#define EN_AA           0x01  //
#define EN_RXADDR       0x02  //
#define SETUP_AW        0x03  //
#define SETUP_RETR      0x04  //
#define RF_CH           0x05  //
#define RF_SETUP        0x06  //
#define STATUS          0x07  //
#define OBSERVE_TX      0x08  // ·
#define CD              0x09  //
#define RX_ADDR_P0      0x0A  //
#define RX_ADDR_P1      0x0B  //
#define RX_ADDR_P2      0x0C  //
#define RX_ADDR_P3      0x0D  //
#define RX_ADDR_P4      0x0E  //
#define RX_ADDR_P5      0x0F  //
#define TX_ADDR         0x10  //
#define RX_PW_P0        0x11  //
#define RX_PW_P1        0x12  //
#define RX_PW_P2        0x13  //
#define RX_PW_P3        0x14  //
#define RX_PW_P4        0x15  //
#define RX_PW_P5        0x16  //
#define FIFO_STATUS     0x17  //
//**************************************************************************************
#define CE PIN_C7
#define CSN PIN_C3
#define SCK PIN_C6
#define MOSI PIN_C2
#define MISO PIN_C5
#define LED PIN_C1
//**************************************************************************************
unsigned char TxBuf[10]=
{
   0x01,0x02,0x03,0x4,0x05,0x06,0x07,0x08,
   0x09,0x10,
};
unsigned char  TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};   //
unsigned char  RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};   //
//****************************************************************************************
void init_NRF24L01(void);
unsigned char SPI_RW(unsigned char Buff);
unsigned char SPI_Read_reg(unsigned char reg);
unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value);
unsigned char SPI_Read_Buf(unsigned char reg, unsigned char *pBuf, unsigned char uchars);
unsigned char SPI_Write_Buf(unsigned char reg, unsigned char *pBuf, unsigned uchars);
void SetRX_Mode(void);
void SetTX_Mode(void);
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);
void nRF24L01_TxPacket(unsigned char * tx_buf);
 char count=0;
 char sv1=15,sv2=15,sv3=15,sv4=15,sv5=15;
 char sv6=15,sv7=15,sv8=15,sv9=15,sv10=15;
// -------------------------------------------------------
#int_TIMER0
void  TIMER0_isr(void)
{
set_timer0(168);
count++;
if(count>=200)
  {
 
  output_b(0xFF);
  output_a(0xFF);
  count=0;
  }
 if(count>=sv1)output_low(PIN_A0); 
 if(count>=sv2)output_low(PIN_A1);
 if(count>=sv3)output_low(PIN_A2);
 if(count>=sv4)output_low(PIN_A3);
 if(count>=sv5)output_low(PIN_A4);
 /////////////////////////////////
 if(count>=sv6)output_low(PIN_B6);
 if(count>=sv7)output_low(PIN_B5);
 if(count>=sv8)output_low(PIN_B4);
 if(count>=sv9)output_low(PIN_B3);
 if(count>=sv10)output_low(PIN_B2);
}
void main()
{
 set_tris_c(0b00100000);
 set_tris_b(0x00);
 set_tris_a(0x00);
 output_a(0x00);
 output_b(0x00);
 output_c(0x00);
 delay_ms(1000);
 setup_timer_0(RTCC_INTERNAL|RTCC_DIV_4);
 set_timer0(164);
 setup_timer_1(T1_DISABLED);
 setup_timer_2(T2_DISABLED,0,1);
 char RxBuf[10];
 output_low(LED); 
 init_NRF24L01(); 
 SetRX_Mode();
 enable_interrupts(INT_TIMER0);
 enable_interrupts(GLOBAL);
 char st=0;
 while(true)
  {
   if(nRF24L01_RxPacket(RxBuf)==1)   // Neu nhan duoc du lieu
       {  
       sv1=RxBuf[0];
       sv2=RxBuf[1];
       sv3=RxBuf[2];
       sv4=RxBuf[3];
       sv5=RxBuf[4];
       ////////////
       sv6=RxBuf[5];
       sv7=RxBuf[6];
       sv8=RxBuf[7];
       sv9=RxBuf[8];
       sv10=RxBuf[9];
       output_toggle(LED);
       SetRX_Mode();
       } 
  }
}

//*NRF24L01
//***************************************************************************************/
void init_NRF24L01(void)
{
     delay_us(100);
   output_low(CE);    // chip enable
   output_high(CSN);   // Spi disable
   output_low(SCK);   // Spi clock line init high
   SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    //
   SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); //
   SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      // EN P0, 2-->P1
   SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  //Enable data P0
   SPI_RW_Reg(WRITE_REG + RF_CH, 0);        // Chanel 0 RF = 2400 + RF_CH* (1or 2 M)
   SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); // Do rong data truyen 32 byte
   SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);         // 1M, 0dbm
   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);          // Enable CRC, 2 byte CRC, Send

}
/****************************************************************************************************/
//unsigned char SPI_RW(unsigned char Buff)
//NRF24L01
/****************************************************************************************************/
unsigned char SPI_RW(unsigned char Buff)
{
      unsigned char bit_ctr;
      for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
      {
         if(Buff & 0x80) output_high(MOSI) ; // output 'uchar', MSB to MOSI 
         else output_low(MOSI);
         delay_us(5);
         Buff = (Buff << 1);           // shift next bit into MSB..
         output_high(SCK);                      // Set SCK high..         
         delay_us(5);
         if((input(MISO))==1)Buff |= 0x01;               // capture current MISO bit
         output_low(SCK);                    // ..then set SCK low again
      }
      return(Buff);                   // return read uchar
}
/****************************************************************************************************/
//unsigned char SPI_Read(unsigned char reg)
//NRF24L01
/****************************************************************************************************/
unsigned char SPI_Read_reg(unsigned char reg)
{
   unsigned char reg_val;
   output_low(CSN);                // CSN low, initialize SPI communication...
   SPI_RW(reg);            // Select register to read from..
   reg_val = SPI_RW(0);    // ..then read registervalue
   output_high(CSN);                // CSN high, terminate SPI communication
   return (reg_val);        // return register value
}
/****************************************************************************************************/
//unsigned char SPI_RW_Reg(unsigned char reg, unsigned char value)
/****************************************************************************************************/
unsigned char SPI_RW_Reg(unsigned char reg,unsigned char value)
{
   unsigned char status1;
   output_low(CSN);                   // CSN low, init SPI transaction
   status1 = SPI_RW(reg);      // select register
   SPI_RW(value);             // ..and write value to it..
   output_high(CSN);     // CSN high again
   return(status1);            // return nRF24L01 status uchar
}
Read More
Đọc thêm »
vào lúc Không có nhận xét nào:

Thứ Năm, 28 tháng 3, 2019

Cách kiểm tra MOSFET, FET còn sống hay chết

tháng 3 28, 2019 0

Cách kiểm tra MOSFET, FET còn sống hay chết

Chuẩn bị: Một đồng hồ vạn năng với 2 que đo, để đồng hồ thang x1KΩ, kiểm tra dây đo còn tốt, dụng cụ kẹp linh kiện cố định hay miếng lót cách điện.
Trước khi đo Mosfet – FET (FET) dùng dây dẫn hay tô vít nối tắt 3 chân của MosFet – FET lại để khử hết điện tích trên các chân (lý do FET là linh kiện rất nhạy cảm, điện tích trên các chân có thể ảnh hưởng đến kết quả đo)
1. Mosfet – Fet còn tốt thì kết quả đo sẽ như sau:
1
B1: Đo giữa G và S cả hai chiều kim không lên (tiếp giáp GS chưa bị thủng)
1. Do giu cuc G va D cua FET
B2. Đo giữa G và D cả hai chiều kim không lên ( tiếp giáp G D chưa bị thủng)
4
B3. Dùng Tô vít nối tắt G vào D để thoát điện tích trên cực G (do quá trình đo đã để lại điện tích trên chân G)
5
B4. Đo giữa D và S (Sau khi G đã thoát điện cực G thì ) có một chiều kim không lên (có đảo que đo)
2. Các trường hợp sau là Mosfet – Fet bị hỏng
1
Đo giữa G và S kim lên => là chập G S
2
Đo giữa G và D kim lên là chập G D
3
Dùng tô vít chập chân G D để thoát điện tích chân G,
4
Đo giữa D và S kim vẫn lên sau khi đã thoát điện cực G là bị chập DS
3. Các đo nhanh và xem khả năng mở kênh của Mostfet – Fet
kenh p kenh n fet
Kiểm tra Mosfet – Fet kênh N.
1. Đặt thang x10K, đặt FET lên vật cách điện hay kẹp chặt bằng dụng cụ không dẫn điện.
2. Đặt que đỏ vào cực S, que đen vào cực D, thông thường VOM sẽ chỉ một giá trị nào đó (do điện tích còn tồn tại trên chân G làm mở)
3. Giữ que đo như ở bước 2, chạm ngón tay từ cực G sang cực D sẽ thấy kim nhíc lên (thường gần bằng 0), chạm tay từ G sang S sẽ thấy kim tụt đi (có trường hợp tụt gần về vô cùng). Để thấy kim thay đổi nhiều hơn thì hay để ngón tay chạm dính nước hoặc chạm vào đầu lưỡi vào cực G.
Đó là FET còn sống, nếu ko có thay đổi là FET chết.
Kiểm tra Mosfet – Fet kênh P.
Với FET kênh P cách làm tương tự nhưng cần đảo que đo.
Read More
vào lúc Không có nhận xét nào:

Thứ Ba, 19 tháng 3, 2019

Mạch điều khiển từ xa RF 4 kênh dùng PT2272- PT2262

tháng 3 19, 2019 0








Xin chào !
Bạn có muốn điều khiển bật tắt 1 bóng đèn từ xa ở khoản cách vài mét đến vài chục mét hay là vài km mà không cần phải lê thân tới chổ có công tắt không , hay chỉ đơn giản là bạn muốn bật tắt 1 bóng đèn trong phòng lúc bạn đã đặt lưng trên giường ngủ và đang ở chế độ lười chỉ muốn nằm . Hãy để mạch sau đây thay bạn làm những việc đó 

IMG_0279
Thêm chú thích
Sau đây là video mô tả hoạt động trên mạch thực tế :

Để bắt đầu làm mạch này bạn cần phải có những đồ nghề sau :
+ Máy hàn nhỏ ,chì hàn , nhựa thông , kìm bấm , đồng hồ đo điện ( không có cũng được mà có thì càng tốt )
+ Mạch nạp pitkit2 hoặc burn-e để nạp chương trình cho vi điều khiển PIC ( có kèm phần mềm nạp ) , 1 máy tính laptop
+ 1 cục nguồn 220V – 12V để test mạch
Linh kiện : ( nên lấy mỗi thứ 10 con nhỡ có hỏng con nào thì có mà thay vô )
+ PIC16F54 , PT2272-M4 , C1815 , 78L05 , nút nhấn nhỏ loại tròn 2 chân , module thu sóng 315Mhz loại không có IC , Role 12V 5 chân , Domino 2C ( màu xanh ) , Diode 1N4007 , Diode 1N4148 , đèn LED 3mm ( màu gì cũng được ) , điện trở 10K , điện trở 4K7 , điện trở 1K , điện trở 620k ( phải mua đúng loại điện trở này ) , tụ hóa 220uF-16V ,tụ hóa 47uF-16V , tụ gốm 100nF ( tụ trên lưng có ghi số 104 ) , loa chíp nhỏ loại 12V
+ Remote 315Mhz loại có 4 nút ( giống như hình )
remote4kenh

Sơ đồ mạch :
so do

Trong sơ đồ có con vi điều khiển PIC16F54 cần phải nạp chương trình thì mạch mới chạy , bạn tải file ad đã đính kèm link , trong đó có file main.hex bạn dùng file đó nạp vào chíp , bạn có thể xem thêm bài viết về cách nạp chương trình cho chíp hoặc nhờ chổ bản chíp nạp dùm
Mạch dưới dạng layout vẽ trên proteus 8 :
mach

Làm mạch in : trong file tải về ( ở cuối bài viết ) có file mach.pdsprj , các bạn dùng proteus 8 để mở file đó lên và chuyển sang phần layout để in mạch , mạch có thể làm thủ công hoặc đặt bên chuyên gia công mạch in làm ( bạn có thể tùy chỉnh file layout này )

Ảnh mạch thực tế ad làm thủ công như hình sau :
IMG_0279
IMG_0280

Cấu hình địa chỉ của remote 4 nút để mạch nhận remote : mở 3 con vít nhỏ để tháo remote ra và để trông 8 chân địa chỉ khoanh vùng màu đỏ trên mạch
IMG_0738

Sơ đồ đấu ghép bóng đèn với mạch :
so do dau dien

Code viết trên CCS :
//////////////////////////////////////////////////////////////////////////////////////////////
///////////////////// Blog: https://220von.blogspot.com  ////////////////
////////////////////  Email : 220von.com@gmail.com   ////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////
#include <16f54.h>
#FUSES WDT // Watch Dog Timer
#FUSES LP //Low power osc < 200 khz
#FUSES PROTECT //Code protected from reading
#FUSES NODEBUG //No Debug mode for ICD
#FUSES RESERVED //Used to set the reserved FUSE bits
#use delay(clock=68000,RESTART_WDT)
#define R4 PIN_B4
#define R3 PIN_B5
#define R2 PIN_B6
#define R1 PIN_B7
#define D0 PIN_A2
#define D1 PIN_A3
#define D2 PIN_A0
#define D3 PIN_A1
#define N1 PIN_B0
#define N2 PIN_B1
#define N3 PIN_B2
#define N4 PIN_B3
void main (void)
{
SETUP_WDT(WDT_1152MS );
RESTART_WDT();
set_tris_b(0b11110000);
set_tris_a(0xff);
output_low(R1);
output_low(R2);
output_low(R3);
output_low(R4);
int1 R1_set=0,R2_set=0,R3_set=0,R4_set=0;
while(true)
{
RESTART_WDT();
if((input(D0))&&(R1_set==1)){output_toggle(R1);R1_set=0;}
else if((input(N1))&&(R1_set==1)){output_toggle(R1);R1_set=0;}
if(((input(D0))==0)&&((input(N1))==0))R1_set=1;
if((input(D1))&&(R2_set==1)){output_toggle(R2);R2_set=0;}
else if((input(N2))&&(R2_set==1)){output_toggle(R2);R2_set=0;}
if(((input(D1))==0)&&((input(N2))==0))R2_set=1;
if((input(D2))&&(R3_set==1)){output_toggle(R3);R3_set=0;}
else if((input(N3))&&(R3_set==1)){output_toggle(R3);R3_set=0;}
if(((input(D2))==0)&&((input(N3))==0))R3_set=1;
if((input(D3))&&(R4_set==1)){output_toggle(R4);R4_set=0;}
else if((input(N4))&&(R4_set==1)){output_toggle(R4);R4_set=0;}
if(((input(D3))==0)&&((input(N4))==0))R4_set=1;
}
}

Chúc các bạn lắp ráp mạch thành công
Ghi chú : không sao chép bài viết này lên các trang khác , nếu chia sẽ xin hay chia sẽ đường link bài viết , xin cám ơn !
Nếu các bạn muốn hợp tác với mình để mở rộng chức năng cho ứng dụng này hoặc chia sẻ ý tưởng ứng dụng vào cuộc sống thì gửi mail cho mình theo địa chỉ : 220von.com@gmail.com
Hoặc theo dõi trang fan page facebook : https://www.facebook.com/220von/
Read More
vào lúc Không có nhận xét nào:

Post Top Ad

Thông tin về tác giả thachdientu

thachdt được viết tắt từ Thạch điện tử