Peripheral
public class Peripheral
Peripheral is a class implementing ReactiveX API which wraps all Core Bluetooth functions allowing to talk to peripheral like discovering characteristics, services and all of the read/write calls.
-
Undocumented
Declaration
Swift
public let manager: BluetoothManager
-
Continuous value indicating if peripheral is in connected state. This is continuous value, which first emits
.Next
with current state, and later whenever state change occursDeclaration
Swift
public var rx_isConnected: Observable<Bool>
-
Value indicating if peripheral is currently in connected state.
Declaration
Swift
public var isConnected: Bool
-
Underlying
CBPeripheral
instanceDeclaration
Swift
public var cbPeripheral: CBPeripheral
-
Current state of
Peripheral
instance described by CBPeripheralState.Declaration
Swift
public var state: CBPeripheralState
Return Value
Current state of
Peripheral
asCBPeripheralState
. -
Current name of
Peripheral
instance. Analogous to name ofCBPeripheral
.Declaration
Swift
public var name: String?
-
Unique identifier of
Peripheral
instance. Assigned once peripheral is discovered by the system.Declaration
Swift
public var identifier: UUID
-
Unique identifier of
Peripheral
object instance. Should be removed in 4.0Declaration
Swift
public var objectId: UInt
-
Establishes local connection to the peripheral. For more information look into
BluetoothManager.connectToPeripheral(_:options:)
because this method calls it directly.Declaration
Swift
public func connect(options: [String: AnyObject]? = nil) -> Observable<Peripheral>
Parameters
peripheral
The
Peripheral
to whichBluetoothManager
is attempting to connect.options
Dictionary to customise the behaviour of connection.
Return Value
Observation which emits next event after connection is established
-
Cancels an active or pending local connection to a
Peripheral
after observable subscription. It is not guaranteed that physical connection will be closed immediately as well and all pending commands will not be executed.Declaration
Swift
public func cancelConnection() -> Observable<Peripheral>
Return Value
Observable which emits next and complete events when peripheral successfully cancelled connection.
-
Triggers discover of specified services of peripheral. If the servicesUUIDs parameter is nil, all the available services of the peripheral are returned; setting the parameter to nil is considerably slower and is not recommended. If all of the specified services are already discovered - these are returned without doing any underlying Bluetooth operations. Next on returned
Observable
is emitted only when all of the requested services are discovered.Declaration
Swift
public func discoverServices(_ serviceUUIDs: [CBUUID]?) -> Observable<[Service]>
Parameters
serviceUUIDs
Return Value
Observable that emits
Next
with array ofService
instances, once they’re discovered. Immediately after that.Complete
is emitted. -
Function that triggers included services discovery for specified services. Discovery is called after subscribtion to
Observable
is made. If all of the specified included services are already discovered - these are returned without doing any underlying Bluetooth operations. Next on returnedObservable
is emitted only when all of the requested included services are discovered.Declaration
Parameters
includedServiceUUIDs
Identifiers of included services that should be discovered. If
nil
- all of the included services will be discovered. If you’ll pass empty array - none of them will be discovered.forService
Service of which included services should be discovered.
Return Value
Observable that emits
Next
with array ofService
instances, once they’re discovered. Immediately after that.Complete
is emitted.
-
Function that triggers characteristics discovery for specified Services and identifiers. Discovery is called after subscribtion to
Observable
is made. If all of the specified characteristics are already discovered - these are returned without doing any underlying Bluetooth operations. Next on returnedObservable
is emitted only when all of the requested characteristics are discovered.Declaration
Swift
public func discoverCharacteristics(_ characteristicUUIDs: [CBUUID]?, for service: Service) -> Observable<[Characteristic]>
Parameters
characteristicUUIDs
Identifiers of characteristics that should be discovered. If
nil
- all of the characteristics will be discovered. If you’ll pass empty array - none of them will be discovered.service
Service of which characteristics should be discovered. Immediately after that
.Complete
is emitted. -
Function that allow to monitor writes that happened for characteristic.
Declaration
Swift
public func monitorWrite(for characteristic: Characteristic) -> Observable<Characteristic>
Parameters
characteristic
Characteristic of which value writes should be monitored.
Return Value
Observable that emits
Next
withCharacteristic
instance every time when write has happened. It’s infinite stream, so.Complete
is never called. -
@method maximumWriteValueLengthForType: @discussion The maximum amount of data, in bytes, that can be sent to a characteristic in a single write type. @see writeValue:forCharacteristic:type:
Declaration
Swift
public func maximumWriteValueLength(for type: CBCharacteristicWriteType) -> Int
-
Function that triggers write of data to characteristic. Write is called after subscribtion to
Observable
is made. Behavior of this function strongly depends on CBCharacteristicWriteType, so be sure to check this out before usage of the method.withResponse
- Observable emitsNext
withCharacteristic
instance write was confirmed without any errors. Immediately after thatComplete
is called. If any problem has happened, errors are emitted.withoutResponse
- Observable emitsNext
withCharacteristic
instance once write was called. Immediately after that.Complete
is called. Result of this call is not checked, so as a user you are not sure if everything completed successfully. Errors are not emitted
Declaration
Swift
public func writeValue(_ data: Data, for characteristic: Characteristic, type: CBCharacteristicWriteType) -> Observable<Characteristic>
Parameters
data
Data that’ll be written written to
Characteristic
instanceforCharacteristic
Characteristic
instance to write value to.type
Type of write operation. Possible values:
.WithResponse
,.WithoutResponse
Return Value
Observable that emition depends on
CBCharacteristicWriteType
passed to the function call. Behavior is following: -
Function that allow to monitor value updates for
Characteristic
instance.Declaration
Swift
public func monitorValueUpdate(for characteristic: Characteristic) -> Observable<Characteristic>
Parameters
characteristic
Characteristic of which value changes should be monitored.
Return Value
Observable that emits
Next
withCharacteristic
instance every time when value has changed. It’s infinite stream, so.Complete
is never called. -
Function that triggers read of current value of the
Characteristic
instance. Read is called after subscription toObservable
is made.Declaration
Swift
public func readValue(for characteristic: Characteristic) -> Observable<Characteristic>
Parameters
characteristic
Characteristic
to read value fromReturn Value
Observable which emits
Next
with given characteristic when value is ready to read. Immediately after that.Complete
is emitted. -
Function that triggers set of notification state of the
Characteristic
. This change is called after subscribtion toObservable
is made.Warning
This method is not responsible for emitting values every time thatCharacteristic
value is changed. For this, refer to other method:monitorValueUpdateForCharacteristic(_)
. These two are often called together.Declaration
Swift
public func setNotifyValue(_ enabled: Bool, for characteristic: Characteristic) -> Observable<Characteristic>
Parameters
enabled
New value of notifications state. Specify
true
if you’re interested in getting valuesforCharacteristic
Characterististic of which notification state needs to be changed
Return Value
Observable which emits
Next
with Characteristic that state was changed. Immediately after.Complete
is emitted -
Function that triggers set of notification state of the
Characteristic
, and monitor for any incoming updates. Notification is set after subscribtion toObservable
is made.Declaration
Swift
public func setNotificationAndMonitorUpdates(for characteristic: Characteristic) -> Observable<Characteristic>
Parameters
characteristic
Characterististic on which notification should be made.
Return Value
Observable which emits
Next
, when characteristic value is updated. This is infinite stream of values.
-
Function that triggers descriptors discovery for characteristic If all of the descriptors are already discovered - these are returned without doing any underlying Bluetooth operations.
Declaration
Swift
public func discoverDescriptors(for characteristic: Characteristic) -> Observable<[Descriptor]>
Parameters
characteristic
Characteristic
instance for which descriptors should be discovered.Return Value
Observable that emits
Next
with array ofDescriptor
instances, once they’re discovered. Immediately after that.Complete
is emitted. -
Function that allow to monitor writes that happened for descriptor.
Declaration
Swift
public func monitorWrite(for descriptor: Descriptor) -> Observable<Descriptor>
Parameters
descriptor
Descriptor of which value writes should be monitored.
Return Value
Observable that emits
Next
withDescriptor
instance every time when write has happened. It’s infinite stream, so.Complete
is never called. -
Function that allow to monitor value updates for
Descriptor
instance.Declaration
Swift
public func monitorValueUpdate(for descriptor: Descriptor) -> Observable<Descriptor>
Parameters
descriptor
Descriptor of which value changes should be monitored.
Return Value
Observable that emits
Next
withDescriptor
instance every time when value has changed. It’s infinite stream, so.Complete
is never called. -
Function that triggers read of current value of the
Descriptor
instance. Read is called after subscription toObservable
is made.Declaration
Swift
public func readValue(for descriptor: Descriptor) -> Observable<Descriptor>
Parameters
descriptor
Descriptor
to read value fromReturn Value
Observable which emits
Next
with given descriptor when value is ready to read. Immediately after that.Complete
is emitted. -
Function that triggers write of data to descriptor. Write is called after subscribtion to
Observable
is made.Declaration
Swift
public func writeValue(_ data: Data, for descriptor: Descriptor) -> Observable<Descriptor>
Parameters
data
Data
that’ll be written toDescriptor
instancedescriptor
Descriptor
instance to write value to.Return Value
Observable that emits
Next
withDescriptor
instance, once value is written successfully. Immediately after that.Complete
is emitted. -
Function that triggers read of
Peripheral
RSSI value. Read is called after subscription toObservable
is made.Declaration
Swift
public func readRSSI() -> Observable<(Peripheral, Int)>
Return Value
Observable that emits tuple:
(Peripheral, Int)
once new RSSI value is read, and just after that.Complete
event.Int
is new RSSI value,Peripheral
is returned to allow easier chaining. -
Function that allow user to monitor incoming
name
property changes ofPeripheral
instance.Declaration
Swift
public func monitorNameUpdate() -> Observable<(Peripheral, String?)>
Return Value
Observable that emits tuples:
(Peripheral, String?)
when name has changed. It’soptional String
because peripheral could also lost his name. It’s infinite stream of values, so.Complete
is never emitted. -
Function that allow to monitor incoming service modifications for
Peripheral
instance. In case you’re interested what exact changes might occur - please refer to Apple DocumentationDeclaration
Swift
public func monitorServicesModification() -> Observable<(Peripheral, [Service])>
Return Value
Observable that emits tuples:
(Peripheral, [Service])
when services were modified. It’s infinite stream of values, so.Complete
is never emitted.
-
Function used to receive service with given identifier. It’s taken from cache if it’s available, or directly by
discoverServices
callDeclaration
Swift
public func service(with identifier: ServiceIdentifier) -> Observable<Service>
Parameters
identifier
Unique identifier of Service
Return Value
Observation which emits
Next
event, when specified service has been found. Immediately after that.Complete
is emitted. -
Function used to receive characteristic with given identifier. If it’s available it’s taken from cache. Otherwise - directly by
discoverCharacteristics
callDeclaration
Swift
public func characteristic(with identifier: CharacteristicIdentifier) -> Observable<Characteristic>
Parameters
identifier
Unique identifier of Characteristic, that has information about service which characteristic belongs to.
Return Value
Observation which emits
Next
event, when specified characteristic has been found. Immediately after that.Complete
is emitted. -
Function used to receive descriptor with given identifier. If it’s available it’s taken from cache. Otherwise - directly by
discoverDescriptor
callDeclaration
Swift
public func descriptor(with identifier: DescriptorIdentifier) -> Observable<Descriptor>
Parameters
identifier
Unique identifier of Descriptor, that has information about characteristic which descriptor belongs to.
Return Value
Observation which emits
Next
event, when specified descriptor has been found. Immediately after that.Complete
is emitted. -
Function that allow to monitor writes that happened for characteristic.
Declaration
Swift
public func monitorWrite(for identifier: CharacteristicIdentifier) -> Observable<Characteristic>
Parameters
identifier
Identifier of characteristic of which value writes should be monitored.
Return Value
Observable that emits
Next
withCharacteristic
instance every time when write has happened. It’s infinite stream, so.Complete
is never called. -
Function that triggers write of data to characteristic. Write is called after subscribtion to
Observable
is made. Behavior of this function strongly depends on CBCharacteristicWriteType, so be sure to check this out before usage of the method.WithResponse
- Observable emitsNext
withCharacteristic
instance write was confirmed without any errors. Immediately after thatComplete
is called. If any problem has happened, errors are emitted.WithoutResponse
- Observable emitsNext
withCharacteristic
instance once write was called. Immediately after that.Complete
is called. Result of this call is not checked, so as a user you are not sure if everything completed successfully. Errors are not emitted
Declaration
Swift
public func writeValue(_ data: Data, for identifier: CharacteristicIdentifier, type: CBCharacteristicWriteType) -> Observable<Characteristic>
Parameters
data
Data that’ll be written written to
Characteristic
instanceforCharacteristicWithIdentifier
unique identifier of service, which also holds information about service characteristic belongs to.
Descriptor
instance to write value to.type
Type of write operation. Possible values:
.WithResponse
,.WithoutResponse
Return Value
Observable that emition depends on
CBCharacteristicWriteType
passed to the function call. Behavior is following: -
Function that allow to monitor value updates for
Characteristic
instance.Declaration
Swift
public func monitorValueUpdate(for identifier: CharacteristicIdentifier) -> Observable<Characteristic>
Parameters
identifier
unique identifier of service, which also holds information about service that characteristic belongs to.
Return Value
Observable that emits
Next
withCharacteristic
instance every time when value has changed. It’s infinite stream, so.Complete
is never called. -
Function that triggers read of current value of the
Characteristic
instance. Read is called after subscription toObservable
is made.Declaration
Swift
public func readValue(for identifier: CharacteristicIdentifier) -> Observable<Characteristic>
Parameters
identifier
unique identifier of service, which also holds information about service that characteristic belongs to.
Return Value
Observable which emits
Next
with given characteristic when value is ready to read. Immediately after that.Complete
is emitted. -
Function that triggers set of notification state of the
Characteristic
. This change is called after subscribtion toObservable
is made.Warning
This method is not responsible for emitting values every time thatCharacteristic
value is changed. For this, refer to other method:monitorValueUpdateForCharacteristic(_)
. These two are often called together.Declaration
Swift
public func setNotifyValue(_ enabled: Bool, for identifier: CharacteristicIdentifier) -> Observable<Characteristic>
Parameters
enabled
New value of notifications state. Specify
true
if you’re interested in getting valuesidentifier
unique identifier of service, which also holds information about service that characteristic belongs to.
Return Value
Observable which emits
Next
with Characteristic that state was changed. Immediately after.Complete
is emitted -
Function that triggers set of notification state of the
Characteristic
, and monitor for any incoming updates. Notification is set after subscribtion toObservable
is made.Declaration
Swift
public func setNotificationAndMonitorUpdates(for identifier: CharacteristicIdentifier) -> Observable<Characteristic>
Parameters
identifier
unique identifier of service, which also holds information about service that characteristic belongs to.
Return Value
Observable which emits
Next
, when characteristic value is updated. This is infinite stream of values. -
Function that triggers descriptors discovery for characteristic
Declaration
Swift
public func discoverDescriptors(for identifier: CharacteristicIdentifier) -> Observable<[Descriptor]>
Parameters
characteristic
Characteristic
instance for which descriptors should be discovered.identifier
unique identifier of descriptor, which also holds information about characteristic that descriptor belongs to.
Return Value
Observable that emits
Next
with array ofDescriptor
instances, once they’re discovered. Immediately after that.Complete
is emitted. -
Function that allow to monitor writes that happened for descriptor.
Declaration
Swift
public func monitorWrite(for identifier: DescriptorIdentifier) -> Observable<Descriptor>
Parameters
identifier
unique identifier of descriptor, which also holds information about characteristic that descriptor belongs to.
Return Value
Observable that emits
Next
withDescriptor
instance every time when write has happened. It’s infinite stream, so.Complete
is never called. -
Function that triggers write of data to descriptor. Write is called after subscribtion to
Observable
is made.Declaration
Swift
public func writeValue(_ data: Data, for identifier: DescriptorIdentifier) -> Observable<Descriptor>
Parameters
data
Data
that’ll be written toDescriptor
instanceidentifier
unique identifier of descriptor, which also holds information about characteristic that descriptor belongs to.
Return Value
Observable that emits
Next
withDescriptor
instance, once value is written successfully. Immediately after that.Complete
is emitted. -
Function that allow to monitor value updates for
Descriptor
instance.Declaration
Swift
public func monitorValueUpdate(for identifier: DescriptorIdentifier) -> Observable<Descriptor>
Parameters
identifier
unique identifier of descriptor, which also holds information about characteristic that descriptor belongs to.
Return Value
Observable that emits
Next
withDescriptor
instance every time when value has changed. It’s infinite stream, so.Complete
is never called. -
Function that triggers read of current value of the
Descriptor
instance. Read is called after subscription toObservable
is made.Declaration
Swift
public func readValue(for identifier: DescriptorIdentifier) -> Observable<Descriptor>
Parameters
descriptor
Descriptor
to read value fromReturn Value
Observable which emits
Next
with given descriptor when value is ready to read. Immediately after that.Complete
is emitted.


