java處理信號_用java編寫交通信號燈

A. java有沒有類似matlab的數字信號處理庫

java有沒有類似matlab的數字信號處理庫
如果不是比較前沿的知識,要用到它最新支持的庫函數
,用舊的一點版本也是可以的了。

B. 有沒有哪位大俠用java實現過將數字信號轉換為模擬信號的指點下或給個實例謝了！！

網卡不能將數字信號轉換成模擬信號，他只能傳輸數字信號，數據機的意思有兩個，調制的意思是把模擬信號轉換成數字信號，解調的意思是把數字信號轉換成模擬信號。數據機主要在使用撥號上網的時候才用的到。

C. 用java如何傳出信號

控制寄存器，用協議通信。

D. java 進程間通訊的有幾種方法

進程間通信的方法主要有以下幾種：

（1）管道（Pipe）：管道可用於具有親緣關系進程間的通信，允許一個進程和另一個與它有共同祖先的進程之間進行通信。
（2）命名管道（named pipe）：命名管道克服了管道沒有名字的限制，因此，除具有管道所具有的功能外，它還允許無親緣關系進程間的通信。命名管道在文件系統中有對應的文件名。命名管道通過命令mkfifo或系統調用mkfifo來創建。
（3）信號（Signal）：信號是比較復雜的通信方式，用於通知接受進程有某種事件發生，除了用於進程間通信外，進程還可以發送信號給進程本身；linux除了支持Unix早期信號語義函數sigal外，還支持語義符合Posix.1標準的信號函數sigaction（實際上，該函數是基於BSD的，BSD為了實現可靠信號機制，又能夠統一對外介面，用sigaction函數重新實現了signal函數）。
（4）消息（Message）隊列：消息隊列是消息的鏈接表，包括Posix消息隊列system V消息隊列。有足夠許可權的進程可以向隊列中添加消息，被賦予讀許可權的進程則可以讀走隊列中的消息。消息隊列克服了信號承載信息量少，管道只能承載無格式位元組流以及緩沖區大小受限等缺
（5）共享內存：使得多個進程可以訪問同一塊內存空間，是最快的可用IPC形式。是針對其他通信機制運行效率較低而設計的。往往與其它通信機制，如信號量結合使用，來達到進程間的同步及互斥。
（6）內存映射（mapped memory）：內存映射允許任何多個進程間通信，每一個使用該機制的進程通過把一個共享的文件映射到自己的進程地址空間來實現它。
（7）信號量（semaphore）：主要作為進程間以及同一進程不同線程之間的同步手段。
（8）套介面（Socket）：更為一般的進程間通信機制，可用於不同機器之間的進程間通信。起初是由Unix系統的BSD分支開發出來的，但現在一般可以移植到其它類Unix系統上：Linux和System V的變種都支持套接字。

而在java中我們實現多線程間通信則主要採用"共享變數"和"管道流"這兩種方法

方法一通過訪問共享變數的方式(注:需要處理同步問題)
方法二通過管道流

其中方法一有兩種實現方法,即
方法一a)通過內部類實現線程的共享變數
代碼如下:

public class Innersharethread {
public static void main(String[] args) {
Mythread mythread = new Mythread();
mythread.getThread().start();
mythread.getThread().start();
mythread.getThread().start();
mythread.getThread().start();
}
}
class Mythread {
int index = 0;
private class InnerThread extends Thread {
public synchronized void run() {
while (true) {
System.out.println(Thread.currentThread().getName()
+ "is running and index is " + index++);
}
}
}
public Thread getThread() {
return new InnerThread();
}
}
/**
* 通過內部類實現線程的共享變數
*
*/
public class Innersharethread {
public static void main(String[] args) {
Mythread mythread = new Mythread();
mythread.getThread().start();
mythread.getThread().start();
mythread.getThread().start();
mythread.getThread().start();
}
}
class Mythread {
int index = 0;
private class InnerThread extends Thread {
public synchronized void run() {
while (true) {
System.out.println(Thread.currentThread().getName()
+ "is running and index is " + index++);
}
}
}
public Thread getThread() {
return new InnerThread();
}
}

b)通過實現Runnable介面實現線程的共享變數
代碼如下：

