TinyOS - Versionsgeschichte

Rosenfalter: /* growthexperiments-addlink-summary-summary:3|0|0 */

2024-12-03T18:51:51Z

Linkvorschlag-Funktion: 3 Links hinzugefügt.

← Nächstältere Version		Version vom 3. Dezember 2024, 19:51 Uhr
Zeile 12:		Zeile 12:

	== Technik ==		== Technik ==
	TinyOS nutzt eine komponentenbasierte Architektur (''component-based architecture'') und ein ereignisbasiertes Ausführungsmodell (''event-driven concurrency model''). Gleichzeitig stellt es auch eine Entwicklungsumgebung und Programmierplattform speziell für Hardwaresysteme mit knappen Ressourcen in Bezug auf Speicher, Rechenleistung und Energieverwendung dar, welche autonom und sicher über Zeiträume von Monaten oder Jahren zuverlässig funktionieren müssen.		TinyOS nutzt eine komponentenbasierte Architektur (''component-based architecture'') und ein ereignisbasiertes Ausführungsmodell (''event-driven concurrency model''). Gleichzeitig stellt es auch eine Entwicklungsumgebung und Programmierplattform speziell für Hardwaresysteme mit knappen Ressourcen in Bezug auf Speicher, [[Rechenleistung]] und Energieverwendung dar, welche autonom und sicher über Zeiträume von Monaten oder Jahren zuverlässig funktionieren müssen.

	Die „Philosophie“ des Betriebssystems ist es, die anstehenden Arbeiten so schnell wie möglich abzuarbeiten, um danach die Hardware in den Schlafmodus zu schicken. Die Umsetzung dieses Konzepts erreicht TinyOS durch eine ereignisgesteuerte Ausführung der in Komponenten (Components) gegliederten Programmteile, die über zweiphasige Operationen aufgerufen werden und somit keinen zusätzlichen Stack für das Zwischenspeichern benötigen.		Die „Philosophie“ des Betriebssystems ist es, die anstehenden Arbeiten so schnell wie möglich abzuarbeiten, um danach die Hardware in den Schlafmodus zu schicken. Die Umsetzung dieses Konzepts erreicht TinyOS durch eine ereignisgesteuerte Ausführung der in Komponenten (Components) gegliederten Programmteile, die über zweiphasige Operationen aufgerufen werden und somit keinen zusätzlichen Stack für das Zwischenspeichern benötigen.