Disclaimer: I claim no ownership of any resources listed below. I have copied a few of them onto this site for your convenience. There is a link to the source on each page that I copied.
Rocket Calculator
This is a little program that will tell you the best way to build a rocket for the requirements that you set it. Build yourself a payload, then tell it how far you need to take it (in dv).
Visit the site.
Delta-V Map 1
I like this map better. It shows the total delta-V needed to reach any destination, as well as the amount of dV used by each leg of the journey. Unfortunately, round trips don't seem to be pre-calculated, but half the work has still be done for you.
View my copy.
Delta-V Map 2
This is another map for those who don't like the first one. The formatting is still nice and clean, but there's just something that looks nicer about Map 1 to me. Feel free to check both and see which one you like better.
View my copy.
Interactive Delta-V Planner
This interactive planner lets you click on starting and ending locations, and shows you how much dV is required to reach that destination. Be warned, however, that aerobraking around any planet whose atmosphere is at least as dense as Kerbin's probably can't bring you safely from super-orbital speeds. Some fuel usage will be required, without large heat shields.
Visit the Site.
How do I get there?
If you're struggling to figure out the correct launch angle to get from LKO to another planet, this is the resource for you. It shows you ejection angles, and what angle Kerbin should be relative to your destination. You can even choose to start at other planets if you prefer.
Visit the Site.
When should I launch?
This resource has you plug in the earliest date you can launch, and then spits out the next optimal window to reach whatever planet you tell it you need to reach, complete with a generated chart to show you how your dV usage would change if you launched at a different nearby time.
Visit the Site.
Visual Airplane Guide
This is a very well-written guide to building airplanes. The copy that I have here has been chopped up into smaller pages, and has the innacurate bits removed that related to Kerbin's atmosphere (which as of 1.0 is much more realistic than it was during the time of the guide's writing)
View my copy.
Manley's Tutorials
Scott Manley is a genious Kerbonaut. He's well regarded among the KSP community, and has dozens of videos available to help you learn how to play the game effectively. Be wary of older tutorials. The physics has changed significantly since previous versions, so older designs and launch profiles may not work as expected.
Visit the Site.
Von Kerman's Rocket School
Another resource that, upon my brief viewing, has lots of great, if outdated, youtube tutorials. Check this out to learn the thought process behind building great rockets for specialized and specific purposes.
Visit the Site.
m_sporkboy's Mun Lander Guide
Reddit's m_sporkboy has created a wonderful guide to creating effective Mun landers. Check it out.
Visit the Site.
jelliestjellyfish's Checklists
Reddit's jelliestjellyfish has created some very extensive and useful checklists. If you're getting stumped by frequently forgetting something, or even just plain not knowing that some parts are useful for a ship, these checklists can be very useful.
Visit the Site.
PhildeCube's KSP Career Mode for Absolute Beginners
Phildecube is a frequent contributor to reddit.com/r/kerbalspaceprogram, and has created a great guide to a very efficient way for new players to get started in career mode. Some contracts are just not worth doing. This guide can help you decide which, not to mention helping you figure out some early game rocket designs that simply work.
Visit the Site.
Kerbal Maps
Kerbal Maps is a website that gives you access to maps of every body in the Kerbol system (that's the star system that Kerbin is part of). It's a great resource for trying to pick a nice place to land, or for comparing the game's coordinates with visual locations.
Visit Site.
Flappy Space Program
Flappy Space Program is just a small game. Click madly to get little birdy things into orbit around a super tiny planet. Get as many birds in orbit as you possibly can. Because it's 2-D, collisions are very likely. It's a fun little time waster.
Visit the Site.


Displays a list of FAQs. Can be placed on the same page as the search form or a different page.
{module_faqresults}


Use it for Tags, Buffers, etc. too?
-
mseiwald
Hello,
I've just installed Command-T and I love it. What about extending it by the possibilty to navigate to function definitions (via ctags), open buffers and so on?
Best regards
Michael
-
Greg Hurrell
Well, initially one of the guiding design philosophies was to do one thing (file navigation) and do it really well, but I think at least in the case of buffer navigation there is a strong case to be made that buffer navigation is actually just a special case of file navigation ie. you're (mostly) navigating open files.
So I am open to adding this and there is already a request for buffer navigation in the issue tracker: see ticket #1608.
As for tags, that one hasn't been requested yet. I'm not a heavy tags user myself so I probably won't be the one to implement it, but if somebody wants to submit a patch or two for it I'd be happy to take a look at it/them. I've added a placeholder ticket in the issue tracker for this: ticket #1746.
-
yfi
Hi,
If files were sorted in this priority:
- last accessed ( acessed before the buffer you're currently in )
- files that are open buffers
- all other files
Command-t would be the one plugin to rule them all.
So if you invoked cmd-t list and if you didnt type anything you'd see a list of open buffers.
Typing <leader>t <cr> would take you to the last file you were working on.
This is how command-t in textmate works, which is a huge timesaver for switching between files.
Also I believe this would also fit within your criteria of doing file navigation exceptionally well as well as it would take care of buffer navigation in a very elegant manner.
Reply
This topic is now closed.


This guide provides descriptions of the Identity and Access Management (IAM) API as well as links to related content in the guide, Using IAM .
IAM is a web service that enables AWS customers to manage users and user permissions under their AWS account. For more information about this product go to AWS Identity and Access Management (IAM) . For information about setting up signatures and authorization through the API, go to Signing AWS API Requests in the AWS General Reference . For general information about using the Query API with IAM, go to Making Query Requests in Using IAM .
If you're new to AWS and need additional technical information about a specific AWS product, you can find the product's technical documentation at http://aws.amazon.com/documentation/ .


loading torrents....
| torrent name | seeds | leeds |
|---|---|---|
|
{{torrent.desc}}
|
{{torrent.seeds}} | {{torrent.leeds}} |
As this is calling an outside site, use this Chrome extension CORS to enable cross-site calls.
If you are using other browser, you can read this article
enabling CORS on your browser is a potential risk! Please disable it if after using this site


staticland
Get started
Docs
Github
Page not found 🤕
But maybe that's just because you haven't made it yet 📦
npm install --global staticland
staticland register
staticland site/ yourdomain.com


So, here it is, my chocolate theme also for BF Hardline.
It looks slightly different, a bit more brighter but, this style now fit more into the general bf hardline feeling - It's more colorful as BF4.
You can find it in the "Themes" of your BBLog options, just enable and you're fine.
http://getbblog.com/themes/user/136066.jpg?m=d1d
Have fun with it, as always, post suggestions here.


Central Chile Rattled by Magnitude 6.3 Earthquake
The European-Mediterranean Seismological Centre (EMSC) reported a magnitude 6.3 earthquake struck near Chile's Coquimbo and rocked the country's central coastal region Monday evening.
Early reports from the EMSC said the earthquake struck approximately 183 kilometers northwest of the Chilean capital of Santiago.
One witness, approximately 89 kilometers from the epicenter, told the EMSC in a translated testimony that they were inside a building with a "good structural design," but the quake still "felt strong."
Footage taken from Santiago's Plaza Italia - also known as Plaza Baquedano - shows the camera reacting to quakes felt amid ongoing protests against Chile's economic and social policies.
Dangerous road conditions within Coquimbo's Province of Choapa IV Region have been reported, with boulders and other rocks having rolled from the mountaintops.


| stubMapping | {{asServeEvent(activeItem).stubMapping.uuid}} |
| {{property.key}} |
|
| {{subProperty.key}} |
|
| {{subProperty.key}} |
|
| bodyFileContent |
|
| body |
|


The Static Head Common
The Static Header
Oops!! Page Not Found!
Application has encountered an error!


No {{ ctrl.label }} yet.
Click on « Discover more » to join existing {{ ctrl.label }}s or click on « New {{ ctrl.label }} » to create your own !
Only institutions can give access to courses.
Click on « New course » to create a course and then invite people to manage them.