public class Interfacaesharethread {
public static void main(String[] args) {
Mythread mythread = new Mythread();
new Thread(mythread).start();
new Thread(mythread).start();
new Thread(mythread).start();
new Thread(mythread).start();
}
}
/* 實現Runnable介面 */
class Mythread implements Runnable {
int index = 0;
public synchronized void run() {
while (true)
System.out.println(Thread.currentThread().getName() + "is running and
the index is " + index++);
}
}
/**
* 通過實現Runnable介面實現線程的共享變數
*/
public class Interfacaesharethread {
public static void main(String[] args) {
Mythread mythread = new Mythread();
new Thread(mythread).start();
new Thread(mythread).start();
new Thread(mythread).start();
new Thread(mythread).start();
}
}
/* 實現Runnable介面 */
class Mythread implements Runnable {
int index = 0;
public synchronized void run() {
while (true)
System.out.println(Thread.currentThread().getName() + "is running and
the index is " + index++);
}
}

方法二(通過管道流）:
代碼如下：

public class CommunicateWhitPiping {
public static void main(String[] args) {
/**
* 創建管道輸出流
*/
PipedOutputStream pos = new PipedOutputStream();
/**
* 創建管道輸入流
*/
PipedInputStream pis = new PipedInputStream();
try {
/**
* 將管道輸入流與輸出流連接 此過程也可通過重載的構造函數來實現
*/
pos.connect(pis);
} catch (IOException e) {
e.printStackTrace();
}
/**
* 創建生產者線程
*/
Procer p = new Procer(pos);
/**
* 創建消費者線程
*/
Consumer c = new Consumer(pis);
/**
* 啟動線程
*/
p.start();
c.start();
}
}
/**
* 生產者線程(與一個管道輸入流相關聯)
*
*/
class Procer extends Thread {
private PipedOutputStream pos;
public Procer(PipedOutputStream pos) {
this.pos = pos;
}
public void run() {
int i = 8;
try {
pos.write(i);
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 消費者線程(與一個管道輸入流相關聯)
*
*/
class Consumer extends Thread {
private PipedInputStream pis;
public Consumer(PipedInputStream pis) {
this.pis = pis;
}
public void run() {
try {
System.out.println(pis.read());
} catch (IOException e) {
e.printStackTrace();
}
}
}

E. java程序怎麼接受壓力感測器信號

非標准信號輸出，要接變送器轉換成標准輸出。
已經是標准輸出可以選擇接有232口 usb口，或者485口的採集卡，數顯表，採集器等儀表，

F. java如何實現信號量集，請注意，是信號量集，而不是信號量，求大神指點

信號量：一個整數；
大於或等於0時代表可供並發進程使用的資源實體數；
小於0時代表正在等待使用臨界區的進程數；
用於互斥的信號量初始值應大於0；
只能通過P、V原語操作而改變；
信號量元素組成：
1、表示信號量元素的值；
2、最後操作信號量元素的進程ID
3、等待信號量元素值+1的進程數；
4、等待信號量元素值為0的進程數；

二、主要函數

1.1 創建信號量
int semget(
key_t key, //標識信號量的關鍵字，有三種方法：1、使用IPC——PRIVATE讓系統產生，
// 2、挑選一個隨機數，3、使用ftok從文件路徑名中產生
int nSemes, //信號量集中元素個數
int flag //IPC_CREAT；IPC_EXCL 只有在信號量集不存在時創建
)
成功：返回信號量句柄
失敗：返回-1

1.2 使用ftok函數根據文件路徑名產生一個關鍵字
key_t ftok(const char *pathname,int proj_id);
路徑名稱必須有相應許可權

1.3 控制信號量
int semctl(
int semid, //信號量集的句柄
int semnum, //信號量集的元素數
int cmd, //命令
/*union senum arg */... //
)
成功：返回相應的值
失敗：返回-1

命令詳細說明:
cmd: IPC_RMID 刪除一個信號量
IPC_EXCL 只有在信號量集不存在時創建
IPC_SET 設置信號量的許可權
SETVAL 設置指定信號量的元素的值為 agc.val
GETVAL 獲得一個指定信號量的值
GETPID 獲得最後操縱此元素的最後進程ID
GETNCNT 獲得等待元素變為1的進程數
GETZCNT 獲得等待元素變為0的進程數

G. 如何用java實現信號量

package synchronization;

public class Semaphore {
private int value;

public Semaphore(){
this.value = 0;
}
public Semaphore(int v){
this.value = v;
}

public synchronized void down(){
while(value <= 0 ){
try{
wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
value--;
}

public synchronized void up(){
value++;
notify();
}
}

使用的時候Semophore s;
while(true){
s.wait();
//臨界區
s.signal();
}

H. 怎麼用Java程序語言模擬手機信號發射器和接收器

考慮用多線程試一試

I. JAVA程序「信號燈」問題

package com.ifeng.test;
import java.awt.BorderLayout;
import java.awt.Canvas;
import java.awt.Choice;
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Label;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

public class SingalCanvas extends Canvas {
private static final long serialVersionUID = -5305107739145145221L;
int red, green, yellow, x, y, r;
SingalCanvas() {
setBackground(Color.CYAN);
}

public void setRed(int r) {
red = r;
}

public void setGreen(int g) {
green = g;
}

public void setYellow(int y) {
yellow = y;
}

public void setPosition(int x, int y) {
this.x = x;
this.y = y;
}

public void setRadius(int r) {
this.r = r;
}

public void paint(Graphics g) {
if (red == 1) {
g.setColor(Color.red);
} else if (green == 1) {
g.setColor(Color.green);
} else if (yellow == 1) {
g.setColor(Color.yellow);
}
g.fillOval(x, y, 2 * r, 2 * r);// 從x,y位置處畫一個實心的圓
}

class SignalFrame extends Frame implements ItemListener
{
private static final long serialVersionUID = 7614643759272879177L;
Choice choice;// 菜單選項
SingalCanvas signal = null;
String itemRed = "Red", itemYellow = "Yellow", itemGreen = "Green";

public SignalFrame(SingalCanvas one)
{
choice = new Choice();
choice.add(itemRed);// 增加選項
choice.add(itemYellow);
choice.add(itemGreen);
add(choice, BorderLayout.NORTH);
try {
// Class cs = Class.forName("SingalCanvas");// 調用，路徑
signal = one;
add(signal, BorderLayout.CENTER);
} catch (Exception e) {
add(new Label("SingalCanvas has no Instance"), BorderLayout.CENTER);
}
setBounds(100, 100, 360, 300);
setVisible(true);
validate();
choice.addItemListener(this);

choice.select(0);
new Thread(){
public void run() {
while(true){
for (int i=0;i<choice.getItemCount();i++)
{
System.out.println(i);
choice.select(i);
String item = choice.getSelectedItem(); // choice返回被選中的條目
int w = signal.getBounds().width;
int h = signal.getBounds().height;
int m = Math.min(w, h);
signal.setRadius(m / 6);
if (item.equals(itemRed))
{
if (signal != null) {
signal.setRed(1);
signal.setYellow(0);
signal.setGreen(0);
signal.setPosition(w / 3, 0);
signal.repaint();
}
}
else if (item.equals(itemYellow))
{
if (signal != null) {
signal.setRed(0);
signal.setYellow(1);
signal.setGreen(0);
signal.setPosition(w / 3, h / 3);
signal.repaint();
}
}
else if (item.equals(itemGreen))
{
if (signal != null)
{
signal.setRed(0);
signal.setYellow(0);
signal.setGreen(1);
signal.setPosition(w / 3, 2 * h / 3);
signal.repaint();
}
}
try {
Thread.sleep(2000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
}.start();

addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
}

public void itemStateChanged(ItemEvent e)
{
String item = choice.getSelectedItem(); // choice返回被選中的條目
int w = signal.getBounds().width;
int h = signal.getBounds().height;
int m = Math.min(w, h);
signal.setRadius(m / 6);
if (item.equals(itemRed))
{
if (signal != null) {
signal.setRed(1);
signal.setYellow(0);
signal.setGreen(0);
signal.setPosition(w / 3, 0);
signal.repaint();
}
}
else if (item.equals(itemYellow))
{
if (signal != null) {
signal.setRed(0);
signal.setYellow(1);
signal.setGreen(0);
signal.setPosition(w / 3, h / 3);
signal.repaint();
}
}
else if (item.equals(itemGreen))
{
if (signal != null)
{
signal.setRed(0);
signal.setYellow(0);
signal.setGreen(1);
signal.setPosition(w / 3, 2 * h / 3);
signal.repaint();
}
}
}

}

public void crate(SingalCanvas one)
{
SignalFrame frame = new SignalFrame(one);
frame.setTitle("信號燈");
}

public static void main(String[] arg){
SingalCanvas one = new SingalCanvas();
one.crate(one);
}
}

J. 用java編寫交通信號燈

按照你的要求編寫的紅綠燈程序，你看看吧，比較簡單。
完整的程序如下：
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import java.awt.Graphics;
public class TrafficLight extends JFrame{
JRadioButton jrbYellow,jrbGreen,jrbRed;
int flag=0;
jpNewPanel jpNewPanel;
public static void main(String[] args){
TrafficLight frame=new TrafficLight();
frame.setSize(500,200);
frame.setLocationRelativeTo(null);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.setTitle("TrafficLight");
frame.setVisible(true);
}
public TrafficLight(){
jpNewPanel=new jpNewPanel();
add(jpNewPanel,BorderLayout.CENTER);
JPanel jpRadioButtons=new JPanel();
jpRadioButtons.setLayout(new GridLayout(1,3));
jpRadioButtons.add(jrbYellow=new JRadioButton("Yellow"));
jpRadioButtons.add(jrbGreen=new JRadioButton("Green"));
jpRadioButtons.add(jrbRed=new JRadioButton("Red"));
add(jpRadioButtons,BorderLayout.SOUTH);
ButtonGroup group=new ButtonGroup();
group.add(jrbYellow);
group.add(jrbGreen);
group.add(jrbRed);

jrbYellow.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
flag=2;
jpNewPanel.repaint();
}
});
jrbGreen.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
flag=1;
jpNewPanel.repaint();
}
});
jrbRed.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
flag=3;
jpNewPanel.repaint();
}
});
}
class jpNewPanel extends JPanel{
protected void paintComponent(Graphics g){
super.paintComponent(g);
g.drawRect(0,0,40,100);
g.drawOval(10,10,20,20);
g.drawOval(10,40,20,20);
g.drawOval(10,70,20,20);
if(flag==1){
g.setColor(Color.GREEN);
g.fillOval(10, 70, 20, 20);
}
else if(flag==2){
g.setColor(Color.YELLOW);
g.fillOval(10, 40, 20, 20);
}
else if(flag==3){
g.setColor(Color.RED);
g.fillOval(10, 10, 20, 20);
}
}
}
}

導航:首頁 > 編程語言 > java處理信號

java處理信號

與java處理信號相關的資料