Zeile 18:		Zeile 18:
	Ursprünglich wurde TinyOS in der [[Programmiersprache]] [[C (Programmiersprache)\|C]] geschrieben. Doch das besondere Anwendungsgebiet machte es notwendig, ein neues Programmierkonzept zu entwerfen, welches das Betriebssystem optimal unterstützen konnte. Zu diesem Zweck wurde die Programmiersprache [[nesC]] geschaffen,<ref>{{Internetquelle \|url=https://www.enterprisenetworkingplanet.com/os/iot-operating-systems/ \|titel=Top IoT Operating Systems \|datum=2022-11-18 \|sprache=en-US \|abruf=2022-11-24}}</ref> welche wiederum so maßgeschneidert für die Programmierung von Sensorknoten entwickelt worden ist, dass TinyOS nochmals überarbeitet und komplett in nesC reimplementiert wurde. Somit wird die besondere Betriebssystem-Architektur optimal unterstützt.		Ursprünglich wurde TinyOS in der [[Programmiersprache]] [[C (Programmiersprache)\|C]] geschrieben. Doch das besondere Anwendungsgebiet machte es notwendig, ein neues Programmierkonzept zu entwerfen, welches das Betriebssystem optimal unterstützen konnte. Zu diesem Zweck wurde die Programmiersprache [[nesC]] geschaffen,<ref>{{Internetquelle \|url=https://www.enterprisenetworkingplanet.com/os/iot-operating-systems/ \|titel=Top IoT Operating Systems \|datum=2022-11-18 \|sprache=en-US \|abruf=2022-11-24}}</ref> welche wiederum so maßgeschneidert für die Programmierung von Sensorknoten entwickelt worden ist, dass TinyOS nochmals überarbeitet und komplett in nesC reimplementiert wurde. Somit wird die besondere Betriebssystem-Architektur optimal unterstützt.

	Für die Anwendungsentwicklung werden einzelne Komponenten (Components) für das jeweilige Anwendungsgebiet der Sensorknoten miteinander verknüpft und bilden somit im Endeffekt eine komplette Applikation, die über die UISP-Schnittstelle oder mittels [[Over-the-Air-Update\|Over-the-air-programming]] (OTAP) auf die Zielhardware aufgespielt wird. Elementare Components kapseln Hardwarekomponenten wie etwa die Funkschnittstelle oder den Timer und bilden somit in einem hierarchischen Komponentenmodell die unterste Ebene, die als [[Hardware Abstraction Layer]] (HAL) bezeichnet wird. In TinyOS bzw. nesC gibt es zwei Arten von Components: '''Modules''' implementieren die einzelnen Funktionen der [[Schnittstelle]]n (zwischen den Components) und '''Configurations''' beschreiben mit Hilfe der Schnittstellen wie die einzelnen Components miteinander verbunden sind.		Für die Anwendungsentwicklung werden einzelne Komponenten (Components) für das jeweilige Anwendungsgebiet der Sensorknoten miteinander verknüpft und bilden somit im Endeffekt eine komplette Applikation, die über die UISP-Schnittstelle oder mittels [[Over-the-Air-Update\|Over-the-air-programming]] (OTAP) auf die Zielhardware aufgespielt wird. Elementare Components kapseln Hardwarekomponenten wie etwa die [[Funkschnittstelle]] oder den Timer und bilden somit in einem hierarchischen [[Komponentenmodell]] die unterste Ebene, die als [[Hardware Abstraction Layer]] (HAL) bezeichnet wird. In TinyOS bzw. nesC gibt es zwei Arten von Components: '''Modules''' implementieren die einzelnen Funktionen der [[Schnittstelle]]n (zwischen den Components) und '''Configurations''' beschreiben mit Hilfe der Schnittstellen wie die einzelnen Components miteinander verbunden sind.

	== Einzelnachweise ==		== Einzelnachweise ==

PantheraLeo1359531: Gekürzt. Ein Open Source-OS, das quelloffen ist, ist eine Tautologie

2024-09-10T10:58:07Z

Gekürzt. Ein Open Source-OS, das quelloffen ist, ist eine Tautologie

← Nächstältere Version		Version vom 10. September 2024, 11:58 Uhr
Zeile 1:		Zeile 1:
	{{Belege fehlen\|}}		{{Belege fehlen\|}}

	'''TinyOS''' ist ein [[Open-Source]]-[[Betriebssystem]] für drahtlose [[Sensornetz]]e~~. Es handelt sich um ein quelloffenes Softwaresystem~~, ~~welches~~ ~~größtenteils~~ unter der [[BSD-Lizenz]] steht.		'''TinyOS''' ist ein [[Open-Source]]-[[Betriebssystem]] für drahtlose [[Sensornetz]]e, dessen Großteil unter der [[BSD-Lizenz]] steht.

	== Entwicklung ==		== Entwicklung ==

Duschgeldrache2: HC: Ergänze Kategorie:Sensorik

2024-07-22T01:34:53Z

HC: Ergänze Kategorie:Sensorik

← Nächstältere Version		Version vom 22. Juli 2024, 02:34 Uhr
Zeile 28:		Zeile 28:

	[[Kategorie:Freies Betriebssystem]]		[[Kategorie:Freies Betriebssystem]]
			[[Kategorie:Sensorik]]

Aka: https, Kleinkram

2022-12-26T15:28:00Z

https, Kleinkram

← Nächstältere Version		Version vom 26. Dezember 2022, 16:28 Uhr
Zeile 1:		Zeile 1:
	{{Belege fehlen\|}}		{{Belege fehlen\|}}

	'''TinyOS''' ist ein [[Open-Source]]-[[Betriebssystem]] für drahtlose [[Sensornetz]]e. Es handelt sich um ein quelloffenes Softwaresystem, welches größtenteils unter der [[BSD-Lizenz]] steht.		'''TinyOS''' ist ein [[Open-Source]]-[[Betriebssystem]] für drahtlose [[Sensornetz]]e. Es handelt sich um ein quelloffenes Softwaresystem, welches größtenteils unter der [[BSD-Lizenz]] steht.

	== Entwicklung ==		== Entwicklung ==
Zeile 12:		Zeile 12:

	== Technik ==		== Technik ==
	TinyOS nutzt eine komponentenbasierte Architektur (''component-based architecture'') und ein ereignisbasiertes Ausführungsmodell (''event-driven concurrency model''). Gleichzeitig stellt es auch eine Entwicklungsumgebung und Programmierplattform speziell für Hardwaresysteme mit knappen Ressourcen in Bezug auf Speicher, Rechenleistung und Energieverwendung dar, welche autonom und sicher über Zeiträume von Monaten oder Jahren zuverlässig funktionieren müssen.		TinyOS nutzt eine komponentenbasierte Architektur (''component-based architecture'') und ein ereignisbasiertes Ausführungsmodell (''event-driven concurrency model''). Gleichzeitig stellt es auch eine Entwicklungsumgebung und Programmierplattform speziell für Hardwaresysteme mit knappen Ressourcen in Bezug auf Speicher, Rechenleistung und Energieverwendung dar, welche autonom und sicher über Zeiträume von Monaten oder Jahren zuverlässig funktionieren müssen.

	Die „Philosophie“ des Betriebssystems ist es, die anstehenden Arbeiten so schnell wie möglich abzuarbeiten, um danach die Hardware in den Schlafmodus zu schicken. Die Umsetzung dieses Konzepts erreicht TinyOS durch eine ereignisgesteuerte Ausführung der in Komponenten (Components) gegliederten Programmteile, die über zweiphasige Operationen aufgerufen werden und somit keinen zusätzlichen Stack für das Zwischenspeichern benötigen.		Die „Philosophie“ des Betriebssystems ist es, die anstehenden Arbeiten so schnell wie möglich abzuarbeiten, um danach die Hardware in den Schlafmodus zu schicken. Die Umsetzung dieses Konzepts erreicht TinyOS durch eine ereignisgesteuerte Ausführung der in Komponenten (Components) gegliederten Programmteile, die über zweiphasige Operationen aufgerufen werden und somit keinen zusätzlichen Stack für das Zwischenspeichern benötigen.
Zeile 24:		Zeile 24:

	== Weblinks ==		== Weblinks ==
	* [~~http~~://github.com/tinyos/tinyos-main TinyOS auf GitHub] (engl.)		* [https://github.com/tinyos/tinyos-main TinyOS auf GitHub] (engl.)
	* [~~http~~://www.~~sensorsmag~~.com/~~networking~~-~~communications~~/tinyos-operating-system-design-wireless-sensor-networks~~-918~~ TinyOS-Artikel aus dem Magazin „sensors“] (englisch)		* [https://www.fierceelectronics.com/iot-wireless/tinyos-operating-system-design-for-wireless-sensor-networks TinyOS-Artikel aus dem Magazin „sensors“] (englisch)

	[[Kategorie:Freies Betriebssystem]]		[[Kategorie:Freies Betriebssystem]]

Qcomp: -tippfehler, +wikilinks

2022-12-06T10:44:23Z

-tippfehler, +wikilinks

← Nächstältere Version		Version vom 6. Dezember 2022, 11:44 Uhr
Zeile 4:		Zeile 4:

	== Entwicklung ==		== Entwicklung ==
	~~TinzOS~~ wurde an der [[University of California, Berkeley\|Universität Berkeley]] (Kalifornien, USA) von ~~Dr.~~ David Culler entwickelt und später vor allem durch die ~~Opensource~~ Community weiterentwickelt. Mittlerweile wurde eine Allianz, ähnlich der [[ZigBee]]-Alliance, gebildet, der Privatpersonen, Organisationen und Unternehmen aus Forschung, dem Dienstleistungssektor und der Industrie angehören. TinyOS hat eine große Verbreitung in der Forschungsgemeinde.		TinyOS wurde an der [[University of California, Berkeley\|Universität Berkeley]] (Kalifornien, USA) von David Culler entwickelt und später vor allem durch die Open-Source Community weiterentwickelt. Mittlerweile wurde eine Allianz, ähnlich der [[ZigBee]]-Alliance, gebildet, der Privatpersonen, Organisationen und Unternehmen aus Forschung, dem Dienstleistungssektor und der Industrie angehören. TinyOS hat eine große Verbreitung in der Forschungsgemeinde.

	== Versionen und Komponenten ==		== Versionen und Komponenten ==
	Mittlerweile existiert es in zwei stabilen Versionen, TinyOS 1.1.15 und TinyOS 2.0.1, wobei Version 2.x komplett überarbeitet wurde und Nachteile des Vorgängers eliminiert hat. Diese Versionen sind zueinander nicht kompatibel, d. h. bestehende Anwendungen müssen überarbeitet werden.		Mittlerweile existiert es in zwei stabilen Versionen, TinyOS 1.1.15 und TinyOS 2.0.1, wobei Version 2.x komplett überarbeitet wurde und Nachteile des Vorgängers eliminiert hat. Diese Versionen sind zueinander nicht kompatibel, d. h. bestehende Anwendungen müssen überarbeitet werden.

	TinyOS bietet von Haus aus neben einbindbaren Komponenten (Kommunikation über UISP, Timer, Scheduler etc.) und den bereitgestellten nesC-Compiler/-Linker einen Hardware- und Netzwerksimulator (TOSSIM), Hilfsmittel zur Sourcecode-Dokumentation und -Visualisierung ([[Graphviz]]), sowie Beispielapplikationen in Java wie etwa „SerialForwarder“ oder das Programm „Surge“ zur Netzwerkverbindungsanalyse.		TinyOS bietet von Haus aus neben einbindbaren Komponenten (Kommunikation über UISP, [[Timer]], [[Scheduler]] etc.) und den bereitgestellten [[nesC]]-Compiler/-Linker einen Hardware- und Netzwerksimulator (TOSSIM), Hilfsmittel zur Sourcecode-Dokumentation und -Visualisierung ([[Graphviz]]), sowie Beispielapplikationen in [[Java (Programmiersprache)\|Java]] wie etwa „SerialForwarder“ oder das Programm „Surge“ zur Netzwerkverbindungsanalyse.

	== Technik ==		== Technik ==
	TinyOS nutzt eine komponentenbasierte Architektur (component-based architecture) und ein ereignisbasiertes Ausführungsmodell (event-driven concurrency model). Gleichzeitig stellt es auch eine Entwicklungsumgebung und Programmierplattform speziell für Hardwaresysteme mit knappen Ressourcen in Bezug auf Speicher, Rechenleistung und Energieverwendung dar, welche autonom und sicher über Zeiträume von Monaten oder Jahren zuverlässig funktionieren müssen.		TinyOS nutzt eine komponentenbasierte Architektur (''component-based architecture'') und ein ereignisbasiertes Ausführungsmodell (''event-driven concurrency model''). Gleichzeitig stellt es auch eine Entwicklungsumgebung und Programmierplattform speziell für Hardwaresysteme mit knappen Ressourcen in Bezug auf Speicher, Rechenleistung und Energieverwendung dar, welche autonom und sicher über Zeiträume von Monaten oder Jahren zuverlässig funktionieren müssen.

	Die „Philosophie“ des Betriebssystems ist es, die anstehenden Arbeiten so schnell wie möglich abzuarbeiten, um danach die Hardware in den Schlafmodus zu schicken. Die Umsetzung dieses Konzepts erreicht TinyOS durch eine ereignisgesteuerte Ausführung der in Komponenten (Components) gegliederten Programmteile, die über zweiphasige Operationen aufgerufen werden und somit keinen zusätzlichen Stack für das Zwischenspeichern benötigen.		Die „Philosophie“ des Betriebssystems ist es, die anstehenden Arbeiten so schnell wie möglich abzuarbeiten, um danach die Hardware in den Schlafmodus zu schicken. Die Umsetzung dieses Konzepts erreicht TinyOS durch eine ereignisgesteuerte Ausführung der in Komponenten (Components) gegliederten Programmteile, die über zweiphasige Operationen aufgerufen werden und somit keinen zusätzlichen Stack für das Zwischenspeichern benötigen.
Zeile 18:		Zeile 18:
	Ursprünglich wurde TinyOS in der [[Programmiersprache]] [[C (Programmiersprache)\|C]] geschrieben. Doch das besondere Anwendungsgebiet machte es notwendig, ein neues Programmierkonzept zu entwerfen, welches das Betriebssystem optimal unterstützen konnte. Zu diesem Zweck wurde die Programmiersprache [[nesC]] geschaffen,<ref>{{Internetquelle \|url=https://www.enterprisenetworkingplanet.com/os/iot-operating-systems/ \|titel=Top IoT Operating Systems \|datum=2022-11-18 \|sprache=en-US \|abruf=2022-11-24}}</ref> welche wiederum so maßgeschneidert für die Programmierung von Sensorknoten entwickelt worden ist, dass TinyOS nochmals überarbeitet und komplett in nesC reimplementiert wurde. Somit wird die besondere Betriebssystem-Architektur optimal unterstützt.		Ursprünglich wurde TinyOS in der [[Programmiersprache]] [[C (Programmiersprache)\|C]] geschrieben. Doch das besondere Anwendungsgebiet machte es notwendig, ein neues Programmierkonzept zu entwerfen, welches das Betriebssystem optimal unterstützen konnte. Zu diesem Zweck wurde die Programmiersprache [[nesC]] geschaffen,<ref>{{Internetquelle \|url=https://www.enterprisenetworkingplanet.com/os/iot-operating-systems/ \|titel=Top IoT Operating Systems \|datum=2022-11-18 \|sprache=en-US \|abruf=2022-11-24}}</ref> welche wiederum so maßgeschneidert für die Programmierung von Sensorknoten entwickelt worden ist, dass TinyOS nochmals überarbeitet und komplett in nesC reimplementiert wurde. Somit wird die besondere Betriebssystem-Architektur optimal unterstützt.

	Für die Anwendungsentwicklung werden einzelne Komponenten (Components) für das jeweilige Anwendungsgebiet der Sensorknoten miteinander verknüpft und bilden somit im Endeffekt eine komplette Applikation, die über die UISP-Schnittstelle oder mittels Over-the-air-programming (OTAP) auf die Zielhardware aufgespielt wird. Elementare Components kapseln Hardwarekomponenten wie etwa die Funkschnittstelle oder den Timer und bilden somit in einem hierarchischen Komponentenmodell die unterste Ebene, die als Hardware Abstraction Layer (HAL) bezeichnet wird. In TinyOS bzw. nesC gibt es zwei Arten von Components: '''Modules''' implementieren die einzelnen Funktionen der [[Schnittstelle]]n (zwischen den Components) und '''Configurations''' beschreiben mit Hilfe der Schnittstellen wie die einzelnen Components miteinander verbunden sind.		Für die Anwendungsentwicklung werden einzelne Komponenten (Components) für das jeweilige Anwendungsgebiet der Sensorknoten miteinander verknüpft und bilden somit im Endeffekt eine komplette Applikation, die über die UISP-Schnittstelle oder mittels [[Over-the-Air-Update\|Over-the-air-programming]] (OTAP) auf die Zielhardware aufgespielt wird. Elementare Components kapseln Hardwarekomponenten wie etwa die Funkschnittstelle oder den Timer und bilden somit in einem hierarchischen Komponentenmodell die unterste Ebene, die als [[Hardware Abstraction Layer]] (HAL) bezeichnet wird. In TinyOS bzw. nesC gibt es zwei Arten von Components: '''Modules''' implementieren die einzelnen Funktionen der [[Schnittstelle]]n (zwischen den Components) und '''Configurations''' beschreiben mit Hilfe der Schnittstellen wie die einzelnen Components miteinander verbunden sind.

	== Einzelnachweise ==		== Einzelnachweise ==

88.8.15.217: Nachweise fehlen

2022-11-24T15:11:19Z

|Nachweise fehlen

← Nächstältere Version		Version vom 24. November 2022, 16:11 Uhr
Zeile 1:		Zeile 1:
			{{Belege fehlen\|}}

	'''TinyOS''' ist ein [[Open-Source]]-[[Betriebssystem]] für drahtlose [[Sensornetz]]e. Es handelt sich um ein quelloffenes Softwaresystem, welches größtenteils unter der [[BSD-Lizenz]] steht.		'''TinyOS''' ist ein [[Open-Source]]-[[Betriebssystem]] für drahtlose [[Sensornetz]]e. Es handelt sich um ein quelloffenes Softwaresystem, welches größtenteils unter der [[BSD-Lizenz]] steht.

Zeile 14:		Zeile 16:
	Die „Philosophie“ des Betriebssystems ist es, die anstehenden Arbeiten so schnell wie möglich abzuarbeiten, um danach die Hardware in den Schlafmodus zu schicken. Die Umsetzung dieses Konzepts erreicht TinyOS durch eine ereignisgesteuerte Ausführung der in Komponenten (Components) gegliederten Programmteile, die über zweiphasige Operationen aufgerufen werden und somit keinen zusätzlichen Stack für das Zwischenspeichern benötigen.		Die „Philosophie“ des Betriebssystems ist es, die anstehenden Arbeiten so schnell wie möglich abzuarbeiten, um danach die Hardware in den Schlafmodus zu schicken. Die Umsetzung dieses Konzepts erreicht TinyOS durch eine ereignisgesteuerte Ausführung der in Komponenten (Components) gegliederten Programmteile, die über zweiphasige Operationen aufgerufen werden und somit keinen zusätzlichen Stack für das Zwischenspeichern benötigen.

	Ursprünglich wurde TinyOS in der [[Programmiersprache]] [[C (Programmiersprache)\|C]] geschrieben. Doch das besondere Anwendungsgebiet machte es notwendig, ein neues Programmierkonzept zu entwerfen, welches das Betriebssystem optimal unterstützen konnte. Zu diesem Zweck wurde die Programmiersprache [[nesC]] geschaffen, welche wiederum so maßgeschneidert für die Programmierung von Sensorknoten entwickelt worden ist, dass TinyOS nochmals überarbeitet und komplett in nesC reimplementiert wurde. Somit wird die besondere Betriebssystem-Architektur optimal unterstützt.		Ursprünglich wurde TinyOS in der [[Programmiersprache]] [[C (Programmiersprache)\|C]] geschrieben. Doch das besondere Anwendungsgebiet machte es notwendig, ein neues Programmierkonzept zu entwerfen, welches das Betriebssystem optimal unterstützen konnte. Zu diesem Zweck wurde die Programmiersprache [[nesC]] geschaffen,<ref>{{Internetquelle \|url=https://www.enterprisenetworkingplanet.com/os/iot-operating-systems/ \|titel=Top IoT Operating Systems \|datum=2022-11-18 \|sprache=en-US \|abruf=2022-11-24}}</ref> welche wiederum so maßgeschneidert für die Programmierung von Sensorknoten entwickelt worden ist, dass TinyOS nochmals überarbeitet und komplett in nesC reimplementiert wurde. Somit wird die besondere Betriebssystem-Architektur optimal unterstützt.

	Für die Anwendungsentwicklung werden einzelne Komponenten (Components) für das jeweilige Anwendungsgebiet der Sensorknoten miteinander verknüpft und bilden somit im Endeffekt eine komplette Applikation, die über die UISP-Schnittstelle oder mittels Over-the-air-programming (OTAP) auf die Zielhardware aufgespielt wird. Elementare Components kapseln Hardwarekomponenten wie etwa die Funkschnittstelle oder den Timer und bilden somit in einem hierarchischen Komponentenmodell die unterste Ebene, die als Hardware Abstraction Layer (HAL) bezeichnet wird. In TinyOS bzw. nesC gibt es zwei Arten von Components: '''Modules''' implementieren die einzelnen Funktionen der [[Schnittstelle]]n (zwischen den Components) und '''Configurations''' beschreiben mit Hilfe der Schnittstellen wie die einzelnen Components miteinander verbunden sind.		Für die Anwendungsentwicklung werden einzelne Komponenten (Components) für das jeweilige Anwendungsgebiet der Sensorknoten miteinander verknüpft und bilden somit im Endeffekt eine komplette Applikation, die über die UISP-Schnittstelle oder mittels Over-the-air-programming (OTAP) auf die Zielhardware aufgespielt wird. Elementare Components kapseln Hardwarekomponenten wie etwa die Funkschnittstelle oder den Timer und bilden somit in einem hierarchischen Komponentenmodell die unterste Ebene, die als Hardware Abstraction Layer (HAL) bezeichnet wird. In TinyOS bzw. nesC gibt es zwei Arten von Components: '''Modules''' implementieren die einzelnen Funktionen der [[Schnittstelle]]n (zwischen den Components) und '''Configurations''' beschreiben mit Hilfe der Schnittstellen wie die einzelnen Components miteinander verbunden sind.

			== Einzelnachweise ==
			<references />

	== Weblinks ==		== Weblinks ==

88.8.15.217 am 24. November 2022 um 15:08 Uhr

2022-11-24T15:08:28Z

← Nächstältere Version		Version vom 24. November 2022, 16:08 Uhr
Zeile 4:		Zeile 4:
	TinzOS wurde an der [[University of California, Berkeley\|Universität Berkeley]] (Kalifornien, USA) von Dr. David Culler entwickelt und später vor allem durch die Opensource Community weiterentwickelt. Mittlerweile wurde eine Allianz, ähnlich der [[ZigBee]]-Alliance, gebildet, der Privatpersonen, Organisationen und Unternehmen aus Forschung, dem Dienstleistungssektor und der Industrie angehören. TinyOS hat eine große Verbreitung in der Forschungsgemeinde.		TinzOS wurde an der [[University of California, Berkeley\|Universität Berkeley]] (Kalifornien, USA) von Dr. David Culler entwickelt und später vor allem durch die Opensource Community weiterentwickelt. Mittlerweile wurde eine Allianz, ähnlich der [[ZigBee]]-Alliance, gebildet, der Privatpersonen, Organisationen und Unternehmen aus Forschung, dem Dienstleistungssektor und der Industrie angehören. TinyOS hat eine große Verbreitung in der Forschungsgemeinde.

	== Versionen ==		== Versionen und Komponenten ==
	Mittlerweile existiert es in zwei stabilen Versionen, TinyOS 1.1.15 und TinyOS 2.0.1, wobei Version 2.x komplett überarbeitet wurde und Nachteile des Vorgängers eliminiert hat. Diese Versionen sind zueinander nicht kompatibel, d. h. bestehende Anwendungen müssen überarbeitet werden.		Mittlerweile existiert es in zwei stabilen Versionen, TinyOS 1.1.15 und TinyOS 2.0.1, wobei Version 2.x komplett überarbeitet wurde und Nachteile des Vorgängers eliminiert hat. Diese Versionen sind zueinander nicht kompatibel, d. h. bestehende Anwendungen müssen überarbeitet werden.

		⚫	TinyOS bietet von Haus aus neben einbindbaren Komponenten (Kommunikation über UISP, Timer, Scheduler etc.) und den bereitgestellten nesC-Compiler/-Linker einen Hardware- und Netzwerksimulator (TOSSIM), Hilfsmittel zur Sourcecode-Dokumentation und -Visualisierung ([[Graphviz]]), sowie Beispielapplikationen in Java wie etwa „SerialForwarder“ oder das Programm „Surge“ zur Netzwerkverbindungsanalyse.

	== Technik ==		== Technik ==
Zeile 15:		Zeile 17:

	Für die Anwendungsentwicklung werden einzelne Komponenten (Components) für das jeweilige Anwendungsgebiet der Sensorknoten miteinander verknüpft und bilden somit im Endeffekt eine komplette Applikation, die über die UISP-Schnittstelle oder mittels Over-the-air-programming (OTAP) auf die Zielhardware aufgespielt wird. Elementare Components kapseln Hardwarekomponenten wie etwa die Funkschnittstelle oder den Timer und bilden somit in einem hierarchischen Komponentenmodell die unterste Ebene, die als Hardware Abstraction Layer (HAL) bezeichnet wird. In TinyOS bzw. nesC gibt es zwei Arten von Components: '''Modules''' implementieren die einzelnen Funktionen der [[Schnittstelle]]n (zwischen den Components) und '''Configurations''' beschreiben mit Hilfe der Schnittstellen wie die einzelnen Components miteinander verbunden sind.		Für die Anwendungsentwicklung werden einzelne Komponenten (Components) für das jeweilige Anwendungsgebiet der Sensorknoten miteinander verknüpft und bilden somit im Endeffekt eine komplette Applikation, die über die UISP-Schnittstelle oder mittels Over-the-air-programming (OTAP) auf die Zielhardware aufgespielt wird. Elementare Components kapseln Hardwarekomponenten wie etwa die Funkschnittstelle oder den Timer und bilden somit in einem hierarchischen Komponentenmodell die unterste Ebene, die als Hardware Abstraction Layer (HAL) bezeichnet wird. In TinyOS bzw. nesC gibt es zwei Arten von Components: '''Modules''' implementieren die einzelnen Funktionen der [[Schnittstelle]]n (zwischen den Components) und '''Configurations''' beschreiben mit Hilfe der Schnittstellen wie die einzelnen Components miteinander verbunden sind.

⚫	TinyOS bietet von Haus aus neben einbindbaren Komponenten (Kommunikation über UISP, Timer, Scheduler etc.) und den bereitgestellten nesC-Compiler/-Linker einen Hardware- und Netzwerksimulator (TOSSIM), Hilfsmittel zur Sourcecode-Dokumentation und -Visualisierung ([[Graphviz]]), sowie Beispielapplikationen in Java wie etwa „SerialForwarder“ oder das Programm „Surge“ zur Netzwerkverbindungsanalyse.

	== Weblinks ==		== Weblinks ==

88.8.15.217 am 24. November 2022 um 15:06 Uhr

2022-11-24T15:06:39Z

← Nächstältere Version		Version vom 24. November 2022, 16:06 Uhr
Zeile 3:		Zeile 3:
	== Entwicklung ==		== Entwicklung ==
	TinzOS wurde an der [[University of California, Berkeley\|Universität Berkeley]] (Kalifornien, USA) von Dr. David Culler entwickelt und später vor allem durch die Opensource Community weiterentwickelt. Mittlerweile wurde eine Allianz, ähnlich der [[ZigBee]]-Alliance, gebildet, der Privatpersonen, Organisationen und Unternehmen aus Forschung, dem Dienstleistungssektor und der Industrie angehören. TinyOS hat eine große Verbreitung in der Forschungsgemeinde.		TinzOS wurde an der [[University of California, Berkeley\|Universität Berkeley]] (Kalifornien, USA) von Dr. David Culler entwickelt und später vor allem durch die Opensource Community weiterentwickelt. Mittlerweile wurde eine Allianz, ähnlich der [[ZigBee]]-Alliance, gebildet, der Privatpersonen, Organisationen und Unternehmen aus Forschung, dem Dienstleistungssektor und der Industrie angehören. TinyOS hat eine große Verbreitung in der Forschungsgemeinde.

			== Versionen ==
			Mittlerweile existiert es in zwei stabilen Versionen, TinyOS 1.1.15 und TinyOS 2.0.1, wobei Version 2.x komplett überarbeitet wurde und Nachteile des Vorgängers eliminiert hat. Diese Versionen sind zueinander nicht kompatibel, d. h. bestehende Anwendungen müssen überarbeitet werden.

	== Technik ==		== Technik ==

88.8.15.217 am 24. November 2022 um 15:06 Uhr

2022-11-24T15:06:31Z

← Nächstältere Version		Version vom 24. November 2022, 16:06 Uhr
Zeile 1:		Zeile 1:
	'''TinyOS''' ist ein [[Open-Source]]-[[Betriebssystem]] für drahtlose [[Sensornetz]]e. Es handelt sich um ein quelloffenes Softwaresystem, welches größtenteils unter der [[BSD-Lizenz]] steht. Mittlerweile existiert es in zwei stabilen Versionen, TinyOS 1.1.15 und TinyOS 2.0.1, wobei Version 2.x komplett überarbeitet wurde und Nachteile des Vorgängers eliminiert hat. Diese Versionen sind zueinander nicht kompatibel, d. h. bestehende Anwendungen müssen überarbeitet werden.		'''TinyOS''' ist ein [[Open-Source]]-[[Betriebssystem]] für drahtlose [[Sensornetz]]e. Es handelt sich um ein quelloffenes Softwaresystem, welches größtenteils unter der [[BSD-Lizenz]] steht.

			== Entwicklung ==
	Es wurde an der Universität Berkeley (Kalifornien, USA) von Dr. David Culler entwickelt und später vor allem durch die Opensource Community weiterentwickelt. Mittlerweile wurde eine Allianz, ähnlich der [[ZigBee]]-Alliance, gebildet, der Privatpersonen, Organisationen und Unternehmen aus Forschung, dem Dienstleistungssektor und der Industrie angehören. TinyOS hat eine große Verbreitung in der Forschungsgemeinde.		TinzOS wurde an der [[University of California, Berkeley\|Universität Berkeley]] (Kalifornien, USA) von Dr. David Culler entwickelt und später vor allem durch die Opensource Community weiterentwickelt. Mittlerweile wurde eine Allianz, ähnlich der [[ZigBee]]-Alliance, gebildet, der Privatpersonen, Organisationen und Unternehmen aus Forschung, dem Dienstleistungssektor und der Industrie angehören. TinyOS hat eine große Verbreitung in der Forschungsgemeinde.

	== Technik ==		== Technik ==

Invisigoth67: typo, form

2019-05-08T15:22:19Z

typo, form

← Nächstältere Version		Version vom 8. Mai 2019, 16:22 Uhr
Zeile 8:		Zeile 8:
	Die „Philosophie“ des Betriebssystems ist es, die anstehenden Arbeiten so schnell wie möglich abzuarbeiten, um danach die Hardware in den Schlafmodus zu schicken. Die Umsetzung dieses Konzepts erreicht TinyOS durch eine ereignisgesteuerte Ausführung der in Komponenten (Components) gegliederten Programmteile, die über zweiphasige Operationen aufgerufen werden und somit keinen zusätzlichen Stack für das Zwischenspeichern benötigen.		Die „Philosophie“ des Betriebssystems ist es, die anstehenden Arbeiten so schnell wie möglich abzuarbeiten, um danach die Hardware in den Schlafmodus zu schicken. Die Umsetzung dieses Konzepts erreicht TinyOS durch eine ereignisgesteuerte Ausführung der in Komponenten (Components) gegliederten Programmteile, die über zweiphasige Operationen aufgerufen werden und somit keinen zusätzlichen Stack für das Zwischenspeichern benötigen.

	Ursprünglich wurde TinyOS in der [[Programmiersprache]] [[C (Programmiersprache) \| C]] geschrieben. Doch das besondere Anwendungsgebiet machte es notwendig, ein neues Programmierkonzept zu entwerfen, welches das Betriebssystem optimal unterstützen konnte. Zu diesem Zweck wurde die Programmiersprache [[nesC]] geschaffen, welche wiederum so maßgeschneidert für die Programmierung von Sensorknoten entwickelt worden ist, dass TinyOS nochmals überarbeitet und komplett in nesC reimplementiert wurde. Somit wird die besondere Betriebssystem-Architektur optimal unterstützt.		Ursprünglich wurde TinyOS in der [[Programmiersprache]] [[C (Programmiersprache)\|C]] geschrieben. Doch das besondere Anwendungsgebiet machte es notwendig, ein neues Programmierkonzept zu entwerfen, welches das Betriebssystem optimal unterstützen konnte. Zu diesem Zweck wurde die Programmiersprache [[nesC]] geschaffen, welche wiederum so maßgeschneidert für die Programmierung von Sensorknoten entwickelt worden ist, dass TinyOS nochmals überarbeitet und komplett in nesC reimplementiert wurde. Somit wird die besondere Betriebssystem-Architektur optimal unterstützt.

	Für die Anwendungsentwicklung werden einzelne Komponenten (Components) für das jeweilige Anwendungsgebiet der Sensorknoten miteinander verknüpft und bilden somit im Endeffekt eine komplette Applikation, die über die UISP-Schnittstelle oder mittels Over-the-air-programming (OTAP) auf die Zielhardware aufgespielt wird. Elementare Components kapseln Hardwarekomponenten wie etwa die Funkschnittstelle oder den Timer und bilden somit in einem hierarchischen Komponentenmodell die unterste Ebene, die als Hardware Abstraction Layer (HAL) bezeichnet wird. In TinyOS bzw. nesC gibt es zwei Arten von Components: '''Modules''' implementieren die einzelnen Funktionen der [[Schnittstelle]]n (zwischen den Components) und '''Configurations''' beschreiben mit Hilfe der Schnittstellen wie die einzelnen Components miteinander verbunden sind.		Für die Anwendungsentwicklung werden einzelne Komponenten (Components) für das jeweilige Anwendungsgebiet der Sensorknoten miteinander verknüpft und bilden somit im Endeffekt eine komplette Applikation, die über die UISP-Schnittstelle oder mittels Over-the-air-programming (OTAP) auf die Zielhardware aufgespielt wird. Elementare Components kapseln Hardwarekomponenten wie etwa die Funkschnittstelle oder den Timer und bilden somit in einem hierarchischen Komponentenmodell die unterste Ebene, die als Hardware Abstraction Layer (HAL) bezeichnet wird. In TinyOS bzw. nesC gibt es zwei Arten von Components: '''Modules''' implementieren die einzelnen Funktionen der [[Schnittstelle]]n (zwischen den Components) und '''Configurations''' beschreiben mit Hilfe der Schnittstellen wie die einzelnen Components miteinander verbunden sind.

	TinyOS bietet von Haus aus neben einbindbaren Komponenten (Kommunikation über UISP, Timer, Scheduler, etc.) und den bereitgestellten nesC-Compiler/-Linker einen Hardware- und Netzwerksimulator (TOSSIM), Hilfsmittel zur Sourcecode-Dokumentation und -Visualisierung ([[Graphviz]]), sowie Beispielapplikationen in Java wie etwa „SerialForwarder“ oder das Programm „Surge“ zur Netzwerkverbindungsanalyse.		TinyOS bietet von Haus aus neben einbindbaren Komponenten (Kommunikation über UISP, Timer, Scheduler etc.) und den bereitgestellten nesC-Compiler/-Linker einen Hardware- und Netzwerksimulator (TOSSIM), Hilfsmittel zur Sourcecode-Dokumentation und -Visualisierung ([[Graphviz]]), sowie Beispielapplikationen in Java wie etwa „SerialForwarder“ oder das Programm „Surge“ zur Netzwerkverbindungsanalyse.

	== Weblinks ==		== Weblinks ==